"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIÁRIO EDIFÍCIO OURINVEST</NomeFundo>
		<CNPJFundo>06175262000173</CNPJFundo>
		<DataFuncionamento>2004-05-04</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BREDFOCTF004</CodigoISIN>
		<QtdCotasEmitidas>236000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Lajes Corporativas</SegmentoAtuacao>
			<TipoGestao>Passiva</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>OLIVEIRA TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>06175262000173</CNPJAdministrador>
		<Logradouro>Avenida das Americas</Logradouro>
		<Numero>3434</Numero>
		<Complemento>Bloco 07, Sala 201</Complemento>
		<Bairro>Barra da Tijuca</Bairro>
		<Cidade>Rio de Janeiro</Cidade>
		<Estado>RJ</Estado>
		<CEP>22640-102</CEP>
		<Telefone1>21 3514-0000</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.oliveiratrust.com.br</Site>
		<Email>ger2.fundos@oliveiratrust.com.br</Email>
		<Competencia>2021-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36113876000191</CNPJ>
				<Endereco>Av. das Américas, nº 3434, bl 07, sala 201</Endereco>
				<telefone>21 3514-0000</telefone>
			</Gestor>
			<Custodiante>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36113876000191</CNPJ>
				<Endereco>Av. das Américas, nº 3434, bl 07, sala 201</Endereco>
				<telefone>21 3514-0000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>GRANT THORNTON AUDITORES INDEPENDENTES LTDA.</Nome>
				<CNPJ>10.830.108/0002-46</CNPJ>
				<Endereco>Rua Voluntários da Pátria, nº 89, sala 504</Endereco>
				<telefone>21 3512-4113</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36113876000191</CNPJ>
				<Endereco>Av. das Américas, nº 3434, bl 07, sala 201</Endereco>
				<telefone>21 3514-0000</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Não há previsão de investimentos para o próximo exercício.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O resultado do Fundo para o exercício social findo em 31/12/2021 foi de R$853.000,00</ResultadoFundo>
			<ConjunturaEconomica>O mercado de condomínios logísticos do Brasil encerrou o ano de 2021 de maneira muito positiva para o setor. Os índices de inventário entregue e absorção líquida consolidam recordes históricos. No comparativo com 2020, o inventário entregue cresceu 58,4% e a absorção líquida que indica o saldo entre novas locações e devoluções aumentou 37,6%. O mercado de escritórios corporativos de alto padrão de São Paulo apresentou sinais de recuperação ao longo de 2021, e no quarto trimestre,a absorção líquida voltou a registrar números positivos próximos aos níveis médios pré-pandêmicos. Este resultado foi reflexo da vacinação quase completa da população adulta da cidade e do encerramento das restrições de mobilidade. O retorno aos escritórios se mostrou mais evidente em duas regiões da cidade de São Paulo no último trimestre do ano. A Faria Lima encerrou o período com absorção líquida positiva de 24 mil m², e a Paulista registrou saldo de 11 mil m². Pinheiros, Chucri Zaidan e Vila Olímpia também fecharam o trimestre com absorções líquidas positivas, mas abaixo dos 5 mil m². Já as regiões JK, Marginal Pinheiros e Itaim Bibi registraram absorções líquidas negativas no período, na ordem de 5, 4 e 2 mil m² respectivamente.
