"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>LATERES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</NomeFundo>
		<CNPJFundo>17209378000100</CNPJFundo>
		<DataFuncionamento>2013-04-04</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>BRLATRCTF009</CodigoISIN>
		<QtdCotasEmitidas>124104</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Desenvolvimento para Venda</Mandato>
			<SegmentoAtuacao>Residencial</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Determinado</PrazoDuracao>
		<DataPrazoDuracao>2023-02-05</DataPrazoDuracao>
		<EncerramentoExercicio>30/06</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>36113876000191</CNPJAdministrador>
		<Logradouro>Av. das Américas</Logradouro>
		<Numero>3434</Numero>
		<Complemento>Bl. 7 Sl. 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>2022-06-30</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>DYNAMO V. C. ADMINISTRADORA DE RECURSOS LTDA.</Nome>
				<CNPJ>03..21.5.5/62/0-00</CNPJ>
				<Endereco>Avenida Ataulfo de Paiva, nº 1235, salas 301,302,303, Leblon, Rio de Janeiro/RJ</Endereco>
				<telefone>(21) 2512-9394</telefone>
			</Gestor>
			<Custodiante>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36..11.3.8/76/0-00</CNPJ>
				<Endereco>Avenida das Américas, 3434 - bl. 07 sl 201, Barra da Tijuca, Rio de Janeiro/ RJ</Endereco>
				<telefone>(21) 3514-0000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KPMG AUDITORES INDEPENDENTES </Nome>
				<CNPJ>09..27.6.2/99/0-00</CNPJ>
				<Endereco>Rua Arquiteto Olavo Redig ampos, 10, 11 º andar, São Paulo/ SP</Endereco>
				<telefone>(11) 3940-1500</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</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 esperamos realizar novos investimentos. Dessa forma, pretende-se distribuir o caixa  atualmente detido pelo Fundo, conforme exista conforto sobre a capacidade de honrar todos os compromissos com despesas futuras. Espera-se encerrar suas operações dentro do próximo exercício social.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Conforme Demostrações Financeiras.</ResultadoFundo>
			<ConjunturaEconomica>Durante o segundo trimestre de 2022 houve aumento das incertezas acerca da situação macroeconômica mundial. No Brasil, alguns indicadores de atividade econômica se mostraram positivos no trimestre. Apesar disso o cenário ainda é bastante adverso e desafiador para o Banco Central. Na esfera do comércio, dados da Pesquisa Mensal de Comércio de abril de 2022 mostram aumento de 0,9% comparado com o mês de maio no volume de vendas do varejo em sua série com ajuste sazonal. O ICC, após avançar 3,8 pontos em abril, apresentou queda de 3,1 pontos em maio, e encerrou o trimestre com crescimento de 3,5 pontos, impactado pelo aumento da confiança dos consumidores com renda mais alta. As expectativas dos consumidores de baixa renda, por outro lado, estão piorando, sobretudo, devido à alta da inflação. Esse cenário de alta da inflação global, associado à deterioração da situação fiscal do país e à proximidade das eleições presidenciais fizeram o IIE-Br (Indicador de Incerteza Econômica) avançar 0,5 ponto em junho, chegando a 116,4 pontos. Em relação à taxa de desemprego, a última Pesquisa Nacional Contínua por Amostra de Domicílios (PNAD) registrou para o trimestre móvel encerrado em maio de 2022, taxa de 9,8%, recuo de 1,4 p.p. em relação ao trimestre anterior e 4,9 p.p. comparado ao mesmo período do ano passado. Acerca da inflação, o IPCA foi de 0,47% em maio, recuando 0,59 p.p. Esse resultado foi impactado principalmente pelos grupos Transportes (0,30 p.p.), e Saúde e Cuidados Pessoais (0,12 p.p.). Nos últimos 12 meses, o índice acumula alta de 11,73% e no ano de 4,78%. O INCC - M (Índice Nacional de Custo da Construção - M) avançou 2,81% em junho e já acumula alta de 7,20% no ano e de 11,75% em 12 meses. Porfim, o PIB do primeiro trimestre apresentou alta de 1% e no acumulado dos quatro trimestres finalizados em março registrou alta de 4,7%.
Fonte: Cushman &amp; Wakefield</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Ao final do exercício de 30 de junho de 2022, todo estoque do Fundo havia sido revendido. Dessa forma, as perpectivas para o mercado imobiliário não devem afetar, de forma relevante, o retorno dos investidores até o encerramento do Fundo.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Não se aplica, pois são imóveis de estoque mantidos a custo de aquisição.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>1065676-05.2019.8.26.0100</Numero>
				<Juizo> 2ª Vara Cível Foro Central - SP</Juizo>
				<Instancia> 2ª Instância</Instancia>
				<DataInstauracao>2019-07-11</DataInstauracao>
				<ValorCausa>128507.00</ValorCausa>
				<PartesProcesso>Eliana Leite dos Santos x Lateres FII</PartesProcesso>
				<PrincipaisFatos>No dia 15/01/2020, foi proferida sentença que julgou "parcialmente procedente a ação para o fim de declarar rescindido o contrato firmado entre as partes e condenar a ré à devolução de 90%dos valores já desembolsado pela autora a título de preço, aos quais deverão ser aplicados juros de 1% ao mês, a contar do trânsito em julgado, e correção monetária nos termos da Tabela Prática do E. Tribunal de Justiça, a contar da data de cada pagamento (...)
