"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>VINCI SHOPPING CENTERS FII</NomeFundo>
		<CNPJFundo>17554274000125</CNPJFundo>
		<DataFuncionamento>2014-03-10</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRVISCCTF005</CodigoISIN>
		<QtdCotasEmitidas>8160576.00000068</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Ativa</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>BRL TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>17554274000125</CNPJAdministrador>
		<Logradouro>RUA IGUATEMI</Logradouro>
		<Numero>151</Numero>
		<Complemento>19  ANDAR</Complemento>
		<Bairro>ITAIM BIBI</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>01451011</CEP>
		<Telefone1>11 3133-0350</Telefone1>
		<Telefone2>11 4871-2221</Telefone2>
		<Telefone3>11 3133-0351</Telefone3>
		<Site>WWW.BRLTRUST.COM.BR</Site>
		<Email>INFOLEGAL@BRLTRUST.COM.BR</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>VINCI REAL ESTATE GESTORA DE RECURSOS LTDA</Nome>
				<CNPJ>13838015000175</CNPJ>
				<Endereco>Av Bartolomeu Mitre, 336 - 5º and - Leblon</Endereco>
				<telefone>(21)  22431-002</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BRL TRUST DTVM S.A.</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 19º and - Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>PRICE WATERHOUSECOOPERS</Nome>
				<CNPJ>54.276.936/0001-79</CNPJ>
				<Endereco>Rua do Russel, 804 - 7° andar Rio de Janeiro - RJ</Endereco>
				<telefone>(21)  3232 6112</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>XP INVESTIMENTOS CORRETORA DE CÂMBIO TÍTULOS E VALORES MOBILIÁRIOS S.A.</Nome>
				<CNPJ>02.332.886/0011-78</CNPJ>
				<Endereco>Av. Brigadeiro Faria Lima, n° 3600, 10° andar, São Paulo, SP</Endereco>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BRL TRUST DTVM S.A.</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 19º and - Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</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>Shopping Tacaruna</Nome>
						<Objetivos>Obtenção de rendas</Objetivos>
						<MontantesInvestidos>81600000</MontantesInvestidos>
						<OrigemRecursos>R$ 41.956 mil em participação direta e R$ 39.648 mil através debêntures permutável em participação direta.</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Shopping Iguatemi Fortaleza</Nome>
						<Objetivos>Obtenção de rendas</Objetivos>
						<MontantesInvestidos>185000000</MontantesInvestidos>
						<OrigemRecursos>R$ 148.000 mil à vista , 37.000 mil a prazo ajustado pela variação do IPCA</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>A Vinci continua buscando novas oportunidades de investimento em especial para alocar o remanescente do capital não investido da 4ª emissão de cotas. Acreditamos que o momento para aquisição de ativos seja oportuno. A Gestora analisa com cautela novos investimentos, por entender que embora existam boas oportunidades no mercado, o cenário apesentar certo nível de volatilidade.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O resultado apurado no exercício do fundo foi lucro no valor de  R$ 58.013 .  As receitas imobiliárias cresceram 12,0% com comparação ao exercicio social do exercício anterior, saindo de R$ 29.325 milhões para R$ 32.823. As despeas operacionais  no exercício de 2018 representaram  1,52% sobre o patrimônio líquido médio de 2018 antes 5,23.</ResultadoFundo>
			<ConjunturaEconomica> O ano de 2018 se mostrou um ano desafiador para os Shopping Centers, com a greve dos caminhoneiros e o período da Copa do Mundo. Começamos a verificar uma melhora gradativa dos indicadores operacionais desde o final de 2017, corroborando a tese de que o período mais conturbado pode ter passado. No entanto, tivemos um quebra nessa tendência de melhora em Maio com a greve dos caminhoneiros e depois com a Copa do Mundo em Junho e Julho. Após esses eventos, os indicadores voltaram a melhorar, tendo um leve revés em Outubro devido às incertezas em relação às eleições presidenciais. Os indicadores de inadimplência dos dois últimos trimestres, por exemplo, foram os mais baixos do ano, indicando que os níveis de aluguel já foram ajustados ao cenário atual. Adicionalmente, os Shoppings conseguiram recuperar grandes volumes de aluguéis em atraso, não somente por já ser um trimestre que apresenta vendas historicamente melhores (Black Friday e Natal), como também em razão de importantes negociações de parcelamento de dívidas de lojistas. Os indicadores de vendas, principalmente Same Store Sales (SSS), no entanto, ainda não apresentaram a recuperação esperada, o que deve ficar mais evidente quando se consolidar a recuperação da economia. 
