"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>VALORA CRI INFRA FII II       </NomeFundo>
		<CNPJFundo>52649680000172</CNPJFundo>
		<DataFuncionamento>2023-11-29</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN>BRVGIICTF007</CodigoISIN>
		<QtdCotasEmitidas>518865</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Papel</Classificacao>
			<Subclassificacao>Híbrido</Subclassificacao>
			<TipoGestao>Definida</TipoGestao>
			<SegmentoAtuacao>Multicategoria</SegmentoAtuacao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BANCO DAYCOVAL S/A</NomeAdministrador>
		<CNPJAdministrador>62232889000190</CNPJAdministrador>
		<Logradouro>AV. PAULISTA</Logradouro>
		<Numero>1793</Numero>
		<Complemento>2º andar</Complemento>
		<Bairro>Bela Vista</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>01311200</CEP>
		<Telefone1>0300 111 0500</Telefone1>
		<Telefone2>(11) 3563-4389</Telefone2>
		<Telefone3 xsi:nil="true"/>
		<Site>www.daycoval.com.br</Site>
		<Email>informes.regulatorios@bancodaycoval.com.br</Email>
		<Competencia>2025-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Valora Imobiliario e Infraestrutura LTDA</Nome>
				<CNPJ>7559989000117</CNPJ>
				<Endereco>Avenida Pres Juscelino Kubitschek, 1830, Vila Nova Conceicao, CEP: 04543-900</Endereco>
				<telefone>(11) 5542-1645</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO DAYCOVAL S.A</Nome>
				<CNPJ>62232889000190</CNPJ>
				<Endereco>Avenida Paulista 1793, Bela Vista, São Paulo SP - 01311-200</Endereco>
				<telefone>(11) 3563-4389</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Rsm Brasil Auditores Independentes LTDA</Nome>
				<CNPJ>16549480000184</CNPJ>
				<Endereco>Avenida Marq de Sao Vicente, 182, Varzea da Barra Funda, CEP: 01139-000</Endereco>
				<telefone>(11) 2154-7795</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BANCO DAYCOVAL S.A</Nome>
				<CNPJ>62232889000190</CNPJ>
				<Endereco>Avenida Paulista 1793, Bela Vista, São Paulo SP - 01311-200</Endereco>
				<telefone>(11) 3563-4389</telefone>
			</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>
					<Ativo>
						<Nome>VALORA CRI2</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>28192047.48</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O programa de investimento do Fundo para os exercícios seguintes seguirá a política de investimentos, em conformidade com o regulamento do Fundo.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Os resultados do fundo de investimento podem ser consultados diretamente na demonstração financeira do fundo (DF). Esta documentação estara disponível para consulta em: (https://fnet.bmfbovespa.com.br/fnet/publico/abrirGerenciadorDocumentosCVM), e proporciona uma visão detalhada do desempenho e das operações realizadas ao longo do período.</ResultadoFundo>
			<ConjunturaEconomica>Em 2025, o mercado brasileiro de Fundos de Investimento Imobiliário (FIIs) apresentou uma dinâmica mais equilibrada em comparação a 2024, período marcado por uma trajetória de recuperação gradual do setor. O Índice de Fundos de Investimentos Imobiliários (IFIX), principal referência da classe, refletiu esse comportamento ao longo do ano, combinando momentos pontuais de volatilidade com relativa estabilidade no acumulado.

Após um ciclo anterior influenciado, em grande medida, pela expectativa de flexibilização da política monetária e pela melhora das perspectivas econômicas, 2025 foi caracterizado por um ambiente mais desafiador e seletivo. A performance dos ativos passou a responder de forma mais direta às condições macroeconômicas, especialmente à condução da política de juros e à evolução do cenário fiscal, exigindo maior diligência.

Ainda assim, os FIIs seguiram demonstrando resiliência e relevância dentro da alocação de portfólios, com diversos fundos mantendo consistência na geração e distribuição de rendimentos, reforçando seu papel como veículo eficiente de renda recorrente.

Nesse contexto, observou-se a consolidação de um mercado mais criterioso, no qual fundos com ativos de qualidade e contratos bem estruturados apresentaram desempenho relativo superior. Tal cenário reforça a importância de uma abordagem disciplinada e fundamentada na seleção de ativos, bem como evidencia o potencial da indústria para continuar gerando valor no médio e longo prazo.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Ao final de 2025, observou-se que o mercado de fundos imobiliários manteve sua relevância, mesmo diante de um cenário mais desafiador em comparação ao período anterior. Nesse contexto, determinados segmentos, como logística e recebíveis imobiliários, voltaram a demonstrar maior resiliência relativa, reforçando a atratividade estrutural da classe.

Para 2026, a perspectiva é de continuidade de um ambiente mais seletivo, com potencial de evolução positiva à medida que se observe maior previsibilidade das taxas de juros e do cenário fiscal. Nesse sentido, os fundos imobiliários tendem a permanecer como uma alternativa relevante para geração de renda recorrente, especialmente em um ambiente de progressiva estabilização macroeconômica.

Diante desse panorama, a gestão do Fundo deve manter uma postura diligente e proativa na condução da estratégia, com foco na diversificação e na alocação em ativos com fundamentos sólidos e capacidade de adaptação a diferentes ciclos econômicos. Ao mesmo tempo, buscar capturar oportunidades que possam gerar valor adicional à carteira, por meio de uma análise criteriosa e disciplinada.

Adicionalmente, reforça-se o compromisso com o monitoramento contínuo dos ativos que compõem o portfólio, bem como com a avaliação rigorosa de novas oportunidades de investimento, sempre alinhadas à estratégia do Fundo de geração consistente de renda e valorização no longo prazo.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>DAY Y VALORA    </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>445346.29</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>FII VALORA C    </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>28192047.48</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI IPCA        </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>9068447.35</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Entende-se por valor justo o valor pelo qual um ativo pode ser trocado ou um passivo liquidado entre partes independentes, conhecedoras do negócio e dispostas a realizar a transação, sem que represente uma operação forçada, conforme instrução CVM 516, Art. 7º §1º.
Os Ativos serão precificados de acordo com procedimentos para registro e avaliação de títulos e valores mobiliários, conforme estabelecido na regulamentação em vigor (tais como o critério de marcação a mercado) e de acordo com o manual de precificação adotado pelo Custodiante. O manual está disponível para consulta no website: https://www.daycoval.com.br/investimentos/mercadocapitais/politicas-manuais-documento</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. Paulista, 1793, 2º andar, 01311200, São Paulo - SP, Bela Vista. </EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>https://www.daycoval.com.br/institucional/mercado-de-capitais</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>O Administrador publicará as informações especificadas abaixo, na periodicidade respectivamente indicada, em sua página na rede mundial de computadores (https://www.daycoval.com.br/institucional/mercado-de-capitais) e as manterá disponíveis aos Cotistas em sua sede, no endereço indicado neste Regulamento.
As informações abaixo especificadas serão remetidas pelo Administrador à CVM, por meio do Sistema de Envio de Documentos, e às entidades administradoras do mercado organizado em que as Cotas sejam admitidas a negociação.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Correio eletrônico e/ou website do administrador fiduciário (https://www.daycoval.com.br/institucional/mercado-de-capitais).

A convocação da Assembleia Geral de Cotistas pelo Administrador far-se-á mediante correspondência por correio eletrônico (e-mail) e disponibilizada na página do Administrador na rede mundial de computadores, da qual constarão, obrigatoriamente, o dia, hora e local em que será realizada tal Assembleia e ainda, de forma sucinta, os assuntos a serem tratados.
Salvo motivo de força maior, a Assembleia Geral de Cotistas realizar-se-á no local onde o Administrador tiver a sede; quando houver necessidade de efetuar-se em outro lugar correspondência encaminhada por correio eletrônico, endereçada aos Cotistas indicarão, com clareza, o lugar da reunião. A administradora também conta com aplicacativo específico para realização de voto eletrônico, que será enviado aos contatos dos cotistas devidamente cadastrado. 
Por ocasião da Assembleia Geral de Cotistas ordinária do FUNDO, os Cotistas que detenham, no mínimo, 3% (três por cento) das Cotas emitidas ou o(s) representante(s) de Cotistas podem solicitar, por meio de requerimento escrito encaminhado à ADMINISTRADORA, a inclusão de matérias na ordem do dia da Assembleia Geral de Cotistas ordinária, que passará a ser Assembleia Geral de Cotistas ordinária e extraordinária. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não obstante, os Cotistas também poderão votar por meio de comunicação escrita ou eletrônica (via e-mail) encaminhada ao Administrador, desde que este receba o voto do Cotista com pelo menos 01 (um) dia de antecedência em relação à data prevista para a realização da Assembleia Geral de Cotistas a que se refere o voto proferido na forma prevista neste Parágrafo.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos serviços de administração fiduciária do Fundo, incluindo as atividades de gestão de Imóveis e custódia de Ativos Financeiros, bem como pelos serviços de tesouraria, controladoria e processamento de ativos e escrituração de Cotas, será devida pela Classe à Administradora uma Taxa de Administração descrita abaixo, com mínimo mensal de R$ 8.000,00 (oito mil reais), com base em um ano de 252 (duzentos e cinquenta e dois) Dias Úteis, calculada sobre (a) o valor contábil do Patrimônio Líquido; ou (b) sobre o valor de mercado do Fundo, calculado com base na média diária da cotação de fechamento das Cotas no mês anterior ao do pagamento, caso referidas Cotas tenham integrado ou passado a integrar, nesse período, índice de mercado, como, por exemplo, o IFIX, cuja metodologia preveja critérios de inclusão que considerem a liquidez das Cotas e critérios de ponderação que considerem o volume financeiro das Cotas emitidas pelo Fundo, sendo certo que o valor mínimo mensal será atualizado anualmente, a partir da data de início das atividades do Fundo, pela variação positiva do IGP-M/FGV.</PoliticaRemuneracao>
			<ValorPagoAno>0</ValorPagoAno>
			<PercentPatrimonioContabil>0</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>Erick Warner de Carvalho</Nome>
				<Idade>46</Idade>
				<CPF>27764653861</CPF>
				<Email>erick.carvalho@bancodaycoval.com.br</Email>
				<Profissao>Diretor de Administração Fiduciária</Profissao>
				<FormacaoAcademica>Administração de Empresas</FormacaoAcademica>
				<DataInicioFuncao>2019-08-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="1" numCotasDetidas="15452" percDetidoRelTotal="0.0297803860349031" percDetidoPF="0" percDetidoPJ="0.03"/>
			<AcimaCincoAteDezPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuinzeAteVintePorcento numCotistas="1" numCotasDetidas="103413" percDetidoRelTotal="0.199306177907548" percDetidoPF="0" percDetidoPJ="0.2"/>
			<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="1" numCotasDetidas="400000" percDetidoRelTotal="0.770913436057549" percDetidoPF="0" percDetidoPJ="0.77"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>A política de divulgação de ato ou fato relevante do fundo, pode ser consultada através dos links: 
https://www.daycoval.com.br/investimentos/mercado-capitais/informacoes-cotista e/ou
https://fnet.bmfbovespa.com.br/fnet/publico/abrirGerenciadorDocumentosCVM</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>A política de negociação de cotas do fundo, se houver, pode ser consultada através dos links: 
https://www.daycoval.com.br/investimentos/mercado-capitais/informacoes-cotista e/ou
https://fnet.bmfbovespa.com.br/fnet/publico/abrirGerenciadorDocumentosCVM</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>A política de exercício do direito de voto em participações societárias do fundo, pode ser consultada através dos links:
https://www.daycoval.com.br/investimentos/mercado-capitais/informacoes-cotista e/ou
https://fnet.bmfbovespa.com.br/fnet/publico/abrirGerenciadorDocumentosCVM</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>O Administrador possui equipes direcionadas para asseguração do cumprimento da política de divulgação de informações do Fundo com segregação de funções para elaboração, validação e envio de informações.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>As regras e prazos para chamada de capital do Fundo, se houver, estarão previstas nos documentos relativos às ofertas de distribuição de cada emissão de cotas.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"