"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>AZ QUEST PANORAMA LOGISTICA FII RESP LIM</NomeFundo>
		<CNPJFundo>51890054000100</CNPJFundo>
		<DataFuncionamento>2024-06-05</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRAZPLCTF000</CodigoISIN>
		<QtdCotasEmitidas>41922689</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Híbrido</Subclassificacao>
			<TipoGestao>Definida</TipoGestao>
			<SegmentoAtuacao>Logística</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>AZ QUEST PANORAMA LTDA</Nome>
				<CNPJ>37783771000102</CNPJ>
				<Endereco>Rua Tabapua, 422, Itaim Bibi, CEP: 04533-001</Endereco>
				<telefone>(11) 3168-0680</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>AZ CREDITO</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>125293512.5</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI000000A21</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>6291840.59</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI000000A2D</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>7331857</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI000000A48</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>3009271.16</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI000000A49</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>7290556.35</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI000000A62</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>137689.99</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI000000AD8</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>103267.49</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI000000B67</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>51633.75</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios - caixa e/ou emissão de cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI000006F8</Nome>
						<Objetivos>Rentabilizar carteira/ativos</Objetivos>
						<MontantesInvestidos>8575166.72</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 de Fundos de Investimento Imobiliário (FIIs) no Brasil apresentou um desempenho mais equilibrado em comparação com 2024, que havia sido marcado por uma recuperação gradual do setor. O Índice de Fundos de Investimentos Imobiliários (IFIX), principal indicador do segmento, refletiu esse movimento ao longo do ano, com períodos de volatilidade, mas mantendo relativa estabilidade no acumulado.

Enquanto 2024 foi impulsionado principalmente pela expectativa de queda das taxas de juros e retomada econômica, 2025 foi caracterizado por um ambiente mais cauteloso, com maior sensibilidade às condições macroeconômicas, especialmente em relação à política monetária e ao cenário fiscal. Ainda assim, muitos FIIs continuaram entregando rendimentos consistentes, reforçando seu papel como instrumento de geração de renda passiva.

De forma geral, 2025 consolidou um cenário mais seletivo para os investidores, no qual fundos com boa gestão, ativos de qualidade e contratos bem estruturados se destacaram em relação ao restante do mercado.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Ao final de 2025, observa-se que o mercado de FIIs manteve sua relevância, mesmo diante de um contexto mais desafiador do que o observado no ano anterior. Segmentos como logística e recebíveis imobiliários continuaram apresentando maior resiliência, enquanto outros, como lajes corporativas, exigiram maior cautela por parte dos investidores.

Para 2026, a perspectiva é de continuidade desse ambiente seletivo, com potencial de melhora caso haja maior previsibilidade em relação às taxas de juros e ao cenário fiscal. A tendência é que os FIIs sigam como uma alternativa atrativa de investimento para geração de renda, especialmente se houver estabilização macroeconômica.

Nesse contexto, a estratégia dos investidores deve permanecer focada na diversificação e na análise criteriosa dos ativos, priorizando fundos com fundamentos sólidos e capacidade de adaptação a diferentes ciclos econômicos.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>GALPAO</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>99300000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>D TIT AZQUES</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>13172564.82</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>AZ CREDITO</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>125293512.5</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>AZ JANDIRA_</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>48470845.93</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000000524</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>16763408.83</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI0000006A5</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>13490392.02</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI0000007BD</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>11765300.95</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000000A21</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6291840.59</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000000A2D</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7331857</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000000A48</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3009271.16</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000000A49</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7290556.35</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000000A62</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>137689.99</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000000AD8</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>103267.49</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000000B67</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>51633.75</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI000006F8</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>8575166.72</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 correspondente ao percentual descrito na tabela abaixo, observado o valor mínimo mensal de R$ 9.000,00 (nove 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. Adicionalmente, pela prestação dos serviços de custódia dos ativos integrantes da carteira do Fundo, será cobrada uma taxa correspondente a 0,035% (trinta e cinco milésimos por cento) ao ano, incidente sobre o Patrimônio Líquido do Fundo, observado o valor mínimo mensal de R$ 2.500,00 (dois mil e quinhentos reais). Os valores mínimos mensais descritos neste dispositivo serão atualizados anualmente, a partir da data de início das atividades do Fundo, pela variação positiva do IPCA/IBGE.</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="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<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="1" numCotasDetidas="41922689" percDetidoRelTotal="1" percDetidoPF="0" percDetidoPJ="1"/>
		</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>
"