"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>HEDGE OFFICE INCOME FUNDO DE INVESTIMENTO IMOBILIÁRIO LTDA.</NomeFundo>
		<CNPJFundo>31894369000119</CNPJFundo>
		<DataFuncionamento>2019-07-12</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRHOFCCTF009</CodigoISIN>
		<QtdCotasEmitidas>3779001</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Escritórios</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>HEDGE INVESTMENTS DTVM LTDA.</NomeAdministrador>
		<CNPJAdministrador>07253654000176</CNPJAdministrador>
		<Logradouro>AVENIDA BRIGADEIRO FARIA LIMA</Logradouro>
		<Numero>3600</Numero>
		<Complemento>11º ANDAR, CJ 112</Complemento>
		<Bairro>ITAIM BIBI</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04538-132</CEP>
		<Telefone1>(11) 5412-5400</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.hedgeinvest.com.br </Site>
		<Email>dtvm@hedgeinvest.com.br</Email>
		<Competencia>2025-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Hedge Investments Real Estate Gestão de Recursos Ltda.</Nome>
				<CNPJ>26843225000101</CNPJ>
				<Endereco>Av. Brigadeiro Faria Lima, 3600 - 11º Andar, cjto 112 (parte) - São Paulo - SP</Endereco>
				<telefone>(11) 5412-5400</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Hedge Investments DTVM Ltda.</Nome>
				<CNPJ>7253654000176</CNPJ>
				<Endereco>Av. Brigadeiro Faria Lima, 3600 - 11º Andar, cjto 112 (parte) - São Paulo - SP</Endereco>
				<telefone>(11) 5412-5400</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>CLA Clifton Larson Allen Brasil Auditores Independentes S/S</Nome>
				<CNPJ>54080721000188</CNPJ>
				<Endereco>Av. das Nações Unidas, 11.541 - 18º Andar - Morumbi, São Paulo - SP</Endereco>
				<telefone>(11) 2050-5320</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 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>O Fundo seguirá sua política de investimentos, conforme regulamento do mesmo, e poderá buscar possibilidades de ampliação de seu patrimônio.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O fundo recebe, mensalmente, o resultado gerado pelos ativos que compõem o seu patrimônio. Durante o exercício de 2025 o Fundo não auferiu rendimentos.</ResultadoFundo>
			<ConjunturaEconomica>Em 2025 a economia brasileira apresentou crescimento moderado, com expansão do PIB de aproximadamente 2,3%, uma desaceleração em relação ao ano anterior, refletindo condições monetárias mais restritivas. O período foi marcado pelo aumento e manutenção da SELIC em patamares elevados, encerrando 2025 em 15% ao ano, visando a contenção de pressões inflacionárias ao longo do ano, com o IPCA fechando o período em 4,26%, abaixo do teto da meta de inflação. Vale destacar a boa performance dos ativos de renda variável, apesar do cenário macroeconômico desafiador, especialmente o IFIX e o IBOVESPA, crescendo 21,1% e 34,0% respectivamente no acumulado de 2025.
No setor imobiliário, a demanda por imóveis bem localizados sustentou a absorção líquida e reduziu a vacância, embora a rentabilidade de novos projetos continuasse pressionada. No ano de 2025 foram entregues mais de 3,6 milhões de m² de novo estoque em todo o Brasil, com absorção líquida de cerca de 3,5 milhões de m² e bruta de 6,4 milhões de m², resultando em uma vacância nacional de 7,1%. O ambiente pouco favorável à construção de novos galpões foi reforçado pela alta de 6,10% no INCC em 12 meses, pela inflação acima do centro da meta e pelos juros elevados, que pressionaram os custos operacionais e limitaram a rentabilidade dos empreendimentos.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A taxa Selic permaneceu elevada até o final de 2025, com possíveis cortes apenas na metade de 2026. Esse cenário deve manter altos os custos de financiamento, desacelerando novos lançamentos de galpões logísticos. Ainda assim, a demanda por imóveis bem localizados provavelmente continuará sustentando a absorção líquida, reduzindo a vacância e pressionando os preços de locação, enquanto a rentabilidade de novos projetos deve permanecer limitada.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Edifício Birmann 20</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>67516000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0043</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Edifício Morumbi</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>30494095.8</Valor>
				<PercentValorizacaoDesvalorizacao>0.0588</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>HOFC Empreendimentos Imobiliários Ltda.</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>53245154.09</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0048</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>As propriedades para investimento estão demonstradas pelos seus respectivos valores justos, os quais foram obtidos através de laudos de avaliação elaborados por entidades profissionais com qualificação reconhecida e formalmente aprovadas pela Administração do fundo. A variação no valor justo das propriedades para investimento é reconhecida na demonstração do resultado do período em que referida valorização ou desvalorização tenha ocorrido.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. Brigadeiro Faria Lima, 3600 - 11º Andar, cjto 112 (parte) - São Paulo - SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.hedgeinvest.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Endereço Físico: Av. Brigadeiro Faria Lima, 3600 - 11º Andar, cjto 112 (parte) - São Paulo - SP
