"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>Sapucaí Rio Fundo de Investimento Imobiliário - FII</NomeFundo>
		<CNPJFundo>19131224000160</CNPJFundo>
		<DataFuncionamento>2014-12-23</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>1175.92651706</QtdCotasEmitidas>
		<FundoExclusivo>true</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>false</Bolsa>
			<MBO>false</MBO>
			<MB>true</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>Oliveira Trust DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>19131224000160</CNPJAdministrador>
		<Logradouro>Av. das Américas</Logradouro>
		<Numero>3434</Numero>
		<Complemento>Bl. 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>2017-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36.113.876/0001-91</CNPJ>
				<Endereco>Avenida 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>36.113.876/0001-91</CNPJ>
				<Endereco>Avenida das Américas, nº 3434, bl 07, sala 201</Endereco>
				<telefone>(21) 3514-0000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KPMG AUDITORES INDEPENDENTES S/S</Nome>
				<CNPJ>57.755.217/0001-29</CNPJ>
				<Endereco>Av. Alm. Barroso, 52 - Centro, Rio de Janeiro - RJ</Endereco>
				<telefone>(21) 2131-5800</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>36.113.876/0001-91</CNPJ>
				<Endereco>Avenida 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>
					<Ativo>
						<Nome>Ações da REC Sapucai S.A.</Nome>
						<Objetivos>Investimento para Renda</Objetivos>
						<MontantesInvestidos>13284176.82</MontantesInvestidos>
						<OrigemRecursos>Aporte de Capital pelos Cotistas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Quotas do FII Via Parque</Nome>
						<Objetivos>Investimento para Renda</Objetivos>
						<MontantesInvestidos>4106024.06</MontantesInvestidos>
						<OrigemRecursos>Aporte de Capital pelos Cotistas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>24 unidades autônomas do CEO CORPORATE EXECUTIVE OFFICES</Nome>
						<Objetivos>Investimento para Renda</Objetivos>
						<MontantesInvestidos>51848986.32</MontantesInvestidos>
						<OrigemRecursos>Aporte de Capital pelos Cotistas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>15% de 112 unidades autônomas do GREEN TOWERS BRASÍLIA</Nome>
						<Objetivos>Investimento para Renda</Objetivos>
						<MontantesInvestidos>162639809.61</MontantesInvestidos>
						<OrigemRecursos>Aporte de Capital pelos Cotistas</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>A princípio não há previsão para novos investimentos pelo Fundo.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Resultado líquido do exercício é de R$ -32.280.000,00</ResultadoFundo>
			<ConjunturaEconomica>O ano de 2017 apresentou os primeiros sinais da tão aguardada retomada econômica, após um longo período de recessão e de instabilidades no âmbito político. A projeção do crescimento do PIB para o fim do respectivo ano foi revisada para cima (0,9%), grande parte devido ao bom desempenho da demanda interna e a liberação dos saques das contas inativas do Fundo de Garantia por Tempo de Serviço (FGTS).
A inflação que encerrou o ano em 2,95%, abaixo da meta estipulada pelo Banco Central, deve subir em 2018, atingindo o patamar de 4,4%, já a taxa básica de juros (SELIC) irá continuar arrefecendo, chegando a 6,75%.
Apesar da melhora na expectativa da atividade econômica, o desemprego no Brasil ainda apresenta taxas altas, acima dos 12%. Vale ressaltar que o indicador segue caindo e que boa parte da diminuição tem como base a informalidade. Enquanto há um aumento de trabalhadores que recorrem ao mercado informal, ocorre uma diminuição da taxa de emprego com carteira assinada no setor privado.
Em relação ao câmbio, o mercado continua apreensivo esperando a votação da reforma da previdência, causando oscilações do valor do real. Além disso, os Estados Unidos com uma política mais protecionista devem elevar novamente a taxa de juros este ano, o que deve causar oscilações no dólar em 2018
Fonte: Cushman &amp; Wakefield</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Há expectativa de aumento no rendimento, superior ao último exercício, uma vez que tivemos a renovação de um do principal contrato de locação do empreendimento Green Towers Brasilia. Com a melhora que o mercado tem apresentado, esperamos também locar os ativos em vacância.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>FII Via Parque Shopping</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>169833701.59</Valor>
				<PercentValorizacaoDesvalorizacao>0.2824</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rec Sapucai S.A.</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>619870746.46</Valor>
				<PercentValorizacaoDesvalorizacao>-0.1644</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CEO Corporate Executive Offices</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>51848986.32</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Green Towers Brasília</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>162639809.61</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Fluxo de Caixa Descontado.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>1058974-14.2017.8.26.0100</Numero>
				<Juizo>38ª Vara Cível do Foro Central de São Paulo - SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-04-20</DataInstauracao>
				<ValorCausa>10107</ValorCausa>
				<PartesProcesso>PrevHab X FII Via Parque, Aliansce Shopping Center S.A., Rio Bravo DTVM Ltda., Sapucai Rio FII</PartesProcesso>
				<PrincipaisFatos>Ação ordinária de anulação de deliberação de Assembleia Geral Extratodinária do FII Via Parque</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Entendemos não ser aplicável</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida das Américas, 3434, bloco 07, sala 201, Barra da Tijuca, Rio de Janeiro/RJ</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.oliveiratrust.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>As solcitaçõ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.

