"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>MÉRITO DESENVOLVIMENTO IMOBILIÁRIO I FII</NomeFundo>
		<CNPJFundo>16915968000188</CNPJFundo>
		<DataFuncionamento>2013-03-06</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRMFIICTF008</CodigoISIN>
		<QtdCotasEmitidas>6800000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Multicategoria</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>MÉRITO DISTRIBUIDORA DE TÍTULOS E VALORES MOBILIÁRIOS LTDA.</NomeAdministrador>
		<CNPJAdministrador>41592532000142</CNPJAdministrador>
		<Logradouro>Rua Funchal</Logradouro>
		<Numero>418</Numero>
		<Complemento>21 andar</Complemento>
		<Bairro>Vila Olímpia</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>04551060</CEP>
		<Telefone1>(11) 3386-2555</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.meritodtvm.com.br</Site>
		<Email>marcos.ikuno@meritodtvm.com.br</Email>
		<Competencia>2025-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Mérito Investimentos S.A.</Nome>
				<CNPJ>15632652000116</CNPJ>
				<Endereco>Rua Funchal, 418, 21 andar, São Paulo-SP, CEP 04551-060</Endereco>
				<telefone>(11) 3386-2555</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Mérito DTVM</Nome>
				<CNPJ>41592532000142</CNPJ>
				<Endereco>Rua Funchal, 418, 21 andar, São Paulo-SP, CEP 04551-060</Endereco>
				<telefone>(11) 3386-2555</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>BDO RCS Auditores Independentes</Nome>
				<CNPJ>54276936000179</CNPJ>
				<Endereco>Rua Major Quedinho, 90, 3 andar, São Paulo-SP, CEP 01050-030</Endereco>
				<telefone>(11) 3848-5880</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>Durante o próximo período, o Fundo analisará novas oportunidades de investimento e caso identifique terrenos atrativos para desenvolvimento de empreendimentos imobiliário realizará novas aquisições.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Conforme as Demonstrações Contábeis Auditadas e publicadas no Fundos Net e no site da Administradora: www.meritodtvm.com.br </ResultadoFundo>
			<ConjunturaEconomica>Em 2025, observamos um novo ciclo de aumento da taxa de juros. Apesar disso, estamos confiantes da resistência da nossa carteira a este cenário.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Continuidade do processo de aprovação de projetos e desenvolvimento dos ativos detidos pelo fundo.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Propriedade p/Investimento - Corifeu</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>27289010.49</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0396</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Propriedade p/Investimento - Paes de Barros</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5355474.26</Valor>
				<PercentValorizacaoDesvalorizacao>0.1878</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Imóveis a Comercializar - Corifeu</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>387000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.4365</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MERITO CEMITERIOS FII FUNDO DE INVESTIMENTO IMOBILIARIO</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>149896554.4</Valor>
				<PercentValorizacaoDesvalorizacao>0.149</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Investimento em Sociedade - Mérito Realty Ltda</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>448842324.04</Valor>
				<PercentValorizacaoDesvalorizacao>0.1055</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>(1) Imóveis a comercializar: são mensurados a valor de custo ou valor realizável líquido dos dois o menor; (2) Propriedade para Investimento: são mensurados pelo valor justo; (3) Valores a receber de imóveis vendidos: valor conforme contrato de parceria; (4) Investimento em Sociedade Limitada: equivalência patrimônial; (5) Cotas de Fundo de Investimento Imobiliário/Ações de Cia Aberta: valor de mercado de fechamento da data; (6) Cotas de Fundo de Investimento Imobiliário - Não Negociados na B3: mensurado pelo valor patrimonial disponibilizado pela Adminsitradora.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Funchal, 418, 21 andar, Vila Olimpia, São Paulo/SP, CEP 04551-060</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.merito.inc/servicos-financeiros/</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>(i) mfii@meritodtvm.com
