"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>GALAPAGOS FEEDER LOGÍSTICO FII RESPONSABILIDADE LIMITADA</NomeFundo>
		<CNPJFundo>58378463000171</CNPJFundo>
		<DataFuncionamento>2024-12-20</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN>BRGLPFCTF009</CodigoISIN>
		<QtdCotasEmitidas>1505000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Papel</Classificacao>
			<Subclassificacao>Híbrido</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Logística</SegmentoAtuacao>
		</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>VÓRTX DISTRIBUIDORA DE TÍTULOS E VALORES MOBILIÁRIOS LTDA.</NomeAdministrador>
		<CNPJAdministrador>22610500000188</CNPJAdministrador>
		<Logradouro>RUA GILBERTO SABINO</Logradouro>
		<Numero>215</Numero>
		<Complemento>4 ANDAR</Complemento>
		<Bairro>PINHEIROS</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>05425020</CEP>
		<Telefone1>(11) 3030-7177</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>https://www.vortx.com.br</Site>
		<Email>regulatorio.funds@vortx.com.br</Email>
		<Competencia>2025-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>GALAPAGOS CAPITAL INVESTIMENTOS E PARTICIPAÇÕES LTDA.</Nome>
				<CNPJ>32706879000188</CNPJ>
				<Endereco>Av. Rebouças, 3507 - Jardim Paulistano, São Paulo - SP, 05401-400</Endereco>
				<telefone>(11) 3777-2088</telefone>
			</Gestor>
			<Custodiante>
				<Nome>VORTX DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS LTDA</Nome>
				<CNPJ>22610500000188</CNPJ>
				<Endereco>Rua Gilberto Sabino, nº 215, 4º andar, Pinheiros, CEP: 05425-020</Endereco>
				<telefone>(11) 3030-7177</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>NEXT AUDITORES INDEPENDENTES S/S LTDA</Nome>
				<CNPJ>19280834000126</CNPJ>
				<Endereco>Rua Itapiranga, 233, Sala 16, bairro Velha, Blumenau - SC, CEP 89036-230</Endereco>
				<telefone>(11) 3568-2868</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>VORTX DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS LTDA</Nome>
				<CNPJ>22610500000188</CNPJ>
				<Endereco>Rua Gilberto Sabino, nº 215, 4º andar, Pinheiros, CEP: 05425-020</Endereco>
				<telefone>(11) 3030-7177</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>MCLO11</Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>149250000</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI 25A1296532</Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1578577.55</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>A carteira do Fundo encontra-se majoritariamente alocada em Ativos-Alvo. A Gestora segue monitorando ativamente novas oportunidades de investimento, em conformidade com a Política de Investimentos prevista no Regulamento, buscando otimizar a relação risco-retorno do portfólio, à luz das condições atuais de mercado.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>R$ 9,98 por cota</ResultadoFundo>
			<ConjunturaEconomica>O período compreendido entre dezembro de 2024 e dezembro de 2025 foi marcado por um ambiente macroeconômico desafiador. A taxa Selic passou por sucessivos aumentos, atingindo o patamar terminal de 15,00% ao ano, elevando de forma relevante o custo de capital das empresas. Apesar desse cenário mais restritivo, o mercado de capitais permaneceu aquecido ao longo do exercício, consolidando-se como importante fonte de financiamento para o setor imobiliário. No período, o IPCA registrou alta acumulada de 4,3%, permanecendo dentro do intervalo da meta de inflação.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A expectativa é de que, após um ciclo prolongado de juros elevados, o Banco Central inicie um processo gradual de flexibilização monetária. Na reunião de março, o Copom decidiu, por unanimidade, reduzir a taxa Selic em 0,25 p.p., para 14,75% ao ano. Em seu comunicado, o Comitê destacou que a manutenção da política monetária em patamar contracionista por período prolongado contribuiu para a desaceleração da atividade econômica, criando condições para o início do ciclo de cortes.
