"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIARIO - FII TORRE ALMIRANTE</NomeFundo>
		<CNPJFundo>07122725000100</CNPJFundo>
		<DataFuncionamento>2012-10-15</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRALMICTF003</CodigoISIN>
		<QtdCotasEmitidas>104700</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Lajes Corporativas</SegmentoAtuacao>
			<TipoGestao>Passiva</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>Dezembro</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>07122725000100</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>2017-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</Gestor>
			<Custodiante>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>PRICEWATERHOUSECOOPERS AUDITORES INDEPENDENTES</Nome>
				<CNPJ>61.562.112/0001-20</CNPJ>
				<Endereco>Av. Francisco Matarazzo, 1400 - Torre Torino - São Paulo - CEP: 05401-400</Endereco>
				<telefone>11 3674-2000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>CAIXA ECONOMICA FEDERAL</Nome>
				<CNPJ>00.360.305/0001-04</CNPJ>
				<Endereco>AV PAULISTA, 2300 - 12º ANDAR - SAO PAULO - SP, CEP 01310-300</Endereco>
				<telefone>(55 11) 2100-9214</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>Hines do Brasil Empreendimentos LTDA.</Nome>
				<CNPJ>02.541.350/0001-90</CNPJ>
				<Endereco>Av. das Nações Unidas, 12901 - Brooklin Novo, São Paulo - SP - CEP: 04578-910</Endereco>
				<telefone>(11) 5504-7600</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Fundo seguirá sua política de investimento conforme prevista em regulamento. Ademais, o Fundo com o objetivo de aumentar a taxa de ocupação poderá efetuar adapatações/benfeitorias nos andares vagos. Vale mencionar que o Fundo possui valores recebidos da desmobilização, ou seja, valores para custear recomposição dos andares nos mesmos estados de conservação quando a antiga locatária entrou no imóvel, que serão utilizados para financiar completamente ou parcialmente tais adaptações no imóvel. Caso tais valores não sejam suficiente, o Fundo realizará uma nova emissão de cotas.

