"<?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 TOP CENTER</NomeFundo>
		<CNPJFundo>23768027000124</CNPJFundo>
		<DataFuncionamento>2016-07-01</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>322214000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Determinado</PrazoDuracao>
		<DataPrazoDuracao>2026-07-01</DataPrazoDuracao>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>true</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BANCO MODAL S.A.</NomeAdministrador>
		<CNPJAdministrador>23768027000124</CNPJAdministrador>
		<Logradouro>PRAIA DE BOTAFOGO</Logradouro>
		<Numero>501</Numero>
		<Complemento>5 ANDAR - TORRE PÃO DE AÇÚCAR</Complemento>
		<Bairro>BOTAFOGO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22250040</CEP>
		<Telefone1>2132237700</Telefone1>
		<Telefone2>2132237746</Telefone2>
		<Telefone3>2132237700</Telefone3>
		<Site>HTTPS://MODAL.COM.BR</Site>
		<Email>FUNDOS.MODAL@MODAL.COM.BR</Email>
		<Competencia>2017-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>MODAL ADMINISTRADORA DE RECURSOS LTDA.</Nome>
				<CNPJ>1116811000115</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO, 501 - 5 ANDAR - PARTE, BLOCO 1, RIO DE JANEIRO</Endereco>
				<telefone>2132237700</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO MODAL S.A.</Nome>
				<CNPJ>30723886000162</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO, 501 - 5 ANDAR - PARTE, BLOCO 1, RIO DE JANEIRO</Endereco>
				<telefone>2132237700</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>ERNEST &amp; YOUNG AUDITORES INDEPENDENTES S.S.</Nome>
				<CNPJ>61366936001440</CNPJ>
				<Endereco>R Antonio De Albuquerque, 156, Andar 11</Endereco>
				<telefone>1125733000</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>
					<Ativo>
						<Nome>SHOPPING TOP CENTER</Nome>
						<Objetivos>RENDA</Objetivos>
						<MontantesInvestidos>322422466</MontantesInvestidos>
						<OrigemRecursos>Aplicação</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Shopping foi inaugurado em 2014, encontra-se localizado no centro da cidade de São Paulo com área total construída de 7.835 m² e ABL (Área Bruta Locável) de 6.534 m².

Para o próximo exercício a gestão planeja atender as necessidades de manutenção e modernização do Shopping, implementar melhorias nos controles de cobrança  e mensuração do faturamento dos lojistas e manter negociações com interessados em alugar as lojas que ainda permanecem vagas.
</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo obteve receitas com propriedade para investimento. Sendo entre elas, as principais, (a) Aluguéis complementares refere-se as receitas variáveis calculadas de acordo com as performances de vendas das lojas e previstas nos respectivos contratos de locação; (b) As receitas de merchandising são obtidas por meio de exploração de determinados espaços para anúncios e propagandas dentro do shopping, onde o anunciante paga um valor para efetuar o anúncio por um determinado período previamente acordado em contrato. </ResultadoFundo>
			<ConjunturaEconomica>Desde meados dos anos 90, os shoppings centers instalados no Brasil estão passando por uma readequação de layout, incluindo novas configurações que auxiliam na demanda para o consumo, considerando-se os novos conceitos de empreendimentos empregados no Brasil. 

A indústria de Shopping Centers no Brasil, apesar das dificuldades, encerrou o ano de 2016 com 20 novos empreendimentos inaugurados no Brasil. O faturamento estimado foi de R$157,9 bilhões de reais, contra os R$ 151,5 bilhões faturados em 2015, representando um aumento de 4,5 % neste período, conforme dados da Associação Brasileira de Shopping Centers (ABRASCE). Considerando os faturamentos regionais, os shoppings do sudeste contribuem com o maior faturamento do setor: R$ 87 bilhões, seguido da região Nordeste, com R$ 25,8 bilhões, Sul (R$ 18,17 bilhões), Centro-Oeste (R$ 13,5 bilhões) e Norte (R$ 6,9 bilhões).  Além disso, os setores que mais se destacaram positivamente em vendas nos empreendimentos no ano passado foram perfumaria (9%), serviços (6%) e alimentação (5,3%).  
De acordo com pesquisas da ABRASCE (Associação Brasileira de Shopping Centers), a indústria de shopping centers continua em desenvolvimento no Brasil, representando quase 3% do PIB nacional. Atualmente possui 558 centros de compras, empregando mais de 1.033 mil pessoas. A área Bruta Locável (ABL) atual no país é de aproximadamente 15,24 milhões de m². 
Em Dezembro de 2016, o setor somava 15,237 milhões de metros quadrados de ABL (área bruta locável), 851.162 vagas para carros, 99.990 lojas, sendo que 3.403 são lojas âncoras, 2.381 megalojas, 7.825 lojas de serviços e 70.738 lojas satélites; 2.707 salas de cinema, 14.408 pontos de alimentação e 1.235 opções de lazer.

