"<?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 - FII VITACON</NomeFundo>
		<CNPJFundo>30982923000157</CNPJFundo>
		<DataFuncionamento>2018-12-24</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>0</CodigoISIN>
		<QtdCotasEmitidas>4120</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Híbrido</Mandato>
			<SegmentoAtuacao>Outros</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</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>VÓRTX DISTRIBUIDORA DE TÍTULOS E VALORES MOBILIÁRIOS LTDA.</NomeAdministrador>
		<CNPJAdministrador>30982923000157</CNPJAdministrador>
		<Logradouro>AVENIDA BRIGADEIRO FARIA LIMA</Logradouro>
		<Numero>2277</Numero>
		<Complemento>CONJUNTO 202</Complemento>
		<Bairro>JARDIM PAULISTANO</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>01452000</CEP>
		<Telefone1>(11) 3030-7177</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.vortxbr.com</Site>
		<Email>juridicofundos@vortx.com.br</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>-</Nome>
				<CNPJ>0</CNPJ>
				<Endereco>0</Endereco>
				<telefone>0</telefone>
			</Gestor>
			<Custodiante>
				<Nome>VÓRTX DISTRIBUIDORA DE TÍTULOS E VALORES MOBILIÁRIOS LTDA</Nome>
				<CNPJ>22.610.500/0001-88</CNPJ>
				<Endereco>Avenida Brigadeiro Faria Lima, 2.277, 2ºandar, conjunto 202, Jardim Paulistano
CEP 01452-000 - São Paulo - SP</Endereco>
				<telefone>(11) 3030-7177</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>RSM</Nome>
				<CNPJ>16.549.480/0001-84</CNPJ>
				<Endereco>R. do Rocio, 350 - 4º andar</Endereco>
				<telefone>(11) 2348-1000</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>VITACON P AS</Nome>
						<Objetivos>.</Objetivos>
						<MontantesInvestidos>4000000</MontantesInvestidos>
						<OrigemRecursos>Cotas</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Não haverá nenhum novo investimento no próximo exercício.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O fundo teve início ao final de 2018, tendo apenas adquirido os ativos alvo, sem nenhuma outra atividade ou resultado. </ResultadoFundo>
			<ConjunturaEconomica>O mercado imobiliário de São Paulo teve um ano de recuperação em 2018, com avanço dos lançamentos e das vendas, especialmente no último trimestre.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A perspectiva para 2019 é de avanço do setor, especialmente no caso de serem aprovadas as reformas da previdência e outras de forte impacto para a economia. O avanço das vendas deve favorecer a venda do estoque que compõem a carteira do fundo. </PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Laudo de Avaliação</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida Brigadeiro Faria Lima, 2277, CJ 202, São Paulo, Jardim Paulistano, SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>admfundos@vortx.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Endereço físico: Avenida Brigadeiro Faria Lima, 2277, CJ 202, São Paulo, Jardim Paulistano, SP; endereço eletrônico: admfundos@vortx.com.br</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>A convocacao da Assembleia geral de cotista deve ser feita(i) com pelo menos trinta dias de antecedencia da datada divulgacao do edital de convocacao, no casoda Assembleia  geral de cotista ordianeria; e(ii) com pelo menos 15 dias de antecendencia da data do edital de convocacao, no casoda Assembleia Geral de cotisa extraordinario.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>A Assembleia Geral de Cotistas será instalada com a presença de pelo menos 01 (um) Cotista, sendo que as deliberações poderão ser realizadas mediante processo de consulta formal, sem a necessidade de reunião presencial de cotistas, por meio de correspondência escrita ou eletrônica (e-mail), a ser realizado pelo Administrador junto a cada Cotista do Fundo, desde que observadas as formalidades previstas nos artigos 19, 19-A e 41, inciso I da Instrução CVM nº 472/08. Da consulta deverão constar todos os elementos informativos necessários ao exercício do direito de voto. Cada Cota corresponderá ao direito de 01 (um) voto na Assembleia Geral de Cotistas.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O fundo pagara ao Administrador, pela prestacao de servicos a remuneracao equivalente a 0,30 % (trinta por cento) ao ano, a razao de 1/252, aplicadosobre o valor do Patrimonio Liquido diario do Fundo, observado o valor minimo mensal de R$ 15.000(quinze milreais). O valor minimo cobrado pelo fundo no 12 (decimo segundo) mes de atividade, sera corrigido anualmente pela variacao positiva do IGP-M ou por outro indice que vier a substitui-lo nos termos da Lei.</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>Edilberto Pereira</Nome>
				<Idade>52</Idade>
				<CPF>536.217.199-20</CPF>
				<Email>ep@vortx.com.br</Email>
				<Profissao>Agronomo</Profissao>
				<FormacaoAcademica>Superior Completo</FormacaoAcademica>
				<DataInicioFuncao>2015-05-14</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Vórtx DTVM</NomeEmpresa>
						<Periodo>2016 até a presente data</Periodo>
						<CargoFuncoes>Administrador de Carteira de Valores 
Mobiliários</CargoFuncoes>
						<AtividadePrincipalEmpresa>Distribuidora de Títulos e Valores Mobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Banco Petra S.A.</NomeEmpresa>
						<Periodo>2009 a 2015</Periodo>
						<CargoFuncoes>Vice Presidente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Responsável pela estruturação e implantação da 
instituição das áreas de suporte</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="4120" percDetidoRelTotal="1" percDetidoPF="1"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>Todos os atos ou fatos relevantes do Fundo serão divulgados na página do Fundo, www.vortx.com.br e no sistema FundosNet da B3 S.A.- Brasil, Bolsa e Balcão (˜B3˜) e da CVM.</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>As cotas do Fundo são negociadas apenas na B3.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>Não possui informação apresentada.</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Não possui informação apresentada.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Não possui informação apresentada.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"