</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo distribuiu a título de rendimentos o equivalente a R$ 110,92 a.a. por cota, o que representa um Dividend Yield de 6,24% considerando a cota de mercado no Fechamento de 2017 (R$ 1.777,99).</ResultadoFundo>
			<ConjunturaEconomica>A melhora no cenário político-econômico, com os indicadores de atividade recuperando, o ciclo de afrouxamento na política monetária, com cortes sucessivos na taxa de juros, e o aumento nos níveis de confiança dos empresários e consumidores propiciaram um ambiente de recuperação para o mercado imobiliário. No mercado de são paulo, indicadores como vacância e valores de locação por metro quadrado já mostram uma recuperação e apresentam perspectivas positivas para o ano de 2018. No entanto, alguns mercados ainda mostram resistência à recuperação, como é o caso do Rio de Janeiro, que ainda é impactado descontrole fiscal do Estado e a elevada violência. Nestes mercados, a vacância permanece elevada e as práticas de desconto e carência continuam agressivas de forma a tentar atrair novos locatários.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Para o fundo específico em questão, vemos um grande desafio para o próximo ano com a busca por novos inquilinos no mercado do Rio de Janeiro que ainda não mostra sinais de recuperação e continua com práticas agressivas de descontos e carência.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Edifício Torre Almirante</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>211739987.4</Valor>
				<PercentValorizacaoDesvalorizacao>0.0394</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Método utilizado para imóveis: Capitalização da renda através do fluxo de caixa descontado; Empresa: Cushman &amp; Wakefield.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>0006168-58.2014.4.02.5101</Numero>
				<Juizo>3ª Vara Cível, Justiça Federal, Rio de Janeiro, RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-05-08</DataInstauracao>
				<ValorCausa>840000</ValorCausa>
				<PartesProcesso>Fundo de Investimento Imobiliário Torre Almirante e Fundo de Investimento Imobiliário  - FII Prime Portfólio X CEF - Caixa Economica Federal</PartesProcesso>
				<PrincipaisFatos>Imóvel no Rio de Janeiro  Os fundos foram citados porém o AR de citação ainda não foi juntado. Em 24/11/2015 foi protocolada Contestação.Em 26/01/2016 foi protocolada tréplica. Processo conclusos para sentença.01/02/2016 – Processo na conclusão para decisão.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Demanda Renovatória, em que houve concordância com o valor proposto pelo autor.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0028404-64.1997.8.19.0001</Numero>
				<Juizo>18ª Vara Cível, Foro Central, Rio de Janeiro, RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>1997-03-11</DataInstauracao>
				<ValorCausa>176020.6</ValorCausa>
				<PartesProcesso>General Eletric do Brasil S.A. X Fundo de Investimento Imobiliário Torre Almirante, Rio Brasil Projetos Ltda.</PartesProcesso>
				<PrincipaisFatos>Na origem, procedimento sumário de reparação de danos; atualmente, execução de sentença. 11/03/1997 – Distribuição da ação; 25/07/1997 – Despacho determinando chamamento ao feito do Condomínio do Edifício Andorinha; 16/12/1998 - Sentença de procedência condenando a GE e o Condomínio (solidariamente) ao pagamento, em favor dos autores, de (i) indenização por lucros cessantes correspondente aos vencimentos do falecido desde o evento danoso até a data em que os autores completaram 24 anos; (ii) indenização por danos morais no valor de 600 salários mínimos vigentes à data do pagamento; (iii) indenização correspondente ao luto funeral arbitrada em 15 salários mínimos, e (iv) custas e honorários de 20% sobre o valor da condenação. A GE recorreu e, ao final da fase recursal, determinou-se a redução da verba referente ao luto e funeral para o montante de 03 salários-mínimos;  18/11/09 - Decisão homologando cálculos apresentado pela GE às fls. 584/586 e intimando os executados para pagamento na forma requerida; 09/12/09 - GE efetuou o pagamento da totalidade do valor devido, no importe de R$ 256.591,20 (duzentos e cinquenta e seis mil, quinhentos e noventa e um reais e vinte centavos), reservando-se ao direito de promover ação regressiva contra o Condomínio; 04/02/2010 -  Petição da GE requerendo a intimação do Condomínio para pagamento de 50% (cinquenta por cento) do valor pago por si na execução, haja vista que a condenação contida na sentença estipulava obrigação solidária entre a GE e o Condomínio; 08/11/2010 – Petição do advogado do Condomínio, informando a extinção do Condomínio e a aquisição de parte das quotas para a empresa Rio do Brasil e para o Fundo Torre do Almirante; 03/05/2011 – Despacho intimando as empresas RIO DO BRASIL Projetos LTDA. e FUNDO para se manifestarem nos autos; 26/03/2014 – Exceção  de Pré-executividade oposta pela Rio do Brasil; 25/04.2014 - Apresentada a manifestação do Fundo sobre a Execução; 02/10/2014 – Decisão determinando o não recebimento da Exceção e a manifestação por meio de impugnação e mediante garantia do juízo; 29/02/2016 – Petição do Fundo reiterando manifestação anterior; 03/06/2016 - Despacho determinando à secretaria que certifique a inclusão de Rio do Brasil e de Fundo no polo passivo da demanda, bem como que os embargos de declaração seriam apreciados após tal providência;</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>De acordo com o escritório responsável, valor apontado, com acréscimo dos encargos legais, deve ser contingenciado em razão da possibilidae de perda da ação.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0156378-25.2013.8.19.0001</Numero>
				<Juizo>12ª Vara Cível, Foro Central, Rio de Janeiro, RJ</Juizo>
				<Instancia>STF</Instancia>
				<DataInstauracao>2013-05-10</DataInstauracao>
				<ValorCausa>533195.84</ValorCausa>
				<PartesProcesso>Fundo de Investimento Imobiliário Torre Almirante X Coordenador Chefe da Coordenadoria do ITBI da Prefeitura do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Mandado de segurança impetrado para contestar a exibilidade de depósito.  10/05/2013 - Impetrado mandado de segurança
