"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIÁRIO THE ONE</NomeFundo>
		<CNPJFundo>12948291000123</CNPJFundo>
		<DataFuncionamento>2011-01-07</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRONEFCTF003</CodigoISIN>
		<QtdCotasEmitidas>911000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Lajes Corporativas</SegmentoAtuacao>
			<TipoGestao>Passiva</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>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>2023-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, cj 112 (parte) - São Paulo - SP</Endereco>
				<telefone>(11) 5412-5400</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KPMG Auditores Independentes</Nome>
				<CNPJ>57755217000129</CNPJ>
				<Endereco>Rua Arquiteto Olavo Redig de Campos, 105, 12º andar - Torre A - São Paulo/SP – Brasil</Endereco>
				<telefone>(11) 3940-1500</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 2023 o Fundo auferiu rendimentos que somaram R$ 34,54 por cota.</ResultadoFundo>
			<ConjunturaEconomica>Os ativos de renda variável apresentaram uma performance bastante positiva ao final do ano, consolidando 2023 como o ano de melhor resultado para estes ativos desde 2019, último ano antes da pandemia. O IFIX encerrou 2023 com 15,50% de valorização e o Ibovespa teve alta de 22,8% no ano. Os números são realmente muito positivos, principalmente quando lembramos que a Selic média do ano se situou em 13,04%. O mercado de lajes corporativas começou a se recuperar dos impactos da pandemia no quarto trimestre de 2021, desde então vêm numa evolução crescente positiva. Apesar da absorção líquida estar ainda em patamares baixos, a velocidade de entrega de novos estoques diminui e foi possível observar a recuperação na ocupação dos escritórios, tanto com a retomada dos funcionários ao trabalho físico, quanto pelo crescimento na busca por áreas menores de até 500 metros por pequenas empresas.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Começamos o ano de 2024 com aspectos positivas, com a perspectiva de uma redução da Selic para um patamar de 9,00% e inflação de 4% ao fim de 2024. Esse cenário permitiria que o prêmio de risco para o Brasil permanecesse estável, com atração de capital estrangeiro, garantindo a manutenção de um fluxo positivo de recursos financeiros para o Brasil. Considerando esses fatores, a expectativa é que o IFIX volte para as máximas históricas no novo ano. Para as lajes corporativas o desempenho não será tão positivo comparado aos demais segmentos de FIIs, mas a recuperação, primeiramente, está ocorrendo em microrregiões com ativos AAA-AA onde o preço pedido é alto, longo a demanda por espaço acabará recaindo em regiões próximas.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>-</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. Brigadeiro Faria Lima, 3600 - 11º andar, cj 112 - Itaim Bibi - São Paulo - SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.hedgeinvest.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Endereço Físico: Av. Brigadeiro Faria Lima, 3600 - 11º andar, cj 112 - Itaim Bibi - 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 de administração correspondente a 0,25% (setenta centésimos por cento) ao ano sobre o valor do patrimônio líquido do Fundo por um período mínimo de 36 meses, provisionada diariamente e paga mensalmente até o 5º (quinto) dia útil de cada mês subsequente ao da prestação dos serviços.
Caso o Fundo seja liquidado antes de findo do prazo de 36 (trinta e seis) meses contados da assunção da administração do Fundo pela Administradora, será pago um valor equivalente à soma das mensalidades da taxa de administração que seriam devidas entre a data da liquidação e o fim do referido prazo de 36 (trinta e seis) meses, sendo calculado pela multiplicação do patrimônio líquido do último dia útil do mês anterior ao evento em questão pelo percentual da Taxa de Administração, ponderado pelo número de dias úteis faltantes, de modo que a Administradora receba integralmente a Remuneração Mínima. </PoliticaRemuneracao>
			<ValorPagoAno>109635.12</ValorPagoAno>
			<PercentPatrimonioContabil>0.0007</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0</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>38 anos</Idade>
				<CPF>343.913.778-37</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>2023-11-01</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>
					<Experiencia>
						<NomeEmpresa>Credit Suisse Hedging-Griffo Corretora de Valores S.A.</NomeEmpresa>
						<Periodo>Outubro/2006 a Fevereiro/2017</Periodo>
						<CargoFuncoes>Vice President - Real Estate</CargoFuncoes>
						<AtividadePrincipalEmpresa>Instituição Financeira</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="2598" numCotasDetidas="641481" percDetidoRelTotal="0.7042" percDetidoPF="0.785" percDetidoPJ="0.215"/>
			<AcimaCincoAteDezPorcento numCotistas="4" numCotasDetidas="269519" percDetidoRelTotal="0.2958" percDetidoPF="0.5215" percDetidoPJ="0.4785"/>
			<AcimaDezAteQuinzePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" 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>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>
"