"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>XP MALLS FUNDO DE INVESTIMENTO IMOBILIARIO</NomeFundo>
		<CNPJFundo>28757546000100</CNPJFundo>
		<DataFuncionamento>2017-12-22</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRXPMLCTF000</CodigoISIN>
		<QtdCotasEmitidas>9484954</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>Junho</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BTG pactual Serviços Financeiros S.A. – DTVM</NomeAdministrador>
		<CNPJAdministrador>28757546000100</CNPJAdministrador>
		<Logradouro>Praia de Botafogo</Logradouro>
		<Numero>501</Numero>
		<Complemento>6º Andar</Complemento>
		<Bairro>Botafogo</Bairro>
		<Cidade>Rio de Janeiro</Cidade>
		<Estado>RJ</Estado>
		<CEP>22250-040</CEP>
		<Telefone1>(11) 3383-3441</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.btgpactual.com</Site>
		<Email>sh-contato-fundoimobiliario@btgpactual.com</Email>
		<Competencia>2019-06-30</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>XP Vista Asset Management Ltda</Nome>
				<CNPJ>16.789.525/0001-98</CNPJ>
				<Endereco>Avenida Presidente Juscelino Kubitschek, nº 1.909, Torre Norte - 25º  ao 30º Andar - Vila Nova Conceição - São Paulo</Endereco>
				<telefone>(11) 4003-3710</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO BTG PACTUAL S A</Nome>
				<CNPJ>30306294000145</CNPJ>
				<Endereco>Praia de Botafogo, nº 501 – 5º andar parte -Cidade do Rio de Janeiro, Estado do Rio de Janeiro</Endereco>
				<telefone>(11) 3383-2000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>ERNST &amp; YOUNG AUDITORES INDEPENDENTES S.S.</Nome>
				<CNPJ>61.366.936/0001-25</CNPJ>
				<Endereco>Avenida Presidente Juscelino Kubitschek, nº 1.909, Torre Norte - 8º Andar - Vila Nova Conceição - São Paulo</Endereco>
				<telefone>(11) 2573-3000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>XP INVESTIMENTOS CORRETORA DE CÂMBIO, TÍTULOS MOBILIÁRIOS SA</Nome>
				<CNPJ>02.332.886/0011-78</CNPJ>
				<Endereco>Avenida Presidente Juscelino Kubitschek, nº 1.909, Torre Norte - 25º  ao 30º Andar - Vila Nova Conceição - São Paulo</Endereco>
				<telefone>(11) 4003-3710</telefone>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>XP INVESTIMENTOS CCTVM S.A.</Nome>
				<CNPJ>02.332.886/0001-04</CNPJ>
				<Endereco>Avenida Presidente Juscelino Kubitschek, nº 1.909, Torre Norte - 25º  ao 30º Andar - Vila Nova Conceição - São Paulo</Endereco>
				<telefone>(11) 4003-3710</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
					<Ativo>
						<Nome>FII Floripa Shopping</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>15026700.26</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Shopping Cidade Jardim</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>245158394.3</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Catarina Fashion Outlet</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>139265901</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Ações da Shopping Ponta Negra S/A</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>147488901.57</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Ações da Shopping Bela Vista S/A</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>133972867.97</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Ações da Acapurana S/A</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>54352529.2</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Investimentos novos ativos: O Fundo está sempre atento e em busca de boas oportunidade de investimento. Todas as propostas vinculantes são informadas ao mercado tempestivamente.
