"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>VECTOR QUELUZ LAJES CORPORATIVAS FUNDO DE INVESTIMENTO IMOB</NomeFundo>
		<CNPJFundo>13842683000176</CNPJFundo>
		<DataFuncionamento>2012-11-14</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>BRVLJSCTF004</CodigoISIN>
		<QtdCotasEmitidas>26068.6439189</QtdCotasEmitidas>
		<FundoExclusivo>true</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
<Autorregulacao>
<Classificacao>Tijolo</Classificacao>
<Subclassificacao>Híbrido</Subclassificacao>
<TipoGestao>Definida</TipoGestao>
<SegmentoAtuacao>Escritórios</SegmentoAtuacao>
</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>PLANNER CORRETORA DE VALORES S.A.</NomeAdministrador>
		<CNPJAdministrador>13842683000176</CNPJAdministrador>
		<Logradouro>Avenida Brigadeiro Faria Lima</Logradouro>
		<Numero>3900</Numero>
		<Complemento>10º andar</Complemento>
		<Bairro>Itaim Bibi</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>04538-132</CEP>
		<Telefone1>(11) 2172-2600</Telefone1>
		<Telefone2>0800 179 444</Telefone2>
		<Telefone3>(11) 2172-2667</Telefone3>
		<Site>www.planner.com.br</Site>
		<Email>inforegulatorio@planner.com.br</Email>
		<Competencia>2025-12-31</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>QLZ GESTÃO DE RECURSOS FINANCEIROS LTDA</Nome>
				<CNPJ>07.250.864/0001-00</CNPJ>
				<Endereco>Rua Tabapua, 500 - Itaim Bibi, Sao Paulo - SP</Endereco>
				<telefone>(11) 2173-6464</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO BRADESCO S.A.</Nome>
				<CNPJ>60.746.948/0001-12</CNPJ>
				<Endereco>Cidade de Deus, S/N, Vila Yara, Osasco/Sp</Endereco>
				<telefone>0800 704 8383</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>CONFIANCE AUDITORES INDEPENDENTES</Nome>
				<CNPJ>05.452.311/0001-05	</CNPJ>
				<Endereco>Av. Ver. José Diniz, 3725 - Campo Belo, São Paulo - SP</Endereco>
				<telefone>(11) 5044-0683</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</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 xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>No exercicio encerrado em 31 de dezembro de 2025 o Fundo apresentou um prejuízo de -R$ 2.342.133,77.</ResultadoFundo>
			<ConjunturaEconomica>O ano de 2025 foi marcado por uma trajetória de notável resiliência e amadurecimento para o mercado de fundos imobiliários no Brasil, consolidando o setor como um pilar estratégico mesmo diante de um cenário macroeconômico desafiador. A dinâmica econômica do período foi ditada, primordialmente, pela condução da política monetária. Após iniciar o ano em patamares já elevados, a Taxa Selic sofreu ajustes que a levaram ao pico de 15,00% ao ano em junho, permanecendo estável nesse nível até o encerramento de dezembro. Essa manutenção dos juros em patamares restritivos criou um ambiente de intensa competição entre a renda fixa e os ativos de risco, pressionando inicialmente o valor das cotas dos fundos de "tijolo". No entanto, essa mesma conjuntura favoreceu os fundos de "papel", cujas carteiras de recebíveis atreladas ao CDI e à inflação entregaram dividendos robustos, servindo como um importante amortecedor para a volatilidade do mercado no primeiro semestre.
