"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FII BTG PACTUAL FUNDO DE FUNDOS</NomeFundo>
		<CNPJFundo>11026627000138</CNPJFundo>
		<DataFuncionamento>2013-06-03</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRBCFFCTF000</CodigoISIN>
		<QtdCotasEmitidas>8449360</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Títulos e Valores Mobiliários</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>11026627000138</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-08-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>BTG PACTUAL GESTORA DE RECURSOS LTDA</Nome>
				<CNPJ>09.631.542/0001-37</CNPJ>
				<Endereco>AV BRIGADEIRO FARIA LIMA 3477 – 14º andar</Endereco>
				<telefone>(21) 2262-5115</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO BTG PACTUAL S.A</Nome>
				<CNPJ>30.306.294/0001-45</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO 501 - 5,6,7 ANDARES</Endereco>
				<telefone>(21) 3262-9757</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>ERNST &amp; YOUNG TERCO AUDITORES INDEPENDENTES</Nome>
				<CNPJ>61.366.936/0002-06</CNPJ>
				<Endereco>Av. Presidente Juscelino Kubitschek, 1.909 - Vila Olimpia - SP - CEP: 04543-011</Endereco>
				<telefone>11 2573-3000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
					<Ativo>
						<Nome>Cotas de fundos CSHG Renda Urbana FII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>513660.29</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de Fundos FII AESAPAR</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>344393.15</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII Água Branca</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>2890607.93</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII Anhanguera Educacional</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>1633035.08</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII Banestes Recebiveis Imobiliarios</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>117.28</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII BB ProgressivoII</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>2670844.53</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII Campus Faria Lima</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>1181152.77</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII CEO Cyrela Commercial Properties</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>29905.4</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII CSHG GR Louveira</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>2043761.46</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII CSHG JHSF Prime Offices</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>14067.06</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII CSHG Logistica</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>3799999.63</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII HSI Malls</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>5851300</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII Imobiliário FII BTG Shoppings</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>70000000</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII JS Real Estate Muitigestão</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>365024.31</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII Kinea Rendimentos Imobiliários</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>4522769.31</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII Maxi Renda</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>9608662.4</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII TRX Edificios Corporativos</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>15847378.46</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FII Valora</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>4124538.15</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos FIIVia Parque Shopping</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>10344017.11</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas de fundos Floripa Shopping</Nome>
						<Objetivos>Lucro na Venda</Objetivos>
						<MontantesInvestidos>5063151.97</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Os ativos-alvo do Fundo serão preponderantemente outros Fundos de Investimento imobiliário que compõe o IFIX, índice que representa o fundos imobiliários mais líquidos do setor.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo distribuiu a título de rendimentos o equivalente a R$6,22 por cota, o que representa um Dividend Yield de 7,24% considerando a cota de Fechamento de 2018 (R$85,90). Quando considerado rendimento mais a valorização da cota no mercado secundário, o Fundo obteve um retorno de 17,4% em 2018.</ResultadoFundo>
			<ConjunturaEconomica>A redução da Taxa Selic e as perspectivas de retomada do mercado imobiliário impulsionaram o mercado de Fundos de Investimento Imobiliário, contribuindo para um retorno do IFIX de 5,7% em 2018.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A expectativa de um patamar de Juros baixos para 2019 deve seguir impulsionando o mercado de Fundos de Investimento Imobiliário. Adicionalmente, as principais Consultorias especializadas em Real Estate projetam um cenário positivo para 2019, com melhora na ocupação, principalmente no setor de edifícios corporativos.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>CRI Ativo CRI 10D0018560</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>94998.54193</Valor>
				<PercentValorizacaoDesvalorizacao>0.00364359838673933</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI Ativo CRI 10D0018564</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>166488.959492</Valor>
				<PercentValorizacaoDesvalorizacao>0.156076492732139</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI Ativo CRI 11A0027576</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>99202.0936487406</Valor>
				<PercentValorizacaoDesvalorizacao>-0.130833922338508</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI Ativo CRI 11F0031919</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>101996.358335</Valor>
				<PercentValorizacaoDesvalorizacao>0.087385803856795</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI Ativo CRI 11F0039975</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>62360.848457</Valor>
				<PercentValorizacaoDesvalorizacao>0.00984659322493808</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI Ativo CRI 11H0020284</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>66079.3314607093</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0317891006739546</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI Ativo CRI 11H0022430</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>63617.671242</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0119099044650316</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI Ativo CRI 11K0018241</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>96107.713385</Valor>
				<PercentValorizacaoDesvalorizacao>0.0166535431071582</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI Ativo CRI 13B0036712</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>253784.924073</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0371765317096932</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII BB ProgressivoII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>149.52</Valor>
				<PercentValorizacaoDesvalorizacao>0.0689162138976267</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Banestes Recebiveis Imobiliarios</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>130.85</Valor>
				<PercentValorizacaoDesvalorizacao>0.189545454545454</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Imobiliário rio Bravo renda Corporativa</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>91</Valor>
				<PercentValorizacaoDesvalorizacao>-0.141509433962264</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Imobiliário FII BTG Shoppings</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>100</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII BTG Pactual Corporate Office Fund</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>97.13</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0607291364471522</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII BTG Pactual Crédito Imobiliário FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>101.52</Valor>
				<PercentValorizacaoDesvalorizacao>0.0151999999999999</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos castello branco Office</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>80.98</Valor>
				<PercentValorizacaoDesvalorizacao>0.100122265996468</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII CEO Cyrela Commercial Properties</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>84.07</Valor>
				<PercentValorizacaoDesvalorizacao>0.0647163120567376</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Cenesp</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>86.12</Valor>
				<PercentValorizacaoDesvalorizacao>0.0812303829252981</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos  FII Edifício Galeria - FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>51</Valor>
				<PercentValorizacaoDesvalorizacao>0.172413793103448</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Anhanguera Educacional</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>243</Valor>
				<PercentValorizacaoDesvalorizacao>0.173913043478261</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Campus Faria Lima</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2370</Valor>
				<PercentValorizacaoDesvalorizacao>0.19215291750503</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Excellence</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>114.9</Valor>
				<PercentValorizacaoDesvalorizacao>0.0738317757009346</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos  FII General Shopping Ativo e Renda</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>64.2</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0880681818181819</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos Floripa Shopping</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1340</Valor>
				<PercentValorizacaoDesvalorizacao>0.0806364464802702</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Água Branca</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>370</Valor>
				<PercentValorizacaoDesvalorizacao>0.117655943210995</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FIIVia Parque Shopping</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>184</Valor>
				<PercentValorizacaoDesvalorizacao>0.0402532790592491</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII GGR Covepi Renda</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>144.9</Valor>
				<PercentValorizacaoDesvalorizacao>0.0742086144265699</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII CSHG GR Louveira</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>118.99</Valor>
				<PercentValorizacaoDesvalorizacao>0.211710794297352</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII CSHG Brasil Shopping</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>250.9</Valor>
				<PercentValorizacaoDesvalorizacao>0.0542016806722689</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII CGHG Recebíveis Imobiliários</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>116.05</Valor>
				<PercentValorizacaoDesvalorizacao>0.00825369244135521</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII CSHG Logistica</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>160.6</Valor>
				<PercentValorizacaoDesvalorizacao>0.147142857142857</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos CSHG Renda Urbana FII</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>112.5</Valor>
				<PercentValorizacaoDesvalorizacao>0.0724499523355575</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII HIS Malls</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>100</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Hotel Maxinvest </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>181.22</Valor>
				<PercentValorizacaoDesvalorizacao>0.22445945945946</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII IRIDIUM</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>112.8</Valor>
				<PercentValorizacaoDesvalorizacao>0.030231071330715</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Shopping Jardim Sul </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>89.7</Valor>
				<PercentValorizacaoDesvalorizacao>0.268920639411515</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII JS Real Estate Muitigestão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>112.5</Valor>
				<PercentValorizacaoDesvalorizacao>0.113861386138614</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Kinea Rendimentos Imobiliários</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>104.29</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0159464049820721</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Kinea Indice de Precos </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>118.99</Valor>
				<PercentValorizacaoDesvalorizacao>0.0832043695949021</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Max Retail</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>12.03</Valor>
				<PercentValorizacaoDesvalorizacao>0.1748046875</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>246.12</Valor>
				<PercentValorizacaoDesvalorizacao>0.106157303370787</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de Fundos FII AESAPAR</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>175</Valor>
				<PercentValorizacaoDesvalorizacao>0.10062893081761</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundo FII RBR Properties</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>81.56</Valor>
				<PercentValorizacaoDesvalorizacao>0.00691358024691358</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundo FII RBR Private Credito Imobiliario</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>117</Valor>
				<PercentValorizacaoDesvalorizacao>0.136142940376772</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Santander Agências</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>128.72</Valor>
				<PercentValorizacaoDesvalorizacao>0.000155400155400276</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Imobiliário rio Bravo renda Corporativa</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>91</Valor>
				<PercentValorizacaoDesvalorizacao>-0.141509433962264</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII TB Office </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>85</Valor>
				<PercentValorizacaoDesvalorizacao>0.0493827160493827</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII TRX Edificios Corporativos</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>107.5</Valor>
				<PercentValorizacaoDesvalorizacao>0.414473684210526</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Valora</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>106.97</Valor>
				<PercentValorizacaoDesvalorizacao>0.0697000000000001</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Vinci Shopping Centers</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>112.42</Valor>
				<PercentValorizacaoDesvalorizacao>0.040925925925926</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII Shopping West Plaza</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>93.5</Valor>
				<PercentValorizacaoDesvalorizacao>0.298611111111111</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>107.5</Valor>
				<PercentValorizacaoDesvalorizacao>-0.00278293135435992</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas de fundos FII SDI Logistica</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>114</Valor>
				<PercentValorizacaoDesvalorizacao>0.0754716981132075</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Método utilizado para CRI: taxa de negociação e método utilizado para cotas de FII mercado: valor das cotas dos fundos divulgadas na B3 </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 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,150% (cento e cinquenta milésimos por cento) à razão de 1/12 avos, aplicados sobre o valor total dos ativos que integrarem o patrimônio do FUNDO vigente no último dia útil do mês anterior observado o valor mínimo de R$ 25.000,00 (vinte e cinco mil reais), valor este que será corrigido anualmente pela variação do IGP-M (Índice Geral de Preços de Mercado), apurado e divulgado pela Fundação Getúlio Vargas – FGV, que deverá ser pago diretamente à ADMINISTRADORA, acrescido ainda do valor equivalente a até 0,30% (trinta centésimos por cento) ao ano à razão de 1/12 avos, calculada (1) sobre o valor contábil do patrimônio líquido do Fundo; ou (2) sobre o valor de mercado do Fundo, caso a Taxa de Administração seja calculada sobre o valor de mercado do Fundo; correspondente aos serviços de escrituração das cotas do Fundo, incluído na Taxa de Administração e a ser pago a terceiros
