"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>PATRIA MALLS FII RL</NomeFundo>
		<CNPJFundo>26499833000132</CNPJFundo>
		<DataFuncionamento>2017-12-14</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRMALLCTF007</CodigoISIN>
		<QtdCotasEmitidas>12975034</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</Subclassificacao>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BANCO GENIAL S.A.</NomeAdministrador>
		<CNPJAdministrador>26499833000132</CNPJAdministrador>
		<Logradouro>PRAIA DE BOTAFOGO</Logradouro>
		<Numero>228</Numero>
		<Complemento>SALA 907</Complemento>
		<Bairro>BOTAFOGO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22250-040</CEP>
		<Telefone1>(21) 3923-3000</Telefone1>
		<Telefone2>(11) 3206-8000</Telefone2>
		<Telefone3 xsi:nil="true"/>
		<Site>www.bancogenial.com</Site>
		<Email>middleadm@genialinvestimentos.com.br</Email>
		<Competencia>4/2025</Competencia>
		<DataEncerTrimestre>2025-12-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Maceió Shopping</Nome>
								<Endereco>Av. Comendador Gustavo Paiva, 2990 - Mangabeiras,
Maceió - AL, 57032-901</Endereco>
								<Area>32896.03</Area>
								<NumUnidades>213</NumUnidades>
								<OutrasCaractRelevantes>Maceió Shopping, inaugurado em 1989, localizado na Av. Gustavo Paiva, 2990, Mangabeiras, Maceió - AL, com uma área bruta locável (ABL) de 29.845,84 m2 e estando o terreno perfeitamente descrito e caracterizado nas matrículas 59.254, 59.255, 99.378, 59.341, 59.256 a 59.263, 59.266 a 59.298, 59.299 a 59.335, 59.336 a 59.340 e 99.379 a 99.435 do 1º Cartório de Registro de Imóveis de Maceió - AL.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>-0.0238</PercentInadimplencia>
								<PercentReceitasFII>0.143723</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Tacaruna</Nome>
								<Endereco>Av. Gov. Agamenon Magalhães, 153 - Santo Amaro,
Recife - PE, 50110-000</Endereco>
								<Area>49872.44</Area>
								<NumUnidades>252</NumUnidades>
								<OutrasCaractRelevantes>Shopping Tacaruna, inaugurado em 1997, localizado na Av. Gov. Agamenon Magalhães, 153, Recife- PE, com uma área bruta locável (ABL) de 44.830 m² e estando o terreno perfeitamente descrito e caracterizado na matrícula 40.920 do 2º Cartório de Registro Geral de Imóveis, resultante da unificação dos lotes matriculados sob os nos. 37.047, 39.207, 39.208, 39.209, 39.210, 39.211, 39.212, 39.213, 39.214 e 39.215 do 2º Cartório de Registro Geral de Imóveis de Recife - PE.</OutrasCaractRelevantes>
								<PercentVacancia>0.06</PercentVacancia>
								<PercentInadimplencia>-0.0554</PercentInadimplencia>
								<PercentReceitasFII>0.023454</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Suzano</Nome>
								<Endereco>R. Sete de Setembro, 555 - Jardim dos Ipês, Suzano -
SP, 08674-210</Endereco>
								<Area>25036</Area>
								<NumUnidades>105</NumUnidades>
								<OutrasCaractRelevantes>Suzano Shopping, inaugurado em 2000, localzado na R. Sete de Setembro, 555, Suzano - SP, com uma área bruta locável (ABL) de 24.058 m² e estando o terreno perfeitamente descrito e caracterizado nas matrículas 50.844, 50.906, 50.907, 50.908, 50.909, 50.910, 50.911, 50.912, 50.941 e 59.298, todas do Ofício de Registro de Imóveis de Suzano - SP</OutrasCaractRelevantes>
								<PercentVacancia>0.03</PercentVacancia>
								<PercentInadimplencia>-0.0554</PercentInadimplencia>
								<PercentReceitasFII>0.046814</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Park Sul</Nome>
								<Endereco>Rod. dos Metalúrgicos, 1189 - São Geraldo, Volta
