"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>GALAPAGOS CRÉDITO ESTRUTURADO FII RESP LIMIT</NomeFundo>
		<CNPJFundo>59669570000111</CNPJFundo>
		<DataFuncionamento>2025-04-01</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN>BRGLCRCTF002</CodigoISIN>
		<QtdCotasEmitidas>360110</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Papel</Classificacao>
			<Subclassificacao>Híbrido</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Multicategoria</SegmentoAtuacao>
		</Autorregulacao>
		<PrazoDuracao>Determinado</PrazoDuracao>
		<DataPrazoDuracao>2035-04-01</DataPrazoDuracao>
		<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>18L1168429          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1359944.24</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>20K0866670          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1657946.1</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>21H0891390          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>20717.04</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>22B0945202          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1671800.66</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>22F0685593          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1232661.86</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>22I0097904          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>828625.38</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>22I2046002          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1589242.65</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>22J0120088          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1279623.12</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>23D1557666          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1691772.67</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>23F1568486          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1764487.72</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>23F2430066          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1648859.78</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>23J0108650          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1291031.67</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>23K2665601          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>908463.65</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>23L1538459          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>3228934.26</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>24A2532710          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>453640.76</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>24E2335939          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>122003.34</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>24F1586813          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>841262.54</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>24G1249772          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1718798.24</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>24G2730555          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>2005839.67</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>24L1964965          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1605260.57</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>24L2959379          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1710945.52</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>25A1296532          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>2248026.68</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>25A3992922          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1702761.8</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>25B2176484          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1710873.84</MontantesInvestidos>
						<OrigemRecursos>Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>25K2451016          </Nome>
						<Objetivos>Aplicação em ativos alvo do fundo</Objetivos>
						<MontantesInvestidos>1313389.9</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$ 8,95 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>31. Assuntos de interesse dos cotistas de todas as Classes e Subclasses do Fundo exigirão a convocação de uma assembleia geral de cotistas, na qual participarão todos os cotistas do Fundo (“Assembleia Geral de Cotistas”). 32. Assuntos de interesse exclusivo de uma Classe e/ou Subclasse específica do Fundo exigirão a convocação de uma assembleia especial para os cotistas da Classe e/ou Subclasse em questão, permitindo a participação apenas dos cotistas de tal Classe e/ou Subclasse, conforme o caso (“Assembleia Especial de Cotistas”). 39. A assembleia de cotistas se instala com a presença de qualquer número de cotistas e possui como quórum de votação, em regra, o da maioria de votos dos presentes. 40. Compete ao Administrador convocar as assembleias de cotistas. 40.1. As assembleias de cotistas também poderão ser convocadas, a qualquer tempo, pelo Gestor, pelo Custodiante, pelo cotista ou grupo de cotistas que detenha, no mínimo, 5% do total das cotas emitidas ou pelo representante dos cotistas, para deliberar sobre ordem do dia de interesse do Fundo, da Classe, da Subclasse, conforme o caso, ou da comunhão de cotistas, observados os requisitos Estabelecidos neste Regulamento e/ou no Anexo, conforme o caso. 40.2. O pedido de convocação de assembleia de cotistas pelo Gestor, pelo Custodiante ou por cotistas deve ser dirigido ao Administrador, que deve, no prazo máximo de 30 dias contado do recebimento, convocar a assembleia de cotistas. 40.3. 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. 40.4. A primeira convocação das assembleias de cotistas deve ocorrer: (i) com, no mínimo, 30 dias de antecedência, no caso das assembleias ordinárias; e (ii) com, no mínimo, 15 dias de antecedência, no caso das assembleias extraordinárias. 41. A convocação da assembleia de cotistas deve ser encaminhada a cada cotista e disponibilizada nas páginas dos Prestadores de Serviços Essenciais e, caso a distribuição de cotas esteja em andamento, dos distribuidores na rede mundial de computadores. 41.1. A convocação da assembleia de cotistas deve observar o Artigo 72, caput e parágrafos, da parte geral da Resolução CVM nº 175/2022. 41.2. 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. 41.3. 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>Taxa de Administração: 0,18% (dezoito centésimos por cento) ao ano sobre o patrimônio líquido da Classe, a qual 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, observado o valor mínimo mensal de R$ 16.000,00 (dezesseis mil reais). Excepcionalmente, para os 12 (doze) primeiros meses do Fundo, o valor mínimo mensal da Taxa de Administração será de R$ 13.000,00 (treze mil reais). Taxa de Gestão: 1,00% (um por cento) ao ano sobre o patrimônio líquido da Classe, a qual 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, observado o valor mínimo mensal de R$ 10.000,00 (dez mil reais). </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="829" numCotasDetidas="80110" percDetidoRelTotal="0.2225" percDetidoPF="0.207" percDetidoPJ="0.015"/>
			<AcimaCincoAteDezPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="2" numCotasDetidas="100000" percDetidoRelTotal="0.2777" percDetidoPF="0" percDetidoPJ="0.277692"/>
			<AcimaQuinzeAteVintePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaVinteAteTrintaPorcento numCotistas="2" numCotasDetidas="180000" percDetidoRelTotal="0.4998" percDetidoPF="0" percDetidoPJ="0.499853"/>
			<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>8.4. O exercício do direito de voto decorrente de ativos financeiros e valores mobiliários detidos pelas Classes, a que se refere o item 9.3., (h), acima, 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>14. O boletim de subscrição e/ou o compromisso de investimento poderão conter obrigação do investidor de integralizar o valor do capital subscrito de acordo com chamadas realizadas pelo
Administrador, conforme orientação do Gestor. Eventuais chamadas de capital devem ser enviadas aos cotistas com, pelo menos, 10 (dez) dias corridos de antecedência.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"