"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DOC_ARQ>
	<CAB_INFORM>
		<NM_FUNDO>SUNO AGRO FIAGRO IMOBILIARIO - SUNO AGRO FII</NM_FUNDO>
		<NR_CNPJ_FUNDO>28152777000190</NR_CNPJ_FUNDO>
		<NM_CLASSE>SUNO AGRO FIAGRO IMOBILIARIO - SUNO AGRO FII</NM_CLASSE>
		<NR_CNPJ_CLASSE>28152777000190</NR_CNPJ_CLASSE>
		<DT_REGS_FUNC>29/04/2022</DT_REGS_FUNC>
		<TP_PUBL_ALVO>INVESTIDORES EM GERAL</TP_PUBL_ALVO>
		<CD_ISIN>BRSNAGCTF000</CD_ISIN>
		<CLASS_UNICA>NAO</CLASS_UNICA>
		<COTST_VINCL_FAMIL>NAO</COTST_VINCL_FAMIL>
		<ClASS_PREVID>NAO</ClASS_PREVID>
		<TIP_CLASS_PREVID/>
		<CLASSIF_AUTO_REGUL>Tijolo, Hibrido, Gestao Ativa, Multicategoria</CLASSIF_AUTO_REGUL>
		<PRZO_DURACAO>Indeterminado</PRZO_DURACAO>
		<DT_ENCER_EXERC_SOC>31/12</DT_ENCER_EXERC_SOC>
		<MERC_NEGOC>BOLSA</MERC_NEGOC>
		<ENTD_ADM_MERC_ORG>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</ENTD_ADM_MERC_ORG>
		<NM_ADM>QI CORRETORA DE TITULOS E VALORES MOBILIARIOS</NM_ADM>
		<NR_CNPJ_ADM>62285390000140</NR_CNPJ_ADM>
		<COMPETENCIA>12/2025</COMPETENCIA>
		<VERSAO>1.0</VERSAO>
	</CAB_INFORM>
	<LISTA_INFORM>
		<DET_PREST_SERV>
			<DET_GESTOR>
				<NM_GESTOR>SUNO GESTORA DE RECURSOS LTDA</NM_GESTOR>
				<NR_CNPJ_GESTOR>11304223000169</NR_CNPJ_GESTOR>
			</DET_GESTOR>
			<DET_CUSTODIANTE>
				<NM_CUSTODIANTEGESTOR>QI CORRETORA DE TITULOS E VALORES MOBILIARIOS</NM_CUSTODIANTEGESTOR>
				<NR_CNPJ_CUSTODIANTE>62285390000140</NR_CNPJ_CUSTODIANTE>
			</DET_CUSTODIANTE>
			<DET_AUDIT_INDEPEN>
				<NM_AUDIT_INDEPEN>KPMG AUDITORES INDEPENDENTES LTDA.</NM_AUDIT_INDEPEN>
				<NR_CNPJ_AUDIT_INDEPEN>57755217000129</NR_CNPJ_AUDIT_INDEPEN>
			</DET_AUDIT_INDEPEN>
			<DET_FORM_MERC>
				<NM_FORM_MERC>QI CORRETORA DE TITULOS E VALORES MOBILIARIOS</NM_FORM_MERC>
				<NR_CNPJ_FORM_MERC>62285390000140</NR_CNPJ_FORM_MERC>
			</DET_FORM_MERC>
			<DET_DISTRIB_COTS>
				<NM_DISTRIB_COTS>QI CORRETORA DE TITULOS E VALORES MOBILIARIOS</NM_DISTRIB_COTS>
				<NR_CNPJ_DISTRIB_COTS>62285390000140</NR_CNPJ_DISTRIB_COTS>
			</DET_DISTRIB_COTS>
		</DET_PREST_SERV>
		<DET_INVEST>
			<DESC_NEG_REALZ_PERIOD>Diminuimos CRA Boa Safra, para aumentar caixa.
