"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIÁRIO PANAMBY</NomeFundo>
		<CNPJFundo>00613094000174</CNPJFundo>
		<DataFuncionamento>1995-03-11</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRPABYCTF012</CodigoISIN>
		<QtdCotasEmitidas>61750.7996135999</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Outros</SegmentoAtuacao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>false</MBO>
			<MB>true</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BANCO GENIAL S.A.</NomeAdministrador>
		<CNPJAdministrador>45246410000155</CNPJAdministrador>
		<Logradouro>PR DE BOTAFOGO</Logradouro>
		<Numero>228</Numero>
		<Complemento>sala 907</Complemento>
		<Bairro>BOTAFOGO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22250-040</CEP>
		<Telefone1>11 3206-8000</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>WWW.BANCOGENIAL.COM</Site>
		<Email>MIDDLEADM@GENIAL.COM.VC</Email>
		<Competencia>2025-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>BANCO GENIAL S.A.</Nome>
				<CNPJ>45246410000155</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO, 228, SALA 907, BOTAFOGO, RIO DE JANEIRO / RJ</Endereco>
				<telefone>(21) 3923-3000</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO GENIAL S.A.</Nome>
				<CNPJ>45246410000155</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO, 228, SALA 907, BOTAFOGO, RIO DE JANEIRO / RJ</Endereco>
				<telefone>(21) 3923-3000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>GRANT THORNTON AUDITORES INDEPENDENTES LTDA</Nome>
				<CNPJ>10830108000165</CNPJ>
				<Endereco>Av. Engenheiro Luís Carlos Berrini, 105 - 12º Andar - Itaim Bibi</Endereco>
				<telefone>(11) 3886-5100</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BANCO GENIAL S.A.</Nome>
				<CNPJ>45246410000155</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO, 228, SALA 907, BOTAFOGO, RIO DE JANEIRO / RJ</Endereco>
				<telefone>(21) 3923-3000</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>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Fundo tem por objetivo proporcionar aos Cotistas a valorização e a rentabilidade de suas cotas, conforme Política de Investimento definida abaixo, por meio de (i) investimentos em Ativos Alvo; (ii) exploração comercial dos Ativos Alvo, mediante locação; e (iii) comercialização dos Ativos Alvo, observados os termos e condições da legislação e regulamentação vigentes.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo> fundo obteve resultado patrimonial negativo  no exercício de 2025 de aproximadamente R$5.457MM.</ResultadoFundo>
			<ConjunturaEconomica>Durante o ano de 2025, o mercado de escritórios de alto padrão da cidade de São Paulo consolidou seu processo de recuperação, com o indicador de absorção líquida nas regiões primárias (CBD) acumulando 213 mil m², em contraste com uma média anual de 78 mil m² verificada nos cinco anos anteriores, sinalizando a força da demanda por espaços corporativos. Houve destaque para os segmentos Financeiro, de Serviços e Tecnologia, que representaram mais de 40% desse volume de absorções em 2025. Ainda nas regiões principais, a taxa de vacância encerrou o período em 11,4%, se aproximando dos níveis pré-pandemia. A melhora nas condições de mercado é também observada no aumento dos preços pedidos de locação, cuja média apresentou uma variação anual positiva de 14,7%.

No mercado de escritórios de alto padrão do Rio de Janeiro, a taxa de vacância nas principais regiões (CBD) segue em queda, reduzindo 2,6 p.p. em relação ao último ano e atingindo 26,2%, seu menor patamar em quase dez anos. O preço médio pedido, por sua vez, registrou aumento de 8,2%.

