"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>TRX REAL ESTATE FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</NomeFundo>
		<CNPJFundo>28548288000152</CNPJFundo>
		<DataFuncionamento>2019-10-15</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN>BRTRXFCTF003</CodigoISIN>
		<QtdCotasEmitidas>32493284</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<SegmentoAtuacao>Multicategoria</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>BRL TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>28548288000152</CNPJAdministrador>
		<Logradouro>Rua Alves Guimarães</Logradouro>
		<Numero>1216</Numero>
		<Complemento xsi:nil="true"/>
		<Bairro>Pinheiros</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>05410-002</CEP>
		<Telefone1>(11) 3509-0600</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.apexgroup.com/apex-brazil/</Site>
		<Email>infolegal@apexgroup.com</Email>
		<Competencia>04/2025</Competencia>
		<DataEncerTrimestre>2025-12-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
					<Terreno>
						<Endereco>Obramax Região Metropolitana do Rio de Janeiro</Endereco>
						<OutrasCaractRelevantes>OBRAMAX_SAOGONÇALO</OutrasCaractRelevantes>
						<Area>18657.83</Area>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<PercentReceitasFII>0</PercentReceitasFII>
					</Terreno>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Assaí Cidade Alta</Nome>
								<Endereco>Rua Aricambú, 65 - Cordovil - Rio de Janeiro - RJ</Endereco>
								<Area>14038.18</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Extra  Peruíbe</Nome>
								<Endereco>Avenida Padre Anchieta, 4.580 – Vila Vermelha</Endereco>
								<Area>6198</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Extra  Praia Grande</Nome>
								<Endereco>Avenida Guadalajara, s/nº - Jardim Glória</Endereco>
								<Area>5436</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Assaí  Campinas</Nome>
								<Endereco>Avenida Senador Saraiva, 835</Endereco>
								<Area>6552</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Assaí  Piracicaba</Nome>
								<Endereco>Avenida Regente Feijó, nº 823</Endereco>
								<Area>10174</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Assaí  Paulínia</Nome>
								<Endereco>Avenida José Paulino, nº 2.600</Endereco>
								<Area>11475</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Sp</Nome>
								<Endereco>Rua Carneiro da Cunha, S/N – Vila da Saúde </Endereco>
								<Area>3872</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Rib.</Nome>
								<Endereco>Avenida Prof. João Fiusa, S/N – Jardim Canada</Endereco>
								<Area>3296</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Extra  Sbc</Nome>
								<Endereco>Avenida Maria Servidei Demarchi, 1897 – Demarchi</Endereco>
								<Area>6144</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Campina</Nome>
								<Endereco>Av. Antônio Carlos C de Barros, 365 – Vila José Lório</Endereco>
								<Area>8628</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Valinhos</Nome>
								<Endereco>Rua Dr. Ademar de Barros, 50 – Jardim Europa</Endereco>
								<Area>3760</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  SP</Nome>
								<Endereco>Rua Dr Altino Arantes, 268 - Vila Clementino</Endereco>
								<Area>3469</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Sant. P</Nome>
								<Endereco>Avenida Marte, 624 – Alphaville </Endereco>
								<Area>6597</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Sjrp</Nome>
								<Endereco>Avenida Miguel Dahma, 1.805</Endereco>
								<Area>5736</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Sjrp</Nome>
								<Endereco>Avenida Bady Bassitt, 5.300</Endereco>
								<Area>6127</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Sp</Nome>
								<Endereco>Rua Maria Amalia Lopes de Azevedo, 852 - Vila Albertina</Endereco>
								<Area>8489</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Sp</Nome>
								<Endereco>Avenida Dr. José Ramon Urtiza, 1000 – Panamby</Endereco>
								<Area>2429</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Scs</Nome>
								<Endereco>Rua Maranhão, 975 – Santa Paula</Endereco>
								<Area>7530</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pão De Açúcar  Rib. Preto</Nome>
								<Endereco>Avenida Prof. João Fiusa, S/N – Jardim Canada </Endereco>
								<Area>3296</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Big Jaboatão</Nome>
								<Endereco>Av. Barreto de Menezes, 800 - Piedade, Jaboatão dos Guararapes - PE - Loja 05</Endereco>
								<Area>15130.54</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_BELEM - GRUPO MATEUS</Nome>
								<Endereco>Estrada do Benguí, n° 386 Benguí - Belém - PA</Endereco>
								<Area>30661.99</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_JUAZEIRO - GRUPO MATEUS </Nome>
								<Endereco>Av. Epitacio Pessoa, S/N, Gleba C - Alto da Alianca, Juazeiro - BA</Endereco>
								<Area>16794.82</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_PETROLINA - GRUPO MATEUS</Nome>
								<Endereco>Av. Dr. Ulisses Guimarães, 423 - Jardim Amazonas, Petrolina - PE</Endereco>
								<Area>19828.85</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DECATLON GOIANIA</Nome>
								<Endereco>Avenida I, número 208, Quadra B-37, Lote 02, bairro Jardim, Goiânia/GO</Endereco>
								<Area>10548.5</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DECATLON JOINVILLE</Nome>
								<Endereco>Rua XV de novembro, 2805 -Glória, Joinville/SC</Endereco>
								<Area>37301.68</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DECHATLON CAMPINAS</Nome>
								<Endereco>Trevo da Rodovia D. Pedro I, Km 129, Jardim das Palmeiras, Campians/SP</Endereco>
								<Area>50391.4</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_ANANINDEUA- GRUPO MATHEUS</Nome>
								<Endereco>Av. Cláudio Saunders, Coqueiro, Ananindeua/PA</Endereco>
								<Area>7601.92</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_CARUARU - GRUPO MATHEUS</Nome>
								<Endereco>Av. Portugal – Bairro Universitário – Caruaru/PE</Endereco>
								<Area>32604</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_GUARABIRA - GRUPO MATHEUS</Nome>
								<Endereco>Rua Otacílio Lira Cabral, 1300 – Guarabira/PB</Endereco>
								<Area>56898.85</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_LEAO DOURADO - GRUPO MATHE</Nome>
								<Endereco>Av. Leão Dourado – Bairro Kennedy – Caruaru/PE</Endereco>
								<Area>32391.18</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_MARANHAO- GRUPO MATHEUS</Nome>
								<Endereco>BR-135, km-190, s/n, São Mateus do Maranhão/MA</Endereco>
								<Area>3734</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_MARITUBA- GRUPO MATHEUS</Nome>
								<Endereco>Rodovia BR-316, KM 25, S/N, Bairro Parque Verde, Marituba –PA</Endereco>
								<Area>10291.95</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_PATOS - GRUPO MATHEUS</Nome>
								<Endereco>Rua Lima Campos, 156 – São Sebastião – Patos/PB</Endereco>
								<Area>36000</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DRS_RUSSAS- GRUPO MATHEUS</Nome>
								<Endereco>356, 208 - Vila Ramalho, Russas - CE, 62900-000</Endereco>
								<Area>8149.08</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>LEROY MERLIN JUNDIAI</Nome>
								<Endereco>Av. Antônio Frederico Ozanan, 4490 - Jardim Liberdade</Endereco>
								<Area>27750</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ASSAÍ CALDAS NOVAS - GO</Nome>
								<Endereco>Av. Santo Amaro, 1.697– Solar de Caldas,Caldas Novas/GO</Endereco>
								<Area>30375.15</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>EXTRA VIERA DE MORAES</Nome>
								<Endereco>R. Vieira de Morais, 1597 - Campo Belo</Endereco>
								<Area>1629</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>EXTRA DOMINGO DE MORAES</Nome>
								<Endereco>R. Domingos de Morais, 316 - Vila Mariana, São Paulo</Endereco>
								<Area>3313</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>EXTRA IBIRAREMA</Nome>
								<Endereco>R. Ibirarema, 100 -Bosque da Saúde, São Paulo</Endereco>
								<Area>1935</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>EXTRA CURSINO</Nome>
								<Endereco>Av. do Cursino, 2568 - Bosque da Saúde, São Paulo</Endereco>
								<Area>2810</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>EXTRA DIADEMA PIRAPORINHA</Nome>
								<Endereco>Praça Bom Jesus de Piraporinha, 435</Endereco>
								<Area>9286</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>COOPERATIVA DE CONSUMO DIADEMA</Nome>
								<Endereco>Av. Fábio Eduardo Ramos Esquivel, 290</Endereco>
								<Area>1457</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>GPA SERAFIM ORLANDI</Nome>
								<Endereco>R. Prof. Serafim Orlandi, 299 - Vila Mariana, São Paulo</Endereco>
								<Area>13260</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ASSAI DIADEMA PIRAPORINHA</Nome>
								<Endereco>Av. Piraporinha, 1144 - Vila Nogueira</Endereco>
								<Area>19620.71</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ASSAI TEOTONIO VILELA</Nome>
								<Endereco>Av. Sen. Teotônio Vilela, 2926</Endereco>
								<Area>107457</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>EXTRA ATIBAIA</Nome>
								<Endereco>Av. Prof. Carlos Alberto de Carvalho Pinto, 210</Endereco>
								<Area>8025</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ASSAI COTIA</Nome>
								<Endereco>R. Prof. José Barreto, 1635 - Vila Santo Antonio do Portao</Endereco>
								<Area>19518</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ASSAÍ APARECIDA DE GOIÂNIA</Nome>
								<Endereco>BR-153, s/n - Jardim Monte Serrat</Endereco>
								<Area>21920.57</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>GPA GRANJA VIANA</Nome>
								<Endereco>Av. São Camilo, 700 - Granja Viana, Cotia</Endereco>
								<Area>4492</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>GPA SANTANA - SÃO PAULO</Nome>
								<Endereco>Rua Augusto Tolle, 470 – Santana</Endereco>
								<Area>2877.15</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>GPA TITO</Nome>
								<Endereco>R. Tito, 639 - 705 – Vila Romana, São Paulo</Endereco>
								<Area>3643.72</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ALCÂNTARA - CEF</Nome>
								<Endereco>Dr. Alfredo Backer, 5</Endereco>
								<Area>1688.88</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ANHANGUERA</Nome>
								<Endereco>R. Luiz Otávio, 1313 - Parque Taquara</Endereco>
								<Area>22787.79</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Faculdade</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ÂNIMA CANOAS</Nome>
								<Endereco>Rua Santos Dumont, 88</Endereco>
								<Area>11664</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Faculdade</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ÂNIMA POA</Nome>
								<Endereco> Rua Orfanotrófio, 555, Alto - Teresópolis</Endereco>
								<Area>29592.24</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Faculdade</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ASSAÍ SÃO BERNADO</Nome>
								<Endereco>Av. Piraporinha, 680,Planalto, São Bernardo do Campo</Endereco>
								<Area>43950</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ATACADÃO - ARAPIRACA</Nome>
								<Endereco>AL-220, 359 - Itapoá</Endereco>
								<Area>34842.89</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ATACADÃO - CAMARAGIBE</Nome>
								<Endereco>Av. Dr. Belmínio Correia, 4817</Endereco>
								<Area>40216</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ATACADÃO - DUQUE DE CAXIAS</Nome>
								<Endereco>Rod. Washington Luiz, 121</Endereco>
								<Area>31600.21</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ATACADÃO - MOSSORÓ</Nome>
								<Endereco>Av. João da Escóssia, 1724</Endereco>
								<Area>87176</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ATACADÃO - RESENDE</Nome>
								<Endereco>Av. Francisco Fortes Filho,</Endereco>
								<Area>47776.57</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ATACADÃO - SOBRAL</Nome>
								<Endereco>Av. Sen. Fernandes Távora, 605</Endereco>
								<Area>33460</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ATACADÃO - TANGARÁ DA SERRA</Nome>
								<Endereco>Av. Domingos Parente de Sá Barreto, 303</Endereco>
								<Area>51443.56</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>BARRA DA TIJUCA - CEF</Nome>
								<Endereco>Av. das Américas, 3959</Endereco>
								<Area>1174.08</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CÂNDIDO BENÍCIO - LOJA A</Nome>
								<Endereco> R. Cândido Benício, 1671</Endereco>
								<Area>4920</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CÂNDIDO BENÍCIO - LOJA B</Nome>
								<Endereco>MAT. 126.225</Endereco>
								<Area>4920</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CIDADELA - CEF</Nome>
								<Endereco>Av. Antônio Carlos Magalhães,</Endereco>
								<Area>1219.44</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CRUZEIRO DO SUL - GUARULHOS/SP</Nome>
								<Endereco>Av. Salgado Filho, 100 - Centro</Endereco>
								<Area>3390.7</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Faculdade</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ESCOLA ELEVA - RJ</Nome>
								<Endereco>Av. José Silva de Azevedo Neto, 309 - Barra da Tijuca</Endereco>
								<Area>17961.67</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Escola</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>FONSECA - CEF</Nome>
								<Endereco>Alameda São Boaventura, 904</Endereco>
								<Area>935.55</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>FRANCISO MATARAZO - CEF</Nome>
								<Endereco>Av. Francisco Matarazzo, 342</Endereco>
								<Area>674.4</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>GRANDE CENTER</Nome>
								<Endereco>R. Oswaldo Cruz, 415</Endereco>
								<Area>2572.58</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Multilocatário</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>JUNDIAÍ - CEF</Nome>
								<Endereco>Rua Rangel Pestana, 278</Endereco>
								<Area>1150</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>LINK - CORPORATE GARDEN</Nome>
								<Endereco>Av. Brigadeiro Luís Antônio, 5083</Endereco>
								<Area>2220.78</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Escola</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>MATEUS - CAMETÁ/PA</Nome>
								<Endereco>Rodovia BR 422, KM 01, Cametá - PA</Endereco>
								<Area>28000</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>MATEUS - CARPINA/PE</Nome>
								<Endereco>Av. Conselheiro João Alfredo, 262</Endereco>
								<Area>18242.09</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>MATEUS - ESTRADA DO ARROZ IMPERATRIZ/MA</Nome>
								<Endereco>Av. Newton Bello, 22</Endereco>
								<Area>29776.6</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>MATEUS - SALVADOR IGUATEMI/BA</Nome>
								<Endereco> Av. Antônio Carlos Magalhães, 3650</Endereco>
								<Area>70050</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>MEDICAL CENTER - EINSTEIN</Nome>
								<Endereco>Marginal Pinheiros, 14.500</Endereco>
								<Area>9185.27</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Hospital</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>PENHA - CEF</Nome>
								<Endereco> Av. Brás de Pina, 02</Endereco>
								<Area>1134.67</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>RIACHUELO - CEF</Nome>
								<Endereco>R. Riachuelo, 61</Endereco>
								<Area>1150</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>RIO SUL - CEF</Nome>
								<Endereco>Rua Lauro Müller, 116</Endereco>
								<Area>1170.07</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>RUA DAS FLORES - CEF</Nome>
								<Endereco>Praça Gen. Osório, 319</Endereco>
								<Area>1789.05</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SÃO BENTO - CEF</Nome>
								<Endereco>R. São Bento, 397</Endereco>
								<Area>1539.8</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SÃO JOÃO DO MERITI - CEF</Nome>
								<Endereco>Av. Getúlio de Moura, 60</Endereco>
								<Area>602.23</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SHOPPING BARRA - CEF</Nome>
								<Endereco>R. Augusto Frederico Schmith, 139</Endereco>
								<Area>829</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Shopping</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SHOPPING BARREIRO</Nome>
								<Endereco>Av. Afonso Vaz de Melo, 640</Endereco>
								<Area>59460</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Shopping</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SHOPPING MARANHÃO</Nome>
								<Endereco>Av. Prof. Carlos Cunha, 100</Endereco>
								<Area>55312.91</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Shopping</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SHOPPING PAMPULHA</Nome>
								<Endereco>Av. Pres. Antônio Carlos, 8100 - Pampulha, Belo Horizonte - MG</Endereco>
								<Area>23631.65</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Shopping</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>STRIP MALL BARRA - RJ</Nome>
								<Endereco>Av. José Silva de Azevedo Neto, 309 - Barra da Tijuca</Endereco>
								<Area>2333.33</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Shopping</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>VILA MADALENA - CEF</Nome>
								<Endereco>R. Fradique Coutinho, 1339</Endereco>
								<Area>800</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Agência</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DELBONI RICARDO JAFET</Nome>
								<Endereco>R. Rodrigo Vieira, 67 - Jardim Vila Mariana, São Paulo</Endereco>
								<Area>6290</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Laboratório</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses>Até 3 meses</AteTresMeses>
							<TresAteSeisMeses>De 3 meses e 1 dia a 6 meses</TresAteSeisMeses>
							<SeisAteNoveMeses>De 6 meses e 1 dia a 9 meses</SeisAteNoveMeses>
							<NoveAteDozeMeses>De 9 meses e 1 dia a 12 meses</NoveAteDozeMeses>
							<DozeAteQuinzeMeses>De 12 meses e 1 dia a 15 meses</DozeAteQuinzeMeses>
							<QuinzeAteDezoitoMeses>De 15 meses e 1 dia a 18 meses</QuinzeAteDezoitoMeses>
							<DezoitoAteVinteUmMeses>De 18 meses e 1 dia a 21 meses</DezoitoAteVinteUmMeses>
							<VinteUmAteVinteQuatroMeses>De 21 meses e 1 dia a 24 meses</VinteUmAteVinteQuatroMeses>
							<VinteQuatroAteVinteSeteMeses>De 24 meses e 1 dia a 27 meses</VinteQuatroAteVinteSeteMeses>
							<VinteSeteAteTrintaMeses>De 27 meses e 1 dia a 30 meses</VinteSeteAteTrintaMeses>
							<TrintaAteTrintaTresMeses>De 30 meses e 1 dia a 33 meses</TrintaAteTrintaTresMeses>
							<TrintaTresAteTrintaSeisMeses>De 33 meses e 1 dia a 36 meses</TrintaTresAteTrintaSeisMeses>
							<AcimaTrintaSeisMeses>Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado>Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM/>
							<INPC/>
							<IPCA/>
							<INCC/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>O aluguel será reajustado anualmente conforme variação positiva do IPCA-IBGE (Índice de Preço ao Consumidor Amplo, calculado e divulgado pelo Instituto Brasileiro de Geografia e Estatística) ou, na impossibilidade de sua utilização, seja pela falta deste ou na hipótese de sua extinção, será reajustado pelo Índice Geral de Preços do Mercado - IGP-M, divulgado pela Fundação Getúlio Vargas – FGV (“IGP-M”), considerando como data base para o reajuste a data de início do prazo de vigência da presente locação</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>Assaí Cidade Alta</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Extra  Peruíbe</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Extra  Praia Grande</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Assaí  Campinas</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Assaí  Piracicaba</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Assaí  Paulínia</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Sp</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Rib.</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Extra  Sbc</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Campina</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Valinhos</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  SP</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Sant. P</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Sjrp</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Sjrp</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Sp</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Sp</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Scs</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pão De Açúcar  Rib. Preto</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Big Jaboatão</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_BELEM - GRUPO MATEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_JUAZEIRO - GRUPO MATEUS </NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_PETROLINA - GRUPO MATEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DECATLON GOIANIA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DECATLON JOINVILLE</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DECHATLON CAMPINAS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_ANANINDEUA- GRUPO MATHEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_CARUARU - GRUPO MATHEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_GUARABIRA - GRUPO MATHEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_LEAO DOURADO - GRUPO MATHE</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_MARANHAO- GRUPO MATHEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_MARITUBA- GRUPO MATHEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_PATOS - GRUPO MATHEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DRS_RUSSAS- GRUPO MATHEUS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>LEROY MERLIN JUNDIAI</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ASSAÍ CALDAS NOVAS - GO</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>EXTRA VIERA DE MORAES</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>EXTRA DOMINGO DE MORAES</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>EXTRA IBIRAREMA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>EXTRA CURSINO</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>EXTRA DIADEMA PIRAPORINHA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>COOPERATIVA DE CONSUMO DIADEMA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>GPA SERAFIM ORLANDI</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ASSAI DIADEMA PIRAPORINHA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ASSAI TEOTONIO VILELA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>EXTRA ATIBAIA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ASSAI COTIA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DELBONI RICARDO JAFET</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ASSAÍ APARECIDA DE GOIÂNIA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>GPA GRANJA VIANA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>GPA SANTANA - SÃO PAULO</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>GPA TITO</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ALCÂNTARA - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ANHANGUERA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ÂNIMA CANOAS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ÂNIMA POA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ASSAÍ SÃO BERNADO</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ATACADÃO - ARAPIRACA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ATACADÃO - CAMARAGIBE</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ATACADÃO - DUQUE DE CAXIAS</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ATACADÃO - MOSSORÓ</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ATACADÃO - RESENDE</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ATACADÃO - SOBRAL</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ATACADÃO - TANGARÁ DA SERRA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>BARRA DA TIJUCA - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CÂNDIDO BENÍCIO - LOJA A</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CÂNDIDO BENÍCIO - LOJA B</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CIDADELA - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CRUZEIRO DO SUL - GUARULHOS/SP</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>ESCOLA ELEVA - RJ</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>FONSECA - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>FRANCISO MATARAZO - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>GRANDE CENTER</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>JUNDIAÍ - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>LINK - CORPORATE GARDEN</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>MATEUS - CAMETÁ/PA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>MATEUS - CARPINA/PE</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>MATEUS - ESTRADA DO ARROZ IMPERATRIZ/MA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>MATEUS - SALVADOR IGUATEMI/BA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>MEDICAL CENTER - EINSTEIN</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>PENHA - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>RIACHUELO - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>RIO SUL - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>RUA DAS FLORES - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>SÃO BENTO - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>SÃO JOÃO DO MERITI - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>SHOPPING BARRA - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>SHOPPING BARREIRO</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>SHOPPING MARANHÃO</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>SHOPPING PAMPULHA</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>STRIP MALL BARRA - RJ</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>VILA MADALENA - CEF</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>13</NomeOuEndereco>
								<CaractContratuais>ÁTIPICO</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>A apólice de seguros deverá ser contratada na modalidade de riscos relativos, tendo a indicação do LOCADOR como beneficiário da indenização devida, no que diz respeito especificamente às proteções da estrutura do IMÓVEL, garantindo,  as perdas e danos materiais decorrentes de incêndio, raio, explosão de qualquer natureza, vendaval, queda de aeronave ou acidentes com veículos terrestres nos exatos termos das coberturas indicadas para o Imóvel</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
							<Imovel>
								<Nome>LEROY MERLIN SALVADOR</Nome>
								<Endereco>Alameda Horto da Bela Vista - Salvador -BA</Endereco>
								<Area>26143.14</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentLocado>0</PercentLocado>
								<PercentConclusaoObras realizado="0" previsto="0"/>
								<CustoConstrucao realizado="0" previsto="0"/>
							</Imovel>
							<Imovel>
								<Nome>OBRAMAX _PIRACICABA</Nome>
								<Endereco>Rodovia do Açucar, Km 06, s/nº - Santa Rita - Piracicaba - SP</Endereco>
								<Area>16675</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula nº 63.079 - Cartório de Registro de Imóveis de Piracicaba - SP, IPTU, Levantamento Planialtimétrico e Escritura de Compra e Venda</OutrasCaractRelevantes>
								<PercentLocado>0</PercentLocado>
								<PercentConclusaoObras realizado="0" previsto="0"/>
								<CustoConstrucao realizado="0" previsto="0"/>
							</Imovel>
							<Imovel>
								<Nome>OBRAMAX_SUZANO</Nome>
								<Endereco>Rua Prudente de Moraes, s/nº - Vila Amorim - Suzano - SP</Endereco>
								<Area>33000</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrículas nº 66.390 e 78.083 - Cartório de Registro de Imóveis de Suzano - SP.</OutrasCaractRelevantes>
								<PercentLocado>0</PercentLocado>
								<PercentConclusaoObras realizado="0" previsto="0"/>
								<CustoConstrucao realizado="0" previsto="0"/>
							</Imovel>
							<Imovel>
								<Nome>ALBERT_EINSTEN</Nome>
								<Endereco>Parque Global, Marginal Pinheiros, 14.500 - Real Parque, São Paulo - SP</Endereco>
								<Area>24500</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade 70%</OutrasCaractRelevantes>
								<PercentLocado>0</PercentLocado>
								<PercentConclusaoObras realizado="0" previsto="0"/>
								<CustoConstrucao realizado="0" previsto="0"/>
							</Imovel>
							<Imovel>
								<Nome>DRS_ARACAJU - GRUPO MATHEUS</Nome>
								<Endereco>Av. João Rodrigues, 592 – Industrial – Aracaju/SE</Endereco>
								<Area>31524</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentLocado>0</PercentLocado>
								<PercentConclusaoObras realizado="0" previsto="0"/>
								<CustoConstrucao realizado="0" previsto="0"/>
							</Imovel>
							<Imovel>
								<Nome>MERCADO LIVRE - ARAUCÁRIA</Nome>
								<Endereco>Av. Cézar Hasselmann, 499-497 - Fazenda Velha, Araucária – PR</Endereco>
								<Area>149452.44</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentLocado>0</PercentLocado>
								<PercentConclusaoObras realizado="0" previsto="0"/>
								<CustoConstrucao realizado="0" previsto="0"/>
							</Imovel>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
							<Imovel>
								<NomeOuEndereco>n/a</NomeOuEndereco>
								<JustEvolucaoInferior>n/a</JustEvolucaoInferior>
								<JustCustoSuperior>n/a</JustCustoSuperior>
							</Imovel>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro>n/a</PoliticaContratacaoSeguro>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
							<Imovel>
								<Nome>CARREFOUR JABAQUARA</Nome>
								<Endereco>Av. Engenheiro George Corbisier, 273 - Jabaquara, São Paulo - SP</Endereco>
								<Area>9768</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
								<PercentTotalInvestido>0</PercentTotalInvestido>
							</Imovel>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro>n/a</PoliticaContratacaoSeguro>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
					<Emissor>
						<Fundo>BLCA11 - FII BLUE AAA</Fundo>
						<CNPJ>41076748000155</CNPJ>
						<Quantidade>151395</Quantidade>
						<Valor>14427943.5</Valor>
					</Emissor>
					<Emissor>
						<Fundo>CPOF11 - FII CPOF</Fundo>
						<CNPJ>48916699000160</CNPJ>
						<Quantidade>140973</Quantidade>
						<Valor>15507030</Valor>
					</Emissor>
					<Emissor>
						<Fundo>CPSH11 - FII CPSH</Fundo>
						<CNPJ>47896665000199</CNPJ>
						<Quantidade>624187</Quantidade>
						<Valor>6915991.96</Valor>
					</Emissor>
					<Emissor>
						<Fundo>CPUR11 - VBI CONSUMO ESSENCIAL FII</Fundo>
						<CNPJ>34691520000100</CNPJ>
						<Quantidade>10936211</Quantidade>
						<Valor>119095337.79</Valor>
					</Emissor>
					<Emissor>
						<Fundo>IBBP11 - FII IBBP</Fundo>
						<CNPJ>52551605000174</CNPJ>
						<Quantidade>6200772</Quantidade>
						<Valor>55558917.12</Valor>
					</Emissor>
					<Emissor>
						<Fundo>LASC11 - FII LEGATUS</Fundo>
						<CNPJ>30248158000146</CNPJ>
						<Quantidade>74315</Quantidade>
						<Valor>8100335</Valor>
					</Emissor>
					<Emissor>
						<Fundo>PQAG11 - FII PARQ ANH</Fundo>
						<CNPJ>12978943000172</CNPJ>
						<Quantidade>549702</Quantidade>
						<Valor>30942725.58</Valor>
					</Emissor>
					<Emissor>
						<Fundo>TJKB11 - FII TJK REND</Fundo>
						<CNPJ>39714024000148</CNPJ>
						<Quantidade>133719</Quantidade>
						<Valor>33432424.38</Valor>
					</Emissor>
					<Emissor>
						<Fundo>TRXB11 - TRX REAL ESTATE II FII</Fundo>
						<CNPJ>36368925000137</CNPJ>
						<Quantidade>3705293</Quantidade>
						<Valor>625823987.7</Valor>
					</Emissor>
					<Emissor>
						<Fundo>TRXY11 - TRX HEDGE FII</Fundo>
						<CNPJ>43985938000110</CNPJ>
						<Quantidade>5666792</Quantidade>
						<Valor>54967882.4</Valor>
					</Emissor>
					<Emissor>
						<Fundo>CPOF12 - FII CPOF</Fundo>
						<CNPJ>34081611000123</CNPJ>
						<Quantidade>54765</Quantidade>
						<Valor>103505.85</Valor>
					</Emissor>
					<Emissor>
						<Fundo>TRXB13 - TRX REAL ESTATE II FII</Fundo>
						<CNPJ>36368925000137</CNPJ>
						<Quantidade>191190</Quantidade>
						<Valor>32291991</Valor>
					</Emissor>
					<Emissor>
						<Fundo>TRXB14 - TRX REAL ESTATE II FII</Fundo>
						<CNPJ>36368925000137</CNPJ>
						<Quantidade>114402</Quantidade>
						<Valor>19322497.8</Valor>
					</Emissor>
				</FII>
				<CriCra>
					<Emissor>
						<Companhia>CRI_18L1364767 - VERTCIASEC</Companhia>
						<CNPJ>25005683000109</CNPJ>
						<Emissao>5</Emissao>
						<Serie>1</Serie>
						<Quantidade>2713</Quantidade>
						<Valor>585280.23</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_18L1364801 - VERTCIASEC</Companhia>
						<CNPJ>25005683000109</CNPJ>
						<Emissao>5</Emissao>
						<Serie>2</Serie>
						<Quantidade>2234</Quantidade>
						<Valor>451318.42</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_20E0031084 - BARI SEC</Companhia>
						<CNPJ>10608405000241</CNPJ>
						<Emissao>1</Emissao>
						<Serie>79</Serie>
						<Quantidade>18500</Quantidade>
						<Valor>7938948.29</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_20H0695880 - BARI SEC</Companhia>
						<CNPJ>10608405000241</CNPJ>
						<Emissao>1</Emissao>
						<Serie>85</Serie>
						<Quantidade>12091</Quantidade>
						<Valor>8515978.76</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_20H0695880 - BARI SEC</Companhia>
						<CNPJ>10608405000241</CNPJ>
						<Emissao>1</Emissao>
						<Serie>85</Serie>
						<Quantidade>1820</Quantidade>
						<Valor>1281869.27</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_20H0695880 - BARI SEC</Companhia>
						<CNPJ>10608405000241</CNPJ>
						<Emissao>1</Emissao>
						<Serie>85</Serie>
						<Quantidade>86</Quantidade>
						<Valor>60571.84</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_20H0695880 - BARI SEC</Companhia>
						<CNPJ>10608405000241</CNPJ>
						<Emissao>1</Emissao>
						<Serie>85</Serie>
						<Quantidade>78</Quantidade>
						<Valor>54937.25</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_20H0695880 - BARI SEC</Companhia>
						<CNPJ>10608405000241</CNPJ>
						<Emissao>1</Emissao>
						<Serie>85</Serie>
						<Quantidade>81</Quantidade>
						<Valor>57050.22</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_20K0010253 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>1</Emissao>
						<Serie>296</Serie>
						<Quantidade>10486</Quantidade>
						<Valor>9888720.89</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_20L0765928 - HABITASEC</Companhia>
						<CNPJ>9304427000158</CNPJ>
						<Emissao>1</Emissao>
						<Serie>221</Serie>
						<Quantidade>32290</Quantidade>
						<Valor>38785984.67</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21C0711012 - COOP AGROINDUSTRIAL COPAGRIL</Companhia>
						<CNPJ>81584278000155</CNPJ>
						<Emissao>4</Emissao>
						<Serie>204</Serie>
						<Quantidade>12730</Quantidade>
						<Valor>6158088.12</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21C0804567 - VIRGOSEC</Companhia>
						<CNPJ>8769451000108</CNPJ>
						<Emissao>4</Emissao>
						<Serie>206</Serie>
						<Quantidade>12971</Quantidade>
						<Valor>6025142.68</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21C0804584 - VIRGOSEC</Companhia>
						<CNPJ>8769451000108</CNPJ>
						<Emissao>4</Emissao>
						<Serie>207</Serie>
						<Quantidade>7345</Quantidade>
						<Valor>4387946.83</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21E0048439 - HABITASEC</Companhia>
						<CNPJ>9304427000158</CNPJ>
						<Emissao>1</Emissao>
						<Serie>257</Serie>
						<Quantidade>24609</Quantidade>
						<Valor>25714990.74</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21H0953104 - HABITASEC</Companhia>
						<CNPJ>9304427000158</CNPJ>
						<Emissao>1</Emissao>
						<Serie>245</Serie>
						<Quantidade>21327</Quantidade>
						<Valor>24657198.46</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21H0953114 - HABITASEC</Companhia>
						<CNPJ>9304427000158</CNPJ>
						<Emissao>1</Emissao>
						<Serie>246</Serie>
						<Quantidade>23659</Quantidade>
						<Valor>20364703.51</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21K0196620 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>1</Emissao>
						<Serie>435</Serie>
						<Quantidade>8526</Quantidade>
						<Valor>8008016.18</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21K0196620 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>1</Emissao>
						<Serie>435</Serie>
						<Quantidade>2637</Quantidade>
						<Valor>2476793.18</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_21K0196620 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>1</Emissao>
						<Serie>435</Serie>
						<Quantidade>19030</Quantidade>
						<Valor>17873862.07</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_22A0791137 - HABITASEC</Companhia>
						<CNPJ>9304427000158</CNPJ>
						<Emissao>1</Emissao>
						<Serie>325</Serie>
						<Quantidade>38000</Quantidade>
						<Valor>38888171.9</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_22L1309906 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>62</Emissao>
						<Serie>1</Serie>
						<Quantidade>2866</Quantidade>
						<Valor>2677415.59</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_22L1309906 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>62</Emissao>
						<Serie>1</Serie>
						<Quantidade>32755</Quantidade>
						<Valor>30599702.7</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_22L1311979 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>62</Emissao>
						<Serie>2</Serie>
						<Quantidade>27044</Quantidade>
						<Valor>25262413.2</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_22L1311979 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>62</Emissao>
						<Serie>2</Serie>
						<Quantidade>2956</Quantidade>
						<Valor>2761266.58</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24E3617804 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>334</Emissao>
						<Serie>2</Serie>
						<Quantidade>829</Quantidade>
						<Valor>976468.25</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24E3617804 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>334</Emissao>
						<Serie>2</Serie>
						<Quantidade>8743</Quantidade>
						<Valor>10298265.35</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24E3617804 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>334</Emissao>
						<Serie>2</Serie>
						<Quantidade>1</Quantidade>
						<Valor>1177.88</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24E3617804 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>334</Emissao>
						<Serie>2</Serie>
						<Quantidade>45740</Quantidade>
						<Valor>53876547.8</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24E3617804 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>334</Emissao>
						<Serie>2</Serie>
						<Quantidade>10612</Quantidade>
						<Valor>12499736.01</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24E3617804 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>334</Emissao>
						<Serie>2</Serie>
						<Quantidade>44984</Quantidade>
						<Valor>52986065.29</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24E3617804 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>334</Emissao>
						<Serie>2</Serie>
						<Quantidade>10612</Quantidade>
						<Valor>12499736.01</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24K0003803_DU2 - BARI SEC</Companhia>
						<CNPJ>10608405000241</CNPJ>
						<Emissao>37</Emissao>
						<Serie>1</Serie>
						<Quantidade>12182</Quantidade>
						<Valor>11141200.68</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24L1567349 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>368</Emissao>
						<Serie>1</Serie>
						<Quantidade>52757</Quantidade>
						<Valor>48837972.44</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24L1567349 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>368</Emissao>
						<Serie>1</Serie>
						<Quantidade>37567</Quantidade>
						<Valor>35126843.62</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_24L1567349 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>368</Emissao>
						<Serie>1</Serie>
						<Quantidade>5374</Quantidade>
						<Valor>5024932.99</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_25J3041088 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>481</Emissao>
						<Serie>3</Serie>
						<Quantidade>12913390</Quantidade>
						<Valor>13345416.24</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_25J3041088 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>481</Emissao>
						<Serie>3</Serie>
						<Quantidade>12913390</Quantidade>
						<Valor>13345416.24</Valor>
					</Emissor>
				</CriCra>
				<LciLca>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
					<Emissor>
						<Sociedade>RT12 EMPREENDIMENTOS IMOBILIAR LTDA</Sociedade>
						<CNPJ>55149209000103</CNPJ>
						<Quantidade>30000</Quantidade>
						<Valor>30000</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>SPE - CORPORATE GARDEN</Sociedade>
						<CNPJ>45448983000161</CNPJ>
						<Quantidade>90000000</Quantidade>
						<Valor>32831933.82</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR14 EMPREENDIMENTOS IMOBILIAR</Sociedade>
						<CNPJ>57745944000105</CNPJ>
						<Quantidade>64050000</Quantidade>
						<Valor>64050000</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR10 EMPREENDIMENTOS IMOBILIARIO</Sociedade>
						<CNPJ>17758161000141</CNPJ>
						<Quantidade>23057796</Quantidade>
						<Valor>31379143.38</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR13 EMPREENDIMENTOS IMOBILIAR LTDA</Sociedade>
						<CNPJ>55149172000113</CNPJ>
						<Quantidade>7548217</Quantidade>
						<Valor>8527843.7</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR2 EMPREEENDIMENTOS</Sociedade>
						<CNPJ>19973878000131</CNPJ>
						<Quantidade>241771960</Quantidade>
						<Valor>275072701</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR3 EMPREEENDIMENTOS IMOBILIARIOS LTDA</Sociedade>
						<CNPJ>22666654000191</CNPJ>
						<Quantidade>86152787</Quantidade>
						<Valor>56341252.5</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR4 EMPREENDIMENTOS IMOBILIARIOS</Sociedade>
						<CNPJ>46136601000127</CNPJ>
						<Quantidade>26789000</Quantidade>
						<Valor>29660829.58</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR5 EMPREENDIMENTOS IMOBILIARIOS</Sociedade>
						<CNPJ>46940669000164</CNPJ>
						<Quantidade>23711000</Quantidade>
						<Valor>30363511.52</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR6 EMPREENDIMENTOS IMOBILIARIOS LTDA</Sociedade>
						<CNPJ>47998005000119</CNPJ>
						<Quantidade>94101000</Quantidade>
						<Valor>120886638.63</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR7 EMPREENDIMENTOS IMOBILIARIOS LTDA</Sociedade>
						<CNPJ>48785843000177</CNPJ>
						<Quantidade>50000</Quantidade>
						<Valor>50000</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR8 EMPREENDIMENTOS IMOBILIARIOS LTDA</Sociedade>
						<CNPJ>49981879000199</CNPJ>
						<Quantidade>36824400</Quantidade>
						<Valor>63480626.97</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>TR9 EMPREENDIMENTOS IMOBILIARIOS LTDA</Sociedade>
						<CNPJ>50552230000131</CNPJ>
						<Quantidade>65627408</Quantidade>
						<Valor>83105987.6</Valor>
					</Emissor>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>FICFI ITAU SOBERANO RENDA FIXA SIMPLES LP</Fundo>
						<CNPJ>60175696000173</CNPJ>
						<Quantidade>4020316.50817</Quantidade>
						<Valor>328693691.13</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>7572323.64</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa>328693691.13</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
					<Imovel>
						<Nome>ALCÂNTARA - CEF</Nome>
						<Endereco>Dr. Alfredo Backer, 5</Endereco>
						<Area>1688.88</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ANHANGUERA</Nome>
						<Endereco>R. Luiz Otávio, 1313 - Parque Taquara</Endereco>
						<Area>22787.79</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ÂNIMA CANOAS</Nome>
						<Endereco>Rua Santos Dumont, 88</Endereco>
						<Area>11664</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ÂNIMA POA</Nome>
						<Endereco> Rua Orfanotrófio, 555, Alto - Teresópolis</Endereco>
						<Area>29592.24</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ASSAÍ SÃO BERNADO</Nome>
						<Endereco>Av. Piraporinha, 680,Planalto, São Bernardo do Campo</Endereco>
						<Area>43950</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ATACADÃO - ARAPIRACA</Nome>
						<Endereco>AL-220, 359 - Itapoá</Endereco>
						<Area>34842.89</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ATACADÃO - CAMARAGIBE</Nome>
						<Endereco>Av. Dr. Belmínio Correia, 4817</Endereco>
						<Area>40216</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ATACADÃO - DUQUE DE CAXIAS</Nome>
						<Endereco>Rod. Washington Luiz, 121</Endereco>
						<Area>31600.21</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ATACADÃO - MOSSORÓ</Nome>
						<Endereco>Av. João da Escóssia, 1724</Endereco>
						<Area>87176</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ATACADÃO - RESENDE</Nome>
						<Endereco>Av. Francisco Fortes Filho,</Endereco>
						<Area>47776.57</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ATACADÃO - SOBRAL</Nome>
						<Endereco>Av. Sen. Fernandes Távora, 605</Endereco>
						<Area>33460</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ATACADÃO - TANGARÁ DA SERRA</Nome>
						<Endereco>Av. Domingos Parente de Sá Barreto, 303</Endereco>
						<Area>51443.56</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>BARRA DA TIJUCA - CEF</Nome>
						<Endereco>Av. das Américas, 3959</Endereco>
						<Area>1174.08</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>CÂNDIDO BENÍCIO - LOJA A</Nome>
						<Endereco> R. Cândido Benício, 1671</Endereco>
						<Area>4920</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>CÂNDIDO BENÍCIO - LOJA B</Nome>
						<Endereco>MAT. 126.225</Endereco>
						<Area>4920</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>CIDADELA - CEF</Nome>
						<Endereco>Av. Antônio Carlos Magalhães,</Endereco>
						<Area>1219.44</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>CRUZEIRO DO SUL - GUARULHOS/SP</Nome>
						<Endereco>Av. Salgado Filho, 100 - Centro</Endereco>
						<Area>3390.7</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>ESCOLA ELEVA - RJ</Nome>
						<Endereco>Av. José Silva de Azevedo Neto, 309 - Barra da Tijuca</Endereco>
						<Area>17961.67</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>FONSECA - CEF</Nome>
						<Endereco>Alameda São Boaventura, 904</Endereco>
						<Area>935.55</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>FRANCISO MATARAZO - CEF</Nome>
						<Endereco>Av. Francisco Matarazzo, 342</Endereco>
						<Area>674.4</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>GRANDE CENTER</Nome>
						<Endereco>R. Oswaldo Cruz, 415</Endereco>
						<Area>2572.58</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>JUNDIAÍ - CEF</Nome>
						<Endereco>Rua Rangel Pestana, 278</Endereco>
						<Area>1150</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>LINK - CORPORATE GARDEN</Nome>
						<Endereco>Av. Brigadeiro Luís Antônio, 5083</Endereco>
						<Area>2220.78</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>MATEUS - CAMETÁ/PA</Nome>
						<Endereco>Rodovia BR 422, KM 01, Cametá - PA</Endereco>
						<Area>28000</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>MATEUS - CARPINA/PE</Nome>
						<Endereco>Av. Conselheiro João Alfredo, 262</Endereco>
						<Area>18242.09</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>MATEUS - ESTRADA DO ARROZ IMPERATRIZ/MA</Nome>
						<Endereco>Av. Newton Bello, 22</Endereco>
						<Area>29776.6</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>MATEUS - SALVADOR IGUATEMI/BA</Nome>
						<Endereco> Av. Antônio Carlos Magalhães, 3650</Endereco>
						<Area>70050</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>MEDICAL CENTER - EINSTEIN</Nome>
						<Endereco>Marginal Pinheiros, 14.500</Endereco>
						<Area>9185.27</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>PENHA - CEF</Nome>
						<Endereco> Av. Brás de Pina, 02</Endereco>
						<Area>1134.67</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>RIACHUELO - CEF</Nome>
						<Endereco>R. Riachuelo, 61</Endereco>
						<Area>1150</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>RIO SUL - CEF</Nome>
						<Endereco>Rua Lauro Müller, 116</Endereco>
						<Area>1170.07</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>RUA DAS FLORES - CEF</Nome>
						<Endereco>Praça Gen. Osório, 319</Endereco>
						<Area>1789.05</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>SÃO BENTO - CEF</Nome>
						<Endereco>R. São Bento, 397</Endereco>
						<Area>1539.8</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>SÃO JOÃO DO MERITI - CEF</Nome>
						<Endereco>Av. Getúlio de Moura, 60</Endereco>
						<Area>602.23</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>SHOPPING BARRA - CEF</Nome>
						<Endereco>R. Augusto Frederico Schmith, 139</Endereco>
						<Area>829</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>SHOPPING BARREIRO</Nome>
						<Endereco>Av. Afonso Vaz de Melo, 640</Endereco>
						<Area>59460</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>SHOPPING MARANHÃO</Nome>
						<Endereco>Av. Prof. Carlos Cunha, 100</Endereco>
						<Area>55312.91</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>SHOPPING PAMPULHA</Nome>
						<Endereco>Av. Pres. Antônio Carlos, 8100 - Pampulha, Belo Horizonte - MG</Endereco>
						<Area>23631.65</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>STRIP MALL BARRA - RJ</Nome>
						<Endereco>Av. José Silva de Azevedo Neto, 309 - Barra da Tijuca</Endereco>
						<Area>2333.33</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
					<Imovel>
						<Nome>VILA MADALENA - CEF</Nome>
						<Endereco>R. Fradique Coutinho, 1339</Endereco>
						<Area>800</Area>
						<NumUnidades xsi:nil="true"/>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido xsi:nil="true"/>
						<Categoria xsi:nil="true"/>
					</Imovel>
				</Aquisicoes>
				<Alienacoes>
					<Imovel>
						<Nome>EXTRA NS SABARA</Nome>
						<Endereco>Av. Nossa Sra. do Sabará, 3015</Endereco>
						<DataAlienacao>2025-12-16</DataAlienacao>
						<Area>2334</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>Direito de propriedade</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<PercentPL>0</PercentPL>
					</Imovel>
				</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="77618972.59" financeiro="64109705.13"/>
					<DespManutencaoConservacao contabil="-34274.51" financeiro="-41228.08"/>
					<ReceitasVenda contabil="525840.65" financeiro="3579261.81"/>
					<CustoPropriedadesVendidas contabil="0" financeiro="0"/>
					<AjusteValor contabil="61999290.87" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="0"/>
					<ResultadoLiquido contabil="140109829.6" financeiro="67647738.86"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="31652361.81" financeiro="31652361.81"/>
					<AjusteValor contabil="19227313.08" financeiro="-23239640.85"/>
					<ResultadoVenda contabil="4146891.03" financeiro="4146891.03"/>
					<OutrasRecOuDesp contabil="46741944.22" financeiro="46741944.22"/>
					<ResultadoLiquido contabil="101768510.14" financeiro="59301556.21"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="241878339.74" financeiro="126949295.07"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="7159617.36" financeiro="7159617.36"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes/>
				<ResultadoLiquido contabil="7159617.36" financeiro="7159617.36"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-7971487.48" financeiro="-7940699.14"/>
				<TaxaDesempenho contabil="-6613184.3"/>
				<ConsultoriaEspecializada contabil="-299787.11" financeiro="-302258.19"/>
				<EmpresaEspecializada/>
				<FormadorMercado/>
				<CustodiaTitulosValores contabil="-100484.33" financeiro="-68906.08"/>
				<AuditoriaIndependente contabil="-86108.08"/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-10191634.87" financeiro="-3118662.16"/>
				<ComissoesEmolumentos/>
				<HonorariosDespesasDefesas/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio contabil="165.27" financeiro="165.27"/>
				<OutrasRecOuDesp contabil="-57283629.03" financeiro="-19174413.66"/>
				<Total contabil="-82546149.93" financeiro="-30604773.96"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="166491807.17" financeiro="103504138.47"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>200084053.66</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>190079850.977</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte>0</ParcelaDistribuidaTriSeguinte>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil>7305524.26</LucroContabil>
			<ResultadoFinanceiroExcedeMinimo>10004202.68</ResultadoFinanceiroExcedeMinimo>
			<RendimentosDeclarados>207389577.917</RendimentosDeclarados>
			<RendimentosPagosAntec>-155825177.26</RendimentosPagosAntec>
			<RendimentoPagar>51564400.657</RendimentoPagar>
			<ResultadoLiquidoDeclarado>1.036512</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"