"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>GENIAL LOGÍSTICA FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>36501198000134</CNPJFundo>
		<DataFuncionamento>2019-12-11</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRPLOGCTF001</CodigoISIN>
		<QtdCotasEmitidas>750000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<SegmentoAtuacao>Logística</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</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>GENIAL INVESTIMENTOS CORRETORA DE VALORES MOBILIÁRIOS S.A.</NomeAdministrador>
		<CNPJAdministrador>36501198000134</CNPJAdministrador>
		<Logradouro>PRAIA DE BOTAFOGO</Logradouro>
		<Numero>228</Numero>
		<Complemento>SL 907</Complemento>
		<Bairro>BOTAFOGO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22250040</CEP>
		<Telefone1>(21) 3923-3000</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.bancogenial.com</Site>
		<Email>middleadm@genialinvestimentos.com.br</Email>
		<Competencia>1/2026</Competencia>
		<DataEncerTrimestre>2026-03-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Parque Logístico Pernambuco</Nome>
								<Endereco>Rodovia PE-060 – Km 14,5 – Ipojuca, Pernambuco</Endereco>
								<Area>70222</Area>
								<NumUnidades>3</NumUnidades>
								<OutrasCaractRelevantes> Todos os galpões contam com capacidade de piso de 5 ton/m², pé direito livre de 12 metros e somados possuem mais de 180 docas. O galpão A possui também uma área de pátio com reforço de piso, sendo capaz de suportar 10 ton/m². Adicionalmente, os galpões B e C são cross docking.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>1</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Logística - Armazenagem/Porto Seco</SetorAtuacao><PercentReceitaImovel>0.356</PercentReceitaImovel><PercentReceitasFII>0.356</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logística - Armazenagem</SetorAtuacao><PercentReceitaImovel>0.276</PercentReceitaImovel><PercentReceitasFII>0.276</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logística - Entrepostagem</SetorAtuacao><PercentReceitaImovel>0.226</PercentReceitaImovel><PercentReceitasFII>0.226</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Outros</SetorAtuacao><PercentReceitaImovel>0.141</PercentReceitaImovel><PercentReceitasFII>0.141</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses>Até 3 meses</AteTresMeses>
							<TresAteSeisMeses>De 3 meses e 1 dia a 6 meses</TresAteSeisMeses>
							<SeisAteNoveMeses>De 6 meses e 1 dia a 9 meses</SeisAteNoveMeses>
							<NoveAteDozeMeses>De 9 meses e 1 dia a 12 meses</NoveAteDozeMeses>
							<DozeAteQuinzeMeses>De 12 meses e 1 dia a 15 meses</DozeAteQuinzeMeses>
							<QuinzeAteDezoitoMeses>De 15 meses e 1 dia a 18 meses</QuinzeAteDezoitoMeses>
							<DezoitoAteVinteUmMeses>De 18 meses e 1 dia a 21 meses</DezoitoAteVinteUmMeses>
							<VinteUmAteVinteQuatroMeses>De 21 meses e 1 dia a 24 meses</VinteUmAteVinteQuatroMeses>
							<VinteQuatroAteVinteSeteMeses>De 24 meses e 1 dia a 27 meses</VinteQuatroAteVinteSeteMeses>
							<VinteSeteAteTrintaMeses>De 27 meses e 1 dia a 30 meses</VinteSeteAteTrintaMeses>
							<TrintaAteTrintaTresMeses>De 30 meses e 1 dia a 33 meses</TrintaAteTrintaTresMeses>
							<TrintaTresAteTrintaSeisMeses>De 33 meses e 1 dia a 36 meses</TrintaTresAteTrintaSeisMeses>
							<AcimaTrintaSeisMeses percentReceitaImovel="1" percentReceitasFII="1">Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado>Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="1" percentReceitasFII="1"/>
							<INPC/>
							<IPCA/>
							<INCC/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Todos os contratos são reajustados anualmente pelo IGP-M. Em relação as multas, variam de acordo com o contrato:
Galpão A: Módulo 1 - Saldo remanescente das parcelas mensais de locação até Dez/2022. A partir de Jan/2023, sem incidência de multa em caso de rescisão pelo Locatário, respeitado o aviso prévio de 6 meses; Módulo 2 - aviso prévio de 06 meses, e aplicação de multa equivalente a 03 meses de aluguel; Módulo 3 - aviso prévio de 06 meses, e aplicação de multa equivalente a 03 meses de aluguel

Galpão B: Na hipótese de rescisão contratual antecipada pela LOCATÁRIA, ou seja, anteriormente ao prazo final de vigência de 31 de março de 2027, bem como na hipótese de inadimplência contratual da LOCATÁRIA, deverá esta, além de arcar com as multas e cominações contratuais aplicáveis na Cláusula Oitava do Contrato ora  aditado, pagar: (i) o desconto de R$ 950.453,10 (novecentos e cinquenta mil quatrocentos e cinquenta e tres reais e dez centavos), concedido no 2 Aditivo Contratual; (ii) a diferença entre o valor efetivamente pago e o  valor devido sem qualquer dos descontos ora concedidos, totalizando R$ 954.635,13 (novecentos e cinquenta e quatro mil seiscentos e trinta e cinco reais e treze centavos), valores esses a serem devidamente atualizados pela variação positiva do índice IGP-M/FGV, a contar da data de cada desconto até o efetivo pagamento.