Investimentos nos ativos atuais: O Gestor do Fundo conta com um corpo técnico de engenheiros que constantemente acompanham as obras nos shoppings do Fundo. O Fundo mantém um acompanhamento intensivo junto aos seus sócios e administradores dos empreendimentos quanto à situação estrutural dos ativos. Para a experiência dos consumidores nos shoppings é importante a manutenção de estruturas confortáveis e atraentes aos consumidores, por isso é necessário um acompanhamento constante relacionado à manutenção dos ativos. O Gestor também atua junto aos respectivos sócios de cada um dos ativos buscando oportunidades de expansões da área bruta locável existente caso haja demanda reprimida na área de influência do empreendimento.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo encerrou seu exercício fiscal (findo em junho-19) com uma cota negociada no mercado secundário a R$ 110,42 e uma cota patrimonial de R$ 102,94 com base no dia 30 de junho de 2019. Um aumento de 10,42% e de 2,94% respectivamente, se comparado a 27 de dezembro de 2017, data em que o Fundo foi lançado ao mercado. Considerando rendimentos distribuídos desde o início, a valorização para o cotista foi de 21,2%. O fundo distribuiu desde seu lançamento R$ 47.093.640,00 em rendimentos, o que equivale a uma média de R$ 2.616.313,33 por mês.</ResultadoFundo>
			<ConjunturaEconomica>O mercado imobiliário se baseia em um tripé que fundamenta a tese de investimentos: 
(i) Taxa de juros – menor patamar da série histórica 
(ii) Oferta de crédito – com a queda dos juros, atualmente a oferta dos bancos é estável e crescente  
(iii) Emprego/ Renda – esta retomada se mostra lenta, porém gradativa e  já começamos a ver pequenas alguns sinais de melhoria conforme apontado o índice de confiança do consumidor que, segundo a Fundação Getúlio Vargas, atingiu 88,5 pontos em junho/19. 
Especificamente o mercado de shoppings apresentou durante a crise dos últimos anos uma resiliência considerável vis a vis outros ramos do mercado imobiliário, conforme pode ser observado em alguns indicadores da indústria como vacância. No último semestre esperava-se que a atividade econômica cresceria mais que o que acabou apresentando. Ainda assim, a perspectiva de crescimento das vendas e do consumo nos próximos meses segue alta, sendo o segundo semestre sempre mais forte que o primeiro para este setor</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A perspectiva para o próximo ano é de consolidação do portfólio do Fundo como um portfólio resiliente, com indicadores operacionais demonstrando a eficiência e qualidade dos ativos. Com um cenário de estabilidade que esperamos no país, o consumo tende a voltar, o acesso a crédito também e a confiança dos consumidores levará a um aumento de vendas e fluxo de pessoas e veículos aos shoppings, melhorando a potencial geração de caixa operacional. As recentes aquisições realizadas pelo Fundo aumentam o otimismo com os resultados e com a perspectiva de ter uma maior diversificação nas receitas.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Cotas do Floripa Shopping FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1297.85</Valor>
				<PercentValorizacaoDesvalorizacao>0.0015</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Caxias Shopping</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>107384550</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0381</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Cidade São Paulo</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>66269040</Valor>
				<PercentValorizacaoDesvalorizacao>0.041</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Parque Belém</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>69092500</Valor>
				<PercentValorizacaoDesvalorizacao>0.0091</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Cidade Jardim</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>257928418.1</Valor>
				<PercentValorizacaoDesvalorizacao>0.0188</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Catarina Fashion Outlet</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>318104366.4</Valor>
				<PercentValorizacaoDesvalorizacao>0.236</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Ponta Negra S/A</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>141725359.8</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0391</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Bela Vista S/A</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>131878977.3</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0156</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Acuparana Participações S/A</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>54651421.07</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Método utilizado para cotas de FII mercado: valor das cotas dos fundos divulgadas na B3;