Diminuimos CRA Leitíssimo II, para aumentar caixa.
Adquirimos o CRA Mapeva, produtor rural com retorno, para diversifica e garantias robustas..
Aumentamos posição em SNFZ, por oportunidade.</DESC_NEG_REALZ_PERIOD>
			<REL_ATIV_ADIQ_PERIOD>
				<NM_ATIVO>CRA Mapeva</NM_ATIVO>
				<DESC_OBJETIV_AQUIS>Diversificacao e retorno</DESC_OBJETIV_AQUIS>
				<VL_MONT_INVEST>3000000,00</VL_MONT_INVEST>
				<DESC_ORIG_RECURS>Caixa</DESC_ORIG_RECURS>
			</REL_ATIV_ADIQ_PERIOD>
			<INF_REGUL_INSC_IMOV_RURAL>Atualizados no ultimo ano.</INF_REGUL_INSC_IMOV_RURAL>
		</DET_INVEST>
		<PGR_INVEST_EXERC_SEGUINTE>Continuaremos a investir em ativos do Agro, sem riscos relevantes, de forma a manter a inadimplência da carteira como hoje, em 0%. Continuaremos a buscar ativos do setor Agro, para continuar retornando com dividendos aos cotistas. Utilizamos análise de crédito para seleção de ativos, com monitoramento elevado. Em adição, a equipe segue atenta às janelas de mercado que possam permitir crescimento do Fundo. Com esse crescimento, tona-se possível maior diversificação do portfólio, buscando tambem algum ganho nos spreads atuais da carteira.</PGR_INVEST_EXERC_SEGUINTE>
		<ANALS_GESTOR>
			<RESULT_EXERC_FINDO>Resultado positivo para 2025, com recuperação do valor das cotas e manutenção de pagamento de dividendos constantes, pela recorrência das receitas dos ativos do fundo e pela inadimplência zerada. No fim de 2024, a categoria FIAGRO sofreu bastante por eventos de crédito e isso impactou toda indústria, inclusive nosso fundo, sem eventos de crédito. Assim, nossa reuperação foi mais vigorosa e fundo fechou ano de 2025 com valor de mercado nas máximas.</RESULT_EXERC_FINDO>
			<CONJUNT_ECON_SEG_ATUAL_EXERC_FINDO>Setor sofreu desde fim de 2024, com vários eventos de crédito e, durante 2025, o setor foi se acomodando nessa nova realidade. Os juros mais elevados, SELIC a 15%, também impactaram produtores rurais, assim como preço dos grãos em baixa. Porém, durante o ano foi ano de aprendizado para os produtores, com gestão financeira mais conservadora, elevação de governança, e elevação das estruturas das operações que foram ao mercado, para dar maior segurança aos investidores nesse momento de turbulência.</CONJUNT_ECON_SEG_ATUAL_EXERC_FINDO>
			<PERSPECT_PERIOD_SEGUINTE_BASE_COMP_CART>Nossa carteira tem ativos com garantias robustas, credores com qualidade creditíca elevada, e por tal motivo passamos ilesos em 2025 e esperamos que assim seja em 2026. Com perspectiva de queda de juros, esperamos que retorno nominal caia, mas retorno em comparação ao CDI se eleve.</PERSPECT_PERIOD_SEGUINTE_BASE_COMP_CART>
		</ANALS_GESTOR>
		<RISC_INCOR_COTST_INERENT_INVEST>Risco de Mercado: O fundo está sujeito a variações de preços e cotações dos ativos da carteira, influenciados por taxas de juros, inflação, câmbio e cenário político-econômico, o que pode resultar em oscilações no valor da cota.
