"<?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>13.842.683/0001-76</CNPJFundo>
		<DataFuncionamento>2012-11-14</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>BRVLJSCTF004</CodigoISIN>
		<QtdCotasEmitidas>58977.19420901</QtdCotasEmitidas>
		<FundoExclusivo>true</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Lajes Corporativas</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Determinado</PrazoDuracao>
		<DataPrazoDuracao>2021-07-14</DataPrazoDuracao>
		<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 SA</NomeAdministrador>
		<CNPJAdministrador>13.842.683/0001-76</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>investfundos@planner.com.br</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Queluz Gestão de Recursos Financeiros Ltda</Nome>
				<CNPJ>07.250.864/0001-00</CNPJ>
				<Endereco>Rua Visconde de Pirajá, n° 351 — Cj. 1005, Ipanema, RJ</Endereco>
				<telefone>(11) 3586-8119</telefone>
			</Gestor>
			<Custodiante>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Baker Tilly Brasil</Nome>
				<CNPJ>67.634.717/0001-66</CNPJ>
				<Endereco>Rua Arizona, 1.349 - 1º andar - Brooklin - CEP 04567-003 - São Paulo - SP</Endereco>
				<telefone>(11) 5102-2510</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>
					<Ativo>
						<Nome>LCI CEF</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>11404333.33</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>COMPROMISSADA BRADESCO </Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>2536489.69</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI HABITASEC SECURITIZADORA SERIE 55</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>8208716.4</MontantesInvestidos>
						<OrigemRecursos>1a. Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI HABITASEC SECURITIZADORA SERIE 62</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>6953002.08</MontantesInvestidos>
						<OrigemRecursos>1a. Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI HABITASEC SECURITIZADORA SERIE 66</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>9864726.11</MontantesInvestidos>
						<OrigemRecursos>1a. Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI HABITASEC SECURITIZADORA SERIE 83</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>7066935.1</MontantesInvestidos>
						<OrigemRecursos>1a. Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI HABITASEC SECURITIZADORA SERIE 89</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>7066935.1</MontantesInvestidos>
						<OrigemRecursos>1a. Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI HABITASEC SECURITIZADORA SERIE 125</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>5028899.09</MontantesInvestidos>
						<OrigemRecursos>1a. Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI HABITASEC SECURITIZADORA SERIE 126</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>5028899.09</MontantesInvestidos>
						<OrigemRecursos>1a. Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI HABITASEC SECURITIZADORA SERIE 127</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>5028899.09</MontantesInvestidos>
						<OrigemRecursos>1a. Emissão de Cotas</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>No exercicio encerrado em 31 de dezembro de 2018 o Fundo apresentou um Resultado Operacional de R$ 1.125mil, e um Lucro Líquido de -R$ 4.675mil. No exercício houve distribuíção aos cotistas de R$ 74mil.</ResultadoFundo>
			<ConjunturaEconomica>Passada a grande euforia vivida nos anos 2010 a 2013, o ano de 2016 nos parece o fechamento do primeiro ciclo da indústria, na medida em que novas ofertas se tornam cada vez menos frequentes e algumas dúvidas anda não foram plenamente esclarecidas. As respostas estão sendo buscadas constantemente e o amadurecimento deste mercado acontece de forma lenta (mas acontece). Dito isso, é hora de reflexão dos agentes participantes da indústria, sejam eles investidores, gestores, administradores, reguladores e fiscalizadores.
O ano de 2017 foi marcado pela retomada das emissões de fundos, na medida em que a taxa de juros voltaram para patamares razoáveis. Somado a isto, os índices tiveram forte valorização, levando o valor de mercado dos fundos para acima de R$ 40 bilhões. Não menos importante, o número de investidores na bolsa passou de aproximadamente 90 mil para mais de 140 mil em pouco menos de 6 meses. Porém, este aumento praticamente manteve constante a proporção de pessoas físicas detentoras do estoque de FIIs em 80%.
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>carteira deve continuar apresentando resultados consistentes, com a maturação dos investimentos realizados, refletindo em resultados de valorização para os investidores. Ademais, há perspectiva da concretização de 2 ou 3 novos investimentos para o primeiro semestre de 2.019, os quais devem representar a confiança e a manutenção na estratégia de investimentos do Fundo.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
		</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, no momento da coleta de assinaturas na Lista de presença;
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, e quando a o envio desta pelo cotista, 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 xsi:nil="true"/>
			<PercentPatrimonioContabil xsi:nil="true"/>
			<PercentPatrimonioValorMercado xsi:nil="true"/>
		</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>Artur Martins de Figueiredo</Nome>
				<Idade>53</Idade>
				<CPF>073.813.338-80</CPF>
				<Email>afigueiredo@planner.com.br</Email>
				<Profissao>Administrador de Empresas</Profissao>
				<FormacaoAcademica>PUC</FormacaoAcademica>
				<DataInicioFuncao>1999-06-07</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Banco Bandeirantes de Investimentos S/A</NomeEmpresa>
						<Periodo>1986/1999</Periodo>
						<CargoFuncoes>Analista de Investimento </CargoFuncoes>
						<AtividadePrincipalEmpresa>Realizava acompanhamento de empresas de capital aberto, bem como o mercado financeiro de um modo geral, objetivando a elaboração de relatórios diários para definição de estratégias na administração de recursos de terceiros.  </AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Planner Corretora de Valores S/A</NomeEmpresa>
						<Periodo>1999/2000</Periodo>
						<CargoFuncoes>Gerente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Coordenação da Área de Agente Fiduciário, realizando entre outras atividades, o acompanhamento diário dos preços unitários das debêntures, controle dos “covenants” financeiros constantes da escritura de emissão, bem como avaliação das providências a serem adotadas nas emissões que encontram-se inadimplentes.</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Banco Bradesco S/A</NomeEmpresa>
						<Periodo>2000/2001</Periodo>
						<CargoFuncoes>Gerente de Underwriting</CargoFuncoes>
						<AtividadePrincipalEmpresa>Realização de prospecção de operações, nas quais as empresas utilizam o mercado de capitais como fonte de recursos para suportar investimentos e/ou alongamento de outros financiamentos / empréstimos.  O trabalho consistia na prospecção propriamente dita, ou seja, visitas / reuniões com os potenciais emissores, bem como o acompanhamento do processo de registro da operação junto à CVM – Comissão de Valores Mobiliário e do procedimento de venda dos títulos ao mercado (basicamente investidores institucionais).</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Grupo Planner </NomeEmpresa>
						<Periodo>2001/ Atual</Periodo>
						<CargoFuncoes>Diretor / Conselheiro</CargoFuncoes>
						<AtividadePrincipalEmpresa>Responsável pela administração fiduciária de Fundos de Investimento</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não </CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="8" numCotasDetidas="10575.92885151" percDetidoRelTotal="0.1793" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento numCotistas="6" numCotasDetidas="25441.02069824" percDetidoRelTotal="0.4314" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="2" numCotasDetidas="13051.44260396" percDetidoRelTotal="0.2213" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuinzeAteVintePorcento numCotistas="1" numCotasDetidas="9908.8020553" percDetidoRelTotal="0.168" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<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>
"