De acordo com a ABRASCE (Associação Brasileira de Shopping Centers), o status atual do Mercado Nacional de Shopping Centers para 2017 é de inaugurações no setor e aponta uma tendência a interiorização dos empreendimentos, em cidades com menos de 500 mil habitantes.  A previsão é de inauguração de 21 Shoppings Centers no período, sendo 53,9% localizado na região Sudeste, 17% na região Sul, e nas regiões Nordeste, Centro-Oeste e Norte, 14,8%%, 9,5% e 4,8%, respectivamente.
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Para o próximo exercício a gestão planeja atender as necessidades de manutenção e modernização do Shopping, implementar melhorias nos controles de cobrança  e mensuração do faturamento dos lojistas e manter negociações com interessados em alugar as lojas que ainda permanecem vagas.
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>SHOPPING TOP CENTER</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>340505000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0514</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Com base nas características físicas do imóvel, tendências, práticas do mercado imobiliário na região na qual se insere o imóvel, riscos e premissas apresentadas, as condições de mercado, fluxo de caixa projetado do empreendimento e nas informações disponíveis, na data das demonstrações financeiras. As principais premissas utilizadas para obtenção do valor justo do imóvel na data base das demonstrações financeiras estão descritas abaixo: (a) Método utilizado na capitalização da renda através do fluxo de caixa descontado, (b) Período de análise 10 anos, (c) Taxa de desconto 13,75% ao ano e (d) Taxa de capitalização 8,5% ao ano.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>1076488-14.2016.8.26.0100</Numero>
				<Juizo>Foro Central</Juizo>
				<Instancia>26ª Vara  Cível </Instancia>
				<DataInstauracao>2016-07-22</DataInstauracao>
				<ValorCausa>867903.84</ValorCausa>
				<PartesProcesso>Paulista Fitness Empreendimentos Ltda.</PartesProcesso>
				<PrincipaisFatos>Inicial distribuida. Despacho inicial determinando a citação  da Ré. Acordo protocolado e homologado. Protocolada repactuação do acordo firmado entre as partes. Proferida decisão homologando o acordo. Como houve descumprimento da repactuaçáo; sendo denunciada. Apesar de se tratar de denuncia de acordo; o cartório expediu e cumpriu equivocadamente mandado notificaçáo para desocupação  voluntaria. Despachamos e diligenciamos no cartório solicitando a expediçáo da ordem de despejo coercitiva.Aguardando a distribuiçáo da ordem de despejo coercitivo para um oficial de justiça realiza-lo.O lojista abandonou o imovel. Foi feita Ata Notarial e o Oficial de Justiça constatou a desocupação do imovel. Processo Extinto. Propusemos embargos de declaração visando a reforma da decisão de extinção, Embargos improvidos. Propusemos novos embargos e aguardamos decisão.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em análise</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1056210-55.2017.8.26.0100</Numero>
				<Juizo>Foro Central</Juizo>
				<Instancia>15ª Vara cível </Instancia>
				<DataInstauracao>2017-06-12</DataInstauracao>
				<ValorCausa>22097.07</ValorCausa>
				<PartesProcesso>Tadamassa Yamada</PartesProcesso>
				<PrincipaisFatos>Ação ajuizada em 12/06/2017, extinta em 23/08/2017</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em análise</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1102494-24.2017.8.26.0100</Numero>
				<Juizo>Foro Central</Juizo>
				<Instancia>45ª Vara cível</Instancia>
				<DataInstauracao>2017-10-17</DataInstauracao>
				<ValorCausa>120156.85</ValorCausa>
				<PartesProcesso>Paulista Fitness Empreendimentos Ltda.</PartesProcesso>
				<PrincipaisFatos>Ação ajuizada em 17/10/2018</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em análise</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1000192-77.2018.8.26.0100</Numero>
				<Juizo>Foro Central</Juizo>
				<Instancia>11ª Vara cível </Instancia>
				<DataInstauracao>2018-01-04</DataInstauracao>
				<ValorCausa>120157.85</ValorCausa>
				<PartesProcesso>Paulista Fitness Empreendimentos Ltda.</PartesProcesso>
				<PrincipaisFatos>Ação ajuizada em 04/01/2018</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em análise</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos>O item em questão trata estritamente dos processos sigilosos, o que não existe para os fundos em questão</AnaliseImpactos>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Praia de Botafogo, n 501 - 6 andar, bloco 01</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.modal.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>(i) correspondência física ou eletrônica / em sua página na rede mundial de computadores, na data de convocação da Assembleia Geral, e mantê-los lá até a sua realização; no Sistema de Envio de Documentos, disponível na página da CVM na rede mundial de computadores; na página da entidade administradora do mercado organizado em que as Cotas do Fundo sejam admitidas à negociação.