Risco de Crédito: Risco de inadimplência (default) por parte dos emissores.
Risco de Liquidez: Risco de não conseguir vender os ativos ou as cotas rapidamente por um preço justo, ocasionando em desvalorização da cota.
Risco de Concentração: O fundo pode manter uma parcela relevante de seu patrimônio em poucos ativos ou emissores específicos, e isso pode impactar de forma desproporcional.
Risco Jurídico e Regulatório: Mudanças nas leis ou decisões judiciais que afetem o fundo, como, por exemplo, fim da isençao de IR para PF. 
O objetivo e a Política de Investimentos do Fundo não constituem promessa de rentabilidade e o cotista assume os riscos decorrentes do investimento no Fundo, ciente da possibilidade de eventuais perdas e eventual necessidade de aportes adicionais de recursos no Fundo, conforme riscos descritos no Informe Anual do Fundo, e no Anexo I deste Regulamento, nos termos da Resolução CVM 175.
A rentabilidade das Cotas não coincide com a rentabilidade dos Ativos que compõem a carteira do Fundo em decorrência dos Encargos do Fundo, dos tributos incidentes sobre os recursos investidos e da forma de apuração do valor dos ativos que compõem a carteira do Fundo.
As aplicações realizadas no Fundo não contam com a garantia da Administradora, da Gestora, de qualquer empresa pertencente ao seu conglomerado financeiro, de qualquer mecanismo de seguro ou do Fundo Garantidor de Créditos - FGC.
A Administradora e a Gestora não poderão ser responsabilizadas por qualquer resultado negativo na rentabilidade do Fundo, depreciação dos ativos integrantes da carteira do Fundo, por eventuais prejuízos em caso de liquidação do Fundo ou resgate de cotas com valor reduzido, sendo a Administradora e a Gestora
responsáveis tão somente por perdas ou prejuízos resultantes de comprovado erro grosseiro ou má-fé de sua parte, respectivamente.
</RISC_INCOR_COTST_INERENT_INVEST>
		<DESC_IMPAC_PERD_PROCES_JUDIC_CONFID>Nao se aplica.</DESC_IMPAC_PERD_PROCES_JUDIC_CONFID>
		<ASSEMB_GERAL>
			<DESC_END_DISPON_DOCM_ASSEMB>Avenida Rebouças, nº 2.942, 7º ao 12º andar, Parte I - Pinheiros - São Paulo - SP
https://qitech.com.br/dtvm/

https://www.suno.com.br/asset/fundos/snag11/

https://fnet.bmfbovespa.com.br/fnet/publico/abrirGerenciadorDocumentosCVM</DESC_END_DISPON_DOCM_ASSEMB>
			<DESC_INDIC_MEIO_COMUNIC_COTST>(i) Os cotistas detentores de no mínimo 3% das cotas poderão solicitar por correio eletrônico encaminhado a administracao.fundos@qitech.com.br e fii.adm@qitech.com.br a inclusão de matérias na ordem do dia da assembleia geral, conforme o Artigo 28 do Anexo Descritivo. A Proposta do Administrador é disponibilizada na sede, no site https://qitech.com.br/dtvm/ e no sistema FundosNet da B3.
(ii) As solicitações de lista de cotistas para pedido público de procuração, por titulares de ao menos 0,5% das cotas, serão atendidas nos termos do Artigo 35 do Anexo Descritivo do Regulamento e da Resolução CVM 175.</DESC_INDIC_MEIO_COMUNIC_COTST>
			<DESC_REGR_PARTIC_COTST_ASSEMB_GERAL>(i) Voto. Somente poderão votar na Assembleia Geral inscritos no livro de registro de Cotistas na data da convocação da Assembleia, ou na conta de depósito, seus representantes legais ou procuradores legalmente constituídos há menos de um ano.
(ii). Os Cotistas também poderão votar por meio de comunicação escrita ou eletrônica, ou mediante plataforma on-line a ser informada pela ADMINISTRADORA, observado o disposto 
neste Regulamento. 
(iii). O pedido de procuração, encaminhado pela Instituição Administradora mediante correspondência ou anúncio publicado, deverá satisfazer aos seguintes 
requisitos:
I. Conter todos os elementos informativos necessários ao exercício do voto pedido;
II. Facultar que o Cotista exerça o voto contrário à proposta, por meio da mesma procuração; e
III. Ser dirigido a todos os Cotistas.</DESC_REGR_PARTIC_COTST_ASSEMB_GERAL>
			<DESC_PRATC_REALZ_ASSEMBL_MEIO_ELETR>Os cotistas poderão participar da assembleia por meio eletrônico através de consulta formal encaminhada ao Administrador através de carta, correio eletrônico ou telegrama.</DESC_PRATC_REALZ_ASSEMBL_MEIO_ELETR>
		</ASSEMB_GERAL>
		<DESC_POLIC_REMUN_ADMIN_GEST>O FUNDO pagará, pela prestação de serviços de administração, gestão, tesouraria, controladoria e escrituração, uma remuneração equivalente à taxa anual conforme tabela abaixo, calculada sobre (a) o valor de mercado das Cotas em circulação (considerando-se o preço de fechamento das Cotas em circulação multiplicado pela quantidade de Cotas), caso as Cotas integrem o índice de mercado, ou (b) o valor do patrimônio líquido do FUNDO, caso as Cotas não integrem o Base de Cálculo da Taxa de Administração Taxa de Administraçãorespectivamente), observada a remuneração mínima mensal equivalente a R$ 10.000,00 (dez mil reais):