Método utilizado para imóveis: Capitalização da renda através do fluxo de caixa descontado; Empresa: Cushman &amp; Wakefield;
Método utilizado para ações de companhia fechada: reconhecimento por meio do resultado utilizando como base o seu respectivo valor justo. O valor justo foi obtido na capitalização da renda através do fluxo de caixa descontado; Empresa: Cushman &amp; Wakefield.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
			<Processo>
				<Numero>1110781-44.2015.8.26.0100</Numero>
				<Valores>230273.76</Valores>
				<CausaContingencia>DESPEJO POR FALTA DE PAGAMENTO. </CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1132577-57.2016.8.26.0100</Numero>
				<Valores>39638.49</Valores>
				<CausaContingencia>EXECUÇÃO DE VALORES DECORRENTES DO CONTRATO DE LOCAÇÃO.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1119609-58.2017.8.26.0100</Numero>
				<Valores>223893.36</Valores>
				<CausaContingencia>AÇÃO DE DESPEJO POR FALTA DE PAGAMENTO CUMULADA COM COBRANÇA. </CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1046969-23.2018.8.26.0100</Numero>
				<Valores>238162.68</Valores>
				<CausaContingencia>AÇÃO RENOVATÓRIA DE CONTRATO DE LOCAÇÃO.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1058626-59.2018.8.26.0100</Numero>
				<Valores>323764.36</Valores>
				<CausaContingencia>AÇÃO DE EXECUÇÃO DE VALORES DECORRENTES DO CONTRATO DE LOCAÇÃO - PERÍODO DE 05/02/2018 A 05/05/2018 E CONFISSÃO DE DÍVIDA VENCIDA EM 05/01/2018. </CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1063613-41.2018.8.26.0100</Numero>
				<Valores>164776.68</Valores>
				<CausaContingencia>AÇÃO DE DESPEJO POR FALTA DE PAGAMENTO NÃO CUMULADA COM COBRANÇA</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1078121-89.2018.8.26.0100</Numero>
				<Valores>177306.84</Valores>
				<CausaContingencia>AÇÃO DE DESPEJO CUMULADA COM COBRANÇA DOS ALUGUEIS E DEMAIS ENCARGOS LOCATÍCIOS VENCIDOS DESDE DEZEMBRO DE 2017, TOTALIZANDO UM DÉBITO ATÉ MAIO DE 2018, DEVIDAMENTE CORRIGIDO.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1033134-02.2017.8.26.0100</Numero>
				<Valores>32715.29</Valores>
				<CausaContingencia>AÇÃO DE EXECUÇÃO DE TÍTULO EXTRAJUDICIAL PARA COBRANÇA DOS ALUGUEIS VENCIDOS EM JANEIRO, FEVEREIRO E MARÇO DE 2017, NO VALOR DE R$ 32.715,29</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1024182-34.2017.8.26.0100</Numero>
				<Valores>234971.76</Valores>
				<CausaContingencia>AÇÃO PARA RESCISÃO DE CONTRATO DE LOCAÇÃO E INSTRUMENTOS DE CESSÃO DE DIREITO DE USO COM DEPÓSITO JUDICIAL DAS CHAVES CUMULADA COM INEXIGIBILIDADE  DE VALORES E PEDIDO DE LIMINAR</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1000100-45.2017.5.02.0006</Numero>
				<Valores>70000</Valores>
				<CausaContingencia>O RECLAMANTE FOI ADMITIDO PELA 1ª RECLAMADA ( TECFAC MANUTENÇÕES TÉCNICAS DE FACHADAS E SUPERFÍCIES LTDA), PARA EXERCER A FUNÇÃO DE AJUDANTE OPERADOR DE BALANCINHO E DISPENSADO EM 03/01/2017, PERCEBENDO COMO ÚLTIMA REMUNERAÇÃO Á IMPORTÂNCIA DE R$ 1.361,80 MENSAL (R$6,19 POR HORA).</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1000160-22.2018.5.02.0058</Numero>
				<Valores>15275</Valores>
				<CausaContingencia>O RECLAMANTE FOI ADMITIDO AOS PRÉSTIMOS DA PRIMEIRA RECLAMADA (MPM PARKING) EM 28/06/2016 PARA EXERCER A FUNÇÃO DE LÍDER PRESTANDO SERVIÇO EXCLUSIVAMENTE PARA A SEGUNDA RECLAMADA (CIDADE SÃO PAULO). FOI DISPENSADO EM 15/02/2018.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1001284-91.2017.5.02.0020</Numero>
				<Valores>39000</Valores>
				<CausaContingencia>O RECLAMANTE FORA ADMITIDO AOS PRÉSTIMOS DA 1ª RECLAMADA (SC2 ENGENHARIA E SERVIÇOS LTDA) EM 29/07/13 PARA EXERCER A FUNÇÃO DE AJUDANTE, EM FAVOR DA 2ª RECLAMADA (SHOPPING CIDADE SÃO PAULO). RECEBEU COMO ÚLTIMO SALÁRIO A QUANTIA FIXA DE R$ 1.509,18 (MIL QUINHENTOS E NOVE REAIS E DEZOITO CENTAVOS). FOI DEMITIDO SEM JUSTA CAUSA, EM 16/01/16.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1000790-80.2018.5.02.0025</Numero>
				<Valores>21872.87</Valores>
				<CausaContingencia>O RECLAMANTE ALEGA QUE FOI CONTRATADA PELA 1ª RECLAMADA EM 01/09/2017, TENDO PRESTADO SERVIÇOS PARA A 2ª E 3ª (DE 03/10/2017 AO FIM - EM 02/05/2018). PROSSEGUE INFORMANDO QUE, EMBORA TENHA SIDO CONTRATADO COMO ATENDENTE, SEMPRE ATIVOU-SE COMO SEGURANÇA, EXECUTANDO O TRABALHO EM EQUIPARAÇÃO AO SR. EDSON.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1000666-45.2018.5.02.0010</Numero>
				<Valores>99424.79</Valores>
				<CausaContingencia>ALEGA A RECLAMANTE QUE FOI ADMITIDA PELA PRIMEIRA RECLAMADA EM 01.11.2013, PARA EXERCER A FUNÇÃO DE AGENTE DE CONSERVAÇÃO E ASSEIO, PERCEBENDO COMO ÚLTIMO SALÁRIO A QUANTIA DE R$ 900,00, SENDO DEMITIDO EM 09/2017, COM JUSTA CAUSA.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1001468-40.2017.5.02.0087</Numero>
				<Valores>25145.86</Valores>
				<CausaContingencia>PEDIDOS: 	RESPONSABILIDADE SUBSIDIÁRIA; 	RECONHECIMENTO DE VÍNCULO DE EMPREGO; 	HORAS EXTRAS; 	INTERVALO INTRAJORNADA; FERIADOS LABORADOS EM DOBRO; 	REFLEXOS; ADICIONAL DE INSALUBRIDADE; 	ACUMULO DE FUNÇÃO; VERBAS RESCISÓRIAS E CONTRATUAIS; MULTAS DOS ARTIGOS 467 E 477 DA CLT; INDENIZAÇÃO POR DANOS MORAIS; 	EXPEDIÇÃO DE OFÍCIOS; HONORÁRIOS ADVOCATÍCIOS. </CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1001480-28.2016.5.02.0010</Numero>
				<Valores>40000</Valores>
				<CausaContingencia>TRATA-SE DE AÇÃO COLETIVA MOVIDA PELO SINDICATO DOS VIGILANTES COMO SUBSTITUTO PROCESSUAL DOS EMPREGADOS, OBJETIVANDO QUE A 1ª RECLAMADA CONCEDA 10 MINUTOS DE DESCANSO EM ASSENTO A CADA 01 HORA DE TRABALHO, CUJA PRESTAÇÃO DE SERVIÇOS É REALIZADA NA 2ª RECLAMADA.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0002279-72.2015.5.02.0059</Numero>
				<Valores>40000</Valores>
				<CausaContingencia>AÇÃO PROPOSTA EM FACE DE VERZANI &amp; SANDRINI (1ª RECLAMADA); SHOPPING IBIRAPUERA (2ª RECLAMADA); SHOPPING LIGHT (3ª RECLAMADA) E SUBCOMDOMÍNIO SHOPPING CIDADE SÃO PAULO (4ª RECLAMADA). HÁ PEDIDO DE RESPONSABILIDADE SUBSIDIÁRIA EM RAZÃO DA PRESTAÇÃO DE SERVIÇOS TERCEIRIZADOS, QUE FOI RECONHECIDA NA SENTENÇA.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1002149-54.2016.5.02.0019</Numero>
				<Valores>40000</Valores>
				<CausaContingencia>1ª RECLAMADA: VERZANI E SANDRINI ADMINISTRAÇÃO DE MÃO DE OBRA 2ª RECLAMADA: SHOPPING CIDADE SÃO PAULO 3ª RECLAMADA: SHOPPING FREI CANECA