Apesar da recuperação ainda em curso, já percebemos lojistas mais animados com as perspectivas de curto e médio prazo, alguns deles já retomando planos de expansão, o que se refletirá em menor vacância e leasing spread positivo. Acreditamos que os primeiros shoppings a sentirem este efeito devem ser os mais maduros e estrategicamente localizados.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte> Os primeiros meses do novo mandato presidencial terão um determinado nível de otimismo com a entrada da nova equipe econômica e o anúncio das primeiras medidas no campo da economia, porém com certa volatilidade especialmente nos mercados líquidos em função tramitação da proposta de alteração da previdência submetida pelo novo governo. O crescimento de apenas 0,1% no PIB do quarto trimestre de 2018 demonstra que a economia ainda não reagiu e o processo de retomada econômica pode variar em função do tamanhão final reforma da previdência a ser aprovada. Por outro lado, a inflação foi a surpresa positiva com o IPCA fechando o ano de 2018 em 3,75%, abaixo do centro da meta do Banco Central de 4,5%. Assim abre-se espaço para especulações a respeito de potenciais novas quedas da taxa SELIC, que já se encontra no menor patamar histórico.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Shopping Belem </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>42369600</Valor>
				<PercentValorizacaoDesvalorizacao>0.0136</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ilha Plaza</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>135093000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0777</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Crystal </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>15645000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.1778</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Granja Vianna </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>36212500</Valor>
				<PercentValorizacaoDesvalorizacao>0.313</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Paralela</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>59290000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0724</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Center Shopping Rio</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>14362500</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0514</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Tacaruna</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>97340801.2</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>West Shopping</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>36442500</Valor>
				<PercentValorizacaoDesvalorizacao>0.0669</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Shopping Iguatemi Fortaleza</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>205251493.65</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Em 31 de dezembro de 2018, os imóveis foram avaliados pela CB Richard-Ellis (“CBRE”), que emitiu Laudos de Avaliação na respectiva data, aprovados pelo Administrador. As avaliações foram elaboradas baseadas nos dados disponíveis no mercado, em cumprimento com contatos com corretores e profissionais especializados no mercado local. O método utilizado para a avaliação do valor econômico dos empreendimentos corresponde a capitalização da renda através do fluxo de caixa descontado.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Iguatemi nº 151 19º andar Bairro Itaim Bibi Cidade de São Paulo Estado de São Paulo</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>WWW.BRLTRUST.COM.BR</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>O comunicado, envio, divulgação e/ou disponibilização, pelo Administrador, de quaisquer informações, comunicados, cartas e documentos, cuja obrigação esteja disposta no Regulamento ou na regulamentação vigente, será realizado por meio de correio eletrônico (e-mail). Quaisquer informações referentes ao Fundo poderão ser solicitadas pelo e-mail juridico.fundos@brltrust.com.br e pelo portal de Relacionamento com Investidores, no endereço www.vincishopping.com.br.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>A comprovação da qualidade de cotista é realizada pela Administradora com base nas informações fornecidas pelo prestador de serviços de escrituração das cotas do Fundo, conciliadas com as posições obtidas nos sistemas do mercado de balcão organizado no qual há a negociação das cotas do Fundo. Manifestações de Cotistas, tais como voto, ciência, concordância ou quaisquer outras formas dispostas no Regulamento ou na regulamentação vigente, serão colhidas pessoalmente quando da realização de assembleias, ocasião em que é solicitada a apresentação de documento original de identificação do Cotista. Manifestações por meio de procuração serão aceitas, desde que originais e com firmas reconhecidas. As menifestações mencionadas poderão ser encaminhadas ao Administrador por meio de correio eletrônico, desde que o endereço eletrônico de origem seja (i) previamente cadastrado pelos Cotistas na base de dados do Administrador, ou (ii) assinado digitalmente por meio de assinatura eletrônica e/ou sistema de chave-pública.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>As deliberações da Assembleia Geral de Cotistas do Fundo poderão ser tomadas mediante processo de consulta formalizada por correio eletrônico (e-mail), com confirmação de recebimento, a ser dirigido pelo Administrador a cada Cotista para resposta no prazo máximo de 30 (trinta) dias. 
