"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>BASÍLICA PARTNERS LED CORPORATE FII</NomeFundo>
		<CNPJFundo>28267555000113</CNPJFundo>
		<DataFuncionamento>2017-07-31</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>BRBPLCCTF007</CodigoISIN>
		<QtdCotasEmitidas>32529</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</Subclassificacao>
			<TipoGestao>Definida</TipoGestao>
			<SegmentoAtuacao>Multicategoria</SegmentoAtuacao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</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>(11) 3138-8928</Telefone1>
		<Telefone2>(11) 3138 - 8805</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>BASÍLICA PARTNERS LATIN AMERICA PRIVATE EQUITY LTDA</Nome>
				<CNPJ>24979104000158</CNPJ>
				<Endereco>R. Pedroso Alvarenga, 900 - conj. 52 - Itaim Bibi, São Paulo - SP, 04531-003</Endereco>
				<telefone>(11) 3382-1513</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO DAYCOVAL S.A</Nome>
				<CNPJ>62232889000190</CNPJ>
				<Endereco>Av. Paulista,1.792 - Bela Vista - SP</Endereco>
				<telefone>(11) 3138-8928</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>RSM BRASIL AUDITORES INDEPENDENTES LTDA.</Nome>
				<CNPJ>16549480000184</CNPJ>
				<Endereco>Av. Marques de São Vicente, 182, 2º andar, Conj 23 - 01139-000, São Paulo - SP, Varzea da Barra Funda</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>Av. Paulista,1.792 - Bela Vista - SP</Endereco>
				<telefone>(11) 3138-8928</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>
				<Prestador>
					<Nome>JULIUS BAER FAMILY OFFICE BRASIL GESTÃO DE PATRIMÔNIO LTDA</Nome>
					<CNPJ>12695840000103</CNPJ>
					<Endereco>Rua Elvira Ferraz, nº 68, 10º e 11º andares - Vila Olimpia - São Paulo - SP</Endereco>
					<telefone>(11)2161-2410</telefone>
				</Prestador>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</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>LED CORP</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>321712023.82</Valor>
				<PercentValorizacaoDesvalorizacao>0.003097</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>Avenida Paulista, 1.793 - 2° andar</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>https://www.daycoval.com.br/institucional/mercado-de-capitais</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>De acordo com regulamento: A convocação da Assembleia deve ser feita com, no mínimo, 10 (dez) dias corridos de antecedência e exclusivamente far-se-á por meio de correio eletrônico (e-mail) endereçado aos cotistas, conforme dados de contato contidos no documento de subscrição das Cotas, cadastro do cotista junto à Administradora e/ou Escriturador, ou conforme posteriormente informados ao prestador de serviço responsável pelo recebimento de tal informação. As solicitaçãos podem ser feitas através email: adm.fundos@bancodaycoval.com.br, informes.regulatorios@bancodaycoval.com.br, middlesmc@bancodaycoval.com.br, website do administrador fiduciário (https://www.daycoval.com.br/institucional/mercado-de-capitais) ou por endereço físico, conforme consta neste documento: Avenida Paulista, 1.793 - 2° andar. São Paulo - SP</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>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. 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>A convocação da Assembleia Geral de Cotistas pelo Administrador far-se-á mediante correspondência encaminhada a cada Cotista, por meio de correio eletrônico (email), contendo, obrigatoriamente, o dia, hora e local em que será realizada tal Assembleia e ainda, de forma sucinta, os assuntos a serem tratados. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Artigo 17 - Taxa de Administração : Parágrafo Primeiro - A partir da entrega do Empreendimento e início do primeiro pagamento de aluguel, a Taxa de Administração será de 0,683300%, (zero vírgula seiscentos e oitenta e três mil trezentos por cento), sendo assegurada uma remuneração mínima mensal de R$ 89.448,00 (oitenta e nove mil quatrocentos e quarenta e oito reais), corrigida anualmente pelo IPCA a partir da data da primeira integralização de Cotas do Fundo (“Taxa de Administração”).
Parágrafo Segundo - A distribuição da Taxa de Administração a partir entrega do Empreendimento e início do primeiro pagamento de aluguel será a seguinte:
a. Administrador: 0,10% (dez décimos por cento) sendo assegurada uma remuneração mínima mensal de R$ 13.000,00 (treze mil reais), corrigida anualmente pelo IPCA a partir
da data da primeira integralização de Cotas do Fundo, sendo certo que essa taxa está englobada na Taxa de Administração 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>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>2020-09-25</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="56" numCotasDetidas="9950" percDetidoRelTotal="0.305880906268253" percDetidoPF="0.293494" percDetidoPJ="0.012389"/>
			<AcimaCincoAteDezPorcento numCotistas="1" numCotasDetidas="3049" percDetidoRelTotal="0.0937317470564727" percDetidoPF="0.093732" 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="19530" percDetidoRelTotal="0.600387346675274" percDetidoPF="0" percDetidoPJ="0.600385"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>A divulgação de ato ou fato relevante pela Administradora é realizada nos termos da regulamentação aplicável e seu conteúdo é disponibilizado no sistema Fundos.Net (https://fnet.bmfbovespa.com.br/fnet/publico/abrirGerenciadorDocumentosCVM), vinculado à CVM e à B3, bem como no site da Administradora https://www.daycoval.com.br/investimentos/mercado-capitais/informacoes-cotista</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>O Gestor adota política de exercício de direito de voto em assembleias gerais de ativos integrantes da carteira da Classe, a qual disciplina os princípios gerais, o processo decisório e quais são as matérias relevantes obrigatórias para o exercício do direito de voto. A política de exercício de voto utilizada pelo Gestor pode ser encontrada em sua página na rede mundial de computadores: www.basilicapartners.com.</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>Ao receberem a notificação da Chamada de Capital, os Cotistas serão obrigados a integralizar parte ou a totalidade de suas respectivas Cotas, nos termos dos respectivos compromissos de investimento e observados os procedimentos específicos de cada Chamada de Capital. O procedimento será repetido até que 100% (cem por cento) das Cotas subscritas pelos Cotistas tenham sido integralizadas. O Cotista que descumprir, total ou parcialmente, sua obrigação de Integralização de Cotas do Fundo, conforme cada Chamada de Capital realizada, será considerado um Cotista Inadimplente (“Cotista Inadimplente”).</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"