Redonda - RJ, 27253-005</Endereco>
								<Area>30840.5</Area>
								<NumUnidades>83</NumUnidades>
								<OutrasCaractRelevantes>Shopping Park Sul, inaugurado em 2018, localizado na Rod. dos Metalúrgicos, 1189, Volta Redonda - RJ, com uma área bruta locável (ABL) de 28.555 m² e estando o terreno perfeitamente descrito e caracterizado na matrícula nº 37.847 do 1º Ofício de Registro de Imóveis de Volta Redonda, criada em 10/11/2014, a partir do remembramento das matrículas nº 26.432, 15.515, 22.742, 21.911, 21.583, 27.494 e 11.164 do mesmo cartório.</OutrasCaractRelevantes>
								<PercentVacancia>0.01</PercentVacancia>
								<PercentInadimplencia>0.034116</PercentInadimplencia>
								<PercentReceitasFII>0.067369</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Park Lagos </Nome>
								<Endereco>Av. Henrique Terra, 1700 - Palmeiras, Cabo Frio - RJ,
28911-320</Endereco>
								<Area>28326.5</Area>
								<NumUnidades>124</NumUnidades>
								<OutrasCaractRelevantes>Shopping Park Lagos, inaugurado em 2013, localizado na Av. Henrique Terra, 1700 - Palmeiras, Cabo Frio - RJ, com uma área bruta locável (ABL) de 27.220 m² e estando o terreno perfeitamente descrito e caracterizado na matrícula nº 52.737 do Registro Geral de Imóveis - 1º e 4º Distritos de Cabo Frio, criada em 03/07/2012, a partir do remembramento das matrículas nº 5.951 e 47.269 do mesmo cartório.</OutrasCaractRelevantes>
								<PercentVacancia>0.03</PercentVacancia>
								<PercentInadimplencia>0.1</PercentInadimplencia>
								<PercentReceitasFII>0.081885</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Boulevard Shopping Feira</Nome>
								<Endereco>Av. João Durval Carneiro, 3665, Caseb - Feira de Santana - BA</Endereco>
								<Area>20239.23</Area>
								<NumUnidades>122</NumUnidades>
								<OutrasCaractRelevantes>Considerado o maior e mais moderno Shopping do interior da Bahia, o Boulevard Feira é um ativo dominante em sua região, possuindo mais de 20 anos de existência. Sendo o principal centro de compras, gastronomia, serviços e lazer da região, o Shopping promoveu profundas mudanças no comércio da cidade, atraindo mensalmente um público de mais de 1 milhão de pessoas.

Com uma ABL de quase 20 mil m², o shopping oferece um mix completo de lojas, serviços e lazer. Possui mais de 120 lojas, 6 lojas âncoras e 2 megalojas, cinema com 4 salas de última geração, entre outras operações.</OutrasCaractRelevantes>
								<PercentVacancia>0.02</PercentVacancia>
								<PercentInadimplencia>0.004368</PercentInadimplencia>
								<PercentReceitasFII>0.073595</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Taboão</Nome>
								<Endereco>Rod. Régis Bittencourt, 2643, Jardim Helena - Taboão da Serra - SP</Endereco>
								<Area>37394.47</Area>
								<NumUnidades>206</NumUnidades>
								<OutrasCaractRelevantes>Inaugurado há 16 anos, o Shopping Taboão vem mudando a dinâmica da região, oferecendo em seu espaço uma enorme variedade de lojas, serviços e lazer. O Shopping é um ativo dominante em sua região, possuindo uma Área Bruta Locável (ABL) de 36.430 m², com mais de 200 lojas, 9 lojas âncoras, praça de alimentação completa, clínica, laboratório, cinema com 5 salas de última geração, banco, lotérica, agências de turismo e câmbio, entre outros. Além disso, possui um amplo espaço para estacionamento que conta com mais de 3 mil vagas.</OutrasCaractRelevantes>
								<PercentVacancia>0.02</PercentVacancia>
								<PercentInadimplencia>0.045548</PercentInadimplencia>
								<PercentReceitasFII>0.038822</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Madureira</Nome>
								<Endereco>Estrada do Portela, nº 222, Madureira, Rio de Janeiro - RJ</Endereco>
								<Area>36581</Area>
								<NumUnidades>170</NumUnidades>
								<OutrasCaractRelevantes>Localizado no bairro de Madureira, o Madureira Shopping é um ativo dominante em sua