§1º - 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 mês em que os serviços forem prestados.</PoliticaRemuneracao>
			<ValorPagoAno>1448027.31</ValorPagoAno>
			<PercentPatrimonioContabil>0.0019</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0019</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="67417" numCotasDetidas="8449360" percDetidoRelTotal="1" percDetidoPF="0.9689" percDetidoPJ="0.0311"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-01</DataTransacao>
				<ValorEnvolvido>1706922.48</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-07</DataTransacao>
				<ValorEnvolvido>-246258.52</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-07</DataTransacao>
				<ValorEnvolvido>23012.45</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-08</DataTransacao>
				<ValorEnvolvido>-268167.8</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BB ProgressivoII</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-08</DataTransacao>
				<ValorEnvolvido>-1396832.82</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Campus Faria Lima</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-08</DataTransacao>
				<ValorEnvolvido>-409690.75</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-08</DataTransacao>
				<ValorEnvolvido>3192211.94</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-09</DataTransacao>
				<ValorEnvolvido>384575.12</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-09</DataTransacao>
				<ValorEnvolvido>261966.72</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-09</DataTransacao>
				<ValorEnvolvido>19581.97</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-10</DataTransacao>
				<ValorEnvolvido>-51361.32</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-10</DataTransacao>
				<ValorEnvolvido>905762.86</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-10</DataTransacao>
				<ValorEnvolvido>344616.67</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-10</DataTransacao>
				<ValorEnvolvido>113171.62</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-10</DataTransacao>
				<ValorEnvolvido>37189.26</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-11</DataTransacao>
				<ValorEnvolvido>-31481.14</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-11</DataTransacao>
				<ValorEnvolvido>701453.64</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-11</DataTransacao>
				<ValorEnvolvido>478282.6</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-11</DataTransacao>
				<ValorEnvolvido>11612.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-11</DataTransacao>
				<ValorEnvolvido>6764.31</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-14</DataTransacao>
				<ValorEnvolvido>-63465.81</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-14</DataTransacao>
				<ValorEnvolvido>36956.51</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-14</DataTransacao>
				<ValorEnvolvido>237582.63</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-14</DataTransacao>
				<ValorEnvolvido>223418.89</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-15</DataTransacao>
				<ValorEnvolvido>-275821.72</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-15</DataTransacao>
				<ValorEnvolvido>32499.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-15</DataTransacao>
				<ValorEnvolvido>337835.51</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-17</DataTransacao>
				<ValorEnvolvido>-86205.54</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-17</DataTransacao>
				<ValorEnvolvido>314122.73</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Campus Faria Lima</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-17</DataTransacao>
				<ValorEnvolvido>-33098.67</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-17</DataTransacao>
				<ValorEnvolvido>473945.09</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-17</DataTransacao>
				<ValorEnvolvido>13239.57</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-17</DataTransacao>
				<ValorEnvolvido>282104.88</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>-182047.78</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Campus Faria Lima</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>-678425.02</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Campus Faria Lima</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>8091.99</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BB ProgressivoII</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>-771428.97</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>182202.85</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>65398.37</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>137042.89</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-23</DataTransacao>
				<ValorEnvolvido>-65773.84</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-23</DataTransacao>
				<ValorEnvolvido>130807.59</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-23</DataTransacao>
				<ValorEnvolvido>71118.2</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-23</DataTransacao>
				<ValorEnvolvido>124681.47</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-23</DataTransacao>
				<ValorEnvolvido>5523.04</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-24</DataTransacao>
				<ValorEnvolvido>-62127.57</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-24</DataTransacao>
				<ValorEnvolvido>151797.5</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-24</DataTransacao>
				<ValorEnvolvido>449984.2</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-24</DataTransacao>
				<ValorEnvolvido>46968.4</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-24</DataTransacao>
				<ValorEnvolvido>140410.38</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-28</DataTransacao>
				<ValorEnvolvido>-77230.37</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-28</DataTransacao>
				<ValorEnvolvido>181490.02</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-28</DataTransacao>
				<ValorEnvolvido>37945.73</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-28</DataTransacao>
				<ValorEnvolvido>123476.4</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-29</DataTransacao>
				<ValorEnvolvido>170681.02</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-29</DataTransacao>
				<ValorEnvolvido>7576.34</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-29</DataTransacao>
				<ValorEnvolvido>140874.36</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII CEO Cyrela Commercial Properties</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-30</DataTransacao>
				<ValorEnvolvido>-27247.43</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-30</DataTransacao>
				<ValorEnvolvido>-97306.82</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BB ProgressivoII</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-30</DataTransacao>
				<ValorEnvolvido>-208428.82</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-30</DataTransacao>
				<ValorEnvolvido>1664862.1</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-30</DataTransacao>
				<ValorEnvolvido>43211.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-31</DataTransacao>
				<ValorEnvolvido>-142164.12</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-31</DataTransacao>
				<ValorEnvolvido>191244.64</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-31</DataTransacao>
				<ValorEnvolvido>-226.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-31</DataTransacao>
				<ValorEnvolvido>52505.59</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-31</DataTransacao>
				<ValorEnvolvido>15654.01</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-01</DataTransacao>
				<ValorEnvolvido>1397551.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-01</DataTransacao>
				<ValorEnvolvido>30006.96</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-04</DataTransacao>
				<ValorEnvolvido>10362</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-05</DataTransacao>
				<ValorEnvolvido>-171214.54</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-07</DataTransacao>
				<ValorEnvolvido>-33837.55</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BB ProgressivoII</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-07</DataTransacao>
				<ValorEnvolvido>-279617.26</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-07</DataTransacao>
				<ValorEnvolvido>47463.61</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-08</DataTransacao>
				<ValorEnvolvido>-102880.83</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BB ProgressivoII</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-08</DataTransacao>
				<ValorEnvolvido>-49292.07</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-08</DataTransacao>
				<ValorEnvolvido>61787.45</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-08</DataTransacao>
				<ValorEnvolvido>4014.61</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-11</DataTransacao>
				<ValorEnvolvido>26680.04</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-11</DataTransacao>
				<ValorEnvolvido>3679.39</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-18</DataTransacao>
				<ValorEnvolvido>27383.55</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-21</DataTransacao>
				<ValorEnvolvido>-169287.34</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Campus Faria Lima</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-21</DataTransacao>
				<ValorEnvolvido>-68030.32</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TRX Edificios Corporativos</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-21</DataTransacao>
				<ValorEnvolvido>-771161.49</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TRX Edificios Corporativos</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-21</DataTransacao>
				<ValorEnvolvido>182.9</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-21</DataTransacao>
				<ValorEnvolvido>232913.67</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-22</DataTransacao>
				<ValorEnvolvido>-73083.66</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-22</DataTransacao>
				<ValorEnvolvido>-10000000</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-22</DataTransacao>
				<ValorEnvolvido>-22563.72</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-22</DataTransacao>
				<ValorEnvolvido>150378.18</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-25</DataTransacao>
				<ValorEnvolvido>-99347.33</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-25</DataTransacao>
				<ValorEnvolvido>325855.21</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-25</DataTransacao>
				<ValorEnvolvido>188291.9</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-26</DataTransacao>
				<ValorEnvolvido>-13149.22</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-26</DataTransacao>
				<ValorEnvolvido>110657.39</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-27</DataTransacao>
				<ValorEnvolvido>163240.32</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-27</DataTransacao>
				<ValorEnvolvido>6612.25</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-28</DataTransacao>
				<ValorEnvolvido>134817.99</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BB ProgressivoII</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-28</DataTransacao>
				<ValorEnvolvido>-29992.2</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-28</DataTransacao>
				<ValorEnvolvido>-23649.51</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-28</DataTransacao>
				<ValorEnvolvido>25517.08</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-28</DataTransacao>
				<ValorEnvolvido>55405.9</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TRX Edificios Corporativos</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-07</DataTransacao>
				<ValorEnvolvido>-7382698.08</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-07</DataTransacao>
				<ValorEnvolvido>138812.54</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TRX Edificios Corporativos</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-08</DataTransacao>
				<ValorEnvolvido>-60859.58</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-08</DataTransacao>
				<ValorEnvolvido>243327.02</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-11</DataTransacao>
				<ValorEnvolvido>127063.63</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-11</DataTransacao>
				<ValorEnvolvido>-169971.96</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-11</DataTransacao>
				<ValorEnvolvido>796725.39</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-12</DataTransacao>
				<ValorEnvolvido>521305.68</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-12</DataTransacao>
				<ValorEnvolvido>-338240.96</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-12</DataTransacao>
				<ValorEnvolvido>205386.63</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-12</DataTransacao>
				<ValorEnvolvido>25510.01</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-12</DataTransacao>
				<ValorEnvolvido>985550.78</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-13</DataTransacao>
				<ValorEnvolvido>113125.7</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-13</DataTransacao>
				<ValorEnvolvido>-66941.25</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-13</DataTransacao>
				<ValorEnvolvido>139674.58</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-14</DataTransacao>
				<ValorEnvolvido>26001.02</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-14</DataTransacao>
				<ValorEnvolvido>237942.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-14</DataTransacao>
				<ValorEnvolvido>-159922.63</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-14</DataTransacao>
				<ValorEnvolvido>81669.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-14</DataTransacao>
				<ValorEnvolvido>-4143491.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-14</DataTransacao>
				<ValorEnvolvido>144460.05</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-15</DataTransacao>
				<ValorEnvolvido>181355.67</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-15</DataTransacao>
				<ValorEnvolvido>-52515.56</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-15</DataTransacao>
				<ValorEnvolvido>167317.12</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-15</DataTransacao>
				<ValorEnvolvido>65381.96</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-15</DataTransacao>
				<ValorEnvolvido>12286.97</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-18</DataTransacao>
				<ValorEnvolvido>233400.3</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-18</DataTransacao>
				<ValorEnvolvido>-138120.6</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-18</DataTransacao>
				<ValorEnvolvido>446685.32</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-18</DataTransacao>
				<ValorEnvolvido>61345.75</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-19</DataTransacao>
				<ValorEnvolvido>260528.14</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-19</DataTransacao>
				<ValorEnvolvido>-131887.85</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-19</DataTransacao>
				<ValorEnvolvido>3389.16</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-19</DataTransacao>
				<ValorEnvolvido>81959.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-20</DataTransacao>
				<ValorEnvolvido>333582.81</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-20</DataTransacao>
				<ValorEnvolvido>-770186.78</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-20</DataTransacao>
				<ValorEnvolvido>12090.67</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-20</DataTransacao>
				<ValorEnvolvido>92462.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-21</DataTransacao>
				<ValorEnvolvido>166735.23</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-21</DataTransacao>
				<ValorEnvolvido>-704262.1</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-21</DataTransacao>
				<ValorEnvolvido>64150.32</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-22</DataTransacao>
				<ValorEnvolvido>224097.62</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-22</DataTransacao>
				<ValorEnvolvido>-39833.32</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-22</DataTransacao>
				<ValorEnvolvido>30963</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-25</DataTransacao>
				<ValorEnvolvido>326939.61</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-25</DataTransacao>
				<ValorEnvolvido>-126047.43</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-26</DataTransacao>
				<ValorEnvolvido>55801.46</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-26</DataTransacao>
				<ValorEnvolvido>-56543.46</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-27</DataTransacao>
				<ValorEnvolvido>134282.09</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-27</DataTransacao>
				<ValorEnvolvido>-344864.95</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-28</DataTransacao>
				<ValorEnvolvido>95516.6</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-28</DataTransacao>
				<ValorEnvolvido>-111671.13</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-29</DataTransacao>
				<ValorEnvolvido>149336.29</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-29</DataTransacao>
				<ValorEnvolvido>-51047.88</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-01</DataTransacao>
				<ValorEnvolvido>172001.26</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-01</DataTransacao>
				<ValorEnvolvido>-78472.68</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-02</DataTransacao>
				<ValorEnvolvido>4522.37</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-03</DataTransacao>
				<ValorEnvolvido>94960.76</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-05</DataTransacao>
				<ValorEnvolvido>138734.75</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TRX Edificios Corporativos</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-05</DataTransacao>
				<ValorEnvolvido>-7632842.21</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-08</DataTransacao>
				<ValorEnvolvido>57689.18</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-11</DataTransacao>
				<ValorEnvolvido>106516.4</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-15</DataTransacao>
				<ValorEnvolvido>1539.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-15</DataTransacao>
				<ValorEnvolvido>-352347.69</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-16</DataTransacao>
				<ValorEnvolvido>21230.18</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-16</DataTransacao>
				<ValorEnvolvido>-34202.4</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-17</DataTransacao>
				<ValorEnvolvido>-56480.76</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-18</DataTransacao>
				<ValorEnvolvido>210188.05</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-22</DataTransacao>
				<ValorEnvolvido>-119548.72</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-22</DataTransacao>
				<ValorEnvolvido>56699.89</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-22</DataTransacao>
				<ValorEnvolvido>-103152.29</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-23</DataTransacao>
				<ValorEnvolvido>-23985.84</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-24</DataTransacao>
				<ValorEnvolvido>-92451.53</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Maxi Renda</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-25</DataTransacao>
				<ValorEnvolvido>-9608662.4</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-26</DataTransacao>
				<ValorEnvolvido>126374.76</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-26</DataTransacao>
				<ValorEnvolvido>-35809.28</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-26</DataTransacao>
				<ValorEnvolvido>60126.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-26</DataTransacao>
				<ValorEnvolvido>128339</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-29</DataTransacao>
				<ValorEnvolvido>245187.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-03</DataTransacao>
				<ValorEnvolvido>49126.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-03</DataTransacao>
				<ValorEnvolvido>286789.52</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-08</DataTransacao>
				<ValorEnvolvido>91512.77</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-09</DataTransacao>
				<ValorEnvolvido>158994.97</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-09</DataTransacao>
				<ValorEnvolvido>749914.54</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-10</DataTransacao>
				<ValorEnvolvido>76195.16</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-10</DataTransacao>
				<ValorEnvolvido>167545.27</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-13</DataTransacao>
				<ValorEnvolvido>88073.67</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-13</DataTransacao>
				<ValorEnvolvido>140614.83</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-14</DataTransacao>
				<ValorEnvolvido>64780.61</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-14</DataTransacao>
				<ValorEnvolvido>29113.48</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos Floripa Shopping</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-15</DataTransacao>
				<ValorEnvolvido>-5003717.6</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-15</DataTransacao>
				<ValorEnvolvido>21171.2</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-15</DataTransacao>
				<ValorEnvolvido>77981.51</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-16</DataTransacao>
				<ValorEnvolvido>230007.36</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-20</DataTransacao>
				<ValorEnvolvido>46663.52</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BB ProgressivoII</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-22</DataTransacao>
				<ValorEnvolvido>7913.87</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-22</DataTransacao>
				<ValorEnvolvido>107857.94</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos Floripa Shopping</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-27</DataTransacao>
				<ValorEnvolvido>-19414.46</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-28</DataTransacao>
				<ValorEnvolvido>2285.99</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-28</DataTransacao>
				<ValorEnvolvido>315790.98</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-29</DataTransacao>
				<ValorEnvolvido>286416.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-30</DataTransacao>
				<ValorEnvolvido>400003.56</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos Floripa Shopping</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-31</DataTransacao>
				<ValorEnvolvido>-9086.81</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-04</DataTransacao>
				<ValorEnvolvido>14741.88</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-04</DataTransacao>
				<ValorEnvolvido>279640.54</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-05</DataTransacao>
				<ValorEnvolvido>1164.23</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-05</DataTransacao>
				<ValorEnvolvido>56508.4</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-05</DataTransacao>
				<ValorEnvolvido>264408.03</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-06</DataTransacao>
				<ValorEnvolvido>433311.6</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-07</DataTransacao>
				<ValorEnvolvido>-149805.87</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-07</DataTransacao>
				<ValorEnvolvido>1135654.61</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-10</DataTransacao>
				<ValorEnvolvido>23813.07</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-10</DataTransacao>
				<ValorEnvolvido>90343.47</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-10</DataTransacao>
				<ValorEnvolvido>292315.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundo FII RBR Properties</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-10</DataTransacao>
				<ValorEnvolvido>484139.25</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-11</DataTransacao>
				<ValorEnvolvido>317185.74</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-12</DataTransacao>
				<ValorEnvolvido>120102.62</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-12</DataTransacao>
				<ValorEnvolvido>10318.57</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-12</DataTransacao>
				<ValorEnvolvido>157807.55</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-12</DataTransacao>
				<ValorEnvolvido>1227921.73</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-13</DataTransacao>
				<ValorEnvolvido>22845.27</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-13</DataTransacao>
				<ValorEnvolvido>190690.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-13</DataTransacao>
				<ValorEnvolvido>18335.26</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-14</DataTransacao>
				<ValorEnvolvido>55669.91</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-14</DataTransacao>
				<ValorEnvolvido>183962.88</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-14</DataTransacao>
				<ValorEnvolvido>52146.82</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-14</DataTransacao>
				<ValorEnvolvido>231101.68</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-14</DataTransacao>
				<ValorEnvolvido>143099.2</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-17</DataTransacao>
				<ValorEnvolvido>255244.13</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-17</DataTransacao>
				<ValorEnvolvido>22478.45</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-17</DataTransacao>
				<ValorEnvolvido>43496.3</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-17</DataTransacao>
				<ValorEnvolvido>425385.16</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-17</DataTransacao>
				<ValorEnvolvido>327144.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-18</DataTransacao>
				<ValorEnvolvido>265160.17</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-18</DataTransacao>
				<ValorEnvolvido>469.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BB ProgressivoII</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-18</DataTransacao>
				<ValorEnvolvido>56833.74</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-18</DataTransacao>
				<ValorEnvolvido>1676669.26</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-18</DataTransacao>
				<ValorEnvolvido>310526.88</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-18</DataTransacao>
				<ValorEnvolvido>113597.99</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos Floripa Shopping</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-19</DataTransacao>
				<ValorEnvolvido>-28259.13</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-19</DataTransacao>
				<ValorEnvolvido>51162.98</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-19</DataTransacao>
				<ValorEnvolvido>69428.49</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-19</DataTransacao>
				<ValorEnvolvido>108176.28</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-19</DataTransacao>
				<ValorEnvolvido>187511.45</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-19</DataTransacao>
				<ValorEnvolvido>841535.12</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-24</DataTransacao>
				<ValorEnvolvido>4351.46</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-24</DataTransacao>
				<ValorEnvolvido>92109.7</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-24</DataTransacao>
				<ValorEnvolvido>377677.9</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BTG Pactual Crédito Imobiliário FII</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-24</DataTransacao>
				<ValorEnvolvido>21070.8</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Excellence</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-25</DataTransacao>
				<ValorEnvolvido>40394.22</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-25</DataTransacao>
				<ValorEnvolvido>2730744.31</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-25</DataTransacao>
				<ValorEnvolvido>237832.36</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-25</DataTransacao>
				<ValorEnvolvido>475485.42</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hotel Maxinvest </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-26</DataTransacao>
				<ValorEnvolvido>6071.45</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-26</DataTransacao>
				<ValorEnvolvido>50674.3</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BTG Pactual Crédito Imobiliário FII</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-26</DataTransacao>
				<ValorEnvolvido>268990.83</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-27</DataTransacao>
				<ValorEnvolvido>197647.33</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII BTG Pactual Crédito Imobiliário FII</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-27</DataTransacao>
				<ValorEnvolvido>174776.48</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-02</DataTransacao>
				<ValorEnvolvido>267962.15</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-03</DataTransacao>
				<ValorEnvolvido>103749.23</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-03</DataTransacao>
				<ValorEnvolvido>201212.6</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-04</DataTransacao>
				<ValorEnvolvido>52979.07</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-04</DataTransacao>
				<ValorEnvolvido>40444.76</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-05</DataTransacao>
				<ValorEnvolvido>2013.24</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-08</DataTransacao>
				<ValorEnvolvido>65002.31</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-10</DataTransacao>
				<ValorEnvolvido>27094.75</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-11</DataTransacao>
				<ValorEnvolvido>209570.27</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-12</DataTransacao>
				<ValorEnvolvido>21609.69</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-12</DataTransacao>
				<ValorEnvolvido>49965.76</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-12</DataTransacao>
				<ValorEnvolvido>105663.49</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-12</DataTransacao>
				<ValorEnvolvido>341921.52</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-15</DataTransacao>
				<ValorEnvolvido>37169.36</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-15</DataTransacao>
				<ValorEnvolvido>61066.86</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-15</DataTransacao>
				<ValorEnvolvido>249848.02</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-16</DataTransacao>
				<ValorEnvolvido>2374.23</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-16</DataTransacao>
				<ValorEnvolvido>34041.78</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-16</DataTransacao>
				<ValorEnvolvido>16754.18</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-16</DataTransacao>
				<ValorEnvolvido>65363.01</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-16</DataTransacao>
				<ValorEnvolvido>332071.86</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-17</DataTransacao>
				<ValorEnvolvido>1546467.95</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-17</DataTransacao>
				<ValorEnvolvido>322936.36</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-18</DataTransacao>
				<ValorEnvolvido>47225.29</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-18</DataTransacao>
				<ValorEnvolvido>77033.16</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-18</DataTransacao>
				<ValorEnvolvido>55063.59</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-19</DataTransacao>
				<ValorEnvolvido>64652.4</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Shopping Jardim Sul </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-19</DataTransacao>
				<ValorEnvolvido>4756.57</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-19</DataTransacao>
				<ValorEnvolvido>9782.11</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-19</DataTransacao>
				<ValorEnvolvido>529101.3</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-19</DataTransacao>
				<ValorEnvolvido>644859.71</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>67564.14</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>235805.8</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>104707.09</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>340969.23</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>181602.02</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>166104.31</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-23</DataTransacao>
				<ValorEnvolvido>74064.53</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-23</DataTransacao>
				<ValorEnvolvido>791468.63</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-23</DataTransacao>
				<ValorEnvolvido>133314.63</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-23</DataTransacao>
				<ValorEnvolvido>240606.41</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-23</DataTransacao>
				<ValorEnvolvido>305003.6</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Imobiliário FII BTG Shoppings</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-24</DataTransacao>
				<ValorEnvolvido>-70000000</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-24</DataTransacao>
				<ValorEnvolvido>135828</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-24</DataTransacao>
				<ValorEnvolvido>669457.82</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Shopping Jardim Sul </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-24</DataTransacao>
				<ValorEnvolvido>1493.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-24</DataTransacao>
				<ValorEnvolvido>561680.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-24</DataTransacao>
				<ValorEnvolvido>161364.5</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-24</DataTransacao>
				<ValorEnvolvido>8575.09</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-25</DataTransacao>
				<ValorEnvolvido>27361.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-25</DataTransacao>
				<ValorEnvolvido>463665.37</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Shopping Jardim Sul </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-25</DataTransacao>
				<ValorEnvolvido>23169.21</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-25</DataTransacao>
				<ValorEnvolvido>50062.77</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-25</DataTransacao>
				<ValorEnvolvido>117379.98</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>77140.52</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>575696.18</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Shopping Jardim Sul </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>4571.6</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>534357.95</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>268252.23</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>50306.54</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII XP Malls Fundo de Investimento Imobiliário</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>14046.37</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII CEO Cyrela Commercial Properties</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-29</DataTransacao>
				<ValorEnvolvido>-2657.97</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-29</DataTransacao>
				<ValorEnvolvido>161041.66</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-29</DataTransacao>
				<ValorEnvolvido>578259.28</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Shopping Jardim Sul </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-29</DataTransacao>
				<ValorEnvolvido>22556.74</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-29</DataTransacao>
				<ValorEnvolvido>180377.12</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-29</DataTransacao>
				<ValorEnvolvido>243804.74</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Anhanguera Educacional</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-30</DataTransacao>
				<ValorEnvolvido>37801.48</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII IRIDIUM</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-30</DataTransacao>
				<ValorEnvolvido>967066.52</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Shopping Jardim Sul </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-30</DataTransacao>
				<ValorEnvolvido>30261.91</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-30</DataTransacao>
				<ValorEnvolvido>197654.07</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Valora</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-30</DataTransacao>
				<ValorEnvolvido>265079.9</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos Floripa Shopping</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-31</DataTransacao>
				<ValorEnvolvido>-2673.97</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Shopping Jardim Sul </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-31</DataTransacao>
				<ValorEnvolvido>66554.98</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII Hospital Nossa Senhora de Lourdes</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-31</DataTransacao>
				<ValorEnvolvido>196713.57</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>Cotas de fundos FII TB Office </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-31</DataTransacao>
				<ValorEnvolvido>404178.68</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI 11L0019380</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>278611.84</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-03</DataTransacao>
				<ValorEnvolvido>200835.25</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-08</DataTransacao>
				<ValorEnvolvido>349265.06</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-09</DataTransacao>
				<ValorEnvolvido>1706922.48</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-10</DataTransacao>
				<ValorEnvolvido>17489.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-11</DataTransacao>
				<ValorEnvolvido>1448963.76</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-14</DataTransacao>
				<ValorEnvolvido>1179482.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-15</DataTransacao>
				<ValorEnvolvido>3911896.99</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-16</DataTransacao>
				<ValorEnvolvido>1527416.76</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-21</DataTransacao>
				<ValorEnvolvido>40126.04</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-21</DataTransacao>
				<ValorEnvolvido>153647.64</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>585491.06</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-22</DataTransacao>
				<ValorEnvolvido>12400.08</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-23</DataTransacao>
				<ValorEnvolvido>1000</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-24</DataTransacao>
				<ValorEnvolvido>54751.14</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-24</DataTransacao>
				<ValorEnvolvido>69059.3</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-29</DataTransacao>
				<ValorEnvolvido>650467.91</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-30</DataTransacao>
				<ValorEnvolvido>1081296.12</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-01-31</DataTransacao>
				<ValorEnvolvido>160000000</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-01</DataTransacao>
				<ValorEnvolvido>537721.89</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-04</DataTransacao>
				<ValorEnvolvido>849959.7</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-05</DataTransacao>
				<ValorEnvolvido>191244.28</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-06</DataTransacao>
				<ValorEnvolvido>29232.97</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-12</DataTransacao>
				<ValorEnvolvido>4929.51</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-13</DataTransacao>
				<ValorEnvolvido>12299.49</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-18</DataTransacao>
				<ValorEnvolvido>256678.47</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-20</DataTransacao>
				<ValorEnvolvido>153694.36</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-21</DataTransacao>
				<ValorEnvolvido>17811.22</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-25</DataTransacao>
				<ValorEnvolvido>12374.33</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-27</DataTransacao>
				<ValorEnvolvido>52428.89</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-02-28</DataTransacao>
				<ValorEnvolvido>142869.12</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-01</DataTransacao>
				<ValorEnvolvido>317827.34</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-06</DataTransacao>
				<ValorEnvolvido>348254.51</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-14</DataTransacao>
				<ValorEnvolvido>1545426.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-15</DataTransacao>
				<ValorEnvolvido>2175161.69</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-20</DataTransacao>
				<ValorEnvolvido>3776140.14</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-21</DataTransacao>
				<ValorEnvolvido>699548.25</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-22</DataTransacao>
				<ValorEnvolvido>166970.53</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-25</DataTransacao>
				<ValorEnvolvido>31256.96</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-03-28</DataTransacao>
				<ValorEnvolvido>184615.48</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-02</DataTransacao>
				<ValorEnvolvido>135099.72</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-03</DataTransacao>
				<ValorEnvolvido>254498.39</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-04</DataTransacao>
				<ValorEnvolvido>187312.3</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-08</DataTransacao>
				<ValorEnvolvido>183403.44</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-09</DataTransacao>
				<ValorEnvolvido>58784.8</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-09</DataTransacao>
				<ValorEnvolvido>310206.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-10</DataTransacao>
				<ValorEnvolvido>1000</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-11</DataTransacao>
				<ValorEnvolvido>192563.55</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-12</DataTransacao>
				<ValorEnvolvido>13875.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-15</DataTransacao>
				<ValorEnvolvido>149747.18</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-15</DataTransacao>
				<ValorEnvolvido>8536.57</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-16</DataTransacao>
				<ValorEnvolvido>450650.34</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-16</DataTransacao>
				<ValorEnvolvido>17967.28</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-17</DataTransacao>
				<ValorEnvolvido>72000</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-22</DataTransacao>
				<ValorEnvolvido>597182.21</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-23</DataTransacao>
				<ValorEnvolvido>530182.8</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-24</DataTransacao>
				<ValorEnvolvido>1417159.02</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-25</DataTransacao>
				<ValorEnvolvido>1559420.38</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-26</DataTransacao>
				<ValorEnvolvido>636680.52</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-04-29</DataTransacao>
				<ValorEnvolvido>195970.62</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-02</DataTransacao>
				<ValorEnvolvido>1294115.55</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-03</DataTransacao>
				<ValorEnvolvido>1279973.86</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-07</DataTransacao>
				<ValorEnvolvido>139321.44</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-08</DataTransacao>
				<ValorEnvolvido>1999.8</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-09</DataTransacao>
				<ValorEnvolvido>982413.56</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-10</DataTransacao>
				<ValorEnvolvido>260014.85</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-13</DataTransacao>
				<ValorEnvolvido>428994.88</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-14</DataTransacao>
				<ValorEnvolvido>1578279.83</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-15</DataTransacao>
				<ValorEnvolvido>3030755.62</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-16</DataTransacao>
				<ValorEnvolvido>989867.57</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-17</DataTransacao>
				<ValorEnvolvido>1177562.57</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-20</DataTransacao>
				<ValorEnvolvido>52757.21</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-21</DataTransacao>
				<ValorEnvolvido>614571.44</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-22</DataTransacao>
				<ValorEnvolvido>2574341.94</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-23</DataTransacao>
				<ValorEnvolvido>1000</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-24</DataTransacao>
				<ValorEnvolvido>614060.88</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-28</DataTransacao>
				<ValorEnvolvido>432181.34</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-29</DataTransacao>
				<ValorEnvolvido>714433.41</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-30</DataTransacao>
				<ValorEnvolvido>481699.03</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO YIELD DI FI REF                                     </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-05-31</DataTransacao>
				<ValorEnvolvido>15448477.77</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-03</DataTransacao>
				<ValorEnvolvido>905885.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-04</DataTransacao>
				<ValorEnvolvido>391900.47</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-05</DataTransacao>
				<ValorEnvolvido>994050.34</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-06</DataTransacao>
				<ValorEnvolvido>829650.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-10</DataTransacao>
				<ValorEnvolvido>917001.54</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-11</DataTransacao>
				<ValorEnvolvido>1080249.44</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-12</DataTransacao>
				<ValorEnvolvido>1229642.86</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-13</DataTransacao>
				<ValorEnvolvido>509942.23</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-14</DataTransacao>
				<ValorEnvolvido>4022482.98</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-17</DataTransacao>
				<ValorEnvolvido>660324.94</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-18</DataTransacao>
				<ValorEnvolvido>1129954.78</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-19</DataTransacao>
				<ValorEnvolvido>1360912.44</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-21</DataTransacao>
				<ValorEnvolvido>4267311.77</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-21</DataTransacao>
				<ValorEnvolvido>100865.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-24</DataTransacao>
				<ValorEnvolvido>3087244.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-25</DataTransacao>
				<ValorEnvolvido>301763.01</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-26</DataTransacao>
				<ValorEnvolvido>2274150.33</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-06-28</DataTransacao>
				<ValorEnvolvido>203271.84</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-01</DataTransacao>
				<ValorEnvolvido>378297.81</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-03</DataTransacao>
				<ValorEnvolvido>428898.15</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-04</DataTransacao>
				<ValorEnvolvido>320150.16</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-08</DataTransacao>
				<ValorEnvolvido>340247.91</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-10</DataTransacao>
				<ValorEnvolvido>285927.06</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-11</DataTransacao>
				<ValorEnvolvido>374900</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-12</DataTransacao>
				<ValorEnvolvido>805728.25</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-15</DataTransacao>
				<ValorEnvolvido>5800</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-16</DataTransacao>
				<ValorEnvolvido>925109.95</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-17</DataTransacao>
				<ValorEnvolvido>2723052.8</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-18</DataTransacao>
				<ValorEnvolvido>1733865.63</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-19</DataTransacao>
				<ValorEnvolvido>3477710.92</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>1571650.79</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-22</DataTransacao>
				<ValorEnvolvido>2265360.25</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-23</DataTransacao>
				<ValorEnvolvido>3346302.37</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-25</DataTransacao>
				<ValorEnvolvido>3669796.26</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>21913.47</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-29</DataTransacao>
				<ValorEnvolvido>17733984.81</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>AQUISICAO DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2019-07-31</DataTransacao>
				<ValorEnvolvido>2211444.21</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-08</DataTransacao>
				<ValorEnvolvido>527443.79</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-09</DataTransacao>
				<ValorEnvolvido>12029.55</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-10</DataTransacao>
				<ValorEnvolvido>300015.51</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-15</DataTransacao>
				<ValorEnvolvido>3442991.96</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-17</DataTransacao>
				<ValorEnvolvido>3436422.09</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-18</DataTransacao>
				<ValorEnvolvido>6476.86</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-23</DataTransacao>
				<ValorEnvolvido>1357.72</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-28</DataTransacao>
				<ValorEnvolvido>1763639.87</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-01-31</DataTransacao>
				<ValorEnvolvido>1083907.62</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-05</DataTransacao>
				<ValorEnvolvido>1304893.77</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-06</DataTransacao>
				<ValorEnvolvido>1053443.48</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-07</DataTransacao>
				<ValorEnvolvido>104124.83</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-08</DataTransacao>
				<ValorEnvolvido>171787.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-11</DataTransacao>
				<ValorEnvolvido>97436.47</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-12</DataTransacao>
				<ValorEnvolvido>270901.48</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-13</DataTransacao>
				<ValorEnvolvido>1747564.51</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-14</DataTransacao>
				<ValorEnvolvido>1219730.74</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-15</DataTransacao>
				<ValorEnvolvido>1242622.9</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-19</DataTransacao>
				<ValorEnvolvido>15539.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-22</DataTransacao>
				<ValorEnvolvido>3099665.68</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-02-25</DataTransacao>
				<ValorEnvolvido>850572.92</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-18</DataTransacao>
				<ValorEnvolvido>1539775.46</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-19</DataTransacao>
				<ValorEnvolvido>4454541.2</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-26</DataTransacao>
				<ValorEnvolvido>593323.59</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-27</DataTransacao>
				<ValorEnvolvido>1720827.7</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-28</DataTransacao>
				<ValorEnvolvido>20039617.92</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-03-29</DataTransacao>
				<ValorEnvolvido>16263185.38</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-01</DataTransacao>
				<ValorEnvolvido>7933376.99</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-04</DataTransacao>
				<ValorEnvolvido>53013.27</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-05</DataTransacao>
				<ValorEnvolvido>645198.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-09</DataTransacao>
				<ValorEnvolvido>310206.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-10</DataTransacao>
				<ValorEnvolvido>7460895.97</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-12</DataTransacao>
				<ValorEnvolvido>2385679.3</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-18</DataTransacao>
				<ValorEnvolvido>94256.21</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-04-30</DataTransacao>
				<ValorEnvolvido>9096418.11</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-03</DataTransacao>
				<ValorEnvolvido>2234.28</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-06</DataTransacao>
				<ValorEnvolvido>33493.87</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-08</DataTransacao>
				<ValorEnvolvido>149346.84</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-15</DataTransacao>
				<ValorEnvolvido>12112179.15</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-20</DataTransacao>
				<ValorEnvolvido>3725459.93</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-23</DataTransacao>
				<ValorEnvolvido>1120458.65</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-05-27</DataTransacao>
				<ValorEnvolvido>5020041.19</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-07</DataTransacao>
				<ValorEnvolvido>248578.56</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-14</DataTransacao>
				<ValorEnvolvido>4469435.33</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-06-27</DataTransacao>
				<ValorEnvolvido>13669218.71</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-02</DataTransacao>
				<ValorEnvolvido>1090.06</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-05</DataTransacao>
				<ValorEnvolvido>285389.83</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-15</DataTransacao>
				<ValorEnvolvido>1560337.83</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-24</DataTransacao>
				<ValorEnvolvido>673115.35</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-26</DataTransacao>
				<ValorEnvolvido>67776517.36</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-29</DataTransacao>
				<ValorEnvolvido>72095.28</ValorEnvolvido>
				<DataAssembleia>2016-07-07</DataAssembleia>
				<Contraparte>BTG PACTUAL SERVIÇOS FINANCEIROS S.A. DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>RESGATE DE COTAS NO FUNDO CAPITAL MKTS FI RF                                  </AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2019-07-30</DataTransacao>
				<ValorEnvolvido>1823970.88</ValorEnvolvido>
				<DataAssembleia>2016-07-07</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>
"