O RECLAMANTE FOI ADMITIDO AOS PRÉSTIMOS DA PRIMEIRA RECLAMADA EM 09/04/2015 PARA EXERCER A FUNÇÃO DE ATENDENTE. </CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1000806-33.2018.5.02.0090</Numero>
				<Valores>47481.15</Valores>
				<CausaContingencia>A RECLAMANTE INGRESSOU COM A RECLAMAÇÃO TRABALHISTA, ALEGANDO QUE FOI   ADMITIDO   AOS   SERVIÇOS   DA   PRIMEIRA RECLAMADA  EM 13 DE FEVEREIRO DE 2007,   PARA  EXERCER  A  FUNÇÃO  DE  AUXILIAR DE LIMPEZA, TENDO SIDO PROMOVIDA A LÍDER, E APÓS, A ENCARREGADA, PERMANECENDO  A TRABALHAR  ATÉ  A PRESENTE DATA, PERCEBENDO  COMO  ÚLTIMA  REMUNERAÇÃO  O IMPORTE DE RR$ 1.690,28 (UM MIL, SEISCENTOS E NOVENTA REAIS E VINTE E OITO CENTAVOS).</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1000860-44.2017.5.02.0054</Numero>
				<Valores>38000</Valores>
				<CausaContingencia>	O RECLAMANTE ALEGA QUE FIRMOU CONTRATO TEMPORÁRIO COM A 2ª RECLAMADA, PARA TRABALHAR NA 1ª RECLAMADA (SHOPPING). 