Fonte: Colliers International
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Com base na Conjutura Econômica apresentada no item anterior, o objetivo do Administrador do Fundo consistirá em focar no relacionamento com os atuais locatários para manutenção dos contratos, bem como esvair esforços para locação do imóvel que encontra-se em vacância. </PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Edifício Ourinvest - Edificações</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>44988000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0956</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>O modelo de análise utilizado na avaliação dos imóveis foi através da análise economico-financeira por Fluxo de Caixa Descontado (DCF), contemplando o ciclo completo de vida de um empreendimento de base imobiliária para renda, podendo-se dividir genericamente em 2 períodos básicos: Ciclo de Implantação, onde ocorre a fase de formatação, desenvolvimento, construção, implantação e equipagem do empreendimento até a sua inauguração e início da operação. No presente caso os móveis já estão prontos e serão adquiridos nesta situação; e o Ciclo Operacional, onde temos o período de exploração do empreendimento no conceito de renda de longo prazo, normalmente com uma fase inicial, após a implantação, de inserção gradativa no mercado, passando assim para um período de maturação ou consolidação com evolução vegetativa até atingir a maturidade representada pela estabilidade. Ao final teremos um período de declínio ou exaustão até o final da vida útil considerada. Nas projeções a fase operacional usualmente se divide em "Período de projeção explícita" e "Valor Residual".
</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. das Americas 3434, Bloco 07, Sala 201, Barra da Tijuca, Rio de Janeiro/RJ</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>http://www.oliveiratrust.com.br/</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>As solicitações dos itens (i) e (ii) podem ser direcionadas diretamente para  e-mail da equipe de Administração, qual seja, ger2.fundos@oliveiratrust.com.br ou ainda pelo "Fale Conosco" disponível no portal do administrador pelo link a seguir: http://www.oliveiratrust.com.br/portal/?item1=Atendimento&amp;item2=Fale_Conosco</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>No que tange ao item (i): Os cotistas do Fundo poderão participar da Assembleia Geral de Cotistas, por si, seus representantes legais ou procuradores, consoante o disposto no artigo 22 da Instrução CVM nº 472, portando os seguintes documentos: (a) se Pessoas Físicas: documento de identificação com foto; (b) se Pessoas Jurídicas: cópia autenticada do último estatuto ou contrato social consolidado e da documentação societária outorgando poderes de representação, bem como documento de identificação com foto do(s) representante(s) legal(is); (c) se Fundos de Investimento: cópia autenticada do último regulamento consolidado do fundo e do estatuto ou contrato social do seu administrador, além da documentação societária outorgando poderes de representação, bem como documento de identificação com foto do(s) representante(s) legal(is). Caso o cotista seja representado por procurador este deverá apresentar o instrumento particular de mandato, sendo certo que o procurador deve estar legalmente constituído há menos de 1 (um) ano. Ressaltamos que os Srs. Cotistas e/ou seus representantes deverão apresentar seus documentos de identificação (documentos pessoais, societários ou procuração) quando da realização da assembleia.
Ao item (ii): As deliberações da Assembleia Geral de Cotistas poderão ser tomadas mediante processo de consulta formalizado em carta, telegrama, correio eletrônico (email) ou fác-símile dirigido pelo ADMINISTRADOR a cada quotista, conforme dados de contato contidos no boletim de subscrição ou, se alterado, conforme informado em documento posterior firmado pelo quotista e encaminhado ao ADMINISTRADOR, para resposta no prazo máximo de 30 (trinta) dias ou excepcionalmente em prazo menor, desde que requerido pelo ADMINISTRADOR e com urgência justificada.
Ao item (iii): Os Cotistas também poderão votar por meio de comunicação escrita ou eletrônica, desde que recebida pelo ADMINISTRADOR antes do início da Assembleia Geral de Quotistas, nos termos da respectiva convocação.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>O Regulamento do Fundo não prevê a prática de assembleia por meio eletrônico.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Art. 19 - A INSTITUIÇÃO ADMINISTRADORA receberá, pela prestação de serviços de gestão e administração do FUNDO, a partir da data da sua constituição, a seguinte remuneração:
I. Taxa de administração, a ser paga pelo FUNDO na forma deste Regulamento, equivalente ao valor correspondente a 0,30% (trinta centésimos por cento) ao ano sobre o valor contábil do patrimônio líquido do FUNDO, pagáveis mensalmente até o dia 7 (sete) de cada mês, a partir do mês subsequente à obtenção da autorização para a constituição e funcionamento do FUNDO junto à CVM, à razão de 1/12 (um doze avos), incidente sobre o patrimônio líquido apurado no último dia útil de cada mês.
II. A taxa de administração prevista no inciso I acima terá o valor mínimo de R$ 5.600,00 (cinco mil e seiscentos reais) mensais. III. Não estão incluídas na remuneração o pagamento de despesas e custos relativos à consultoria externa, à transferência da propriedade fiduciária dos bens e direitos sobre os ativos integrantes do patrimônio do FUNDO, salvo quando motivada pela INSTITUIÇÃO ADMINISTRADORA, bem como as despesas relativas ao processo de liquidação do FUNDO, a ser de responsabilidade do FUNDO;
IV. Os honorários a serem pagos à INSTITUIÇÃO ADMINISTRADORA compreendem somente os serviços de administração do FUNDO, conforme descriminado neste Regulamento, não incluindo o pagamento pelos serviços de terceiros especialistas contratados para o exercício das atividades ou defesa dos interesses do FUNDO, tais como auditoria e/ou fiscalização, escriturador de quotas do FUNDO, entre outros, ou assessoria legal ao FUNDO.
§ 1º - O valor mínimo mensal a que fará jus a INSTITUIÇÃO ADMINISTRADORA pela administração do FUNDO, previsto no inciso II acima, será atualizado monetariamente, a cada 12 (doze) meses, pela variação do IGP-M (Índice Geral de Preços de Mercado, elaborado e divulgado pela Fundação Getúlio Vargas - FGV). Para efeitos de cálculo da remuneração prevista no inciso I, não será aplicada a correção monetária pelo IGPM/FGV sobre o patrimônio integralizado do FUNDO ao final de cada exercício.
§ 2º - A remuneração dos prestadores de serviços contratados pelo FUNDO, serão fixadas em instrumentos particulares a serem firmados entre a INSTITUIÇÃO ADMINISTRADORA, por conta e ordem do FUNDO, e os respectivos terceiros. Todos os contratos firmados estarão disponíveis para consulta dos quotistas, na sede da INSTITUIÇÃO ADMINISTRADORA.</PoliticaRemuneracao>
			<ValorPagoAno>204000</ValorPagoAno>
			<PercentPatrimonioContabil>0.0045</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.004</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>José Alexandre Costa de Freitas</Nome>
				<Idade>49</Idade>
				<CPF>899120717</CPF>
				<Email>ger2.fundos@oliveiratrust.com.br</Email>
				<Profissao>Diretor Presidente</Profissao>
				<FormacaoAcademica>Direito</FormacaoAcademica>
				<DataInicioFuncao>2012-11-10</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Oliveira Trust</NomeEmpresa>
						<Periodo>Março de 1992 - Data atual</Periodo>
						<CargoFuncoes>Diretor Presidente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Distribuidora de Títulos e Valores Mobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="566" numCotasDetidas="158919" percDetidoRelTotal="0.6734" percDetidoPF="0.9902" percDetidoPJ="0.0098"/>
			<AcimaCincoAteDezPorcento numCotistas="1" numCotasDetidas="15360" percDetidoRelTotal="0.0651" percDetidoPF="1" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuinzeAteVintePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaVinteAteTrintaPorcento numCotistas="1" numCotasDetidas="61721" percDetidoRelTotal="0.2615" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuarentaAteCinquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCiquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>São considerados relevantes pelo Administrador qualquer deliberação da assembleia geral de cotistas ou do Administrador ou qualquer outro ato ou fato que possa influir de modo ponderável (I) na cotação das cotas ou de valores mobiliários a elas referenciados, (II) na decisão dos investidores de comprar, vender ou manter as cotas, e (III) na decisão dos investidores de exercer quaisquer direitos inerentes à condição de titular cotas ou de valores mobiliários a elas referenciados, tais como, exemplificativamente, mas não limitados a: I – atraso para o recebimento de quaisquer rendimentos que representem percentual significativo dentre as receitas do fundo; II – venda ou locação dos imóveis de propriedade do fundo destinados a arrendamento ou locação, e que possam gerar impacto significativo em sua rentabilidade; III – fusão, incorporação, cisão, transformação do fundo ou qualquer outra operação que altere substancialmente a sua composição patrimonial; IV – emissão de cotas nos termos do inciso VIII do artigo 15 da Instrução CVM 472. Tais informações são divulgadas à CVM, à BM&amp;FBovespa, e também através do site do Administrador, no endereço https://www.oliveratrust.com.br/. Adicionalmente, o Administrador adota segregação física da sua área de administração de fundos imobiliários em relação às áreas responsáveis por outras atividades e linhas de negócio. Neste sentido, o acesso a sistemas e arquivos, inclusive em relação à guarda de documentos de caráter confidencial, é restrito à equipe dedicada pela administração de tais fundos, sendo possível o compartilhamento de informações às equipes jurídicas e de compliance que atendam tal área de negócio. Adicionalmente, o Administrador tem como política interna a exigência de termos de confidencialidade com todos os seus funcionários, no momento de sua contratação.</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>Fundo listado em bolsa de valores (B3), onde suas cotas são admitidas à negociação no mercado secundário. As informações e documentos públicos do fundo estão disponíveis no website do Administrador: https://www.oliveratrust.com.br</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.oliveiratrust.com.br/downloads/OLIVEIRA_TRUST_Politica_de_Voto.pdf</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Fundo não possui chamada de capital. Novas emissões de cotas podem ser realizadas mediante aprovação da assembleia geral de cotistas.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"