15/05/2013 - Concedida liminar que declarou suspensa a exigibilidade do crédito constituído pela Nota de Lançamento de ITBI n° 0491/2010.
17/05/2013 - Expedido mandado de notificação para que o impetrado apresente informações.
05/06/2013 - Juntado mandado confirmando a intimação do  impetrado para apresentar informações.
29/07/2013 - Aguardando julgamento de 1ª instância.
20/08/2013 - Aguardando julgamento de 1ª instância
06/09/2013 - Apresentadas informações. 
19/09/2013 - Remessa ao MP
25/10/2013 - Processo concluso para sentença.
18/11/2013 - Proferida sentença que determinou o cancelamento integral da Nota de Lançamento nº 0491/2010.				
21/12/2013 - Aguardando publicação de sentença.	
11/04/2014 - Publicada sentença que determinou o cancelamento integral da Nota de Lançamento nº 0491/2010. Em 10.03.2014, juntada Apelação da outra parte e, na mesma data, certificada sua tempestividade. Em 11.03.2014, conclusão. Em 11.04, despacho determinando apresentação de contrarrazões.Aguardamos remessa ao Tribunal de Justiça para julgamento.
26/08/2014 - Autuação da apelação do Município no TJ/RJ - Distribuição para a 19ª Câmara Cível. Relator  DES. LUCIO DURANTE.
05/09/2014 - Remessa dos autos ao Ministério Público para apresentação de parecer.
29/09/2014 - Aguardando decisão de recurso.	
29/10/2014 - Aguardando julgamento de apelação do Município do Rio de Janeiro pela 19ª Câmara Cível.
14/11/2014 - 19ª Câmara Cível do TJ/RJ (Relator  DES. LUCIO DURANTE) negou provimento à Apelação do Município,por decisão monocrática, mantendo a Sentença de primeira instância, que determinou o cancelamento da Nota de Lançamento de ITBI n° 0491/2010.
10/03/2015 - Negado provimento ao Agravo Regimental do Município.
28/04/2015 - Negado provimento aos Embargos de Declaração do Município.
01.07.2015 - Município do RJ apresentou Recurso Extraordinário e, em seguida, apresentamos contrarrazões. 28.08.2015 - RE do Município foi inadmitido. O MRJ apresentou agravo contra a decisão.
16.10.2015 - Apresentamos contrarrazões ao agravo do MRJ.
16.11.2015 - Juntadas as nossas contrarrazões e realizada remessa ao STF.			
31.05.2016 - Aguardando o processamento do Agravo em RE no STF .				
				
				
				
				
			
			
		
			
			
			
				
				
				
				
							
				
				
				
				
</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>De acordo com o escritório responsável: Considerando que houve o depósito integral da quantia discutida, a perda implicará tão somente na conversão do depósito em pagamento, sem desembolso adicional.</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</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>A ADMINISTRADORA receberá por seus serviços uma taxa de administração equivalente a 0,383% (trezentos e oitenta e três milésimos por cento), à razão de 1/12 avos, aplicados sobre o valor do Patrimônio do Fundo vigente no último dia útil do mês anterior, observado o valor mínimo de R$ 30.000,00 (trinta mil reais), valor este que será corrigido anualmente pela variação do IGPM (Índice Geral de Preços de Mercado), elaborado e divulgado pela Fundação Getúlio Vargas - FGV.
Parágrafo Único - A taxa de administração será calculada e paga à ADMINISTRADORA mensalmente, por período vencido, até o 5º (quinto) dia útil do mês subsequente ao dos serviços prestados.
</PoliticaRemuneracao>
			<ValorPagoAno>811866.66</ValorPagoAno>
			<PercentPatrimonioContabil>0.003818</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.004361</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>41 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. Certificado como CFA (Chartered Financial Analyst), certificado de distinção do mercado financeiro.</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="4219" numCotasDetidas="91000" percDetidoRelTotal="0.869149952244508" percDetidoPF="0.789808978032474" percDetidoPJ="0.0793409742120344"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="13700" percDetidoRelTotal="0.130850047755492" percDetidoPF="0" percDetidoPJ="0.130850047755492"/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</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 xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"