O mercado de condomínios logísticos segue em fase de forte expansão, com a absorção líquida atingindo o nível recorde de 3,3 milhões de m² em todo o Brasil, com destaque para a persistente demanda por espaços por parte do segmento de E-Commerce.  A taxa de vacância, por sua vez, reduziu em 0,8 p.p. para 7,0%, próximo dos menores patamares da série histórica.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Considerando o atual cenário de forte demanda e um volume esperado de nova oferta para 2026 que, apesar de elevado, já se encontra em parte comprometido por pré-locações, a expectativa para o mercado de escritórios de alto padrão nas principais regiões de São Paulo é de continuidade da melhora nas condições gerais, com quedas nas taxas de vacância e aumento dos preços de locação. Para o mercado de alto padrão do Rio de Janeiro a expectativa é de novas reduções nas taxas de vacância, uma vez que o volume de novo estoque é relativamente limitado (19 mil m²) e não deverá haver pressões de oferta sobre o indicador.

O mercado de condomínios logísticos do Brasil deve continuar recebendo volumes historicamente elevados de novo estoque ao longo de 2026, e seu desempenho dependerá essencialmente da capacidade dos principais segmentos de absorver a oferta a ser entregue.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Villaggio Panamby	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>0</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Setores 1 e 6B	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>0</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Setor 7	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>0</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Setor 8	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>0</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Setor 6A	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>0</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Villaggio Panamby: As contas a receber pela venda de lotes, conforme Escritura de Promessa de Compra e Venda Sob Condições Suspensivas, firmada em 29 e 30 de setembro de 1995, são atualizadas pela variação do IGP-M e, a partir da assinatura das Escrituras de Confissão de Dívida, atualizadas pela variação do IGP-M, acrescidas de juros anuais de 12%. Quando do "habite-se" do empreendimento, a dívida confessada é novada e substituída pelo direito de participação na receita de venda das unidades construídas. Os percentuais de participação na receita de venda são definidos nas Escrituras de Confissão de Dívida. O valor das contas a receber é baixado à medida que o Incorporador recebe e repassa ao Fundo os percentuais de participação pertencentes ao Fundo. Em cumprimento ao disposto na Instrução CVM nº 516, de 29 de dezembro de 2011, conforme alterada (“ICVM 516”), os terrenos Setor 6A e Setor 8 integrantes da carteira do Fundo foram preliminarmente reavaliados pela Administradora e tiveram seus valores ora contabilizados provisionados integralmente. Neste mesmo sentido, foram provisionados integralmente os valores ora registrados como recebíveis oriundos dos Instrumentos Particulares de Venda e Compra, firmados pela BRKB DTVM e (i) Cyrela Vermont de Investimentos Imobiliários Ltda. (“Cyrela”) em 17 de agosto de 2004, referente ao Setor 7; e (ii) Camargo Correa Desenvolvimento Imobiliário S.A. (“CCDI”) em 14 de junho de 2006, referente aos Setores 1 e 6B. Tais impactos nos registros contábeis decorrem da deterioração das perspectivas de realização dos referidos terrenos e recebíveis, diretamente associadas às sucessivas tentativas para aprovação de diferentes projetos imobiliários junto aos órgãos municipais, sem que se tenha obtido, até o presente momento, aprovação ou reprovação em caráter formal pela Prefeitura de São Paulo. Estas deteriorações nas perspectivas elevam o grau de imprevisibilidade de determinação das despesas ainda a serem incorridas para viabilizar a realização desses ativos, não sendo possível, portanto, determinar com segurança o valor realizável líquido dos mesmos. Ainda conforme disposto na ICVM 516, em períodos subsequentes tais registros continuarão sendo reavaliados e, eventualmente, quando houver evidências do aumento no valor realizável líquido dos ativos, tais provisões serão revertidas até o menor valor entre o valor do custo ou valor realizável líquido revisado.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>1001310-96.2021.5.02.0716</Numero>
				<Juizo>16ª Vara do Trabalho de São Paulo - Zona Sul - SP</Juizo>
				<Instancia>2ª Instância</Instancia>
				<DataInstauracao>2021-10-21</DataInstauracao>
				<ValorCausa>35484.08</ValorCausa>
				<PartesProcesso>Reclamante: Nerivaldo de Andrade; Reclamada: Fundo de Investimentos Imobiliários Panamby</PartesProcesso>
				<PrincipaisFatos>Trata-se de reclamação trabalhista, referente a responsabilidade subsidiária: Horas extras; intervalo intrajornada; férias; 13º; reintegração ao emprego ou pagamento dos salários do período estabilitário de 10.04.2021 a 09.04.2022; reflexos do período estabilitário nos 13º salários; nas férias + 1/3; FGTS + 40% sobre verbas acima, exceto férias.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 0022979-76.2014.4.03.6100 </Numero>
				<Juizo>21ª Vara Cível da Justiça Federal de São Paulo</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-12-01</DataInstauracao>
				<ValorCausa>270766048</ValorCausa>
				<PartesProcesso>Autor: Ministério Púbico Federal (“MPF”)
