"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>HEDGE ATRIUM SHOPPING SANTO ANDRÉ FII LTDA.</NomeFundo>
		<CNPJFundo>12809972000100</CNPJFundo>
		<DataFuncionamento>2011-03-23</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRATSACTF000</CodigoISIN>
		<QtdCotasEmitidas>1751141</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Desenvolvimento</Subclassificacao>
			<TipoGestao>Definida</TipoGestao>
			<SegmentoAtuacao>Shoppings</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>PriceWaterHouseCoopers Auditores Independentes</Nome>
				<CNPJ>61562112000120</CNPJ>
				<Endereco>Av. Brigadeiro Faria Lima, 3732, 16º andar, partes 1 e 6  - Ed. Adalmiro Dellape Baptista B32</Endereco>
				<telefone>(11) 4004-8000</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 auferiu rendimentos que somaram R$ 2,41 por cota.</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.
Nesse contexto, o consumo das famílias e o comércio varejista mantiveram crescimento, porém em ritmo mais lento, com alta de cerca de 1,6% nas vendas do varejo em 2025. O mercado de shoppings centers, segmento no qual o fundo se insere, apresentou um faturamento em 2025 de R$ 200,9 bilhões segundo o Censo 2025/2026 realizado pela Abrasce, o que significa um crescimento de 1,3% vs. o ano de 2024. Levando-se em conta o faturamento por m², em 2025 o setor apresentou crescimento, em termos nominais, de 0,4% quando comparado ao valor apresentado em 2024.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>No período seguinte, acreditamos que os imóveis da carteira se manterão resilientes, mesmo num ambiente de taxas de juros ainda em patamares bastante restritivos. Ao longo do exercício seguinte, esperamos que se inicie um novo ciclo de afrouxamento monetário que poderá favorecer o consumo, impactando positivamente o resultado dos shopping centers e consequentemente o resultado do Fundo. Adicionalmente, acreditamos que o aumento da renda líquida disponível gerado pela nova tabela do IRPF para 2026 irá incentivar um aumento do consumo para as famílias afetadas, o que poderá se traduzir no crescimento do faturamento de vendas para os shopping centers que atendem o público da nova faixa de isenção.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Atrium Shopping Santo André</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>125100000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0384</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,5% (meio por cento) ao ano sobre o valor de mercado das cotas do Fundo, 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>446243.19</ValorPagoAno>
			<PercentPatrimonioContabil>0.0035</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0044</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>2018-06-12</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="286" numCotasDetidas="723386" percDetidoRelTotal="0.4131" percDetidoPF="0.9954" percDetidoPJ="0.0046"/>
			<AcimaCincoAteDezPorcento numCotistas="5" numCotasDetidas="802147" percDetidoRelTotal="0.4581" percDetidoPF="0.853" percDetidoPJ="0.147"/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="225608" percDetidoRelTotal="0.1288" 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>
"