Galpão C: A rescisão antecipada do presente instrumento por parte da LOCATÁRIA deverá ser comunicada por intermédio de notificação formal, com antecedência mínima de 3 (três) meses, sendo devido o pagamento de locação e encargos durante os meses do Aviso Prévio, bem como ensejando única e exclusivamente a aplicação de multa equivalente a 3 (três) meses do valor do aluguel vigente a época, reduzida proporcionalmente ao cumprimento do contrato (60 meses).</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>Parque Logístico Pernambuco</NomeOuEndereco>
								<CaractContratuais>A aquisição do Parque Logístico Pernambuco possui locação garantida em caso de rescisão por qualquer dos atuais locatários, pela qual o vendedor obriga-se a pagar aos compradores o valor de locação e encargos equivalente ao previsto nos contratos de locação vigentes, pelo prazo de até (i) 2 anos contados de eventual vacância ou (ii) 3 anos da data da aquisição, limitado a R$ 8.000.000,00. O valor referente à Locação Garantida refere-se à totalidade da operação, sendo certo que o Fundo faz jus à Locação Garantida na proporção da fração ideal de 50% do Ativo, ou seja, equivalente a R$ 4.000.000,00</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>Os 3 galpões possuem seguros, no entanto, a contratação é uma obrigação dos locatários.</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
					<Emissor>
						<Fundo>FATOR VERITA FUNDO DE INVESTIMENTO IMOBILIARIO (VRTA11)</Fundo>
						<CNPJ>11664201000100</CNPJ>
						<Quantidade>568</Quantidade>
						<Valor>46916.8</Valor>
					</Emissor>
				</FII>
				<CriCra>
				</CriCra>
				<LciLca>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>ITAÚ SOBERANO RENDA FIXA SIMPLES FI EM FIC</Fundo>
						<CNPJ>6175696000173</CNPJ>
						<Quantidade>21364.11</Quantidade>
						<Valor>1799109.73</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>46901.74</Disponibilidades>
				<TitulosPublicos>0</TitulosPublicos>
				<TitulosPrivados>0</TitulosPrivados>
				<FundosRendaFixa>1799109.73</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda/>
					<CustoImovEstoque/>
					<AjusteValor/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="0" financeiro="1567213.86"/>
					<DespManutencaoConservacao contabil="-21394.56" financeiro="-21394.56"/>
					<ReceitasVenda contabil="0" financeiro="0"/>
					<CustoPropriedadesVendidas contabil="0" financeiro="0"/>
					<AjusteValor contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="-22667.55" financeiro="-22667.55"/>
					<ResultadoLiquido contabil="-44062.11" financeiro="1523151.75"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="0" financeiro="0"/>
					<AjusteValor contabil="-2828.64" financeiro="0"/>
					<ResultadoVenda contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="1448.4"/>
					<ResultadoLiquido contabil="-2828.64" financeiro="1448.4"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="-46890.75" financeiro="1524600.15"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="0" financeiro="0"/>
				<AjusteValorAplicacoes contabil="0" financeiro="0"/>
				<ResultadoVendaAplicacoes contabil="36416.82" financeiro="41504.36"/>
				<OutrasRecOuDespAplicacoes contabil="0" financeiro="0"/>
				<ResultadoLiquido contabil="36416.82" financeiro="41504.36"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-170772.54" financeiro="-170806.01"/>
				<TaxaDesempenho contabil="0" financeiro="0"/>
				<ConsultoriaEspecializada contabil="0" financeiro="0"/>
				<EmpresaEspecializada contabil="0" financeiro="0"/>
				<FormadorMercado contabil="0" financeiro="0"/>
				<CustodiaTitulosValores contabil="0" financeiro="0"/>
				<AuditoriaIndependente contabil="0" financeiro="0"/>
				<RepresentantesCotistas contabil="0" financeiro="0"/>
				<TaxasImpostosContribuicoes contabil="-933.33" financeiro="-1261.72"/>
				<ComissoesEmolumentos contabil="0" financeiro="0"/>
				<HonorariosDespesasDefesas contabil="0" financeiro="0"/>
				<GastosContratosSeguros contabil="0" financeiro="0"/>
				<DespesasAvaliacoes contabil="0" financeiro="0"/>
				<TaxasIngressoSaidaFundos contabil="0" financeiro="0"/>
				<DespesasRegistroCartorio contabil="0" financeiro="0"/>
				<OutrasRecOuDesp contabil="-35659.31" financeiro="-35659.31"/>
				<Total contabil="-207365.18" financeiro="-207727.04"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="-217839.11" financeiro="1358377.47"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>1358377.47</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>1290458.5965</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte xsi:nil="true"/>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<ResultadoFinanceiroExcedeMinimo xsi:nil="true"/>
			<RendimentosDeclarados>1290458.5965</RendimentosDeclarados>
			<RendimentosPagosAntec>-720000</RendimentosPagosAntec>
			<RendimentoPagar>570458.5965</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.95</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"