Réu: FIIP, BRKB/Banco Genial, Camargo Correa Desenvolvimento Imobiliário e outros</PartesProcesso>
				<PrincipaisFatos>Declaração de nulidade de todos os atos praticados pela CETESB, incluindo a autorização 
de supressão de vegetação nativa do Lote A4, ressarcimento de dano ambiental e licenciamento ambiental do empreendimento pelo IBAMA, e não apenas pela CETESB.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0003683-63.2017.4.03.6100</Numero>
				<Juizo> 21ª Vara Cível da Justiça Federal de São Paulo</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-31</DataInstauracao>
				<ValorCausa>251977008</ValorCausa>
				<PartesProcesso>Autor: MPF
Réu: FIIP, BRKB, Cyrela Vermont de Investimentos Imobiliários Ltda. (“Cyrela”), CETESB e 
Município de São Paulo.</PartesProcesso>
				<PrincipaisFatos>Declaração de nulidade de todos os atos administrativos expedidos em favor de BRKB 
ou Cyrela de modo a preservar fragmento de Mata Atlântica, incluindo vegetação de 
preservação permanente e espécies de fauna e flora ameaçadas de extinção, existentes na denominada Gleba C do Projeto Urbanístico Panamby (Lotes 6 a 12).</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1014790-75.2021.8.26.0053</Numero>
				<Juizo> 10ª Vara da Fazenda Pública do Foro Central</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2021-03-12</DataInstauracao>
				<ValorCausa>1022.15</ValorCausa>
				<PartesProcesso>Autor: FIIP, CCDI e Cyrela
Réu: Prefeitura Municipal de São Paulo</PartesProcesso>
				<PrincipaisFatos>Notificação de Protesto Interruptivo de Prescrição contra o Município de São Paulo para
interromper a referida a prescrição, conservando e ressalvando, dessa forma, o seu direito de ajuizar oportunamente a competente ação para exigir do Protestado o pagamento de 
indenização pelos prejuízos experimentados referente ao “Projeto Urbanístico Panamby”.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 14.0482.0000471/2013-2</Numero>
				<Juizo> 4ª Promotoria de Justiça de Meio Ambiente da Capital </Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2023-12-17</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Órgão: Ministério Público do Estado de São Paulo (“MPSP”)
Investigados: FIIP, BRKB e outros </PartesProcesso>
				<PrincipaisFatos>Averiguar suposto desmatamento em área com vegetação do Bioma Mata Atlântica, 
dos setores 1 e 6B do Loteamento Projeto Urbanístico Panamby, localizado na Av. Major Sylvio de Magalhães Padilha, entre a Rua Dona Helena Pereira de Moraes e Rua Itapaiuna, Vila Andrade, São Paulo. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1.34.001.006193/2014-72</Numero>
				<Juizo>31º Ofício do Grupo I – Meio Ambiente e Patrimônio Histórico e Cultural</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-09-11</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Órgão: MPF