(a) Taxa de Administração incidente nos primeiros 3 (três) meses contados da data da 1ª integralização de cotas do Fundo:(a.1) Exclusivamente no 1º. (primeiro) mês contado da data da 1ª integralização de cotas do Fundo, (cinco mil reais).
Taxa de Administração incidente sobre a Base de Cálculo da Taxa de Administração:
Até R$ 200.000.000,00 (duzentos milhões de reais)0,21% a.a.
De R$ 200.000.000,00 (duzentos milhões de reais) a R$ 500.000.000,00 (quinhentos milhões de reais)0,19% a.a.
De R$ 500.000.000,00 (quinhentos milhões de reais) a R$ 700.000.000,00 (setecentos milhões de reais)0,17% a.a.
Maior que R$ 700.000.000,00 (setecentos milhões de reais)0,15% a.a.

(b) Taxa de Administração incidente após os primeiros 3 (três) meses contados da data da 1ª integralização de cotas do Fundo:
Taxa de Administração incidente sobre a Base de Cálculo da Taxa de Administração:
Até R$ 200.000.000,00 (duzentos milhões de reais) 0,91% a.a.
De R$ 200.000.000,00 (duzentos milhões de reais) a R$ 500.000.000,00 (quinhentos milhões de reais)0,89% a.a.
De R$ 500.000.000,00 (quinhentos milhões de reais) a R$ 700.000.000,00 (setecentos milhões de reais)0,87% a.a.
Maior que R$ 700.000.000,00 (setecentos milhões de reais)0,85% a.a.</DESC_POLIC_REMUN_ADMIN_GEST>
		<POLIC_REMUN_ADMIN_GEST>
			<VL_PAGO_ANO_REF>577668,80</VL_PAGO_ANO_REF>
			<VL_PERC_PATRIM_LIQ>0,01</VL_PERC_PATRIM_LIQ>
			<VL_PERC_PATRIM_LIQ_A_MERCADO>0,01</VL_PERC_PATRIM_LIQ_A_MERCADO>
		</POLIC_REMUN_ADMIN_GEST>
		<GOVERNANCA>
			<REPR_COTST/>
			<DIR_RESP_FUNDO>
				<NOME_DIR_FUNDO>Daniel Doll Lemos</NOME_DIR_FUNDO>
				<IDADE_DIR_FUNDO>47</IDADE_DIR_FUNDO>
				<PROFISSAO_DIR_FUNDO>Diretor</PROFISSAO_DIR_FUNDO>
				<NR_CPF_DIR_FUNDO>27560576818</NR_CPF_DIR_FUNDO>
				<DESC_EMAIL_DIR_FUNDO>daniel.doll@qitech.com.br</DESC_EMAIL_DIR_FUNDO>
				<DESC_FORMC_ACADEM_DIR_FUNDO>Administração de Empresas</DESC_FORMC_ACADEM_DIR_FUNDO>
				<QTD_COTS_DETIDA_DIR_FUNDO>0</QTD_COTS_DETIDA_DIR_FUNDO>
				<QTD_COTS_COMPR_PERIOD_DIR_FUNDO>0</QTD_COTS_COMPR_PERIOD_DIR_FUNDO>
				<QTD_COTS_VEND_PERIOD_DIR_FUNDO>0</QTD_COTS_VEND_PERIOD_DIR_FUNDO>
				<DT_INI_FUNC_DIR_FUNDO>13/03/2008</DT_INI_FUNC_DIR_FUNDO>