região e está entre os principais shopping centers da Zona Norte do Rio de Janeiro, possuindo mais de 30 anos de existência.
Situado na Estrada do Portela, em frente ao Parque Madureira, no centro do comércio
de rua do bairro, o shopping oferece diversas opções de lojas, alimentação e serviços pensados para atender todas as necessidades de seus clientes.
O shopping possui 37.188 m² de ABL (área bruta total), com aproximadamente 74.197m²
de área total construída e recebe uma média de 1,4 milhão de clientes por mês.
Atualmente, o shopping apresenta um mix completo distribuído em 170 lojas, sendo 7
âncoras, 8 megalojas e 25 opções de alimentação, além de contar com um amplo espaço de estacionamento que abriga aproximadamente 600 vagas e forte ancoragem de lojas, com marcas renomadas como: Renner, Riachuelo, Leader, Lojas Americanas, Pernambucanas, Outback Steakhouse e Universidade Estácio de Sá. Possui também cinema de alto padrão, dispondo de 5 salas com equipamentos de última geração, operado pela Kinoplex.</OutrasCaractRelevantes>
								<PercentVacancia>0.03</PercentVacancia>
								<PercentInadimplencia>-0.036</PercentInadimplencia>
								<PercentReceitasFII>0.137174</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Campinas Shopping</Nome>
								<Endereco>:R. Jacy Teixeira de Camargo, 940 - Jardim do Lago, Campinas - SP, 13050-913</Endereco>
								<Area>34165.63</Area>
								<NumUnidades>150</NumUnidades>
								<OutrasCaractRelevantes>O Fundo possui participação direta de 20% (vinte por cento) da fração ideal do Campinas Shopping, localizado em Campinas/SP. O Campinas Shopping é um ativo maduro e bem ancorado, sendo um dos principais shoppings da região. Sua localização privilegiada, próximo às principais rodovias da região (Anhanguera e Santos Dummont), fazem com que o shopping tenha se tornado uma excelente opção de compras, lazer, serviços e entretenimento para Campinas e região. O shopping foi inaugurado em 1994, e desde 2002 vem fortalecendo o seu posicionamento com a chegada de 10 (dez) salas de cinema e a expansão do seu estacionamento. O shopping possui hoje aproximadamente 36.165 m² (trinta e seis mil, cento e sessenta e cinco metros quadrados) de ABL (área bruta locável) total, distribuídos em cerca de 150 (cento e cinquenta) lojas, complexo de cinema, praça de alimentação com restaurantes diversificados e estacionamento coberto.</OutrasCaractRelevantes>
								<PercentVacancia>0.04</PercentVacancia>
								<PercentInadimplencia>-0.013905</PercentInadimplencia>
								<PercentReceitasFII>0.055763</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Caxias Shopping</Nome>
								<Endereco> Rodovia Washington Luiz, nº 2.895, Parque Duque,
