"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>VINCI SHOPPING CENTERS FUNDO DE INVESTIMENTO IMOBILIÁRIO-FII</NomeFundo>
		<CNPJFundo>17554274000125</CNPJFundo>
		<DataFuncionamento>2013-08-07</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRVISCCTF005</CodigoISIN>
		<QtdCotasEmitidas>28828640</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BRL TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>17554274000125</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>01/2026</Competencia>
		<DataEncerTrimestre>2026-03-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>West Shopping</Nome>
								<Endereco>Estrada do Mendanha, 450 / 550 e 555 – Rio de Janeiro – RJ</Endereco>
								<Area>44233.67</Area>
								<NumUnidades>171</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 110,075 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0252</PercentVacancia>
								<PercentInadimplencia>0.0596</PercentInadimplencia>
								<PercentReceitasFII>0.0005</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Loja de Departamento</SetorAtuacao><PercentReceitaImovel>0.266</PercentReceitaImovel><PercentReceitasFII>0.002433</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Semi-âncoras</SetorAtuacao><PercentReceitaImovel>0.139</PercentReceitaImovel><PercentReceitasFII>0.001271</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.118</PercentReceitaImovel><PercentReceitasFII>0.001079</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Quiosques</SetorAtuacao><PercentReceitaImovel>0.114</PercentReceitaImovel><PercentReceitasFII>0.001043</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Paralela</Nome>
								<Endereco>Avenida Luiz Viana, 8544 - Salvador - BA</Endereco>
								<Area>40166.56</Area>
								<NumUnidades>275</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 40.167 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0301</PercentVacancia>
								<PercentInadimplencia>0.0267</PercentInadimplencia>
								<PercentReceitasFII>0.0017</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Conveniência</SetorAtuacao><PercentReceitaImovel>0.188134</PercentReceitaImovel><PercentReceitasFII>0.012084</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.186639</PercentReceitaImovel><PercentReceitasFII>0.011988</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.150133</PercentReceitaImovel><PercentReceitasFII>0.009643</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Center Shopping Rio</Nome>
								<Endereco>Avenida Geremario Dantas, 404 - Rio de Janeiro - RJ</Endereco>
								<Area>15143.73</Area>
								<NumUnidades>102</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 44.000 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0846</PercentVacancia>
								<PercentInadimplencia>0.1021</PercentInadimplencia>
								<PercentReceitasFII>0.0001</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Quiosques/Eventos</SetorAtuacao><PercentReceitaImovel>0.1861</PercentReceitaImovel><PercentReceitasFII>0.000203</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Âncora</SetorAtuacao><PercentReceitaImovel>0.1721</PercentReceitaImovel><PercentReceitasFII>0.000188</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Conveniência</SetorAtuacao><PercentReceitaImovel>0.1305</PercentReceitaImovel><PercentReceitasFII>0.000142</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentações</SetorAtuacao><PercentReceitaImovel>0.1143</PercentReceitaImovel><PercentReceitasFII>0.000125</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Crystal</Nome>
								<Endereco>Rua Comendador Araujo, 731 - Curitiba - PR</Endereco>
								<Area>15139.519994812</Area>
								<NumUnidades>96</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 15.140 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.2543</PercentVacancia>
								<PercentInadimplencia>0.1483</PercentInadimplencia>
								<PercentReceitasFII>0.0001</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.196298</PercentReceitaImovel><PercentReceitasFII>0.000159</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Outros</SetorAtuacao><PercentReceitaImovel>0.145701</PercentReceitaImovel><PercentReceitasFII>0.000118</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.137314</PercentReceitaImovel><PercentReceitasFII>0.000111</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Relojoarias, Joalherias e Bijuterias</SetorAtuacao><PercentReceitaImovel>0.125782</PercentReceitaImovel><PercentReceitasFII>0.000102</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.123294</PercentReceitaImovel><PercentReceitasFII>0.0001</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Ilha Plaza</Nome>
								<Endereco>Av. Maestro Paulo e Silva, 400 - Rio de Janeiro - RJ</Endereco>
								<Area>21933.04</Area>
								<NumUnidades>127</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 21.933 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0486</PercentVacancia>
								<PercentInadimplencia>0.0964</PercentInadimplencia>
								<PercentReceitasFII>0.0022</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.294</PercentReceitaImovel><PercentReceitasFII>0.006575</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.179</PercentReceitaImovel><PercentReceitasFII>0.004003</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pátio Belém</Nome>
								<Endereco>Trav. Padre Eutíquio, 1078 – Belém - PA</Endereco>
								<Area>21727.43</Area>
								<NumUnidades>189</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 21.727,43 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0372</PercentVacancia>
								<PercentInadimplencia>0.0121</PercentInadimplencia>
								<PercentReceitasFII>0.0003</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.195242</PercentReceitaImovel><PercentReceitasFII>0.004237</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Loja de Departamento</SetorAtuacao><PercentReceitaImovel>0.158005</PercentReceitaImovel><PercentReceitasFII>0.003429</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Outros</SetorAtuacao><PercentReceitaImovel>0.121466</PercentReceitaImovel><PercentReceitasFII>0.002636</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.114242</PercentReceitaImovel><PercentReceitasFII>0.002479</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Conveniência</SetorAtuacao><PercentReceitaImovel>0.109634</PercentReceitaImovel><PercentReceitasFII>0.002379</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Granja Vianna</Nome>
								<Endereco>Rodovia Raposo Tavares, 23.500 - Lageadinho, Cotia-SP </Endereco>
								<Area>30376.63</Area>
								<NumUnidades>161</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 30.377 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.063</PercentVacancia>
								<PercentInadimplencia>0.0301</PercentInadimplencia>
								<PercentReceitasFII>0.0016</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.282113</PercentReceitaImovel><PercentReceitasFII>0.014535</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Loja de Departamento</SetorAtuacao><PercentReceitaImovel>0.123876</PercentReceitaImovel><PercentReceitasFII>0.006382</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.107293</PercentReceitaImovel><PercentReceitasFII>0.005528</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Tacaruna</Nome>
								<Endereco>Avenida Governador Agamenon Magalhães, 153 - Sto Amaro, Recife - PE</Endereco>
								<Area>49897.569749527</Area>
								<NumUnidades>259</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 100.096 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0659</PercentVacancia>
								<PercentInadimplencia>0.0496</PercentInadimplencia>
								<PercentReceitasFII>0.0007</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.208397</PercentReceitaImovel><PercentReceitasFII>0.003075</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.1441</PercentReceitaImovel><PercentReceitasFII>0.002126</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Calçados</SetorAtuacao><PercentReceitaImovel>0.104797</PercentReceitaImovel><PercentReceitasFII>0.001546</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Iguatemi Fortaleza</Nome>
								<Endereco>Av. Washington Soares, 85 - Edson Queiroz, Fortaleza - CE</Endereco>
								<Area>89832.9699992371</Area>
								<NumUnidades>432</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 89.832,97 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0873</PercentVacancia>
								<PercentInadimplencia>-0.0203</PercentInadimplencia>
								<PercentReceitasFII>-0.000633250574723758</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.287759</PercentReceitaImovel><PercentReceitasFII>0.008976</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos Diversos</SetorAtuacao><PercentReceitaImovel>0.218712</PercentReceitaImovel><PercentReceitasFII>0.006822</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Ancoras</SetorAtuacao><PercentReceitaImovel>0.184281</PercentReceitaImovel><PercentReceitasFII>0.005748</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.112791</PercentReceitaImovel><PercentReceitasFII>0.003518</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Minas Shopping</Nome>
								<Endereco>Av. Cristiano Machado, 4000 - União - Belo horizonte - MG</Endereco>
								<Area>45860.92</Area>
								<NumUnidades>239</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 45.861 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0579</PercentVacancia>
								<PercentInadimplencia>0.0471</PercentInadimplencia>
								<PercentReceitasFII>0.0009</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.144535</PercentReceitaImovel><PercentReceitasFII>0.00282</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.117652</PercentReceitaImovel><PercentReceitasFII>0.002295</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.103998</PercentReceitaImovel><PercentReceitasFII>0.002029</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Prudenshopping</Nome>
								<Endereco>Av. Manoel Goulart, 2400 - Jardim das Rosas - Presidente Prudente - SP</Endereco>
								<Area>31108.36</Area>
								<NumUnidades>170</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 31.108 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0553</PercentVacancia>
								<PercentInadimplencia>-0.0123</PercentInadimplencia>
								<PercentReceitasFII>-0.0014</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.224153</PercentReceitaImovel><PercentReceitasFII>0.026461</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.184133</PercentReceitaImovel><PercentReceitasFII>0.021737</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Calçados</SetorAtuacao><PercentReceitaImovel>0.117736</PercentReceitaImovel><PercentReceitasFII>0.013899</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Villa Romana</Nome>
								<Endereco>Av. Madre Benvenuta, 687 - Santa Mônica, Trindade - Florianópolis - SC</Endereco>
								<Area>22438.81</Area>
								<NumUnidades>160</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 28.840 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0152</PercentVacancia>
								<PercentInadimplencia>-0.0305</PercentInadimplencia>
								<PercentReceitasFII>-0.0012</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.250675</PercentReceitaImovel><PercentReceitasFII>0.00985</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.178964</PercentReceitaImovel><PercentReceitasFII>0.007033</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>0,0000%</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping ABC</Nome>
								<Endereco>Av. Pereira Barreto, 42 - Santo André - SP</Endereco>
								<Area>48017.36</Area>
								<NumUnidades>270</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 48.017 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0307</PercentVacancia>
								<PercentInadimplencia>0.0147</PercentInadimplencia>
								<PercentReceitasFII>0.0002</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.1742</PercentReceitaImovel><PercentReceitasFII>0.002416</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.1706</PercentReceitaImovel><PercentReceitasFII>0.002366</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Conveniência e Serviço</SetorAtuacao><PercentReceitaImovel>0.1612</PercentReceitaImovel><PercentReceitasFII>0.002235</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Semi Âncora</SetorAtuacao><PercentReceitaImovel>0.1014</PercentReceitaImovel><PercentReceitasFII>0.001406</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Ribeirão</Nome>
								<Endereco>Avenida Coronel Fernando Ferreira Leite nº 1.540 - Ribeirão Preto/SP</Endereco>
								<Area>74988</Area>
								<NumUnidades>340</NumUnidades>
								<OutrasCaractRelevantes>74.998 m² de ABL</OutrasCaractRelevantes>
								<PercentVacancia>0.0885</PercentVacancia>
								<PercentInadimplencia>0.0186</PercentInadimplencia>
								<PercentReceitasFII>0.0008</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.350232</PercentReceitaImovel><PercentReceitasFII>0.015915</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos Diversos</SetorAtuacao><PercentReceitaImovel>0.227994</PercentReceitaImovel><PercentReceitasFII>0.01036</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Lazer</SetorAtuacao><PercentReceitaImovel>0.184539</PercentReceitaImovel><PercentReceitasFII>0.008386</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos para o Lar</SetorAtuacao><PercentReceitaImovel>0.119138</PercentReceitaImovel><PercentReceitasFII>0.005414</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Praia da Costa</Nome>
								<Endereco>Avenida Doutor Olivio Lira, 353 - Praia da Costa, Vila Velha/ES</Endereco>
								<Area>39765</Area>
								<NumUnidades>200</NumUnidades>
								<OutrasCaractRelevantes> Aréa total construida 39.765 m² </OutrasCaractRelevantes>
								<PercentVacancia>0.0777</PercentVacancia>
								<PercentInadimplencia>0.0737</PercentInadimplencia>
								<PercentReceitasFII>0.0058</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Loja de Departamento</SetorAtuacao><PercentReceitaImovel>0.278577</PercentReceitaImovel><PercentReceitasFII>0.022</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Outros</SetorAtuacao><PercentReceitaImovel>0.130806</PercentReceitaImovel><PercentReceitasFII>0.01033</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.110462</PercentReceitaImovel><PercentReceitasFII>0.008723</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Entretenimento</SetorAtuacao><PercentReceitaImovel>0.106558</PercentReceitaImovel><PercentReceitasFII>0.008415</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Boulevard</Nome>
								<Endereco>Rua Barão de São Francisco, 236 - Rio de Janeiro/RJ</Endereco>
								<Area>28948.08</Area>
								<NumUnidades>180</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 28.948 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0921</PercentVacancia>
								<PercentInadimplencia>0.0404</PercentInadimplencia>
								<PercentReceitasFII>0.0009</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.278577</PercentReceitaImovel><PercentReceitasFII>0.005928</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos Diversos</SetorAtuacao><PercentReceitaImovel>0.130806</PercentReceitaImovel><PercentReceitasFII>0.002783</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Lazer</SetorAtuacao><PercentReceitaImovel>0.110462</PercentReceitaImovel><PercentReceitasFII>0.00235</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos para o Lar</SetorAtuacao><PercentReceitaImovel>0.106558</PercentReceitaImovel><PercentReceitasFII>0.002267</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>North Shopping Maracanaú</Nome>
								<Endereco>Av. Carlos Jereissati, 100 - Maracanaú/CE</Endereco>
								<Area>20001.81</Area>
								<NumUnidades>114</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 20.001 m² </OutrasCaractRelevantes>
								<PercentVacancia>0.0531</PercentVacancia>
								<PercentInadimplencia>0.0291</PercentInadimplencia>
								<PercentReceitasFII>0.0011</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.196298</PercentReceitaImovel><PercentReceitasFII>0.007475</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Outros</SetorAtuacao><PercentReceitaImovel>0.271483</PercentReceitaImovel><PercentReceitasFII>0.010338</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.137314</PercentReceitaImovel><PercentReceitasFII>0.005229</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.123294</PercentReceitaImovel><PercentReceitasFII>0.004695</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pantanal Shopping</Nome>
								<Endereco>Av. Historiador Rubens de Mendonça (Av. CPA), 3300 - Cuiabá/MT</Endereco>
								<Area>45222.15</Area>
								<NumUnidades>219</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 45.222 m² </OutrasCaractRelevantes>
								<PercentVacancia>0.0241</PercentVacancia>
								<PercentInadimplencia>0.0309</PercentInadimplencia>
								<PercentReceitasFII>0.0015</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.38486</PercentReceitaImovel><PercentReceitasFII>0.01824</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos Diversos</SetorAtuacao><PercentReceitaImovel>0.1956</PercentReceitaImovel><PercentReceitasFII>0.00927</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Lazer</SetorAtuacao><PercentReceitaImovel>0.165</PercentReceitaImovel><PercentReceitasFII>0.00782</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Porto Velho Shopping</Nome>
								<Endereco>Av. Prefeito Chiquilito Erse, 3288 - Porto Velho/RO</Endereco>
								<Area>44824.38</Area>
								<NumUnidades>218</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 44.824 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0653</PercentVacancia>
								<PercentInadimplencia>0.0122</PercentInadimplencia>
								<PercentReceitasFII>0.0009</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.29642</PercentReceitaImovel><PercentReceitasFII>0.020587</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos Diversos</SetorAtuacao><PercentReceitaImovel>0.26565</PercentReceitaImovel><PercentReceitasFII>0.01845</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Lazer</SetorAtuacao><PercentReceitaImovel>0.15218</PercentReceitaImovel><PercentReceitasFII>0.010569</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Campinas Shopping </Nome>
								<Endereco>Rua Jacy Teixeireira de Camargo, 940 - Campinas/SP</Endereco>
								<Area>36165</Area>
								<NumUnidades>265</NumUnidades>
								<OutrasCaractRelevantes>Aréa total construida 36.165m² </OutrasCaractRelevantes>
								<PercentVacancia>0.0333</PercentVacancia>
								<PercentInadimplencia>0.0338</PercentInadimplencia>
								<PercentReceitasFII>0.0023</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.232674</PercentReceitaImovel><PercentReceitasFII>0.016045</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.137633</PercentReceitaImovel><PercentReceitasFII>0.009491</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Restaurantes</SetorAtuacao><PercentReceitaImovel>0.116239</PercentReceitaImovel><PercentReceitasFII>0.008016</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Lojas de Departamento</SetorAtuacao><PercentReceitaImovel>0.115774</PercentReceitaImovel><PercentReceitasFII>0.007984</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Conjunto Nacional</Nome>
								<Endereco>SDN, CNB - Asa Norte, Brasilia - DF</Endereco>
								<Area>43271</Area>
								<NumUnidades>254</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 43.271 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0387</PercentVacancia>
								<PercentInadimplencia>0.0125</PercentInadimplencia>
								<PercentReceitasFII>0.0002</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.275244</PercentReceitaImovel><PercentReceitasFII>0.004416</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Loja de Departamento</SetorAtuacao><PercentReceitaImovel>0.138799</PercentReceitaImovel><PercentReceitasFII>0.002227</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Via Sul Shopping </Nome>
								<Endereco>Av. Washington Soares, 4335 - Lagoa Sapiranga - Fortaleza - CE</Endereco>
								<Area>25847</Area>
								<NumUnidades>124</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 48.950 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0627</PercentVacancia>
								<PercentInadimplencia>0.0019</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.21701</PercentReceitaImovel><PercentReceitasFII>0.002405</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Telefonia</SetorAtuacao><PercentReceitaImovel>0.148127</PercentReceitaImovel><PercentReceitasFII>0.001642</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Loja de Departamento</SetorAtuacao><PercentReceitaImovel>0.137491</PercentReceitaImovel><PercentReceitasFII>0.001524</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.104003</PercentReceitaImovel><PercentReceitasFII>0.001153</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Natal Shopping</Nome>
								<Endereco>Avenida Senador Salgado Filho, 2234 - Natal, RN</Endereco>
								<Area>28363</Area>
								<NumUnidades>173</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 85.031 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0425</PercentVacancia>
								<PercentInadimplencia>0.0331</PercentInadimplencia>
								<PercentReceitasFII>0.001</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.321441</PercentReceitaImovel><PercentReceitasFII>0.009339</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.140537</PercentReceitaImovel><PercentReceitasFII>0.004083</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.112961</PercentReceitaImovel><PercentReceitasFII>0.003282</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Estação Curitiba</Nome>
								<Endereco>Avenida Sete de Setembro nº 2.775 - Curitiba - PR</Endereco>
								<Area>27663.17</Area>
								<NumUnidades>113</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 49.869 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0515</PercentVacancia>
								<PercentInadimplencia>0.0569</PercentInadimplencia>
								<PercentReceitasFII>0.0028</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Outros</SetorAtuacao><PercentReceitaImovel>0.320202</PercentReceitaImovel><PercentReceitasFII>0.015619</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.22813</PercentReceitaImovel><PercentReceitasFII>0.011128</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Madureira</Nome>
								<Endereco>Estr. do Portela, 222 - Madureira, Rio de Janeiro – RJ</Endereco>
								<Area>37000</Area>
								<NumUnidades>170</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 37.000 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0778</PercentVacancia>
								<PercentInadimplencia>0.0759</PercentInadimplencia>
								<PercentReceitasFII>0.0011</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.194042</PercentReceitaImovel><PercentReceitasFII>0.002871</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Eletrodomésticos &amp; Eletroeletrônicos</SetorAtuacao><PercentReceitaImovel>0.166725</PercentReceitaImovel><PercentReceitasFII>0.002467</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.154418</PercentReceitaImovel><PercentReceitasFII>0.002284</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Plaza Sul</Nome>
								<Endereco>Praça Leonor Kaupa, 100 - Jardim da Saúde, São Paulo - SP</Endereco>
								<Area>23500</Area>
								<NumUnidades>207</NumUnidades>
								<OutrasCaractRelevantes>Área total contruida 26.870 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.034</PercentVacancia>
								<PercentInadimplencia>0.0465</PercentInadimplencia>
								<PercentReceitasFII>0.0003</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.301311</PercentReceitaImovel><PercentReceitasFII>0.002254</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Acessórios</SetorAtuacao><PercentReceitaImovel>0.144293</PercentReceitaImovel><PercentReceitasFII>0.001079</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.112825</PercentReceitaImovel><PercentReceitasFII>0.000844</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Carioca Shopping </Nome>
								<Endereco>Av Vicente de Carvalho, 909 - Vila da Penha - RJ</Endereco>
								<Area>33918</Area>
								<NumUnidades>212</NumUnidades>
								<OutrasCaractRelevantes>Área total construida 33.918 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0567</PercentVacancia>
								<PercentInadimplencia>0.061</PercentInadimplencia>
								<PercentReceitasFII>0.0013</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.269373</PercentReceitaImovel><PercentReceitasFII>0.005955</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.126791</PercentReceitaImovel><PercentReceitasFII>0.002803</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.125837</PercentReceitaImovel><PercentReceitasFII>0.002782</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Villagio Caxias</Nome>
								<Endereco>Rodovia RSC 453, 2780 - Desvio Rizzo, Caixas do Sul - RS </Endereco>
								<Area>29685</Area>
								<NumUnidades>132</NumUnidades>
								<OutrasCaractRelevantes>Área total contruida 29.685 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0288</PercentVacancia>
								<PercentInadimplencia>0.0097</PercentInadimplencia>
								<PercentReceitasFII>0.0001</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.354177</PercentReceitaImovel><PercentReceitasFII>0.003008</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Eletrodomésticos &amp; Eletroeletrônicos</SetorAtuacao><PercentReceitaImovel>0.096106</PercentReceitaImovel><PercentReceitasFII>0.000816</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Acessórios</SetorAtuacao><PercentReceitaImovel>0.091052</PercentReceitaImovel><PercentReceitasFII>0.000773</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Bangu </Nome>
								<Endereco>Rua Fonseca, 240 - Bangu, Rio de Janeiro - RJ</Endereco>
								<Area>57982</Area>
								<NumUnidades>200</NumUnidades>
								<OutrasCaractRelevantes>Área total contruida 57.982 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0158</PercentVacancia>
								<PercentInadimplencia>0.1015</PercentInadimplencia>
								<PercentReceitasFII>0.0018</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.26321</PercentReceitaImovel><PercentReceitasFII>0.004555</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.14686</PercentReceitaImovel><PercentReceitasFII>0.002542</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Eletrodomésticos &amp; Eletroeletrônicos</SetorAtuacao><PercentReceitaImovel>0.116088</PercentReceitaImovel><PercentReceitasFII>0.002009</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.107719</PercentReceitaImovel><PercentReceitasFII>0.001864</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>São Luís Shopping</Nome>
								<Endereco>Av. Prof. Carlos Cunha, 1000 - Jaracaty, São Luís - MA</Endereco>
								<Area>56226.42</Area>
								<NumUnidades>238</NumUnidades>
								<OutrasCaractRelevantes>Área total contruida 56.226,42 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.1627</PercentVacancia>
								<PercentInadimplencia>0.0313</PercentInadimplencia>
								<PercentReceitasFII>0.0002</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.195407</PercentReceitaImovel><PercentReceitasFII>0.001056</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos diversos</SetorAtuacao><PercentReceitaImovel>0.107938</PercentReceitaImovel><PercentReceitasFII>0.000583</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.09335</PercentReceitaImovel><PercentReceitasFII>0.000505</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Calçados</SetorAtuacao><PercentReceitaImovel>0.08491</PercentReceitaImovel><PercentReceitasFII>0.000459</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>TERRENOS MIDWAY MALL</Nome>
								<Endereco>Av. Nevaldo Rocha, 3775 - Tirol, Natal - RN, 59015-450</Endereco>
								<Area>67796</Area>
								<NumUnidades>300</NumUnidades>
								<OutrasCaractRelevantes>Área total contruida 67.796 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.0081</PercentVacancia>
								<PercentInadimplencia>0.0333</PercentInadimplencia>
								<PercentReceitasFII>0.0009</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Artigos Diversos</SetorAtuacao><PercentReceitaImovel>0.421301</PercentReceitaImovel><PercentReceitasFII>0.011333</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.129432</PercentReceitaImovel><PercentReceitasFII>0.003482</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.271547</PercentReceitaImovel><PercentReceitasFII>0.007305</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.17772</PercentReceitaImovel><PercentReceitasFII>0.004781</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>BH SHOPPING</Nome>
								<Endereco>BR-356, nº 3049, no bairro Belvedere, região sul de Belo Horizonte</Endereco>
								<Area>47474</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Área total contruida 47.474 m²</OutrasCaractRelevantes>
								<PercentVacancia>0.024</PercentVacancia>
								<PercentInadimplencia>0.013</PercentInadimplencia>
								<PercentReceitasFII>0.0002</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Artigos Diversos</SetorAtuacao><PercentReceitaImovel>0.27823</PercentReceitaImovel><PercentReceitasFII>0.004297</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.099878</PercentReceitaImovel><PercentReceitasFII>0.001542</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.455242</PercentReceitaImovel><PercentReceitasFII>0.00703</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.166649</PercentReceitaImovel><PercentReceitasFII>0.002574</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses percentReceitaImovel="0.042213" percentReceitasFII="0.042213">Até 3 meses</AteTresMeses>
							<TresAteSeisMeses percentReceitaImovel="0.023835" percentReceitasFII="0.023835">De 3 meses e 1 dia a 6 meses</TresAteSeisMeses>
							<SeisAteNoveMeses percentReceitaImovel="0.022122" percentReceitasFII="0.022122">De 6 meses e 1 dia a 9 meses</SeisAteNoveMeses>
							<NoveAteDozeMeses percentReceitaImovel="0.040382" percentReceitasFII="0.040382">De 9 meses e 1 dia a 12 meses</NoveAteDozeMeses>
							<DozeAteQuinzeMeses percentReceitaImovel="0.023193" percentReceitasFII="0.023193">De 12 meses e 1 dia a 15 meses</DozeAteQuinzeMeses>
							<QuinzeAteDezoitoMeses percentReceitaImovel="0.028516" percentReceitasFII="0.028516">De 15 meses e 1 dia a 18 meses</QuinzeAteDezoitoMeses>
							<DezoitoAteVinteUmMeses percentReceitaImovel="0.028347" percentReceitasFII="0.028347">De 18 meses e 1 dia a 21 meses</DezoitoAteVinteUmMeses>
							<VinteUmAteVinteQuatroMeses percentReceitaImovel="0.034702" percentReceitasFII="0.034702">De 21 meses e 1 dia a 24 meses</VinteUmAteVinteQuatroMeses>
							<VinteQuatroAteVinteSeteMeses percentReceitaImovel="0.029318" percentReceitasFII="0.029318">De 24 meses e 1 dia a 27 meses</VinteQuatroAteVinteSeteMeses>
							<VinteSeteAteTrintaMeses percentReceitaImovel="0.029476" percentReceitasFII="0.029476">De 27 meses e 1 dia a 30 meses</VinteSeteAteTrintaMeses>
							<TrintaAteTrintaTresMeses percentReceitaImovel="0.025039" percentReceitasFII="0.025039">De 30 meses e 1 dia a 33 meses</TrintaAteTrintaTresMeses>
							<TrintaTresAteTrintaSeisMeses percentReceitaImovel="0.062821" percentReceitasFII="0.062821">De 33 meses e 1 dia a 36 meses</TrintaTresAteTrintaSeisMeses>
							<AcimaTrintaSeisMeses percentReceitaImovel="0.386716" percentReceitasFII="0.386716">Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado percentReceitaImovel="0.22332" percentReceitasFII="0.22332">Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0.603615" percentReceitasFII="0.603615"/>
							<INPC percentReceitaImovel="0.007246" percentReceitasFII="0.007246"/>
							<IPCA percentReceitaImovel="0.018984" percentReceitasFII="0.018984"/>
							<INCC/>
							<OutrosIndicadores>
								<Indicador nome="IGPM-DI" percentReceitaImovel="0.359873" percentReceitasFII="0.359873"/>
								<Indicador nome="MÉDIA (IGP-DI | IPCA) " percentReceitaImovel="0.003934" percentReceitasFII="0.003934"/>
								<Indicador nome="MÉDIA (IGP-DI | IPCA e IPC)" percentReceitaImovel="0.001556" percentReceitasFII="0.001556"/>
								<Indicador nome="IPC" percentReceitaImovel="0.004792" percentReceitasFII="0.004792"/>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Principais características contratuais comuns (Cláusulas de reajuste, indexadores, cláusulas de rescisão, garantias exigidas, entre outras informações relevantes): Contratos negociados e firmados pelos administradores das propriedades. Em geral, locatários possuem contratos padrão com 5 anos de duração que prevêm aluguel mínimo e percentual mensal sobre vendas informadas para os empreendedores além de valores referentes ao condomínio e fundo de promoção das propriedades. Valores são reajustados anualmente conforme indexadores pactuados, em sua maioria IGP. Em relação às garantias, previamente a assinatura dos contratos, é realizada uma avaliação da qualidade do crédito do lojista, podendo ser exigidos ou não fiadores nos contratos.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>West Shopping</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Crystal</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Center Shopping Rio</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Paralela</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Ilha Plaza</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Pátio Belém</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Granja Vianna</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Tacaruna</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Shopping Iguatemi Fortaleza</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Minas Shopping</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>TERRENOS MIDWAY MALL</NomeOuEndereco>
								<CaractContratuais>Conforme item 1.1.2.1.4 deste informe.</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>Política de contratação de seguros para preservação dos imóveis dessa categoria: Em geral, são realizados dois seguros relacionados a Responsabilidade Civil e Riscos Nomeados, adequados a cobertura dos ativos e possíveis contingências que possam ocorrer no exercício. As apólices padrão têm prazo de 1 ano e são renovadas antes de seus vencimentos. No caso dos imóveis West Shopping, Shopping Crystal, Center Shopping Rio e Pátio Belém, os contratos são negociados individualmente através da administração do próprio imóvel. Já no caso dos imóveis Shopping Paralela e Ilha Plaza, as apólices são negociadas corporativamente pelo administrador.</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
					<Emissor>
						<Fundo>FII EQI RECE - EQIR11</Fundo>
						<CNPJ>41076380000125</CNPJ>
						<Quantidade>102</Quantidade>
						<Valor>878.22</Valor>
					</Emissor>
					<Emissor>
						<Fundo>FII V PARQUE - FVPQ11</Fundo>
						<CNPJ>332266000131</CNPJ>
						<Quantidade>50869</Quantidade>
						<Valor>3357354</Valor>
					</Emissor>
					<Emissor>
						<Fundo>FII HTOPFOF3 -HFOF11</Fundo>
						<CNPJ>18307582000119</CNPJ>
						<Quantidade>414960</Quantidade>
						<Valor>2846625.6</Valor>
					</Emissor>
					<Emissor>
						<Fundo>FII LEGATUS - LASC11</Fundo>
						<CNPJ>30248158000146</CNPJ>
						<Quantidade>1</Quantidade>
						<Valor>118.24</Valor>
					</Emissor>
					<Emissor>
						<Fundo>SHOPPING PARALELA FII - RESP LTDA</Fundo>
						<CNPJ>32892018000131</CNPJ>
						<Quantidade>59222.53</Quantidade>
						<Valor>111143740.66</Valor>
					</Emissor>
				</FII>
				<CriCra>
					<Emissor>
						<Companhia>CRI_25L2639507 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>568</Emissao>
						<Serie>1</Serie>
						<Quantidade>14727428</Quantidade>
						<Valor>15154987.91</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CRI_25L2639530 - OPEASEC</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>568</Emissao>
						<Serie>2</Serie>
						<Quantidade>83455423</Quantidade>
						<Valor>83455654.17</Valor>
					</Emissor>
				</CriCra>
				<LciLca>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
					<Emissor>
						<Sociedade>GRANJA VIANNA 2019 EMPREENDIMENTOS E PARTICIPACOES S.A.</Sociedade>
						<CNPJ>32476916000109</CNPJ>
						<Quantidade>100</Quantidade>
						<Valor>100</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>SPE MARACANAU LTDA</Sociedade>
						<CNPJ>49325633000169</CNPJ>
						<Quantidade>21000</Quantidade>
						<Valor>1013314.4</Valor>
					</Emissor>
					<Emissor>
						<Sociedade>SPE ANCAR NEVADA</Sociedade>
						<CNPJ>53440638000100</CNPJ>
						<Quantidade>28952941</Quantidade>
						<Valor>2026705.87</Valor>
					</Emissor>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>FICFI ITAU SOBERANO RENDA FIXA SIMPLES LP</Fundo>
						<CNPJ>6175696000173</CNPJ>
						<Quantidade>8673.07502</Quantidade>
						<Valor>730400.83</Valor>
					</Emissor>
					<Emissor>
						<Fundo>ITAÚ CORP FEDERAL PLUS RF CP FICFI</Fundo>
						<CNPJ>3557198000105</CNPJ>
						<Quantidade>829406.7391</Quantidade>
						<Valor>143799527.7</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>879122.84</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa>144529928.53</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
					<Imovel>
						<Nome>BH Shopping</Nome>
						<Endereco>BR-356, 3049 - Belvedere, Belo Horizonte - MG, 30320-900</Endereco>
						<Area>47547.19</Area>
						<NumUnidades>445</NumUnidades>
						<OutrasCaractRelevantes>Área total contruida 47.547 m²</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.1</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda financeiro="102416429.23"/>
					<CustoImovEstoque/>
					<AjusteValor/>
					<OutrasRecOuDesp financeiro="-1373948.57"/>
					<ResultadoLiquido contabil="0" financeiro="101042480.66"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="100194110.18"/>
					<DespManutencaoConservacao contabil="-15387.57"/>
					<ReceitasVenda/>
					<CustoPropriedadesVendidas/>
					<AjusteValor/>
					<OutrasRecOuDesp contabil="-17356725.6"/>
					<ResultadoLiquido contabil="82821997.01" financeiro="0"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="-66587.95" financeiro="90512.91"/>
					<AjusteValor contabil="431700.77"/>
					<ResultadoVenda/>
					<OutrasRecOuDesp contabil="533007.73"/>
					<ResultadoLiquido contabil="898120.55" financeiro="90512.91"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="83720117.56" financeiro="101132993.57"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="4167680.97" financeiro="4169688.86"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes/>
				<ResultadoLiquido contabil="4167680.97" financeiro="4169688.86"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-8563751.13" financeiro="-9100907.57"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada contabil="-12066.99" financeiro="-18262.74"/>
				<EmpresaEspecializada/>
				<FormadorMercado financeiro="-63728.61"/>
				<CustodiaTitulosValores contabil="-207810.09" financeiro="-232728.88"/>
				<AuditoriaIndependente contabil="-62736.04" financeiro="-133529.99"/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-950492.86" financeiro="-936658.79"/>
				<ComissoesEmolumentos/>
				<HonorariosDespesasDefesas financeiro="-90468.07"/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio contabil="-656.36" financeiro="-656.36"/>
				<OutrasRecOuDesp contabil="-2491323.07" financeiro="-13817883.05"/>
				<Total contabil="-12288836.54" financeiro="-24394824.06"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="75598961.99" financeiro="80907858.37"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>80907858.37</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>76862465.4515</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte>-4214292.65</ParcelaDistribuidaTriSeguinte>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil>0</LucroContabil>
			<ResultadoFinanceiroExcedeMinimo>0</ResultadoFinanceiroExcedeMinimo>
			<RendimentosDeclarados>72648172.8015</RendimentosDeclarados>
			<RendimentosPagosAntec>-48432115.2</RendimentosPagosAntec>
			<RendimentoPagar>24216057.6015</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.897912</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"