"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>AROEIRA 333 RENDA LOGÍSTICA FII</NomeFundo>
		<CNPJFundo>44674528000111</CNPJFundo>
		<DataFuncionamento>2022-05-06</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRAROACTF003</CodigoISIN>
		<QtdCotasEmitidas>167926832</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Multicategoria</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>SONATA GESTORA DE RECURSOS LTDA.</Nome>
				<CNPJ>29996127000194</CNPJ>
				<Endereco>Rua Funchal, 263, 1º andar, Conj 11, CEP: 04551-060, Vila Olimpia, São Paulo - SP.</Endereco>
				<telefone>11 3121-5454</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>TATICCA AUDITORES INDEPENDENTES S.S. - EPP</Nome>
				<CNPJ>20840718000101</CNPJ>
				<Endereco>Av. Nove de Julho, 5966, cj 21, Jardim Paulista, CEP: 01406-200</Endereco>
				<telefone>(11) 3062-3000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>AROEIRA 333 GESTÃO IMOBILIÁRIA LTDA</Nome>
				<CNPJ>37576759000127</CNPJ>
				<Endereco>Rodovia Quarto Anel Viario, 3333, Santa Clara. EUSEBIO - CE. CEP: 61768-260</Endereco>
				<telefone>85 8650-4625</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>SANCHO INVESTIMENTOS IMOBILIARIOS</Nome>
				<CNPJ>22767235000146</CNPJ>
				<Endereco>AV CESAR CALS,2339 - PRAIA DO FUTURO I CEP:60.182-385</Endereco>
				<telefone>(85) 9925-4443</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Não possui informação apresentada</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Não possui informação apresentada</ResultadoFundo>
			<ConjunturaEconomica>Não possui informação apresentada</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Não possui informação apresentada</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>ARACATI</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>25800000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0301</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CANINDÉ</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>22700000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0542</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MARACANAU</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>34680000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0063</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MARANGUAPE</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>25340000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0018</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>QUIXERAMOBIM</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>26470000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0519</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>PARANGABA</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>21288000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0995</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os ativos estão demonstradas pelos seus respectivos valores justos, os quais foram obtidos através de laudos de avaliação, elaborados por entidade profissional com qualificação reconhecida.</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 26 A Assembleia Geral de Cotistas realizar-se-á, ordinariamente, até o dia 30 de abril de cada ano, para deliberar sobre a matéria prevista no inciso “i” do Parágrafo 1º abaixo, e, extraordinariamente, sempre que convocada na forma prevista neste Capítulo.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Artigo 27 A Assembleia Geral de Cotistas quando convocada poderá ser feita mediante consulta formal ou presencialmente. Em ambas as hipóteses, será convocada pelo Administrador mediante a divulgação de carta consulta ou edital de convocação, conforme o caso, nos sites do Administrador e da CVM/Fundos.Net, de acordo com a legislação aplicável. Artigo 28 A convocação da Assembleia Geral de Cotistas deve ser feita (i) com pelo menos 30 (trinta) dias de antecedência da data realização da Assembleia ou da data da apuração dos votos, conforme o caso, no caso da Assembleia Geral de Cotistas ordinária; e (ii) com pelo menos 15 (quinze) dias de antecedência, no caso da Assembleia Geral de Cotistas extraordinária. Artigo 29 A Assembleia Geral de Cotistas também pode reunir-se por convocação do Administrador, do Custodiante ou de Cotistas detentores de Cotas que representem, no mínimo, 5% (cinco por cento) do total das Cotas emitidas, observados os procedimentos do artigo 28 acima.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Artigo 8º Pelos serviços de administração, controladoria, contabilidade, tesouraria e gestão do Fundo e de suas Cotas, o Fundo pagará (“Taxa de Administração”): (i) ao Administrador uma remuneração mensal composta pelos percentuais previstos na tabela abaixo, em regra de cascata, sendo que cada percentual será calculado respectivamente sobre a correspondente do Patrimônio Líquido do Fundo, sendo assegurado ao Administrador uma remuneração mínima mensal equivalente a R$ 15.000,00 (quinze mil reais): Valor contábil do Patrimônio Líquido do Fundo até R$ 200.000.00,00, taxa do administrador de 0,20% a.a.; Valor contábil do Patrimônio Líquido do Fundo de R$ 200.000.00,01 até R$ 400.000.000,00, taxa do administrador de 0,18% a.a.; Valor contábil do Patrimônio Líquido do Fundo de R$ 400.000.000,01 até R$ 800.000.000,00, taxa do administrador de 0,15% a.a.;  Valor contábil do Patrimônio Líquido do Fundo acima de R$ 800.000.00,01, taxa do administrador de 0,20% a.a</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="5101" numCotasDetidas="66308411" percDetidoRelTotal="0.394864895682663" percDetidoPF="0.394607999999984" percDetidoPJ="0.00002"/>
			<AcimaCincoAteDezPorcento numCotistas="7" numCotasDetidas="84863813" percDetidoRelTotal="0.50536184116187" percDetidoPF="0.505363000000017" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="16754608" percDetidoRelTotal="0.0997732631554676" percDetidoPF="0.100009000000007" 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>A gestão da carteira do fundo é a gestão profissional, conforme estabelecido no seu regulamento, dos ativos financeiros dela integrantes, tendo poderes para (i) negociar, em nome do fundo, os ativos financeiros que compõem a sua carteira; e (ii) exercer o direito de voto decorrente dos ativos financeiros detidos pelo fundo, realizando todas as demais ações necessárias para tal exercício, observado o disposto no presente regulamento.</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Não aplicável.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Parágrafo 6º: A integralização de Cotas pelos Cotistas, até o valor comprometido, deverá ocorrer em até 10 (dez) dias úteis contados do recebimento da chamada de capital a ser enviada pelo Administrador mediante o envio de correspondência com aviso de recebimento ou correio eletrônico dirigido para os Cotistas, conforme as informações constantes no Boletim de Subscrição e no Compromisso de Investimento (“Chamada de Capital”), sendo certo que o referido valor deverá ser líquido de quaisquer impostos, observado o descrito no Compromisso de Investimento.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"