</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O Administrador receberá remuneração fixa e anual equivalente a 1,35% (um inteiro e trinta e cinco centésimos por cento) ao ano sobre o Valor de Mercado das Cotas (“Taxa de Administração”), observado o valor mínimo mensal de R$ 15.000,00 (quinze mil reais) mensais, acrescida de valor adicional de R$ 50.000,00 (cinquenta mil reais) pela prestação de serviços de gestão, acrescida de valor adicional de R$ 2.050,00 (dois mil e cinquenta reais) mensais além de despesas extraordinárias, pela prestação dos serviços de escrituração de cotas, sendo certo que (i) o valor mínimo mensal será atualizado anualmente, a partir da data de início das atividades do FUNDO, pela variação positiva do IPCA-IBGE (Índice de Preços ao Consumidor Amplo).</PoliticaRemuneracao>
			<ValorPagoAno>7548904.19</ValorPagoAno>
			<PercentPatrimonioContabil>0.0092</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0128</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>Danilo Christófaro Barbieri</Nome>
				<Idade>38</Idade>
				<CPF>28729710847</CPF>
				<Email>dbarbieri@brltrust.com.br</Email>
				<Profissao>Administrador de empresas</Profissao>
				<FormacaoAcademica>Administração de empresas</FormacaoAcademica>
				<DataInicioFuncao>2018-04-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>BRL TRUST DTVM S.A</NomeEmpresa>
						<Periodo>Desde 01/04/2016</Periodo>
						<CargoFuncoes>Sócio-Diretor</CargoFuncoes>
						<AtividadePrincipalEmpresa>Administrador fiduciário</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>BANCO SANTANDER BRASIL S.A</NomeEmpresa>
						<Periodo>de 1999 até 03/2016</Periodo>
						<CargoFuncoes>Superindentente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Country Head da Santander Securities Services</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="48098" numCotasDetidas="8160576.00000068" percDetidoRelTotal="1" percDetidoPF="0.8333" percDetidoPJ="0.1667"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>A divulgação de ato ou fato relevante pela Administradora é realizada nos termos da regulamentação aplicável e seu conteúdo é disponibilizado no sistema Fundos.Net, vinculado à CVM e à B3, bem como no site da Administradora (http://www.brltrust.com.br/pt/administracao-de-fundos/fii/fii-vinci-shopping-centers/informacoes-fii-vinci) e no site de Relacionamento com Investidores, disponível no endereço www.vincishopping.com.br, portal em que o Cotista poderá consultar todos os documentos do Fundo e cadastrar-se para recebimento de atualizações via e-mail.     
</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>A negociação das cotas do Fundo é realizada exclusivamente por meio dos sistemas operacionalizados pela B3 - Brasil, Bolsa, Balcão S.A.     
</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>O Gestor adota política de exercício de direito de voto em assembleias gerais de ativos integrantes da carteira do Fundo, a qual disciplina os princípios gerais, o processo decisório e quais são as matérias relevantes obrigatórias para o exercício do direito de voto. Para tanto, o Administrador dá, desde que requisitado pelo Gestor, representação legal para o exercício do direito de voto em assembleias gerais dos emissores dos ativos da carteira do Fundo, de acordo com os requisitos mínimos exigidos pelo Código ANBIMA e pelas diretrizes fixadas pelo Conselho de Regulação e Melhores Práticas. Link para acesso à Política de Exercício de Direito de Voto pelo Gestor: https://www.vincipartners.com/uploads/Vinci%20Infraestrutura%20Gestora%20de%20Recursos_3.pdf     
</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Daniela Assarito Bonifacio Borovicz  – CPF: 320.334.648-65 - Diretora responsável pelo Departamento Jurídico.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>As regras e prazos para chamada de capital do Fundo, se houver, estarão previstas nos documentos relativos às ofertas de distribuição de cada emissão de cotas.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"