"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIARIO - FII NOVO HORIZONTE</NomeFundo>
		<CNPJFundo>17025970000144</CNPJFundo>
		<DataFuncionamento>2012-12-17</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRNVHOCTF003</CodigoISIN>
		<QtdCotasEmitidas>41494533</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<SegmentoAtuacao>Hospital</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>BANCO GENIAL S.A.</NomeAdministrador>
		<CNPJAdministrador>17025970000144</CNPJAdministrador>
		<Logradouro>PRAIA DE BOTAFOGO</Logradouro>
		<Numero>228</Numero>
		<Complemento>SALA 907</Complemento>
		<Bairro>BOTAFOGO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22250-040</CEP>
		<Telefone1>(21) 3923-3000</Telefone1>
		<Telefone2>(11) 3206-8000</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>Hospital São Luiz - BLOCO A</Nome>
								<Endereco>Rua Doutor Alceu de Campos Rodrigues, 95, Itaim Bibi, São Paulo, SP</Endereco>
								<Area>7520.15</Area>
								<NumUnidades>10</NumUnidades>
								<OutrasCaractRelevantes>Composto por subsolo, térreo, intermediário, 6 pavimentos e ático. O subsolo é composto por estacionamento e está interligado ao estacionamento. Atualmente possui 73 apartamentos, berçário, UTI com 10 leitos, setor de medicina fetal, áreas de convivência, recepção, lojas, capela e lanchonete.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.25</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Apartamentos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Berçário</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>UTI</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Lanchonete</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Hospital São Luiz - BLOCO B</Nome>
								<Endereco>Rua Desembargador Aguiar Valim, Itaim Bibi, São Paulo, SP</Endereco>
								<Area>9897.05</Area>
								<NumUnidades>15</NumUnidades>
								<OutrasCaractRelevantes>Abriga centro cirúrgico com 18 salas, UTI neo natal com 46 leitos, banco de leite, isolamento, centro obstétrico, 6 apartamentos pré-parto e 2 apartamentos delivery, UTI individuais, UTI coletiva com 26 leitos, espera para UTI, hotelaria, casa de máquinas, ar condicionado, central de esterilização, almoxarifado e manutenção.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.33</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Centro Cirurgico</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>UTI neo natal</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Banco de Leite</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Area de isolamento</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Hospital São Luiz - BLOCO C e E</Nome>
								<Endereco>Rua Doutor Alceu de Campos Rodrigues, 95, Itaim Bibi, São Paulo, SP</Endereco>
								<Area>7121.25</Area>
								<NumUnidades>10</NumUnidades>
								<OutrasCaractRelevantes>Bloco C, Abriga 43 apartamentos/leitos distribuídos entre o 1º e 3º pavimentos, 11 leitos de UTI, 14 apartamentos/leitos máster no 5º pavimento, 14 Aprtamentos/leito destinados a maternidade no 6º pavimento,o subsolo localiza-se o setor de endoscopia e nos pavimentos térreo e intermediário núcleos operacionais (5 por pavimento) composto por consultórios, salas de ultrassom, leitos para observação, área de edicação. O térreo possui também área administrativa e lanchonete. Bloco E, ocupado pelo Pronto Atendimento, acessado através da Avenida Santo Amaro. Conta com 12 box de atendimento, leitos de observação, 24 poltronas para medicação, salas de emergência, curativos, sutura, gesso, oftalmológico e ortopedia.