Ainda assim, o Copom ressaltou que o cenário permanece incerto, especialmente diante de riscos externos, como as tensões geopolíticas no Oriente Médio e seus potenciais impactos inflacionários. Dessa forma, a continuidade do ciclo de redução de juros deverá depender da evolução do cenário inflacionário, da atividade econômica e das condições externas.
De acordo com o Relatório Focus de 20/03, a projeção é de que a taxa Selic encerre o ano em 12,50% ao ano, enquanto o IPCA deve atingir 4,17%, permanecendo dentro do limite superior da meta de 4,5%.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Não aplicável. </CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Gilberto Sabino, nº 215, 4º andar, Pinheiros, CEP: 05425-020</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.vortx.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Endereço físico: Rua Gilberto Sabino, nº 215, 4º Andar, Pinheiros, SP e endereço eletrônico: fundos@vortx.com.br  e  www.vortx.com.br</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Somente podem votar na assembleia os Cotistas inscritos no registro de Cotistas na data da convocação da assembleia de Cotistas, seus representantes legais ou procuradores legalmente constituídos. Os Cotistas poderão deliberar por meio de consulta formal, sem que haja necessidade da reunião dos Cotistas, a respeito de matérias que não exijam quórum qualificado nos termos deste Regulamento, bem como da legislação e regulamentação aplicáveis. Os Cotistas podem votar por meio de comunicação escrita ou eletrônica, desde que recebida pelo Administrador antes do início da Assembleia de Cotistas.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Desde que assim permitido pela regulação aplicável, será admitida a realização de Assembleias Gerais de forma remota, dispensada a instalação presencial, bem com a participação por meio eletrônico em Assembleia Geral instalada de forma presencial, inclusive por telefone, videoconferência ou outros meios similares, bem como outras formas de comunicação eletrônica, desde que observada a regulação aplicável e as demais regras de convocação e instalação estabelecidas neste Regulamento, não excluídos a obrigatoriedade de elaboração e assinatura de ata de reunião, admitindo-se assinatura da ata por meio físico e/ou digital, inclusive assinatura por meio de sistemas eletrônicos, com descrição da ordem do dia e dos assuntos deliberados.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos serviços de administração fiduciária, escrituração, tesouraria e controladoria, a Classe pagará Taxa de Administração equivalente a 0,18% (dezoito centésimos por cento), ao ano, sendo que esta poderá ser reduzida esporadicamente conforme os termos e condições previamente acordados entre os Prestadores de Serviços Essenciais.</PoliticaRemuneracao>
			<ValorPagoAno xsi:nil="true"/>
			<PercentPatrimonioContabil xsi:nil="true"/>
			<PercentPatrimonioValorMercado xsi:nil="true"/>
		</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>Ricardo Fuscaldi de Figueiredo Baptista</Nome>
				<Idade>54</Idade>
				<CPF>11475074816</CPF>
				<Email>rfb@vortx.com.br</Email>
				<Profissao>Engenheiro</Profissao>
				<FormacaoAcademica>Engenharia Eletrônica (ITA), MBA Finanças (IBMEC-SP)</FormacaoAcademica>
				<DataInicioFuncao>2025-06-24</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Vórtx DTVM</NomeEmpresa>
						<Periodo>2023-atual</Periodo>
						<CargoFuncoes>Diretor de Administração Fiduciária, Diretor responsável pela área de Risco, Compliance e Controles internos</CargoFuncoes>
						<AtividadePrincipalEmpresa>Diretor de Administração Fiduciária, Diretor responsável pela área de Risco, Compliance e Controles internos</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>RCF Financial Consulting</NomeEmpresa>
						<Periodo>2022-2023</Periodo>
						<CargoFuncoes>Sócio Fundador</CargoFuncoes>
						<AtividadePrincipalEmpresa>Sócio Fundador</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Armor Capital Asset</NomeEmpresa>
						<Periodo>2020-2022</Periodo>
						<CargoFuncoes>Sócio Sênior e Diretor Executivo</CargoFuncoes>
						<AtividadePrincipalEmpresa>Sócio Sênior e Diretor Executivo</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="2455" numCotasDetidas="1105000" percDetidoRelTotal="0.7342" percDetidoPF="0.552" percDetidoPJ="0.182"/>
			<AcimaCincoAteDezPorcento numCotistas="2" numCotasDetidas="200000" percDetidoRelTotal="0.1329" percDetidoPF="0" percDetidoPJ="0.133"/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="200000" percDetidoRelTotal="0.1329" percDetidoPF="0" percDetidoPJ="0.132871"/>
			<AcimaQuinzeAteVintePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaVinteAteTrintaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<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>Todos os atos ou fatos relevantes do Fundo serão divulgados na página do Fundo, www.vortx.com.br e no sistema FundosNet da B3 S.A.- Brasil, Bolsa e Balcão (B3) e da CVM.</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>Depois das Cotas estarem integralizadas e após o Fundo e esta Classe estarem devidamente constituídos e em funcionamento, os titulares das Cotas poderão negociá-las secundariamente em mercado de bolsa operacionalizado pela B3. https://www.vortx.com.br/</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.galapagoscapital.com/</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Não aplicável.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>O documento de aceitação da oferta pode conter obrigação do investidor de integralizar à vista o valor do capital subscrito ou de acordo com chamadas realizadas pelo Administrador, conforme orientação do Gestor, observados prazos e demais condições estabelecidas nos documentos de subscrição e na referida chamada de capital. O Administrador divulgará comunicado ao mercado para dar publicidade ao procedimento de chamada de capital, nos prazos estipulados pela B3, contendo, no mínimo, as seguintes informações: (a) quantidade de cotas que deverão ser integralizadas; (b) valor total que deverá ser integralizado; e (c) data prevista para liquidação da Chamada de Capital, de modo que os investidores acessem seus custodiantes para realização das operações de integralização das cotas.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"