"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>]</NomeFundo>
		<CNPJFundo>58523711000120</CNPJFundo>
		<DataFuncionamento>2025-03-26</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN>BRGFDLCTF005</CodigoISIN>
		<QtdCotasEmitidas>254927</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>GALAPAGOS CAPITAL DTVM S.A.</Nome>
				<CNPJ>28650236000192</CNPJ>
				<Endereco>Avenida Rebouças, 3507, 1º andar, Pinheiros, São Paulo - SP, CEP 05401-400</Endereco>
				<telefone>(11) 3777-2088</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>FII HCO LOG</Nome>
						<Objetivos>Aplicações em ativo alvo do fundo</Objetivos>
						<MontantesInvestidos>24406135.95</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$ 0,08 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>Artigo 25. A Assembleia de Cotistas pode ser convocada, a qualquer tempo, pelos Prestadores de Serviços Essenciais, pelo custodiante, pelo Cotista ou grupo de Cotistas que detenha, no mínimo, 5% (cinco por cento) do total das Cotas ou pelo representante dos Cotistas, para deliberar sobre ordem do dia de interesse do Fundo, da classe, da subclasse ou da comunhão de Cotistas. Parágrafo Primeiro - O pedido de convocação de Assembleia de Cotistas pelo Gestor, por Cotistas ou pelo representante dos Cotistas, deve ser dirigido ao Administrador, que deve, no prazo máximo de 30 (trinta) dias contado do recebimento, convocar a Assembleia de Cotistas. Parágrafo Segundo - A convocação e a realização da Assembleia de Cotistas devem ser custeadas pelos requerentes, salvo se a Assembleia de Cotistas convocada deliberar em contrário. Parágrafo Quinto - O aviso de convocação deve indicar a página na rede mundial de computadores em que o Cotista pode acessar os documentos pertinentes à proposta a ser submetida à apreciação da Assembleia de Cotistas. Parágrafo Sexto - Caso seja admitida a participação do Cotista por meio de sistema eletrônico, a convocação deve conter informações detalhando as regras e os procedimentos para viabilizar a participação e votação a distância, incluindo as informações necessárias e suficientes para acesso e utilização do sistema, assim como se a Assembleia de Cotistas será realizada parcial ou exclusivamente de modo eletrônico. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>As deliberações da assembleia geral de cotistas poderão ser tomadas mediante processo de consulta formal, por meio eletrônico, dirigido pelo ADMINISTRADOR a cada cotista, para resposta de acordo com os prazos e quóruns estabelecidos na regulamentação aplicável.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Artigo 31 - 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. Parágrafo Primeiro - A Taxa de Administração será paga até o 5º (quinto) Dia Útil de cada mês subsequente ao da prestação dos serviços, vencendo-se a primeira mensalidade no 5º (quinto) Dia Útil do mês seguinte ao da primeira integralização de recursos na Classe. Parágrafo Terceiro - O cálculo da Taxa de Administração levará em conta a quantidade efetiva de Dias Úteis de cada mês e terá como base um ano de 252 (duzentos e cinquenta e dois) Dias Úteis. Parágrafo Quarto - A Taxa de Administração observará o valor mínimo total de R$8.000,00 (oito mil reais) ao mês. Parágrafo Quinto - O valor mínimo mensal da Taxa de Administração, será atualizado anualmente, desde a data de início da Classe, pela variação do IPCA, ou qualquer outro índice que venha a substituí-lo e que adote metodologia de apuração e cálculo semelhante. Artigo 32 - O Gestor não receberá Taxa de Gestão pela prestação de serviços de gestão de ativos.</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="1780" numCotasDetidas="254927" percDetidoRelTotal="1" percDetidoPF="0.955" percDetidoPJ="0.045"/>
			<AcimaCincoAteDezPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<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>As Cotas serão admitidas à negociação no Mercado de Bolsa administrado pela B3 S.A – Brasil, Bolsa, Balcão, observados o disposto no Regulamento do Fundo</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>Parágrafo Terceiro - O exercício do direito de voto decorrente de ativos detidos pelas classes do Fundo, a que se refere o inciso XII deste artigo, seguirá o disposto na política de exercício de direito de voto do Gestor, disponível no seguinte endereço eletrônico: 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>
"