Em razão da sucumbência recíproca quanto à ré, e por força do disposto nos artigos 82, § 2º, 84, 85, § 14, e 86, todos do Código de Processo Civil, a autora arcará com 50% e a ré com 50% das custas e despesas processuais, bem como condeno a autora a pagar aos advogados da ré honorários que fixo em 10% sobre metade do valor da causa, e a ré a pagar ao advogado da autora honorários advocatícios que fixo em 10% sobre o valor da condenação atualizado, observado o disposto no §14 do artigo 85 do Código de Processo Civil e em atendimento aos parâmetros delineados nos incisos I a IV do parágrafo 2º do artigo 85 também do Código de Processo Civil”.
Em 12/02/2020, foi apresentado Recurso de Apelação por parte do Réu com a finalidade de obter decisão favorável à retenção de 20% (vinte por cento) dos valores despendidos pela Autora.
Em 31/03/2022, o Fundo comunicou ao Juízo sua intenção de não mais prosseguir com o Recurso de Apelação, manifestando, assim, sua desistência. Nesta mesma data, deu início ao cumprimento voluntário da sentença, depositando em Juízo a quantia de R$ 114.807,79 (cento e quatorze mil, oitocentos e sete reais e setenta e nove centavos). Posteriormente, em 28/04/2022, a Autora se manifestou favoravelmente ao levantamento integral dos valores depositados em Juízo, concordando com a desistência recursal do Réu.
A desistência do Recurso de Apelação foi homologada em 31/05/2022. 
Aguardando o trânsito em julgado.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Em 31/03/2022, o Fundo início o cumprimento voluntário da sentença, depositando em Juízo a quantia de R$ 114.807,79. Não houve impacto material no Patrimônio Líquido do Fundo, daquela data, uma vez que o Fundo já havia provisionado no passivo.</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos>Não se aplica.</AnaliseImpactos>
		<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>Os prestadores de serviços de administração ao FUNDO, dentre eles o ADMINISTRADOR e o GESTOR, com exceção do Custodiante e do Auditor Independente, receberão pela prestação de seus serviços, uma taxa de administração (“Taxa de Administração”) anual correspondente a 1,40% (um vírgula quarenta por cento) do valor contábil do Patrimônio Líquido do FUNDO, conforme definido no artigo 19 (Capítulo VI) do Regulamento, sem prejuízo da remuneração mínima mensal de R$ 20.000,00 (vinte mil reais), dos dois o que for maior.</PoliticaRemuneracao>
			<ValorPagoAno>152996.42</ValorPagoAno>
			<PercentPatrimonioContabil>0.1114</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0771</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>50</Idade>
				<CPF>899120717</CPF>
				<Email>alexandre.freitas@oliveiratrust.com.br</Email>
				<Profissao>Diretor Presidente</Profissao>
				<FormacaoAcademica>Direito</FormacaoAcademica>
				<DataInicioFuncao>2014-07-01</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="164" numCotasDetidas="106178" percDetidoRelTotal="0.85556629" percDetidoPF="0.8249" percDetidoPJ="0.0307"/>
			<AcimaCincoAteDezPorcento numCotistas="2" numCotasDetidas="17926" percDetidoRelTotal="0.1444" percDetidoPF="0.1444" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</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, à B3, 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>O direito de voto do FUNDO em assembleias gerais será exercido pelo GESTOR por meio de delegação de poderes pelo ADMINISTRADOR. O GESTOR adota política de exercício de direito de voto em assembleias gerais, que disciplina os princípios gerais, o processo decisório e as matérias relevantes obrigatórias para o exercício do direito de voto. Tal política, disponível na sede do GESTOR, orienta suas decisões em assembleias dos emissores de títulos e valores mobiliários detidos pelo FUNDO, no intuito de defender os interesses do FUNDO e de seus cotistas. O FUNDO se reserva o direito de abstenção do exercício de voto, ou mesmo o de não comparecer às assembleias cuja participação seja facultativa.</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>No ato de subscrição de cotas, o subscritor (i) assinará o Boletim de Subscrição pelo qual se comprometerá a integralizar, exclusivamente em moeda corrente nacional, mediante Transferência Eletrônica Disponível – TED, as cotas subscritas em até 5 (cinco) dias úteis do envio pelo ADMINISTRADOR de cada chamada de capital, conforme recomendação prévia do GESTOR, respeitadas as demais condições previstas neste Regulamento e no respectivo boletim. Quando da assinatura do Boletim de Subscrição, o cotista pode ser informado da primeira chamada de capital, devendo integralizar os valores relativos às cotas subscritas em até 5 (cinco) dias úteis contados da assinatura do Boletim de Subscrição. Os valores integralizados serão investidos em títulos de renda fixa ou cotas de fundos de investimento, conforme Parágrafo 2º do Artigo 4º acima, até o encerramento da distribuição inicial de cotas.
Ressalta-se que não há saldos a serem integralizados no presente FUndo. Novas emissões de cotas podem ser realizadas mediante aprovação da assembleia geral de cotistas.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"