</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1002232-52.2016.5.02.0025</Numero>
				<Valores>100000</Valores>
				<CausaContingencia>GODOY SERVIÇOS MÉDICOS EM GERAL S/S LTDA, (1ª RECLAMADA), GOHY SOLUÇÕES EM FACILITIES EIRLEI ¿ME¸ (2ª RECLAMADA), CONDOMÍNIO CIVIL VOLUNTÁRIO DO SANTANA PARQUE SHOPPING, (3ª RECLAMADA), MICONIA EMPREENDIMENTOS IMOBILIÁRIOS LTDA (SHOPPING CIDADE SÃO PAULO), (4ª RECLAMADA), COMPACTA CEBTRAL DE RESTAURAÇÃO E REVESTIMENTO LTDA, (5ª RECLAMADA).</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1002145-17.2017.5.02.0040</Numero>
				<Valores>500000</Valores>
				<CausaContingencia>O RECLAMANTE ALEGA QUE FOI CONTRATADO PELA 1ª RECLAMADA EM 01.06.2011 PARA EXERCER A FUNÇÃO DE INSPETOR DE SEGURANÇA. FOI DISPENSADO EM 13.10.2016.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1000674-38.2018.5.02.0037</Numero>
				<Valores>37225.7</Valores>
				<CausaContingencia>O RECLAMANTE ALEGA TER SIDO ADMITIDO PELA 1ª RECLAMADA EM 25 DE JUNHO DE 2012, PARA EXERCER A FUNÇÃO DE ATENDENTE, TENDO PRESTADO SERVIÇOS NAS DEPENDÊNCIA DO SHOPPING CIDADE SÃO PAULO.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1001929-22.2017.5.02.0019</Numero>
				<Valores>100000</Valores>
				<CausaContingencia>A RECLAMANTE FOI ADMITIDA AOS SERVIÇOS DA RECLAMADA EM 02/02/2015 PARA EXERCER A FUNÇÃO DE GERENTE DE MARKETING. FOI DEMITIDA POR JUSTA CAUSA EM 17/04/2017.</CausaContingencia>
			</Processo>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida Brigadeiro Faria Lima, 3477 - 14º andar - Itaim Bibi - São Paulo/SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>Os documentos relativos à Assembleia Geral estarão disponíveis na sede do Administrador bem como no site da B3 e do Banco BTG Pactual conforme endereços abaixo:
http://www.bmfbovespa.com.br/pt_br/produtos/listados-a-vista-e-derivativos/renda-variavel/fundos-de-investimentos/fii/fiis-listados/
https://www.btgpactual.com/home/asset-management/fundos-btg-pactual</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Disponibilizamos aos cotistas o endereço de e-mail abaixo para solicitações referentes as assembleias bem como dúvidas em geral:
Sh-contato-fundoimobiliario@btgpactual.com</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>(i) O cotista é apto ao voto caso conste da base de cotistas na data da convocação da AGC. No dia da AGC, a qualidade de cotista é comprovada através de documento de identificação com foto (RG, RNE, CNH) para PF. No caso da PJ, é exigido (1)Cópia autenticada do último estatuto ou contrato social consolidado e da documentação societária outorgando poderes de representação (ata de eleição dos diretores e/ou procuração com firma reconhecida);(2)Documento de identificação com foto do(s) representante(s) legal(is);(c) no caso de Fundos de Investimento é exigido (1)Cópia autenticada do último regulamento consolidado do fundo e estatuto social do seu administrador, além da documentação societária outorgando poderes de representação (ata de eleição dos diretores e/ou procuração); (2)Documento de identificação com foto do(s) representante(s) legal(is); (d)caso o Cotista seja representado, o procurador deverá estar munido de procuração válida, com poderes específicos e firma reconhecida pelo cotista outorgante. Adotamos, ainda, o procedimento de verificar a Base de cotistas antes da assembleia buscando identificar possíveis cotistas impedidos de votar para que possamos informar caso estejam presentes na AGC. Adicionalmente, iniciamos questionando se algum cotista presente se considera conflitado. Ainda relacionado a plateia, caso exista um convidado de cotista ou outro presente apenas telespectador, solicitamos aos cotistas presentes autorização para que o mesmo assista a AGC. Previamente ainda, verificamos se o Fundo possui representantes de cotistas eleitos para que possamos identificá-los. 
(ii)  Quando previsto em regulamento, é possível a realização de consultas formais. Tais consultas são realizadas por meio do envio de uma carta consulta para toda a base de cotistas, na qual consta a exposição do Administrador sobre os itens a serem deliberados, data limite para manifestação do voto, prazo para apuração dos votos e orientação sobre o envio da manifestação bem como documentos que devem ser anexados. Além disso, segue uma carta resposta modelo com os itens em deliberação, campo para voto e itens para preenchimento de dados do cotistas e assinatura. Estabelecemos um mínimo de 5 dias após o prazo final para apuração dos votos dos cotistas que postaram seus votos dentro do prazo mas que por algum motivo tenham demorado um pouco mais para chegar até a Administradora. 
(iii) Para AGCs não realizamos o operacional de participação à distância, uma vez que tais procedimentos ainda não estão previstos no regulamento do Fundo e as entidades nas quais as cotas do Fundo estão registradas ainda não disponibilizaram sistemas e operacionais para tanto. Caso o cliente deseje, pode fornecer procuração concedendo a um procurador, ou mesmo à Administradora, o direito de exercer seu voto em Assembleia presencial, sendo certo que de tal procuração pode constar expressa a declaração de voto do cotista (o que no caso de procurações à Administradora é mandatório).</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não realizamos assembleias por meio eletrônico para os fundos imobiliários dado que entendemos que não é do perfil de grande parte dos cotistas que acabariam prejudicados pelo modelo eletrônico</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O Administrador receberá por seus serviços uma (a) Taxa de Administração fixa e anual composta de valor equivalente aos percentuais previstos na tabela abaixo, à razão de 1/12 avos, calculada (a.1) sobre o valor contábil do patrimônio líquido do Fundo, ou (a.2) sobre o valor de mercado do Fundo, caso suas cotas tenham integrado ou passado a integrar, no período, índices de mercado, cuja metodologia preveja critérios de inclusão que considerem a liquidez das cotas e critérios de ponderação que considerem o volume financeiro das cotas emitidas pelo Fundo, como por exemplo, o Índice de Fundos de Investimentos Imobiliários (IFIX), calculado com base na média diária da cotação de fechamento das cotas de emissão do Fundo no mês anterior ao do pagamento da remuneração e que deverá ser pago diretamente ao Administrador, observado o valor mínimo mensal de R$ 60.000,00 (sessenta mil reais), atualizado anualmente segundo a variação do IPCA, ou índice que vier a substituí-lo, a partir do mês subsequente à data de autorização para funcionamento do Fundo; na qual já estão incluídas as taxas de escrituração e de gestão. Para fins do cálculo ora previsto, será utilizada: Valor Contábil do Patrimônio Líquido ou Valor de Mercado do Fundo     x  Taxa de Administração Até R$ 500.000.000,00   x   0,95% a.a.; ou De R$ 500.000.000,01 até R$1.000.000.000,00 x 0,85% a.a; ou Acima de R$1.000.000.000,01  x           0,75% a.a.            </PoliticaRemuneracao>
			<ValorPagoAno>981819.11</ValorPagoAno>
			<PercentPatrimonioContabil>0.001</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0009</PercentPatrimonioValorMercado>
		</RemuneracaoAdministrador>
		<Governanca>
			<RepresentantesCotistas>
				<Representante1>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal xsi:nil="true"/>
						<CondenacaoProcAdminCVM xsi:nil="true"/>
					</Eventos>
				</Representante1>
				<Representante2>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante2>
				<Representante3>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante3>
				<Representante4>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante4>
				<Representante5>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante5>
			</RepresentantesCotistas>
			<DiretorResponsavel>
				<Nome>Allan Hadid</Nome>
				<Idade>43 anos</Idade>
				<CPF>071.913.047-66</CPF>
				<Email>ol-reguladores@btgpactual.com</Email>
				<Profissao>Economista</Profissao>
				<FormacaoAcademica>Graduado em ciências econômicas pela Pontifícia Universidade Católica do Rio de Janeiro em dezembro de 1997. </FormacaoAcademica>
				<DataInicioFuncao>2016-09-29</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Banco BTG Pactual S.A</NomeEmpresa>
						<Periodo>De julho de 2014 até hoje</Periodo>
						<CargoFuncoes>Ingressou como partner no Banco BTG Pactual S.A. na posição de COO (Chief Operations Officer) da área de Merchant Banking e, atualmente, ocupa o cargo de COO (Chief Operations Officer) da área de Global Asset Management</CargoFuncoes>
						<AtividadePrincipalEmpresa>Atualmente, ocupa o cargo de COO (Chief Operations Officer) da área de Global Asset Management.</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>BRZ Investimentos</NomeEmpresa>
						<Periodo>De junho de 2011 até junho de 2014</Periodo>
						<CargoFuncoes>CEO (Chief Executive Officer)</CargoFuncoes>
						<AtividadePrincipalEmpresa>Atuou na área de gestão de recursos</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não há</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não há</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="64379" numCotasDetidas="9484954" percDetidoRelTotal="1" percDetidoPF="0.78" percDetidoPJ="0.22"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
			<Ativo>
				<AtivoNegociado>Floripa Shopping FII</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-15</DataTransacao>
				<ValorEnvolvido>15026700.26</ValorEnvolvido>
				<DataAssembleia>2018-12-12</DataAssembleia>
				<Contraparte>Floripa Shopping FII</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Floripa Shopping FII</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-28</DataTransacao>
				<ValorEnvolvido>3493901.51</ValorEnvolvido>
				<DataAssembleia>2018-12-12</DataAssembleia>
				<Contraparte>Floripa Shopping FII</Contraparte>
			</Ativo>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>De acordo com o previsto na IN CVM 472 nossa política de divulgação define prioritariamente como fato relevante eventos significativos de vacância que possam representar 5% ou mais da Receita do Fundo na data da divulgação. Para outras situações, todas são devidamente analisadas para que se confirme se devem ou não ser classificadas como um fato relevante e consequentemente serem divulgadas de acordo com nossa política.
A divulgação é feita antes da abertura ou depois do fechamento do mercado através dos seguintes canais:
http://www.bmfbovespa.com.br/pt_br/produtos/listados-a-vista-e-derivativos/renda-variavel/fundos-de-investimentos/fii/fiis-listados/
https://www.cvm.gov.br/menu/regulados/fundos/consultas/fundos/fundos.html
https://www.btgpactual.com/home/asset-management/fundos-btg-pactual</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>https://www.btgpactual.com/home/asset-management/fundos-btg-pactual</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.btgpactual.com/home/asset-management/fundos-btg-pactual</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Bruno Duque Horta Nogueira</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Será de acordo com estabelecido em Assembleia Geral Extraordinária respeitando as regras do regulamento.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"