"<?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 RBR ALPHA FUNDO DE FUNDOS</NomeFundo>
		<CNPJFundo>27529279000151</CNPJFundo>
		<DataFuncionamento>2017-09-14</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRRBRFCTF003</CodigoISIN>
		<QtdCotasEmitidas>1623931</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Títulos e Val. Mob.</SegmentoAtuacao>
			<TipoGestao>Ativa</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>27529279000151</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-02-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>RBR GESTÃO DE RECURSOS LTDA.</Nome>
				<CNPJ>18.259.351/0001-87</CNPJ>
				<Endereco> Avenida Doutor Cardoso de Melo, nº 1.340, 7º andar, conjunto 72, parte, Vila Olímpia, CEP 04548-004 - SP</Endereco>
				<telefone>(11) 4083-9144</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO BTG PACTUAL S.A</Nome>
				<CNPJ>30.306.294/0001-45</CNPJ>
				<Endereco>Praia de Botafogo, nº 501, 5º, 6º e 7º andares, Botafogo
CEP 22250-040 - Rio de Janeiro -RJ</Endereco>
				<telefone>11 3383-2000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>PRICEWATERHOUSECOOPERS AUDITORES INDEPENDENTES</Nome>
				<CNPJ>61.562.112/0001-20</CNPJ>
				<Endereco>Avenida Francisco Matarazzo, nº 1.400, 9º, 10º, 13º, 14º, 15º, 16º e 17º andares, Torre Torino, Água Branca, CEP 05001-100</Endereco>
				<telefone>11 3674.-2000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>XP INVESTIMENTOS CCTVM S.A.</Nome>
				<CNPJ>2332886000104</CNPJ>
				<Endereco>Av. Brg. Faria Lima, 3311 - São Paulo - SP CEP:  04538-133</Endereco>
				<telefone>(11) 3073-1135</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>CRI 19A0625067</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>1700000</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FII Parque Dom Pedro Shopping center </Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>366094.4</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CSHG Real Estate FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>282714.94</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Bradesco Carteira Imobiliária Ativa FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>91616.88</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Bradesco Carteira Imobiliária Ativa FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>1362379.62</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Bradesco Carteira Imobiliária Ativa FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>324443.23</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Bradesco Carteira Imobiliária Ativa FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>187900.48</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Bradesco Carteira Imobiliária Ativa FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>161671.29</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Bradesco Carteira Imobiliária Ativa FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>54054.39</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Bradesco Carteira Imobiliária Ativa FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>107031.62</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FII BTG Pactual Corporate Office Fund</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>406920.06</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>JS Real Estate Multigestão </Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>101529.95</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>JS Real Estate Multigestão </Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>14924.9</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Bradesco Carteira Imobiliária Ativa FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>928768.53</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>GESTOR: RBR GESTÃO DE RECURSOS LTDA.
