"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FII SJ AU LOG</NomeFundo>
		<CNPJFundo>27771547000147</CNPJFundo>
		<DataFuncionamento>2020-10-02</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRSJAUCTF009</CodigoISIN>
		<QtdCotasEmitidas>7932248</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</Subclassificacao>
			<TipoGestao>Definida</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>0</Nome>
				<CNPJ>0</CNPJ>
				<Endereco>0</Endereco>
				<telefone>0</telefone>
			</Gestor>
			<Custodiante>
				<Nome>VÓRTX DISTRIBUIDORA DE TÍTULOS E
VALORES MOBILIÁRIOS LTDA.</Nome>
				<CNPJ>22610500000188</CNPJ>
				<Endereco>R. Gilberto Sabino, 215 - Pinheiros, São Paulo - SP, 05425-020</Endereco>
				<telefone>(11) 3030-7177</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>RSM BRASIL AUDITORES INDEPENDENTES LTDA</Nome>
				<CNPJ>16549480000184</CNPJ>
				<Endereco>Av. Marq de São Vicente, 182, 2º andar, Conj 23, São Paulo - SP, CEP: 01139-000</Endereco>
				<telefone>11 2154-7795</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>VÓRTX DISTRIBUIDORA DE TÍTULOS E
VALORES MOBILIÁRIOS LTDA.</Nome>
				<CNPJ>22610500000188</CNPJ>
				<Endereco>R. Gilberto Sabino, 215 - Pinheiros, São Paulo - SP, 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>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Informação não apresentada</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Informação não apresentada</ResultadoFundo>
			<ConjunturaEconomica>Informação não apresentada</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Informação não apresentada</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>SPE NK 085</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>8975790.54</Valor>
				<PercentValorizacaoDesvalorizacao>0.0672</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Informação não apresentada</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 54 – Sem prejuízo de ser disponibilizada nas páginas na rede mundial de computadores do Administrador, a convocação da Assembleia Geral deverá ser realizada preferencialmente por meio de correspondência eletrônica, podendo ser realizada também por carta com aviso de recebimento, encaminhada pelo Administrador, a cada um dos Cotistas, (i) com antecedência mínima de 30 (trinta) dias, no caso de Assembleia Geral ordinária, ou (ii) com antecedência mínima de 15 (quinze) dias, no caso de Assembleia Geral extraordinária. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Artigo 50 – Para fins do disposto neste Regulamento, considerar-se-á o correio eletrônico uma forma de correspondência válida entre o Administrador, Gestor e os Cotistas, inclusive para convocação de Assembleias Gerais e procedimentos de consulta formal ou declaração de voto. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Artigo 51 Pela administração do Fundo, nela compreendida as atividades de administração do Fundo, gestão dos Ativos, tesouraria, escrituração, controladoria, custódia qualificada dos Ativos integrantes do patrimônio do Fundo, controle e processamento dos títulos e valores mobiliários integrantes de sua carteira e escrituração da emissão de suas Cotas, e pelos serviços prestados pelo Gestor, será devida pelo Fundo uma taxa de administração anual, composta de valor equivalente aos percentuais previstos na tabela abaixo multiplicados sobre a Base de Cálculo da Taxa de Administração, sendo assegurado ao Administrador um valor mínimo mensal de R$20.000,00 (vinte mil reais). A taxa será defibida  conforme  o  Valor Contábil do Patrimônio Líquido ou Valorde Mercado do Fundo :Até R$ 300.000.000,00- 0,25% ao ano; De R$ 300.000.000,01 até R$ 1.000.000.000,00 - 0,22% ao ano e  A partir de R$ 1.000.000.000,01  - 0,20% ao ano. </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="602" numCotasDetidas="4782272" percDetidoRelTotal="0.602889874345835" percDetidoPF="0.294312999999999" percDetidoPJ="0.308585"/>
			<AcimaCincoAteDezPorcento numCotistas="4" numCotasDetidas="2038419" percDetidoRelTotal="0.256978727846129" percDetidoPF="0" percDetidoPJ="0.256979"/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="1111557" percDetidoRelTotal="0.140131397808036" percDetidoPF="0" percDetidoPJ="0.140123"/>
			<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>Artigo 38 – As Cotas emitidas pelo Fundo poderão ser registradas para negociação no mercado de bolsa de valores ou de balcão administrados pela B3, observado que apenas Cotas integralizadas podem ser negociadas no mercado secundário. </PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>Artigo 14 - Fica estabelecido que o Gestor deste Fundo adota Política de Exercício de Direito de Voto em assembleias, que disciplina os princípios gerais, o processo decisório e quais as matérias relevantes obrigatórias para o exercício do direito de voto pelo Gestor do Fundo em assembleias de sociedades nas quais o Fundo participe, inclusive da Sociedade Investida. Tal política orienta as decisões do Gestor em assembleias de detentores de títulos e valores mobiliários que confiram aos seus titulares o direito de voto.
Parágrafo Único – A Política de Exercício de Direito de Voto adotada pelo Gestor, cuja cópia é entregue ao cotista no momento de seu ingresso no Fundo, quando da assinatura do boletim de subscrição, está divulgada no sítio do Gestor na rede mundial de computadores .</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Não aplicável.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Não aplicável.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"