Investigado: FIIP, BRKB e outros</PartesProcesso>
				<PrincipaisFatos>Instaurado diante da notícia de desmatamento ilegal em área remanescente de Mata Atlântica nas adjacências do Parque Global, ou seja, mais especificamente sobre supressão de vegetação de bioma Mata Atlântica, ocorrida em atividade acelerada, pelos responsáveis legais de imóvel sitiado à Av. Major Silvio Magalhães Padilha (marginal Oeste do Rio Pinheiros – sentido Interlagos, à Av. Dona Helena e à Rua Itapaiuna, Vila Andrade, nesta Capital).</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1.34.001.007912/2014-72 </Numero>
				<Juizo>31º Ofício do Grupo I Meio Ambiente e Patrimônio Histórico</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-12-04</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Órgão: MPF Investigado: FIIP, BRKB e outros</PartesProcesso>
				<PrincipaisFatos>Instaurado diante da notícia de manejo, sem autorização de órgãos ambientais competentes, de espécies nativas de Mata Atlântica, em área da empresa Cyrela Vermont de Investimentos Imobiliários LTDA., localizada entre a Marginal Oeste do Rio Pinheiros e o Parque Burle Marx, nesta Capital.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 1.34.001.001192/2016-01</Numero>
				<Juizo>31º Ofício do Grupo I – Meio Ambiente e Patrimônio Histórico</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-03-21</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Órgão: MPF Investigado: FIIP, BRKB e outros</PartesProcesso>
				<PrincipaisFatos>Instaurado em razão de notícia divulgada pela imprensa de modificações inoportunas na lei de zoneamento do Município de São Paulo, que poderiam ampliar o perímetro da Operação Urbana Água Espraiada, na zona sul de São Paulo, para compreender a área do loteamento.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 02027.001639/2014-43</Numero>
				<Juizo>Administrativo</Juizo>
				<Instancia>Administrativo</Instancia>
				<DataInstauracao>2014-10-20</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Autor da Fiscalização: IBAMA
Autuado: FIIP, BRKB e outros </PartesProcesso>
				<PrincipaisFatos>Apuração de indevida intervenção, por meio de roçada na vegetação, efetuada nos 
terrenos denominados “Setor 1 e 6B”.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 2013-0.352.842-4</Numero>
				<Juizo>Administrativo</Juizo>
				<Instancia>Administrativo</Instancia>
				<DataInstauracao>2013-11-29</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Autor da Fiscalização: SVMA Autuado: FIIP e BRKB</PartesProcesso>
				<PrincipaisFatos>Auto de Intimação nº 058891, que determinou a apresentação de (i) autorização para intervenção/supressão de vegetação nativa da Mata Atlântica; (ii) esclarecimentos sobre fita que delimita regiões dentro do terreno; (iii) matrículas atualizadas dos imóveis; (iv) termos de compromisso ambiental (TCA); (v) autorização para supressão ou plano de manejo de espécie ameaçada de extinção, segundo lista oficial.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>6021.2023/0022353-6</Numero>
				<Juizo>Administrativo</Juizo>
				<Instancia>Administrativo</Instancia>
				<DataInstauracao>2023-04-05</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Localização: Prefeitura do Município de São Paulo 
Interessados: FIIP, BRKB, Cyrela Vermont de Investimento Imobiliário Ltda. e Camargo Correia
Desenvolvimento Imobiliário S.A.</PartesProcesso>
				<PrincipaisFatos>Trata-se de processo administrativo deflagrado na Prefeitura do Município de São Paulo (“Protocolo de Intenções”) para propor a ampliação do Parque Burle Marx, mediante a inclusão dos imóveis de propriedade dos Interessados na categoria “parque” proposta no Quadro 7 do Plano Diretor Estratégico, de 2014 (“PDE/14”), em troca da Transferência do Direito de Construir (“TDC”), intencionando obter a extinção das Ações Civis Públicas (itens 1.1 e 1.2) e o encerramento dos Inquéritos Civis nº 1.34.001.007912/2014 e 1.34.001.001192/2016 (itens 2.3 e 2.4).</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>6068.2023/0010940-3</Numero>
				<Juizo>Administrativo</Juizo>
				<Instancia>Administrativo</Instancia>
				<DataInstauracao>2023-11-21</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Localização: Prefeitura do Município de São Paulo; Interessados: Banco Genial S.A., FIIP, Cyrela Vermont de Investimento Imobiliário Ltda. e 
