"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>Fundo de Investimento Imobiliário Brasil Varejo FII</NomeFundo>
		<CNPJFundo>21126204000143</CNPJFundo>
		<DataFuncionamento>2014-10-30</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRBVARCTF006</CodigoISIN>
		<QtdCotasEmitidas>625540</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>true</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Outros</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>Rio Bravo Investimentos DTVM Ltda.</NomeAdministrador>
		<CNPJAdministrador>21126204000143</CNPJAdministrador>
		<Logradouro>Av. Chedid Jafet</Logradouro>
		<Numero>222</Numero>
		<Complemento>3º Andar - Bloco B</Complemento>
		<Bairro>Vila Olímpia</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>04551065</CEP>
		<Telefone1>(11) 3509-6600</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.riobravo.com.br</Site>
		<Email>investimentosimobiliarios@riobravo.com.br</Email>
		<Competencia>03/2018</Competencia>
		<DataEncerTrimestre>2018-09-28</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Loja 536-B</Nome>
								<Endereco>Av. Paraná, 321,Belo Horizonte-MG</Endereco>
								<Area>4724</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.061725</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.061725</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 513</Nome>
								<Endereco>Av. Sete de Setembro, 740,Manaus-AM</Endereco>
								<Area>5284.81</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0366242693375315</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.036624</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 546</Nome>
								<Endereco>Rua Marechal Deodoro, 900,SBC-SP</Endereco>
								<Area>2587</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0284153832971494</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.028415</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 543</Nome>
								<Endereco>Rua Coronel Agostinho, 146,Rio de Janeiro-RJ</Endereco>
								<Area>2444</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0277864570678491</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.027786</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 536</Nome>
								<Endereco>Rua Carijós, 645,Belo Horizonte-MG</Endereco>
								<Area>2002</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0277860581068094</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.027786</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 596</Nome>
								<Endereco>Rua Dias da Cruz, 155,Rio de Janeiro-RJ</Endereco>
								<Area>4120.97</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0266043791069507</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.026604</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 574</Nome>
								<Endereco>Estrada da Portela, 92,Rio de Janeiro-RJ</Endereco>
								<Area>3107</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0258755118991507</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.025875</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 519</Nome>
								<Endereco>Av. Sete de Setembro, 941-A,Porto Velho-RO</Endereco>
								<Area>4061.35</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0257300558795397</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.02573</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 53</Nome>
								<Endereco>Rua Tiradentes, 268,Canoas-RS</Endereco>
								<Area>508</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0253192937328581</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.025319</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 11</Nome>
								<Endereco>Rua dos Andradas, 1.441,Porto Alegre-RS</Endereco>
								<Area>782</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0221008566792898</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.0221</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 518</Nome>
								<Endereco>Av. Presidente Kennedy, 09,Diadema-SP</Endereco>
								<Area>2662.45</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0215565434523071</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.021556</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 504</Nome>
								<Endereco>Rua Desembargador Westphalen, 130,Curitiba-PR</Endereco>
								<Area>4215</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0215266443339336</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.021526</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 506</Nome>
								<Endereco>Av. Nossa Senhora de Copacabana, 748,Rio de Janeiro-RJ</Endereco>
								<Area>2215</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0211536739016585</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.021153</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 659</Nome>
								<Endereco>Rua Conselheiro João Alfredo, 68 - Marisa,Belem-PA</Endereco>
								<Area>3685.17</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.020048650355088</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.020048</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Escritório Central</Nome>
								<Endereco>Rua James Holland, 422, São Paulo-SP</Endereco>
								<Area>7500</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Escritório</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.018343709514782</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.018343</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 512</Nome>
								<Endereco>Rua 13 de Junho, 264 - Marisa,Cuiaba-MT</Endereco>
								<Area>4067</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0183121346687658</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.018312</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 39</Nome>
								<Endereco>Rua Manoel Correa, 76,Duque de Caxias-RJ</Endereco>
								<Area>1546.7</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0173649579612336</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.017364</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 581</Nome>
								<Endereco>Rua Regente Feijó, 1.037,Campinas-SP</Endereco>
								<Area>1639.99</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0173649571255034</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.017364</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 528</Nome>
								<Endereco>Av. Rio Branco, 637,Natal-RN</Endereco>
								<Area>5010</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0169178874500075</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.016918</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 521</Nome>
								<Endereco>Rua dos Andradas, 1.307 /  1.315,Porto Alegre-RS</Endereco>
								<Area>2558</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0164307219818779</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.016431</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 561</Nome>
								<Endereco>Av. Sete de Setembro, 238,Salvador-BA</Endereco>
								<Area>2147</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0157351039333376</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.015735</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 659-B</Nome>
								<Endereco>Avenida Portugal, 213 e Av. 13 de Maio -Belem-PA</Endereco>
								<Area>2540.14</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0148659844329384</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.014866</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 514</Nome>
								<Endereco>Rua Candido Mendes, 1.280,Macapa-AP</Endereco>
								<Area>3604.95</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0145549933309319</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.014555</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 558</Nome>
								<Endereco>Av. Eduardo Ribeiro, 390,Manaus-AM</Endereco>
								<Area>1899.61</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0142708393129925</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.014271</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 517</Nome>
								<Endereco>Av. Getulio Vargas, 258,Rio Branco-AC</Endereco>
								<Area>2894.37</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.013765676377301</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.013766</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 104</Nome>
								<Endereco>Praça Antonio Menck,  103,Osasco-SP</Endereco>
								<Area>2229</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0137201299071063</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.01372</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja RS-10</Nome>
								<Endereco>Rua General Bacelar, 268,Rio Grande-RS</Endereco>
								<Area>922</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0130395059439159</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.01304</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 570</Nome>
								<Endereco>Rua Barão do Rio Branco, 118,Sorocaba-SP</Endereco>
								<Area>1478.88</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0128816419630805</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.012882</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 568</Nome>
								<Endereco>Rua Major Facundo, 532,Fortaleza-CE</Endereco>
								<Area>2357</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0126922057868238</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.012692</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 10</Nome>
								<Endereco>Rua Direita, 25, São Paulo-SP</Endereco>
								<Area>1383.1</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.012127369568767</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.012127</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 91</Nome>
								<Endereco>Rua Nova, 163,Recife-PE</Endereco>
								<Area>1280</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0119319349457159</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.011932</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 550</Nome>
								<Endereco>Rua D. Pedro II, 27, 31 e 35,Guarulhos-SP</Endereco>
								<Area>818</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0117361849311208</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.011736</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 130</Nome>
								<Endereco>Pça XV de Novembro, 111,Florianopolis-SC</Endereco>
								<Area>1145</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0115218313885895</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.011522</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 591</Nome>
								<Endereco>Rua Batista de Carvalho, 62-9,Bauru-SP</Endereco>
								<Area>1559</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0108925634045575</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.010892</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 552</Nome>
								<Endereco>Rua Voluntários da Pátria, 29,Porto Alegre-RS</Endereco>
								<Area>2069</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0108557860580547</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.010856</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 47</Nome>
								<Endereco>Rua Sete de Setembro, 142,SJC-SP</Endereco>
								<Area>749</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0107672538409357</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.010767</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 72</Nome>
								<Endereco>Pça Dom Epaminondas, 131,Taubate-SP</Endereco>
								<Area>1073.7</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0101979663037946</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.010198</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 87</Nome>
								<Endereco>Rua Senador Teodoro Pacheco, 1074,Teresina-PI</Endereco>
								<Area>1267</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0101714523879937</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.010171</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 120</Nome>
								<Endereco>Rua Grande, 517/523,Sao Luis-MA</Endereco>
								<Area>888</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00958450872456533</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.009585</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 113</Nome>
								<Endereco>Rua Teodoro Sampaio, 2.382, São Paulo-SP</Endereco>
								<Area>946.3</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00925078542251122</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.009251</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 564</Nome>
								<Endereco>R. Serra Dourada, 102, São Paulo-SP</Endereco>
								<Area>930</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00921921304961123</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.009219</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 592</Nome>
								<Endereco>Rua Oswaldo Cruz, 132,Sao Luis-MA</Endereco>
								<Area>1832</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00907587527965358</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.009076</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 80</Nome>
								<Endereco>Rua Maciel Pinheiro, 185,Campina Grande-PB</Endereco>
								<Area>1220</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00888548013865797</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.008885</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 54</Nome>
								<Endereco>Rua Barão de Jundiaí, 955,Jundiai-SP</Endereco>
								<Area>807.2</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00880567483829487</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.008805</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 529</Nome>
								<Endereco>Rua Independência, 906,São Leopoldo-RS</Endereco>
								<Area>1760</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00871405192513758</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.008714</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 60</Nome>
								<Endereco>Rua Imperatriz Tereza Cristina, 35,Recife-PE</Endereco>
								<Area>1241</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00860670482622169</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.008607</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 567</Nome>
								<Endereco>Av. Senhor dos Passos, 1.167,Feira de Santana-BA</Endereco>
								<Area>1670.26</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00852461642913036</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.008525</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 589</Nome>
								<Endereco>Rua do Comercio, 352,Maceio-AL</Endereco>
								<Area>953.45</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00842989632664193</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.00843</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 582</Nome>
								<Endereco>Rua Voluntários da Pátria, 167,Porto Alegre-RS</Endereco>
								<Area>1600</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00802292709314953</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.008023</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 69</Nome>
								<Endereco>Av. Julio de Castilhos, 2.050,Caxias do Sul-RS</Endereco>
								<Area>1131</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00795630792394766</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.007956</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 61</Nome>
								<Endereco>Rua Duque de Caxias, 222,Recife-PE</Endereco>
								<Area>1135.64</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00768686060181065</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.007687</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 22</Nome>
								<Endereco>Rua da Azenha, 795,Porto Alegre-RS</Endereco>
								<Area>755</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.0074328325180099</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.007433</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 51</Nome>
								<Endereco>Rua Marechal Deodoro, 1.315,SBC-SP</Endereco>
								<Area>689</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00732319791647635</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.007323</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 132</Nome>
								<Endereco>Av. Geronimo Monteiro, 299,Vitoria-ES</Endereco>
								<Area>810</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00700455092873463</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.007005</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 93</Nome>
								<Endereco>Av. Anhanguera, 5.520,Goiânia-GO</Endereco>
								<Area>1385</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00694598198202191</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.006946</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Escritório </Nome>
								<Endereco>Rua dos Americanos, 465, São Paulo-SP</Endereco>
								<Area>1007.52</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Escritório</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00666182935321821</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.006662</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 569</Nome>
								<Endereco>Pça Ramos de Azevedo, 229, São Paulo-SP</Endereco>
								<Area>503</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00663025715779693</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.00663</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja PA-1</Nome>
								<Endereco>Rua Conselheiro João Alfredo, 38,Belem-PA</Endereco>
								<Area>1770</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00645502861966627</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.006455</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 512-C</Nome>
								<Endereco>Rua Antônio João, 59 - Romero,Cuiaba-MT</Endereco>
								<Area>450</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00636503041425933</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.006365</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 66</Nome>
								<Endereco>Rua Riachuelo, 360 ,João Pessoa-PB</Endereco>
								<Area>1118</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00610266493039696</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.006102</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja PE-4</Nome>
								<Endereco>Rua Imperatriz Tereza Cristina, 57,Recife-PE</Endereco>
								<Area>5206</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00555678749482839</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.005557</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 98</Nome>
								<Endereco>Rua Marechal Deodoro, 102,Lages-SC</Endereco>
								<Area>932</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00439208797227864</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.004392</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 541</Nome>
								<Endereco>Rua Visconde de Pirajá, 138 -A,Rio de Janeiro-RJ</Endereco>
								<Area>994.76</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00430335241311085</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.004303</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 551</Nome>
								<Endereco>Rua Sete de Setembro, 12/34,Recife-PE</Endereco>
								<Area>2202</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00387789204976728</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.003878</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 555</Nome>
								<Endereco>Rua Dr. Deodato Wertheimer, 1.374,Mogi das Cruzes-SP</Endereco>
								<Area>331</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00346771949035884</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.003468</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja PE-6</Nome>
								<Endereco>Rua da Paz, 338,Recife-PE</Endereco>
								<Area>1576</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00341410904358489</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.003414</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja PE-7</Nome>
								<Endereco>Rua João de Barros, 1.812,Recife-PE</Endereco>
								<Area>1192</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00315726481079437</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.003157</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 659-C</Nome>
								<Endereco>Av. Portugal, 221/229 - Jander,Belem-PA</Endereco>
								<Area>1099.46</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00262053121799554</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.00262</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 659-F</Nome>
								<Endereco>Travessa 7 de Setembro, 126,Belem-PA</Endereco>
								<Area>333.08</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00179989121440347</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.001799</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 659-D</Nome>
								<Endereco>Travessa 7 de Setembro, 140,Belem-PA</Endereco>
								<Area>355</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00178170964241897</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.001781</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 659-G</Nome>
								<Endereco>Rua Treze de Maio, 53 - Altos, Belem-PA</Endereco>
								<Area>4198</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Estacionamento</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00170874618051115</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>serviço</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.001709</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 512-B</Nome>
								<Endereco>Rua Antônio João, 59 - Padilha,Cuiaba-MT</Endereco>
								<Area>27</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.00168433552078956</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.001684</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 512-D</Nome>
								<Endereco>Rua Antônio João, 59 - Neurivany,Cuiaba-MT</Endereco>
								<Area>27</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.000634374460580736</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.000634</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja RS-5</Nome>
								<Endereco>Rua Viagrio José Inacio, 285,Porto Alegre-RS</Endereco>
								<Area>2329</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.000631838273879487</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.000632</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Loja 515</Nome>
								<Endereco>Av. Adolfo Pinheiro, 62, São Paulo-SP</Endereco>
								<Area>3264</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Loja</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.056614</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.056614</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses percentReceitaImovel="0" percentReceitasFII="0"/>
							<TresAteSeisMeses percentReceitaImovel="0" percentReceitasFII="0"/>
							<SeisAteNoveMeses percentReceitaImovel="0.00349384095190196" percentReceitasFII="0.00346604516320854"/>
							<NoveAteDozeMeses percentReceitaImovel="0.00895673683519367" percentReceitasFII="0.00888548013865797"/>
							<DozeAteQuinzeMeses percentReceitaImovel="0.00181432535865461" percentReceitasFII="0.00179989121440347"/>
							<QuinzeAteDezoitoMeses percentReceitaImovel="0" percentReceitasFII="0"/>
							<DezoitoAteVinteUmMeses percentReceitaImovel="0" percentReceitasFII="0"/>
							<VinteUmAteVinteQuatroMeses percentReceitaImovel="0.00390899062549716" percentReceitasFII="0.00387789204976728"/>
							<VinteQuatroAteVinteSeteMeses percentReceitaImovel="0" percentReceitasFII="0"/>
							<VinteSeteAteTrintaMeses percentReceitaImovel="0.0158612908707274" percentReceitasFII="0.0157351039333376"/>
							<TrintaAteTrintaTresMeses percentReceitaImovel="0.011215820359286" percentReceitasFII="0.0111265911765551"/>
							<TrintaTresAteTrintaSeisMeses percentReceitaImovel="0" percentReceitasFII="0"/>
							<AcimaTrintaSeisMeses percentReceitaImovel="0.892579015292634" percentReceitasFII="0.88547796574779"/>
							<PrazoIndeterminado percentReceitaImovel="0.0621699791298423" percentReceitasFII="0.0616753763053986"/>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0.056701" percentReceitasFII="0.0562492"/>
							<INPC percentReceitaImovel="0.001796" percentReceitasFII="0.0017817"/>
							<IPCA percentReceitaImovel="0.941503" percentReceitasFII="0.934013"/>
							<INCC/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Contratos típicos de 5 anos, ajustado anualmente pelo IGP-M, INPC ou IPCA com garantia de fiadores.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>Loja 569</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 10</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Escritório Central</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Escritório </NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 113</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 515</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 564</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 51</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 546</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 518</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 104</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 550</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 555</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 591</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 581</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 54</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 570</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 47</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 72</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 506</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 541</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 574</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 596</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 543</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 39</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 536</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 536-B</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 132</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 504</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 130</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 98</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 521</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 11</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 552</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 582</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja RS-5</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 22</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 53</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 529</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 69</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja RS-10</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 589</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 561</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 567</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 528</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 568</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 120</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 592</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 66</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 80</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 91</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 61</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 60</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja PE-4</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 551</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja PE-6</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja PE-7</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 93</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 512</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 512-B</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 512-C</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 512-D</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 517</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 513</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 558</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 514</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja PA-1</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 659</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 659-B</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 659-C</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 659-D</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 659-F</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 659-G</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 519</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Loja 87</NomeOuEndereco>
								<CaractContratuais>Contratos típicos de 5 anos, ajustados anualmente pelo indíce IGP-M com garantia de Fiadores.</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>Contratos típicos de 5 anos, ajustado anualmente pelo IGP-M INPC ou IPCA com garantia de fiadores.</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
				</FII>
				<CRI>
				</CRI>
				<LCI>
				</LCI>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>ITAÚ TOP REFERENCIADO DI FICFI</Fundo>
						<CNPJ>5902521000158</CNPJ>
						<Quantidade>1298477.69594</Quantidade>
						<Valor>5775367.78</Valor>
					</Emissor>
					<Emissor>
						<Fundo>ITAÚ SOBERANO RF SIMPLES LP FICFI</Fundo>
						<CNPJ>6175696000173</CNPJ>
						<Quantidade>16370.92043</Quantidade>
						<Valor>726051.29</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>7441.07</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa>6501419.07</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda/>
					<CustoImovEstoque/>
					<AjusteValor/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="12132223.94" financeiro="11846660.33"/>
					<DespManutencaoConservacao/>
					<ReceitasVenda financeiro="593680"/>
					<CustoPropriedadesVendidas/>
					<AjusteValor/>
					<OutrasRecOuDesp contabil="-231101.82" financeiro="-231101.82"/>
					<ResultadoLiquido contabil="11901122.12" financeiro="12209238.51"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros/>
					<AjusteValor/>
					<ResultadoVenda/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="11901122.12" financeiro="12209238.51"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="100397.78" financeiro="100397.78"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes/>
				<ResultadoLiquido contabil="100397.78" financeiro="100397.78"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos contabil="0" financeiro="0"/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-139589.23" financeiro="-139981.24"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada/>
				<EmpresaEspecializada contabil="-176443.14" financeiro="-176443.14"/>
				<FormadorMercado/>
				<CustodiaTitulosValores/>
				<AuditoriaIndependente contabil="-11427.51"/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-14438.28" financeiro="-14438.28"/>
				<ComissoesEmolumentos/>
				<HonorariosDespesasDefesas contabil="-165026.88" financeiro="-165026.88"/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio contabil="-45929.17" financeiro="-45929.17"/>
				<OutrasRecOuDesp contabil="-7816.01" financeiro="-5121.67"/>
				<Total contabil="-560670.22" financeiro="-546940.38"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="11440849.68" financeiro="11762695.91"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>11762695.91</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>11174561.1145</PercentResultFinanLiqAcumulado>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil>1730329.09</LucroContabil>
			<RendimentosDeclarados>12904890.2045</RendimentosDeclarados>
			<RendimentosPagosAntec>-12904890.2</RendimentosPagosAntec>
			<RendimentoPagar>0.0045</RendimentoPagar>
			<ResultadoLiquidoDeclarado>1.097103</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"