</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.23</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>UTI</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Leitos maternidade</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Endoscopia</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Sala de Ultrason</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Hospital São Luiz - BLOCO D</Nome>
								<Endereco>Rua Doutor Alceu de Campos Rodrigues, 95, Itaim Bibi, São Paulo, SP</Endereco>
								<Area>5820.73</Area>
								<NumUnidades>10</NumUnidades>
								<OutrasCaractRelevantes>Ocupado pelo Centro de Diagnóstico possui acesso através dos demais blocos, não há acesso através de logradouro. Composto por subsolo, térreo, intermediário, 7 pavimentos, ático e heliponto.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.19</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Apartamento</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Raio X</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Radiologia</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Ressonancia Magnetica</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</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>O prazo de locação é 240 meses, a partir de 26 de agosto de 2014(data de início da locação) encerrando-se em 26 de agosto 2034. Ocorrendo a renovação ou a prorrogação do contrato, o aluguel mensal para o novo período será reajustado de acordo com a variação acumuluada do Índice Nacional de Preços ao Consumidor Amplo - IPCA. Os alugueis devidos e não pagos na data própria estarão sujeitos a : (i) juros de mora para 1% ao mes ou fração, (ii) correção monetária mensal, segundo o índice vigente para reajuste dos alugueis e (iii) multa por inadimplemento de 2% sobre o valor do aluguel que estiver em atraso, devidamente corrigido e acrescido dos juros de mora. </CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>Hospital São Luiz - BLOCO A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Hospital São Luiz - BLOCO B</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Hospital São Luiz - BLOCO C e E</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Hospital São Luiz - BLOCO D</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>N/A</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>
				</FII>
				<CriCra>
				</CriCra>
				<LciLca>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>ITAU SOBERANO RF SIMPLES LP
FIC FI</Fundo>
						<CNPJ>6175696000173</CNPJ>
						<Quantidade>103196.86</Quantidade>
						<Valor>8636944.31</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>9512.84</Disponibilidades>
				<TitulosPublicos>0</TitulosPublicos>
				<TitulosPrivados>0</TitulosPrivados>
				<FundosRendaFixa>8636944.31</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 contabil="0" financeiro="0"/>
					<CustoImovEstoque contabil="0" financeiro="0"/>
					<AjusteValor contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="0"/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="12035842.61" financeiro="11918882.4"/>
					<DespManutencaoConservacao contabil="0" financeiro="0"/>
					<ReceitasVenda contabil="0" financeiro="0"/>
					<CustoPropriedadesVendidas contabil="0" financeiro="0"/>
					<AjusteValor contabil="3170000" financeiro="0"/>
					<OutrasRecOuDesp contabil="-5250" financeiro="0"/>
					<ResultadoLiquido contabil="15200592.61" financeiro="11918882.4"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="0" financeiro="0"/>
					<AjusteValor contabil="0" financeiro="0"/>
					<ResultadoVenda contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="0"/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="15200592.61" financeiro="11918882.4"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="0" financeiro="0"/>
				<AjusteValorAplicacoes contabil="0" financeiro="0"/>
				<ResultadoVendaAplicacoes contabil="279390.12" financeiro="0"/>
				<OutrasRecOuDespAplicacoes contabil="0" financeiro="0"/>
				<ResultadoLiquido contabil="279390.12" financeiro="0"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-168911.79" financeiro="-166312.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="0" financeiro="0"/>
				<ComissoesEmolumentos contabil="0" financeiro="0"/>
				<HonorariosDespesasDefesas contabil="-21091.1" financeiro="-24723.89"/>
				<GastosContratosSeguros contabil="0" financeiro="0"/>
				<DespesasAvaliacoes contabil="0" financeiro="0"/>
				<TaxasIngressoSaidaFundos contabil="0" financeiro="0"/>
				<DespesasRegistroCartorio contabil="0" financeiro="0"/>
				<OutrasRecOuDesp contabil="-1956.65" financeiro="-415.13"/>
				<Total contabil="-191959.54" financeiro="-191451.03"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="15288023.19" financeiro="11727431.37"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>11727431.37</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>11141059.8015</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte>0</ParcelaDistribuidaTriSeguinte>
			<ParcelasRendimentosRetidos>
				<Parcela valor="0"/>
				<Parcela valor="0"/>
				<Parcela valor="0"/>
				<Parcela valor="0"/>
				<Parcela valor="0"/>
			</ParcelasRendimentosRetidos>
			<LucroContabil>0</LucroContabil>
			<ResultadoFinanceiroExcedeMinimo>0</ResultadoFinanceiroExcedeMinimo>
			<RendimentosDeclarados>11141059.8015</RendimentosDeclarados>
			<RendimentosPagosAntec>-7357938.3</RendimentosPagosAntec>
			<RendimentoPagar>3783121.5015</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.95</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"