Surpreendendo as projeções mais conservadoras, o IFIX apresentou um desempenho vigoroso ao longo do ano, encerrando 2025 com uma valorização acumulada de 21,08%. Este resultado foi impulsionado por um segundo semestre mais otimista, onde o mercado passou a precificar o fim do ciclo de aperto monetário e a possibilidade de cortes nos juros para 2026, gerando um expressivo rali de recuperação nos ativos reais, especialmente nos segmentos de shoppings e logística. Paralelamente, o mercado imobiliário físico manteve sua força, com os preços de venda subindo cerca de 6,52%, superando a inflação e garantindo o lastro real dos ativos. O setor logístico continuou operando com vacâncias mínimas devido à demanda constante do e-commerce, enquanto o segmento de shoppings se beneficiou da recuperação do consumo e da eficiência na gestão de custos.
O crescimento da base de investidores foi outro ponto alto do período, com a indústria alcançando a marca histórica de 2,9 milhões de cotistas. Esse fluxo constante de capital, somado a um patrimônio líquido total que atingiu os R$ 183 bilhões, demonstra que o investidor brasileiro passou a enxergar os fundos imobiliários como um veículo de proteção patrimonial e renda passiva de longo prazo, independentemente das oscilações de curto prazo da Selic. Ao final de dezembro, o balanço de 2025 revelou um mercado mais maduro, com liquidez diária estável e uma capacidade de adaptação que provou que os fundamentos imobiliários permanecem sólidos. Assim, o ano se encerrou não apenas com números recordes, mas com a confirmação de que os FIIs são indispensáveis para uma carteira diversificada no cenário econômico contemporâneo.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>O cenário para o mercado de fundos imobiliários em 2026 desenha-se como um período de colheita e transição estratégica, impulsionado pela estabilização macroeconômica e pela expectativa de flexibilização monetária. Após um 2025 de juros em patamares restritivos, o ano de 2026 inicia-se sob a égide da convergência da inflação para a meta, o que abre espaço para que o Comitê de Política Monetária (Copom) inicie um ciclo de cortes graduais na Taxa Selic. Essa mudança de direção nos juros atua como o principal catalisador para o setor de FIIs, uma vez que a redução das taxas de desconto tende a valorizar os ativos de tijolo e a reduzir o custo de capital para novas aquisições e expansões, tornando as emissões de cotas (follow-ons) mais atrativas e frequentes.
No setor de lajes corporativas e logística, a perspectiva para 2026 é de uma absorção líquida positiva, sustentada pelo crescimento do PIB e pela consolidação de modelos de trabalho que privilegiam espaços de alta qualidade (flight to quality). Com a redução do custo financeiro, fundos que estavam alavancados devem passar por um processo de desalavancagem ou repactuação de dívidas, melhorando o fluxo de caixa disponível para distribuição aos cotistas. Já o segmento de shoppings tende a se beneficiar do aumento do poder de compra e da redução do endividamento das famílias, o que se traduz em aluguéis variáveis mais gordos e vacância controlada em ativos dominantes.
Em contrapartida, os fundos de papel, que foram os protagonistas dos anos de juros altos, devem passar por um período de normalização. Com a queda da Selic, os rendimentos desses fundos tendem a convergir para patamares mais baixos em comparação ao biênio anterior, exigindo do investidor uma gestão mais ativa e uma rotação de carteira em direção a fundos de tijolo para capturar o ganho de capital. Contudo, o crédito imobiliário continuará sendo um motor essencial para o setor, e a demanda por novos Certificados de Recebíveis Imobiliários (CRIs) deve permanecer aquecida para financiar o estoque imobiliário remanescente de 2025.
Ao longo de dezembro de 2026, espera-se que o IFIX consolide um novo patamar de preços, refletindo não apenas o cenário de juros menores, mas também o amadurecimento institucional do mercado brasileiro. A liquidez deve continuar em ascensão, atraindo inclusive o investidor estrangeiro, que volta a olhar para os ativos reais brasileiros em busca de rendimentos reais superiores aos mercados desenvolvidos. Em suma, 2026 promete ser o ano da consolidação do valor patrimonial, onde a renda passiva se une à valorização das cotas, premiando os investidores que mantiveram a visão de longo prazo durante os ciclos de aperto monetário anteriores.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Não há</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>0</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Não possui informação apresentada.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida Brigadeiro Faria Lima, 3.900 - 10º andar - Itaim Bibi - CEP 04538-132 - São Paulo - SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>Site Fundos Net: fnet.bmfbovespa.com.br/fnet/login - Site administradora: www.planner.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Item (i) são utilizados como meios de comunicação aos cotistas:(a) FundosNet; (b) site da Administradora; (iii) escrita; e (iv) e-mail 
Item (ii) o endereço físico e eletrônico são disponibilizados no Edital de Convocação</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Item (i) são solicitados os documentos societários do cotista, quando do envio da manifestação de voto se aplicável ou antes da assembleia;
Item (ii) a Consulta Formal é elaborada nos termos do Regulamento do Fundo e enviada a todos os cotistas, juntamente com a carta resposta;
Item (iii) as manifestações dos cotistas, deverão ocorrer na forma prevista no comunicado até o horário estabelecido.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Ao enviarmos a comunicação ao cotista sobre a realização da Assembleia, é disponibilizado o canal eletrônico para retorno da sua manifestação nos termos do Regulamento do Fundo, sendo assim, procedemos com a apuração do quorum no momento do encerramento do prazo para manifestação.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Como remuneração de todos os serviços de que trata o Capítulo III, exceto os serviços de custódia a serem prestados pelo CUSTODIANTE, é devido pelo FUNDO aos prestadores de serviços de administração o montante equivalente a até 2,25 % (dois inteiros vinte e cinco centésimos por cento) ao ano sobre o patrimônio líquido do FUNDO (“Taxa de Administração”). 
A remuneração prevista no caput deste artigo deve ser provisionada diariamente (em base de 252 dias por ano) sobre o valor do patrimônio líquido do FUNDO e paga mensalmente, por períodos vencidos, até o 5º (quinto) dia útil do mês subseqüente.
A remuneração da ADMINISTRADORA corresponderá ao montante equivalente de 0,14% (catorze centésimos por cento) ao ano sobre o Patrimônio Líquido do FUNDO, assegurado um valor mínimo mensal de R$ 5.000,00 (cinco mil reais), a ser reajustado pelo IGP-M a cada intervalo de 12 (doze) meses. 
</PoliticaRemuneracao>
			<ValorPagoAno>286611.16</ValorPagoAno>
			<PercentPatrimonioContabil>0.003</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.003</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>Claudia Siola Cianfarani</Nome>
				<Idade>50</Idade>
				<CPF>11974586898</CPF>
				<Email>csiola@planner.com.br</Email>
				<Profissao>Psicóloga</Profissao>
				<FormacaoAcademica>UMESP Universidade Metodista de São Paulo</FormacaoAcademica>
				<DataInicioFuncao>2021-04-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>CONGLOMERADO PLANNER</NomeEmpresa>
						<Periodo>De 08/1997 até atual</Periodo>
						<CargoFuncoes>1997-2006 - Gerente de Back Ofiice e Qualidade</CargoFuncoes>
						<AtividadePrincipalEmpresa>Manutenção do sistema de gestão da qualidade, fornecendo informações à Diretoria de Controles Internos e demais áreas, contribuindo com o objetivo global institucional;