(ii) contato@meritodtvm.com.br</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Compete ao Administrador convocar a Assembleia Geral de Cotistas. A Assembleia Geral de Cotistas também pode ser convocada diretamente por Cotistas que detenham, no mínimo, 5% cinco por cento) das Cotas emitidas ou pelo Representante dos Cotistas, observados os requisitos estabelecidos no presente Regulamento. Somente poderão votar na Assembleia Geral de Cotistas inscritos no registro de Cotistas na data da convocação da Assembleia Geral de Cotistas, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano. Os Cotistas também poderão votar por meio de comunicação escrita ou eletrônica, desde que o façam com até 1 (um) dia útil de antecedência à data prevista para realização da Assembleia Geral, nos termos da respectiva convocação. As deliberações da Assembleia Geral poderão ser tomadas mediante processo de consulta formalizado em carta, telegrama, correio eletrônico (e-mail) ou fac-símile dirigido pelo Administrador a cada cotista para resposta no prazo máximo de 10 (dez) dias ou, excepcionalmente, em prazo maior, desde que expresso o prazo na comunicação. A consulta deverá constar todos os elementos informativos necessários ao exercício de voto.  Para fins de verificação de quórum, serão consideradas somente as consultas efetivamente respondidas pelos cotistas. Os cotistas que não enviarem a resposta no prazo determinado pelo Administrador não serão considerados.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Os Cotistas também poderão votar por meio de comunicação escrita ou eletrônica, desde que o façam com até 1 (um) dia útil de antecedência à data prevista para realização da Assembleia  geral, nos termos da respectiva convocação.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Taxa de Administração. Pelos serviços de administração, gestão, custódia e escrituração, será devida pelo Fundo uma remuneração correspondente a 2,0% (dois por cento) ao ano, calculada sobre o valor de mercado do Fundo, com base na média diária da cotação de fechamento das cotas de emissão do Fundo, a qual será apropriada por Dia Útil como despesa do Fundo, com base em um ano de 252 (duzentos e cinquenta e dois) dias úteis, e pagas mensalmente, até o 5º (quinto) Dia Útil de cada mês subsequente ao vencido, a partir do mês em que ocorrer a primeira Integralização de Cotas, sendo que: i) 1,995% ao ano, apurados da forma acima, serão destinados diretamente ao Administrador, observado o valor mínimo mensal de R$27.500,00 (vinte e sete mil e quinhentos  reais), a ser reajustado pelo IGP-M a cada intervalo de 12 (doze) meses; e ii) A taxa máxima de custódia, recebida pelos serviços indicados acima, a ser paga pelo Fundo ao Custodiante é de 0,005% ao ano, sobre o valor do patrimônio líquido do Fundo. Sendo que, em nenhuma hipótese poderá ser inferior a R$2.500,00 (dois mil e quinhentos reais) ao mês, sendo que este valor será atualizado pelo Índice Geral de Produtos ao Mercado-IPGM, a cada 12 (doze) meses. </PoliticaRemuneracao>
			<ValorPagoAno>8906867.9</ValorPagoAno>
			<PercentPatrimonioContabil>0.0131635389750059</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0176960317750706</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>Marcos Alexandre Ikuno</Nome>
				<Idade>43</Idade>
				<CPF>303.669.678-43</CPF>
				<Email>marcos.ikuno@meritoinvestimentos.com</Email>
				<Profissao>Economista</Profissao>
				<FormacaoAcademica>FEA-USP</FormacaoAcademica>
				<DataInicioFuncao>2021-10-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Mérito DTVM</NomeEmpresa>
						<Periodo>2021/Atual</Periodo>
						<CargoFuncoes>Diretor de Administração Fiduciária</CargoFuncoes>
						<AtividadePrincipalEmpresa>Responvável pela (o): divulgação dos eventos legais/informações dos fundos; acompanhamento e apuração da aplicação da política de investimentos dos fundos de investimentos; negociação e formas de remuneração dos parceiros; administração fiduciária das carteiras de fundos e de títulos e valores mobiliários; acompanhamento e apuração da aplicação de políticas internas e gestão de risco; apura e acompanha a exposição de risco de liquidez dos fundos e carteiras administradas.</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Cadence Gestora de Recursos</NomeEmpresa>
						<Periodo>2015/2020</Periodo>
						<CargoFuncoes>Sócio-diretor / Administração Carteira</CargoFuncoes>
						<AtividadePrincipalEmpresa>Responsável pela(o): alocação de ativos dos fundos/carteiras administradas; divulgação de informações legais; adequação a política de investimento dos fundos/carteiras administradas; acompanhamento e monirotamento de exposição de risco de liquidez, considerando ambiente macroeconômico e estratégia de mercado.</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="32496" numCotasDetidas="6800000" percDetidoRelTotal="1" percDetidoPF="0.9982" percDetidoPJ="0.00180000000000002"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
			<Ativo>
				<AtivoNegociado>MCEM - MÉRITO CEMITÉRIOS FII</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2025-01-02</DataTransacao>
				<ValorEnvolvido>12051350.8</ValorEnvolvido>
				<DataAssembleia>2022-01-04</DataAssembleia>
				<Contraparte/>
			</Ativo>
			<Ativo>
				<AtivoNegociado>MCEM - MÉRITO CEMITÉRIOS FII</AtivoNegociado>
				<NaturezaTransacao>alienação</NaturezaTransacao>
				<DataTransacao>2025-11-06</DataTransacao>
				<ValorEnvolvido>45531000</ValorEnvolvido>
				<DataAssembleia>2022-01-04</DataAssembleia>
				<Contraparte/>
			</Ativo>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>www.merito.inc/servicos-financeiros/</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>www.merito.inc/servicos-financeiros/</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>www.merito.inc/servicos-financeiros/</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>N/A</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>N/A</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"