Camargo Correia Desenvolvimento Imobiliário S.A</PartesProcesso>
				<PrincipaisFatos>Trata-se de processo administrativo deflagrado na Prefeitura do Município de São Paulo para propor a doação de áreas para ampliação do Parque Burle Marx em troca da Transferência do Direito de Construir (“TDC”), intencionando obter a extinção das Ações Civis Públicas (itens 1.1 e 1.2) e o encerramento dos Inquéritos Civis nº 1.34.001.007912/2014 e 1.34.001.001192/2016 (itens 2.3 e 2.4).</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Não aplicável</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Praia de Botafogo, n° 228, sala 907 – Parte, Botafogo, CEP 22.250-906, Rio de Janeiro/RJ</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>https://www.bancogenial.com/pt-BR/AdministracaoFiduciaria/FundsSelect</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>(i) email: assembleia@genial.com.vc; telefones: (11) 2137-8888, (21) 2169-9999 para esclarecimentos julgados necessários.
(ii)A manifestação de voto e, conforme o caso, a via original ou cópia reprográfica do instrumento de mandato, devidamente autenticada, ou pedidos de esclarecimentos deverá(ão) ser encaminhado(s) por escrito à Administradora no seguinte endereço aos cuidados do Sr. Rodrigo Godoy, com endereço na PR DO BOTAFOGO. 228, SALA 907 - RIO DE JANEIRO -RJ; CEP: 22.250-040, ou por meio do e-mail: assembleia@genial.com.vc.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>i) A identificação dos cotistas é realizada mediante a apresentação de documentos comprobatórios, nos casos de voto presencial ou a distância.

ii) Conforme o Regulamento do Fundo e Anexo(s) descritivo(s), as deliberações da Assembleia Geral ou Especial de Cotistas poderão ser tomadas mediante processo de consulta, formalizada por escrito, dirigida pelo Administrador a cada Cotista, devendo constar da consulta todos os elementos informativos necessários ao exercício do direito de voto, cuja resposta deverá ser enviada pelos Cotistas ao Administrador no prazo máximo de 30 (trinta) ou 15 (quinze) dias, conforme se trate de Assembleia Geral ordinária ou extraordinária ou Assembleia Especial ordinária ou extraordinária, observadas as formalidades previstas nos arts. 13, 14 e 37 da Resolução CVM 175. Em caso de deliberação mediante consulta formal, para fins de cálculo de quórum de deliberação, serão considerados presentes todos os Cotistas, sendo que a aprovação da matéria objeto da consulta formal obedecerá aos mesmos quóruns de aprovação previstos no Regulamento e Anexo(s) descritivo(s). O comunicado de consulta formal enviado pelo Administrador informará o prazo em que será divulgada a apuração dos votos, nos termos do art. 37 da Resolução CVM 175.