Processamento de Clubes e Fundos;

Liquidação Financeira (Tesouraria);

Acompanhamento de auditorias externas dos órgãos certificadores – Anbima;

Coordenar as atividades de acordo com o Código de 

Regulamentação Anbima vigente;

Preparar e elaborar em conjunto com os colaboradores das áreas, os procedimentos, indicadores, pesquisa de satisfação e demais ferramentas que facilitem a execução das atividades das áreas.</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>CONGLOMERADO PLANNER</NomeEmpresa>
						<Periodo/>
						<CargoFuncoes>2006-até atual – Diretora Estatutária – Conglomerado</CargoFuncoes>
						<AtividadePrincipalEmpresa>Gestão de Controles Internos na aplicação de normas de Controles Internos;

Gestão de Riscos;

Prevenção e mitigação dos riscos de prevenção à lavagem de dinheiro, implementação, cumprimento de regras, políticas e procedimentos internos;

Gestão de Controles Internos na aplicação de normas de Controles Internos;

Realiza processo contínuo de Qualidade e Controles Internos e condução de Canal de Denúncias;

Monitora em sistema integrado (GR Trade) operações de clientes que possam apresentar risco de crédito/ mercado, indicando a necessidade de redução de exposição/ depósito de garantias visando a redução do risco intraday, por meio de ferramentas de stress (teste) e avaliar quanto a adequabilidade da capacidade financeira e limites operacionais; 

Conduzir a análise das causas, elaborar e implementar planos de ações corretivas e preventivas relativas às observações realizadas por órgãos reguladores e de certificações;

Gestão dos Riscos alinhada com o planejamento estratégico da Corretora;

Especificação de parâmetros e controles para PLD, como análises que permitem a comunicação ao COAF;

Responsável pelo desenvolvimento da mesa fiduciária, administração de fundo de investimentos imobiliários e escrituração. Implementação de Sistema Gerencial.</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não </CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="3" numCotasDetidas="1807.1943014" percDetidoRelTotal="0.069324" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento numCotistas="2" numCotasDetidas="2947.6682247" percDetidoRelTotal="0.113073" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="2" numCotasDetidas="6641.8186308" percDetidoRelTotal="0.254782" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuinzeAteVintePorcento numCotistas="1" numCotasDetidas="4763.1607067" percDetidoRelTotal="0.182716" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="1" numCotasDetidas="9908.8020553" percDetidoRelTotal="0.380104" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante xsi:nil="true"/>
			<PoliticaNegociacaoCotas xsi:nil="true"/>
			<PoliticaExercicioDireitoVoto xsi:nil="true"/>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"