Eletrônico: dtvm@hedgeinvest.com.br</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Poderão participar da Assembleia os cotistas inscritos no registro de cotistas do Fundo na data da convocação da respectiva Assembleia, seus representantes legais ou procuradores legalmente constituídos. Sendo assim, é necessário apresentar documento de identificação válido, no caso de cotista pessoa física, ou, em caso de pessoa jurídica ou fundo de investimento, os documentos de representação necessários para comprovar poderes do(s) seu(s) representante(s) legal(is). Em caso de cotista representado por procurador, a procuração deve trazer poderes específicos para prática do voto e estar com firma reconhecida ou assinada com utilização dos certificados emitidos pela Infraestrutura de Chaves Públicas Brasileira ICP-Brasil. Na hipótese da convocação/edital prever voto à distância, a participação dos cotistas poderá ocorrer de forma não presencial, por meio de voto eletrônico ou por procuração, de acordo com as regras descritas especificamente na convocação/edital. Em caso de consultas formais, deverão ser observados os prazos e condições específicos a cada consulta a ser dirigido pela Administradora a cada cotista, observadas as formalidades previstas na regulamentação em vigor.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>O Fundo poderá realizar assembleia por meio eletrônico, hipótese na qual deverão ser observados os procedimentos e prazos previstos em seu edital de convocação e demais documentos relacionados.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O Fundo paga à Administradora uma taxa global correspondente a 0,83% (setenta centésimos por cento) ao ano  sobre o valor de mercado do Fundo, calculado com base na média diária da cotação de fechamento das cotas de emissão do Fundo no mês anterior ao do pagamento da remuneração, provisionada diariamente e paga mensalmente até o 5º (quinto) dia útil de cada mês subsequente ao da prestação dos serviços.</PoliticaRemuneracao>
			<ValorPagoAno>865913.85</ValorPagoAno>
			<PercentPatrimonioContabil>0.0039</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0076</PercentPatrimonioValorMercado>
		</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>Maria Cecilia Carrazedo de Andrade</Nome>
				<Idade>40 anos</Idade>
				<CPF>34391377837</CPF>
				<Email>dtvm@hedgeinvest.com.br</Email>
				<Profissao>Administrador de Empresas</Profissao>
				<FormacaoAcademica>Administração de Empresas EAESP-FGV. 
Certificação Profissional - CFA</FormacaoAcademica>
				<DataInicioFuncao>2022-09-16</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Hedge Investments</NomeEmpresa>
						<Periodo>Fevereiro/2017 até a presente data</Periodo>
						<CargoFuncoes>Sócia e Diretora - Real Estate</CargoFuncoes>
						<AtividadePrincipalEmpresa>Instituição Financeira</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="4571" numCotasDetidas="2348684" percDetidoRelTotal="0.6215" percDetidoPF="0.9804" percDetidoPJ="0.0196"/>
			<AcimaCincoAteDezPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="3" numCotasDetidas="1430317" percDetidoRelTotal="0.3785" percDetidoPF="0" percDetidoPJ="1"/>
			<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>A Política de Fatos Relevantes está disponível no site da Administradora (www.hedgeinvest.com.br).</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>A Política de Investimentos Pessoais está disponível no site da Administradora (www.hedgeinvest.com.br).</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>A Política de Exercício de Direito de Voto está disponível no site da Administradora (www.hedgeinvest.com.br).</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Não aplicável.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>O Fundo não possui previsão de chamadas de capital.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"