iii) Para a participação à distância, os cotistas enviarão o voto, juntamente com os documentos comprobatórios, no endereço eletrônico indicado na Convocação, dentro do prazo limite estabelecido. Poderão, também, conforme o caso, proferir o voto em sistema eletrônico de assembleia virtual disponibilizado pelo Administrador. Todos os procedimentos, regras e prazos estarão dispostos no Edital de Convocação.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>As deliberações da Assembleia Geral ou Especial de Cotistas poderão ser tomadas mediante processo de consulta formal, sem a necessidade de reunião de cotistas, formalizado em carta ou correio eletrônico (e-mail) dirigido pelo Administrador a cada cotista, para resposta nos prazos previstos para convocação das Assembleias Gerais ou Especiais de Cotistas previstos no item acima, desde que observadas as formalidades previstas nos artigos 13, 14 e 37 da Resolução CVM 175.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O Administrador fará jus a uma remuneração, a título de participação nos resultados apurados pelo Fundo na alienação dos lotes que integram seu patrimônio inicial. Tal remuneração corresponderá a 1,99% (um inteiro e noventa e nove centésimos por cento) do valor efetivamente disponível para pagamento aos cotistas, sob a forma de distribuição de resultados. Essa remuneração terá alocação própria de acordo com os seguintes percentuais: (a) 28,64% (vinte e oito inteiros e sessenta e quatro centésimos por cento) da referida remuneração será disponibilizada ao Administrador para sua livre utilização, enquanto (b) 71,36% (setenta e um inteiros e trinta e seis centésimos por cento) será utilizada pelo Administrador para efetuar as seguintes compensações: (i) do saldo do valor dos adiantamentos, de acordo com o disposto no Artigo 32, item III, parágrafo 3, sub-item I do Regulamento do Fundo, (ii) do saldo da quantia de R$ 235.514,00, de acordo com o disposto no Artigo 32, item III, parágrafo 3, sub-item II do Regulamento do Fundo.</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>Rodrigo de Godoy</Nome>
				<Idade>52</Idade>
				<CPF>665141777</CPF>
				<Email>atendimentocvm@genial.com.vc</Email>
				<Profissao>Diretor</Profissao>
				<FormacaoAcademica>Administrador</FormacaoAcademica>
				<DataInicioFuncao>2019-01-23</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>BANCO GENIAL S.A.</NomeEmpresa>
						<Periodo>2016/Atual</Periodo>
						<CargoFuncoes>Diretor</CargoFuncoes>
						<AtividadePrincipalEmpresa>Instituição Financeira</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>N/A</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="554" numCotasDetidas="304111" percDetidoRelTotal="0.250771624662633" percDetidoPF="0.20103843662347" percDetidoPJ="0.79896156337653"/>
			<AcimaCincoAteDezPorcento numCotistas="2" numCotasDetidas="193496" percDetidoRelTotal="0.159557879477299" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaDezAteQuinzePorcento numCotistas="2" numCotasDetidas="298698" percDetidoRelTotal="0.246308034709298" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaQuinzeAteVintePorcento numCotistas="2" numCotasDetidas="416396" percDetidoRelTotal="0.34336246115077" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>A Política de Divulgação de Fato Relevante do Administrador estabelece diretrizes e procedimentos a serem por ele observados quando da divulgação de fato relevante. Vale destacar que a divulgação de fato relevante deve ocorrer imediatamente após a ciência, pelo Administrador, do fato que o motivou. No mesmo sentido, a divulgação dos fatos relevantes deverá ocorrer de modo a garantir aos cotistas e aos demais investidores o acesso às informações completas e tempestivas, assegurando a igualdade e a transparência da transmissão dessa informação a todos os interessados, sem privilegiar alguns em detrimento de outros. A divulgação dos fatos relevantes se dará por meio do Sistema de Envio de Documentos disponível na página CVM, da página do Administrador na rede mundial de computadores, e, da entidade administradora de mercado organizado onde as cotas do Fundo estejam admitidas à negociação, quando for o caso, sem prejuízo de outro meio que o Administrador entenda necessário.</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>A política está descrita no regulamento do Fundo, disponível no link abaixo:
https://www.bancogenial.com/pt-BR/AdministracaoFiduciaria/Fund/478</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>A política está descrita no regulamento do Fundo, disponível no link abaixo:
https://www.bancogenial.com/pt-BR/AdministracaoFiduciaria/Fund/478</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>O Administrador possui equipes direcionadas para assegurar o cumprimento da política de divulgação de informações do Fundo.</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>
"