Com relação ao item (ii), as deliberações da Assembleia Geral poderão ser tomadas, independentemente de convocação, mediante processo de consulta, formalizada por carta, correio eletrônico ou telegrama dirigido pelo ADMINISTRADOR aos cotistas, para resposta no prazo de 30 (trinta) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto.

Por fim, no que se refere 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 possibilidade de realização de assembleia por meio eletrônico.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O ADMINISTRADOR receberá, pelos serviços de administração, gestão, tesouraria, controle e processamento dos títulos e valores mobiliários integrantes da carteira do FUNDO, bem como pelos serviços de escrituração das Cotas, mensalmente, uma taxa de administração (“Taxa de Administração”), calculada e paga conforme a seguinte fórmula:
TAtotal = TAi + TAii + TAiii
onde:
TAtotal = Taxa de Administração.
TAi = Parcela da Taxa de Administração, devida ao ADMINISTRADOR, equivalente a 0,04% (quatro centésimos por cento) ao ano, incidente sobre o patrimônio líquido do FUNDO, no último dia útil de cada mês, até R$ 500.000.000,00 (quinhentos milhões de reais), acrescido de 0,01% (um centésimo por cento) sobre o valor do Patrimônio Líquido maior que R$ 500.000.000,00 (quinhentos milhões de reais) e será paga mensalmente à razão de 1/12 (um doze avos) sendo a primeira no quinto dia útil do mês subsequente à primeira integralização de Cotas e as demais sempre no quinto dia útil dos meses subsequentes, observado o valor mínimo mensal de R$ 12.000,00 (doze mil reais) e o valor máximo de R$ 35.000,000 (trinta e cinco mil reais).
TAii = Parcela da Taxa de Administração, devida ao prestador dos serviços de custódia, controladoria e escrituração, equivalente a 0,04% (quatro centésimos por cento) ao ano até R$ 500.000.000,00 (quinhentos milhões de reais) ou 0,03% (três centésimos por cento) ao ano caso o patrimônio líquido do FUNDO supere R$ 500.000.000,00 (quinhentos milhões de reais), incidente sobre o patrimônio líquido do FUNDO do ultimo dia útil de cada mês, a ser paga mensalmente à razão de 1/12 (um doze avos) sendo a primeira no quinto dia útil do mês subsequente à primeira integralização de Cotas e as demais sempre no quinto dia útil dos meses subsequentes, observado o valor mínimo mensal de R$ 15.000,00 (quinze mil reais), prevalecendo o maior valor.
TAiii = Parcela da Taxa de Administração, devida ao ADMINISTRADOR equivalente a R$ 30.000,00 (trinta mil reais) devidos na data da primeira integralização de Cotas do FUNDO, a ser paga em até 2 dias úteis após a data da primeira integralização.</PoliticaRemuneracao>
			<ValorPagoAno>245235.93</ValorPagoAno>
			<PercentPatrimonioContabil>0.0004</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0004</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>46</Idade>
				<CPF>008.991.207-17</CPF>
				<Email>ger2.fundos@oliveiratrust.com.br</Email>
				<Profissao>Diretor Presidente</Profissao>
				<FormacaoAcademica>Direito</FormacaoAcademica>
				<DataInicioFuncao>2014-11-14</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Oliveira Trust</NomeEmpresa>
						<Periodo>Março/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/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="138.24607795" percDetidoRelTotal="0.1176" percDetidoPJ="1"/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="1037.68043911" percDetidoRelTotal="0.8824" percDetidoPJ="1"/>
		</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>Tendo em vista tratar-se de Fundo exclusivo, eventual negociação de cotas será realizada diretamente pelos cotistas, com interveniência do administrador, para posterior mudança na escrituração.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.oliveiratrust.com.br/downloads/OLIVEIRA_TRUST_Politica_de_Voto.pdf</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>As chamadas de capital serão realizadas pelo ADMINISTRADOR na medida em que forem verificadas necessidades de caixa para o FUNDO honrar com obrigações decorrentes de investimentos já realizados ou novas oportunidades de investimento para o FUNDO. As chamadas de Capital serão realizadas pelo ADMINISTRADOR e deverão ocorrer nos 12 (doze) meses subsequentes à data da subscrição de cotas do FUNDO. Ao receberem a chamada de capital, os cotistas serão obrigados a integralizar parte ou a totalidade de suas cotas, no prazo máximo de 15 (quinze) dias úteis contados do recebimento da chamada de capital, conforme solicitado pelo ADMINISTRADOR.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"