(ii) correspondência física ou eletrônica.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>(i) Somente poderão votar na Assembleia Geral os Cotistas inscritos no registro de cotistas na data da convocação da Assembleia Geral os Cotistas, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano.
(ii)As deliberações da Assembleia Geral poderão ser tomadas, 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;
(iii) Os Cotistas poderão votar por meio de comunicação escrita ou eletrônica, desde que recebida pelo Administrador em até 24 (vinte e quatro) horas antes do início da assembleia, no endereço físico ou eletrônico do Administrador por ele informado na convocação para a Assembleia Geral de Cotistas.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Os Cotistas poderão votar por meio de comunicação escrita ou eletrônica, desde que recebida pelo Administrador em até 24 (vinte e quatro) horas antes do início da assembleia, no endereço físico ou eletrônico do Administrador por ele informado na convocação para a Assembleia Geral de Cotistas.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pelos serviços de administração, gestão e custódia qualificada dos ativos integrantes do patrimônio do Fundo, será devida pelo Fundo uma taxa de administração de 0,085% a.a. sobre o valor do patrimônio líquido do Fundo, com o valor de remuneração mínima mensal de R$23. A remuneração mínima mensal será atualizada anualmente pelo IGP-M (Índice Geral de Preços do Mercado), calculado e divulgado pela Fundação Getúlio Vargas do Rio de Janeiro – RJ, ou por outro índice que por ventura venha a substituí-lo. O valor da Taxa de Administração, a qual será apropriada por dia útil como despesa do Fundo, com base em um ano de 252 dias úteis, deverá ser paga mensalmente, no 3º (terceiro) dia útil de cada mês subsequente.</PoliticaRemuneracao>
			<ValorPagoAno>139780.44</ValorPagoAno>
			<PercentPatrimonioContabil>0.0004</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado xsi:nil="true"/>
		</RemuneracaoAdministrador>
		<Governanca>
			<RepresentantesCotistas>
				<Representante1>
					<Nome>n/a</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>RONALDO FABIANO BAETA GUIMARÃES JÚNIOR</Nome>
				<Idade>48</Idade>
				<CPF>922.919.377-15</CPF>
				<Email>ronaldo.guimaraes@modal.com.br</Email>
				<Profissao>Bancário</Profissao>
				<FormacaoAcademica>Economista</FormacaoAcademica>
				<DataInicioFuncao>2015-06-08</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="322214000" percDetidoRelTotal="1" percDetidoPJ="1"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>https://www.modal.com.br/fundos-administrados/</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>Adimite-se a negociação no mercado secundário.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>o exercício do direito de voto do Fundo nas eventuais assembleias das sociedades, será definido pela Assembleia Geral de Cotistas</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>O ADMINISTRADOR notificará o Cotista, por escrito e com antecedência mínima de 2 (dois) dias corridos, da chamada de capital referente ao capital comprometido no Boletim de Subscrição e respectiva integralização de cotas que tenham que ser feitas pelo Cotista (“Requerimento de Integralização”). O Requerimento de Integralização será enviado ao endereço do Cotista constante no preâmbulo do Boletim de Subscrição, por meio de carta ou correio eletrônico, na qual constará a data em que o aporte deverá ser recebido e as instruções para transferência dos aportes requeridos para o Fundo.
A integralização de Cotas do FUNDO deverá ser feita em moeda corrente nacional, em uma conta de titularidade do FUNDO junto ao ADMINISTRADOR, podendo ser efetuada por meio de débito em conta corrente, por meio de documento de ordem de crédito, transferência eletrônica disponível ou por qualquer outro mecanismo de transferência de recursos autorizado pelo Banco Central do Brasil – BACEN.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"