Duque de Caxias – RJ</Endereco>
								<Area>27780.56</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>fração ideal de 17,5%</OutrasCaractRelevantes>
								<PercentVacancia>0.05</PercentVacancia>
								<PercentInadimplencia>0.029677</PercentInadimplencia>
								<PercentReceitasFII>0.034742</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Metropolitano Barra</Nome>
								<Endereco>Avenida Embaixador Abelardo Bueno, 1300, Barra da Tijuca, Rio de Janeiro - RJ</Endereco>
								<Area>44035</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>fração ideal de 20%</OutrasCaractRelevantes>
								<PercentVacancia>0.08</PercentVacancia>
								<PercentInadimplencia>0.024</PercentInadimplencia>
								<PercentReceitasFII>0.045397</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses percentReceitaImovel="0" percentReceitasFII="0">Até 3 meses</AteTresMeses>
							<TresAteSeisMeses percentReceitaImovel="0" percentReceitasFII="0">De 3 meses e 1 dia a 6 meses</TresAteSeisMeses>
							<SeisAteNoveMeses percentReceitaImovel="0" percentReceitasFII="0">De 6 meses e 1 dia a 9 meses</SeisAteNoveMeses>
							<NoveAteDozeMeses percentReceitaImovel="0" percentReceitasFII="0">De 9 meses e 1 dia a 12 meses</NoveAteDozeMeses>
							<DozeAteQuinzeMeses percentReceitaImovel="0" percentReceitasFII="0">De 12 meses e 1 dia a 15 meses</DozeAteQuinzeMeses>
							<QuinzeAteDezoitoMeses percentReceitaImovel="0" percentReceitasFII="0">De 15 meses e 1 dia a 18 meses</QuinzeAteDezoitoMeses>
							<DezoitoAteVinteUmMeses percentReceitaImovel="0" percentReceitasFII="0">De 18 meses e 1 dia a 21 meses</DezoitoAteVinteUmMeses>
							<VinteUmAteVinteQuatroMeses percentReceitaImovel="0" percentReceitasFII="0">De 21 meses e 1 dia a 24 meses</VinteUmAteVinteQuatroMeses>
							<VinteQuatroAteVinteSeteMeses percentReceitaImovel="0" percentReceitasFII="0">De 24 meses e 1 dia a 27 meses</VinteQuatroAteVinteSeteMeses>
							<VinteSeteAteTrintaMeses percentReceitaImovel="0" percentReceitasFII="0">De 27 meses e 1 dia a 30 meses</VinteSeteAteTrintaMeses>
							<TrintaAteTrintaTresMeses percentReceitaImovel="0" percentReceitasFII="0">De 30 meses e 1 dia a 33 meses</TrintaAteTrintaTresMeses>
							<TrintaTresAteTrintaSeisMeses percentReceitaImovel="0" percentReceitasFII="0">De 33 meses e 1 dia a 36 meses</TrintaTresAteTrintaSeisMeses>
							<AcimaTrintaSeisMeses percentReceitaImovel="0" percentReceitasFII="0">Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado percentReceitaImovel="0" percentReceitasFII="0">Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0" percentReceitasFII="0"/>
							<INPC percentReceitaImovel="0" percentReceitasFII="0"/>
							<IPCA percentReceitaImovel="0" percentReceitasFII="0"/>
							<INCC percentReceitaImovel="0" percentReceitasFII="0"/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>n/a</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>Maceió Shopping</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Tacaruna</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Suzano</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Park Sul</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Park Lagos </NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Boulevard Shopping Feira</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Taboão</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Madureira</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Campinas Shopping</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Caxias Shopping</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Metropolitano Barra</NomeOuEndereco>
								<CaractContratuais>n/a</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>n/a</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
					<Emissor>
						<Fundo>VISC11 - FII VINCI SC</Fundo>
						<CNPJ>17554274000125</CNPJ>
						<Quantidade>134454</Quantidade>
						<Valor>14871956.94</Valor>
					</Emissor>
					<Emissor>
						<Fundo>BTML11 - FII BR MALLS</Fundo>
						<CNPJ>36501210000100</CNPJ>
						<Quantidade>1135160	</Quantidade>
						<Valor>144783708.63</Valor>
					</Emissor>
				</FII>
				<CriCra>
				</CriCra>
				<LciLca>
					<Emissor>
						<Nome>Caixa Economica Federal</Nome>
						<CNPJ>360305000104</CNPJ>
						<Vencimento>2026-01-26</Vencimento>
						<Quantidade>2</Quantidade>
						<Valor>24930363.53</Valor>
					</Emissor>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
				</AcoesSocFII>
				<CotasSocFII>
					<Emissor>
						<Sociedade>DGBZIBEN PARTICIPAÇÕES LTDA.</Sociedade>
						<CNPJ>9459394000115</CNPJ>
						<Quantidade>1876395</Quantidade>
						<Valor>5331882.57</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>SDT3 CENTRO COMERCIAL LTDA</Sociedade>
						<CNPJ>2463746000167</CNPJ>
						<Quantidade>1098</Quantidade>
						<Valor>1</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>VÉRTICO BAURU EMPREENDIMENTO IMOB.</Sociedade>
						<CNPJ>10193021000124</CNPJ>
						<Quantidade>41502581</Quantidade>
						<Valor>91455000</Valor>
					</Emissor>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>ITAU SOBERANO RF SIMPLES FIF FIC RL</Fundo>
						<CNPJ>6175696000173</CNPJ>
						<Quantidade>261806.11</Quantidade>
						<Valor>21370067.04</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>4492557.81</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados>24930363.53</TitulosPrivados>
				<FundosRendaFixa>21370067.04</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda/>
					<CustoImovEstoque/>
					<AjusteValor/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="40458852.65" financeiro="37824292.09"/>
					<DespManutencaoConservacao contabil="0" financeiro="0"/>
					<ReceitasVenda contabil="0" financeiro="173327.89"/>
					<CustoPropriedadesVendidas contabil="0" financeiro="0"/>
					<AjusteValor contabil="-86559328.73" financeiro="0"/>
					<OutrasRecOuDesp contabil="-3489683.2" financeiro="-3489683.2"/>
					<ResultadoLiquido contabil="-49590159.28" financeiro="34507936.78"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="2823552.53" financeiro="2342844.46"/>
					<AjusteValor contabil="-3508210.39" financeiro="0"/>
					<ResultadoVenda contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="-61866.07" financeiro="-3059303.67"/>
					<ResultadoLiquido contabil="-746523.93" financeiro="-716459.21"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="-50336683.21" financeiro="33791477.57"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="2778668.82" financeiro="2778668.82"/>
				<AjusteValorAplicacoes contabil="-3210519.57" financeiro="5816286.15"/>
				<ResultadoVendaAplicacoes contabil="0" financeiro="0"/>
				<OutrasRecOuDespAplicacoes contabil="699164.99" financeiro="0"/>
				<ResultadoLiquido contabil="267314.24" financeiro="8594954.97"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-144633.87" financeiro="-1788717.48"/>
				<TaxaDesempenho contabil="0" financeiro="0"/>
				<ConsultoriaEspecializada contabil="0" financeiro="0"/>
				<EmpresaEspecializada contabil="0" financeiro="0"/>
				<FormadorMercado contabil="0" financeiro="0"/>
				<CustodiaTitulosValores contabil="7798.68" financeiro="0"/>
				<AuditoriaIndependente contabil="-224532" financeiro="0"/>
				<RepresentantesCotistas contabil="0" financeiro="0"/>
				<TaxasImpostosContribuicoes contabil="-1758046.52" financeiro="-68798.5"/>
				<ComissoesEmolumentos contabil="0" financeiro="0"/>
				<HonorariosDespesasDefesas contabil="-250800.42" financeiro="-250800.42"/>
				<GastosContratosSeguros contabil="0" financeiro="0"/>
				<DespesasAvaliacoes contabil="-156000" financeiro="-156000"/>
				<TaxasIngressoSaidaFundos contabil="0" financeiro="0"/>
				<DespesasRegistroCartorio contabil="0" financeiro="0"/>
				<OutrasRecOuDesp contabil="-83601.86" financeiro="-83601.86"/>
				<Total contabil="-2609815.99" financeiro="-2347918.26"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="-52679184.96" financeiro="40038514.28"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>74738877.8</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>71001933.91</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte xsi:nil="true"/>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<ResultadoFinanceiroExcedeMinimo>1145665.88</ResultadoFinanceiroExcedeMinimo>
			<RendimentosDeclarados>72147599.79</RendimentosDeclarados>
			<RendimentosPagosAntec>-60122999.81</RendimentosPagosAntec>
			<RendimentoPagar>12024599.98</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.965329</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"