<PRINC_EXP_PROFIS_5ANOS_DIR_FUNDO>
<DET_EXP_PROFIS_DIR_FUNDO>
<NOME_EMPR_EXP_PROFIS_DIR_FUNDO>QI CORRETORA DE TÍTULOS E VALORES MOBILIÁRIOS</NOME_EMPR_EXP_PROFIS_DIR_FUNDO>
<DESC_PERIOD_EXP_PROFIS_DIR_FUNDO>05/2000</DESC_PERIOD_EXP_PROFIS_DIR_FUNDO>
<DESC_CARGO_FUNCOES_DIR_FUNDO>(i) Diretor de Administração de Fundos (ii) Diretor de Distribuição e Suitability</DESC_CARGO_FUNCOES_DIR_FUNDO>
<DESC_ATIV_PRINC_EMPR_DIR_FUNDO>Atuação no mercado financeiro e de capitais e no mercado cambial intermediando a negociação de títulos e valores mobiliários entre investidores e tomadores de recursos, e oferecendo serviços como plataformas de investimento pela internet (home broker), clubes de investimentos, financiamento para compra de ações (conta margem) e administração e custódia de títulos e valores mobiliários dos clientes. </DESC_ATIV_PRINC_EMPR_DIR_FUNDO>
</DET_EXP_PROFIS_DIR_FUNDO>
</PRINC_EXP_PROFIS_5ANOS_DIR_FUNDO>
				<DESC_QUALQUER_COND_CRIMINAL_DIR_FUNDO>Nao há.</DESC_QUALQUER_COND_CRIMINAL_DIR_FUNDO>
				<DESC_QUALQUER_COND_PROCS_ADM_CVM_DIR_FUNDO>Nao há.</DESC_QUALQUER_COND_PROCS_ADM_CVM_DIR_FUNDO>
			</DIR_RESP_FUNDO>
		</GOVERNANCA>
		<DISTRIB_COTST_PERC_ADQ>
			<DET_FAIXA_5>
				<QTD_COTST_FAIXA_5>118889</QTD_COTST_FAIXA_5>
				<QTD_COTS_EMIT_FAIXA_5>60740353</QTD_COTS_EMIT_FAIXA_5>
				<PERC_COTS_DETID_TOT_EMIT_FAIXA_5>100,00</PERC_COTS_DETID_TOT_EMIT_FAIXA_5>
				<PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_5>99,38</PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_5>
				<PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_5>0,62</PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_5>
			</DET_FAIXA_5>
			<DET_FAIXA_5_10>
				<QTD_COTST_FAIXA_5_10>0</QTD_COTST_FAIXA_5_10>
				<QTD_COTS_EMIT_FAIXA_5_10>0</QTD_COTS_EMIT_FAIXA_5_10>
				<PERC_COTS_DETID_TOT_EMIT_FAIXA_5_10>0,00</PERC_COTS_DETID_TOT_EMIT_FAIXA_5_10>
				<PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_5_10>0,00</PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_5_10>
				<PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_5_10>0,00</PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_5_10>
			</DET_FAIXA_5_10>
			<DET_FAIXA_10_15>
				<QTD_COTST_FAIXA_10_15>0</QTD_COTST_FAIXA_10_15>
				<QTD_COTS_EMIT_FAIXA_10_15>0</QTD_COTS_EMIT_FAIXA_10_15>
				<PERC_COTS_DETID_TOT_EMIT_FAIXA_10_15>0,00</PERC_COTS_DETID_TOT_EMIT_FAIXA_10_15>
				<PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_10_15>0,00</PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_10_15>
				<PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_10_15>0,00</PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_10_15>
			</DET_FAIXA_10_15>
			<DET_FAIXA_15_20>
				<QTD_COTST_FAIXA_15_20>0</QTD_COTST_FAIXA_15_20>
				<QTD_COTS_EMIT_FAIXA_15_20>0</QTD_COTS_EMIT_FAIXA_15_20>
				<PERC_COTS_DETID_TOT_EMIT_FAIXA_15_20>0,00</PERC_COTS_DETID_TOT_EMIT_FAIXA_15_20>
				<PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_15_20>0,00</PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_15_20>
				<PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_15_20>0,00</PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_15_20>
			</DET_FAIXA_15_20>
			<DET_FAIXA_20_30>
				<QTD_COTST_FAIXA_20_30>0</QTD_COTST_FAIXA_20_30>
				<QTD_COTS_EMIT_FAIXA_20_30>0</QTD_COTS_EMIT_FAIXA_20_30>
				<PERC_COTS_DETID_TOT_EMIT_FAIXA_20_30>0,00</PERC_COTS_DETID_TOT_EMIT_FAIXA_20_30>
				<PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_20_30>0,00</PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_20_30>
				<PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_20_30>0,00</PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_20_30>
			</DET_FAIXA_20_30>
			<DET_FAIXA_30_40>
				<QTD_COTST_FAIXA_30_40>0</QTD_COTST_FAIXA_30_40>
				<QTD_COTS_EMIT_FAIXA_30_40>0</QTD_COTS_EMIT_FAIXA_30_40>
				<PERC_COTS_DETID_TOT_EMIT_FAIXA_30_40>0,00</PERC_COTS_DETID_TOT_EMIT_FAIXA_30_40>
				<PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_30_40>0,00</PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_30_40>
				<PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_30_40>0,00</PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_30_40>
			</DET_FAIXA_30_40>
			<DET_FAIXA_40_50>
				<QTD_COTST_FAIXA_40_50>0</QTD_COTST_FAIXA_40_50>
				<QTD_COTS_EMIT_FAIXA_40_50>0</QTD_COTS_EMIT_FAIXA_40_50>
				<PERC_COTS_DETID_TOT_EMIT_FAIXA_40_50>0,00</PERC_COTS_DETID_TOT_EMIT_FAIXA_40_50>
				<PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_40_50>0,00</PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_40_50>
				<PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_40_50>0,00</PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_40_50>
			</DET_FAIXA_40_50>
			<DET_FAIXA_ACIMA_50>
				<QTD_COTST_FAIXA_ACIMA_50>0</QTD_COTST_FAIXA_ACIMA_50>
				<QTD_COTS_EMIT_FAIXA_ACIMA_50>0</QTD_COTS_EMIT_FAIXA_ACIMA_50>
				<PERC_COTS_DETID_TOT_EMIT_FAIXA_ACIMA_50>0,00</PERC_COTS_DETID_TOT_EMIT_FAIXA_ACIMA_50>
				<PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_ACIMA_50>0,00</PERC_COTS_DETID_PF_TOT_EMIT_FAIXA_ACIMA_50>
				<PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_ACIMA_50>0,00</PERC_COTS_DETID_PJ_TOT_EMIT_FAIXA_ACIMA_50>
			</DET_FAIXA_ACIMA_50>
		</DISTRIB_COTST_PERC_ADQ>
		<POLIT_DIVULG_INFO>
			<DESC_POLIT_DIVULG_ATO_FATO>A divulgação de ato ou fato relevante  será divulgado aos cotistas através do site do Administrador pelo endereço eletrônico  https://qitech.com.br/dtvm/ e no site da B3  (sistema FundosNet)/CVM pelo link https://cvmweb.cvm.gov.br/swb/default.asp?sg_sistema=fundosreg, concomitantemente.</DESC_POLIT_DIVULG_ATO_FATO>
			<DESC_POLIT_NEGOC_COTS>As Cotas serão admitidas à negociação no mercado de bolsa na B3 S.A Brasil, Bolsa, Balcão, observado o disposto no Regulamento do Fundo.</DESC_POLIT_NEGOC_COTS>
			<DESC_POLIT_EXERC_VOTO>Nao aplicavel.</DESC_POLIT_EXERC_VOTO>
			<RELC_FUNC_RESP_FISCZ_POLIT>O Administrador possui equipe direcionada para assegurar o cumprimento da política de divulgação de informações do Fundo.</RELC_FUNC_RESP_FISCZ_POLIT>
		</POLIT_DIVULG_INFO>
		<DESC_REGRA_PRAZO_CHAM_CAPTL>Não aplicável.</DESC_REGRA_PRAZO_CHAM_CAPTL>
		<DESC_POLIT_DISTIB_RESULT>O Fundo tem como política a distribuição de resultados com base no lucro contábil auferido segundo o regime de competência. A periodicidade da distribuição é mensal, realizada a critério da Administradora sob orientação da Gestora, a título de antecipação dos rendimentos do exercício.Os pagamentos são previstos para o dia 25 do mês subsequente ao do recebimento dos recursos pela Classe, sendo antecipados para o dia útil anterior caso não haja pregão na B3 na data estipulada. Farão jus aos rendimentos os cotistas inscritos no registro na data de corte definida pelos procedimentos operacionais da B3 e do escriturador.Eventuais saldos de lucros não distribuídos mensalmente podem ser reinvestidos pela Gestora em Ativos Alvo ou Ativos de Liquidez, desde que respeitados os limites legais e regulamentares. A conciliação e o tratamento definitivo dos resultados apurados no exercício findo são deliberados anualmente em Assembleia Geral Ordinária (AGO), que deve ser realizada em até 120 dias após o encerramento do exercício social (31 de dezembro).</DESC_POLIT_DISTIB_RESULT>
	</LISTA_INFORM>
</DOC_ARQ>"