CNPJ: 18.259.351/0001-87
Av. Brg. Faria Lima, 3015 - Jardim Paulistano, São Paulo - SP, 01452-000
TEL: (11) 4083-9144
</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O fundo distribuiu de rendimentos o equivalente a R$ 8,5437 em 2018, o que representa um Dividend Yield de 8,59% a.a. considerando a cota de Fechamento 2018 de (R$ 99,51). Em complemento, a cota patrimonial encerrou 2018 em R$ 97,93 comparativamente à cota PL inicial de 2018 do fundo de R$ 97,18 com valorização no ano (2018) de 0,77% e acumulada desde o início do fundo (Set/17) de 2,43%.</ResultadoFundo>
			<ConjunturaEconomica>Expectativa de cenário com manutenção de juros baixos (abaixo de 2 dígitos) pelos próximos anos e recuperação econômica com crescimento do PIB. Como resultado, esperamos redução nos níveis de vacância dos ativos de propriedade dos fundos imobiliários e em especial em Imóveis Corporativos, AAA e localizados em São Paulo.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Expectativa de recuperação do PIB, consequente redução de vacância nos Imóveis dos fundos em carteira com consequente aumento nos dividendos pagos pelos fundos investidos e de valorização dos ativos no mercado secundário. As principais casas de pesquisa imobiliária, projetam um cenário positivo para os próximos anos no mercado de imóveis corporativos (com maior ênfase para São Paulo).</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Cotas FII Bradesco Carteira Imobiliária Ativa </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4403835.72</Valor>
				<PercentValorizacaoDesvalorizacao>0.0330594305369769</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas Fundo de Investimento Imobiliário FII BTG Pactual Corporate Office Fund</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>15587501.25</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0112174838023401</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII BTG Pactual Fundo de CRI</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7086960</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0209574584481336</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Castello Branco Office Park  Fundo de Investimento Imobiliário - FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4404289.59</Valor>
				<PercentValorizacaoDesvalorizacao>-0.00842276864556457</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII VBI FL 4440</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>16364535.89</Valor>
				<PercentValorizacaoDesvalorizacao>0.0150200803212852</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas CSHG Brasil Shopping Fundo de Investimento Imobiliario</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2758968</Valor>
				<PercentValorizacaoDesvalorizacao>0.00210084033613445</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas CSHG Brasil Shopping Fundo de Investimento Imobiliario - direito de preferência</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>31262.52</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas CSHG Logistica</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7509320.86</Valor>
				<PercentValorizacaoDesvalorizacao>0.0392142857142859</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas CSHG Real Estate </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6973741.6</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0283227318379644</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII CSHG Renda Urbana - Fundo de Investimento Imobiliário - FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6844058.7</Valor>
				<PercentValorizacaoDesvalorizacao>0.0190657769304099</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas JS Real Estate Multigestão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6517219.17</Valor>
				<PercentValorizacaoDesvalorizacao>0.0204950495049505</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Kinea Rendimentos Imobiliários Fundo de Investimento Imobiliário FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3889125.8</Valor>
				<PercentValorizacaoDesvalorizacao>-0.00264200792602376</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Kinea Rendimentos Imobiliários Fundo de Investimento Imobiliário FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4506000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0272192586513471</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Mogno</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>480528</Valor>
				<PercentValorizacaoDesvalorizacao>0.0128218941924361</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Ourinvest JPP</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3595490.21</Valor>
				<PercentValorizacaoDesvalorizacao>0.0395760404511862</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Parque Dom Pedro Shopping</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>793502.22</Valor>
				<PercentValorizacaoDesvalorizacao>0.0251966666666668</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII SDI Rio Bravo Renda Logística</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>601838</Valor>
				<PercentValorizacaoDesvalorizacao>0.0660377358490567</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII TB Office</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>672100.92</Valor>
				<PercentValorizacaoDesvalorizacao>0.0492592592592591</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Torre Norte</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>9537740.86</Valor>
				<PercentValorizacaoDesvalorizacao>0.114228571428572</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Valora RE III FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>901000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Valora RE III FII - direito de preferência</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>139.08</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Vinci Logística </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7500000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Vinci Shopping Centers</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7522314</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0092592592592593</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII XP Hotéis</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1500000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Valora RE I FII</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>592297.06</Valor>
				<PercentValorizacaoDesvalorizacao>-0.000475373524838618</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Barigui</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>12063600</Valor>
				<PercentValorizacaoDesvalorizacao>0.00530000000000008</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII SDI Rio Bravo Renda Logística</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>1254074</Valor>
				<PercentValorizacaoDesvalorizacao>0.175491521897431</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII JPP Allocation</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>1000000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 17I0152208</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>858865.07843</Valor>
				<PercentValorizacaoDesvalorizacao>-0.012690176165472</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 17B0048606</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1304744.651285</Valor>
				<PercentValorizacaoDesvalorizacao>0.00178208265383817</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 17J0158695</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1292068.848</Valor>
				<PercentValorizacaoDesvalorizacao>0.000737755600869416</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18C0693219</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1245037.2744</Valor>
				<PercentValorizacaoDesvalorizacao>0.000393008484371959</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 17K0150400</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>974625.286671</Valor>
				<PercentValorizacaoDesvalorizacao>-0.00217757010889097</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18E0913223</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>902640.663</Valor>
				<PercentValorizacaoDesvalorizacao>0.000892322262000311</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18G0817265</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1057714.558357</Valor>
				<PercentValorizacaoDesvalorizacao>0.0000948075721831643</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18H0860172</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>964970.489019</Valor>
				<PercentValorizacaoDesvalorizacao>-0.000376134263695094</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18I0295172</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>987354.792216</Valor>
				<PercentValorizacaoDesvalorizacao>0.000346663018482296</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18D0788427</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1911199.7542</Valor>
				<PercentValorizacaoDesvalorizacao>0.00178029877602737</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18F0668321</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3323824.722382</Valor>
				<PercentValorizacaoDesvalorizacao>0.0105344327184478</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18L1128176</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3533615.2775</Valor>
				<PercentValorizacaoDesvalorizacao>0.00585842951718329</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 18L1168429</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3525013.216029</Valor>
				<PercentValorizacaoDesvalorizacao>-0.00999490867266895</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI 19A0625067</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1703514.0156</Valor>
				<PercentValorizacaoDesvalorizacao>0.00206706800000012</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Método utilizado para cotas de FII mercado: valor das cotas dos fundos divulgadas na B3,  Método utilizado para CRI: taxa de negociação, Método utilizado para cotas de FII balcão: valor das cotas dos fundos divulgado pelo administrador onde os recursos são aplicados</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</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 do regulamento vigente do fundo e estatuto social do seu administrador e/ou gestor, conforme o caso, 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á uma taxa de administração composta de: (a) valor equivalente a 0,20% (vinte centésimos por cento) à razão de 1/12 avos, calculada (a.1) sobre o valor contábil do patrimônio líquido do FUNDO; ou (a.2) caso as cotas do FUNDO 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 IFIX, sobre o valor de mercado do FUNDO, 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 (“Base de Cálculo da Taxa de Administração”) e que deverá ser pago diretamente à ADMINISTRADORA, observado o valor mínimo mensal de R$ 23.000,00 (vinte e três mil reais), atualizado anualmente segundo a variação do IGP-M (Índice Geral de Preços de Mercado), apurado e divulgado pela Fundação Getúlio Vargas – FGV, a partir do mês subsequente à data de funcionamento do Fundo;  (b) valor equivalente a 0,80% a.a. (oitenta centésimos por cento) ao ano, calculado sobre a mesma Base de Cálculo da Taxa de Administração, acima definida correspondente aos serviços de gestão dos ativos integrantes da carteira do FUNDO, a ser pago ao GESTOR, nos termos do §3º deste artigo; e  (c) valor equivalente a até 0,10% (dez centésimos por cento) ao ano à razão de 1/12 avos, calculada sobre o valor contábil do patrimônio líquido do FUNDO, correspondente aos serviços de escrituração das cotas do FUNDO, a ser pago a terceiros, nos termos do §3º deste artigo (“Taxa de Escrituração”). Ver no regulamento § 1º, ao 6º</PoliticaRemuneracao>
			<ValorPagoAno>31159.69</ValorPagoAno>
			<PercentPatrimonioContabil>0.0002</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.000186742739439652</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.</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="4904" numCotasDetidas="1623931" percDetidoRelTotal="1" percDetidoPF="0.959125110611227" percDetidoPJ="0.0408748893887733"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
			<Ativo>
				<AtivoNegociado>FII PDP Shopping Center </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-02</DataTransacao>
				<ValorEnvolvido>366094.4</ValorEnvolvido>
				<DataAssembleia>2017-09-28</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM </Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>FII BTG Pactual Corporate Office Fund</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-24</DataTransacao>
				<ValorEnvolvido>406920.06</ValorEnvolvido>
				<DataAssembleia>2017-09-28</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM </Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>FII Torre Norte</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-30</DataTransacao>
				<ValorEnvolvido>37232.1</ValorEnvolvido>
				<DataAssembleia>2017-09-28</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM </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>
"