"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>VBI ULIVING FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>31547782000107</CNPJFundo>
		<DataFuncionamento>2018-11-30</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>10000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>true</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Híbrido</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>BRL TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>31547782000107</CNPJAdministrador>
		<Logradouro>RUA IGUATEMI</Logradouro>
		<Numero>151</Numero>
		<Complemento>19  ANDAR</Complemento>
		<Bairro>ITAIM BIBI</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>01451011</CEP>
		<Telefone1>11 3133-0350</Telefone1>
		<Telefone2>11 4871-2221</Telefone2>
		<Telefone3>11 3133-0351</Telefone3>
		<Site>WWW.BRLTRUST.COM.BR</Site>
		<Email>CONTABILIDADEDEFUNDOS@BRLTRUST.COM.BR</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>VBI</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 - 19º and Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BRL TRUST DTVM S.A.</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 - 19º and Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>NA</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 - 19º and Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BRL TRUST DTVM S.A.</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 - 19º and Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</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>NA</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O resultado apurado no exercício do fundo foi prejuizo no valor de R$ 12.594 (em milhares).</ResultadoFundo>
			<ConjunturaEconomica>Em linhas gerais, o ano de 2017 foi um ano de cautela, mas ao mesmo tempo de descolamento da crise política, trazendo um crescimento reativo para o mercado imobiliário. Sinais como a contínua queda da taxa de juros, controle da inflação e a retomada, mesmo que tímida, do emprego elevam a confiança de empresas e consumidores e dão mais motivos para uma perspectiva muito mais otimista para 2018. Além disso, Estados ligados ao agronegócio estão puxando a recuperação do mercado imobiliário no Brasil desde 2017. Na média, o crédito total (para pessoa física e construtoras) com recursos da poupança recuou 7,4% no país no ano passado, na comparação com 2016, segundo a Abecip (Associação Brasileira das Entidades de Crédito Imobiliário e Poupança). Em Mato Grosso, porém, houve aumento de 10%, a maior variação registrada pela entidade. Em Mato Grosso do Sul, que teve o segundo melhor desempenho, o crescimento foi de 4%, seguido pelo Tocantins (3%). Como comparação, o financiamento imobiliário de São Paulo, o principal mercado do país, caiu 6% em 2017. No Rio, a queda foi de 3%. O financiamento à construção caiu quase 14% no Brasil em 2017. No Tocantins, no entanto, ele disparou 253%. A safra recorde de 237,7 milhões de toneladas de grãos no país entre 2016 e 2017, segundo estimativa de janeiro da Conab (Companhia Nacional de Abastecimento), ajudou a elevar o ânimo das construtoras que atuam nas regiões de influência do agronegócio, impulsionando a desova de lançamentos.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A recuperação econômica deve dar forças ao mercado imobiliário, fazendo com que os preços voltem a subir em 2018, mas as incertezas econômicas e políticas potencializadas pelo ano eleitoral pode colocar obstáculos no caminho. O investimento imobiliário está entre os favoritos do brasileiro por tradição. A chegada de 2018, somando mínima histórica da taxa básica de juros (Selic) e a potencial recuperação do mercado de imóveis, promete nova confirmação dessa preferência, principalmente à medida que a rentabilidade da renda fixa sai prejudicada. Mas comprar casas e terrenos não é a única - tampouco a mais vantajosa - forma de lucrar nesse mercado. Para especialistas, as melhores escolhas estão, cada vez mais, em fundos de investimento imobiliários (FIIs), que normalmente investem em imóveis comerciais de grande porte.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Imóveis</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>8848095.62</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os investimentos foram avaliados conforme laudo de avaliação efetuado por consultor independente contratado pelo administrador.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Iguatemi nº 151 19º andar Bairro Itaim Bibi Cidade de São Paulo Estado de São Paulo</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>WWW.BRLTRUST.COM.BR</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>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.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>A convocação da Assembleia Geral de Cotistas deve ser feita com pelo menos 30 (trinta) dias de antecedência no caso de Assembleias Gerais Ordinárias e com pelo menos 15 (quinze) dias de antecedência no caso de Assembleias Gerais  30 Extraordinárias, contado o prazo da data de comprovação de recebimento da convocação pelos Cotistas. </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>Pela administração do Fundo, nela compreendida as atividades de administração do Fundo, gestão dos Outros Ativos, tesouraria, controle e processamento dos títulos e valores mobiliários integrantes de sua carteira e escrituração da emissão de suas Cotas, o Fundo pagará ao Administrador uma Taxa de Administração, equivalente a 0,20% (vinte centésimos por cento) ao ano, calculada e provisionada todo Dia Útil à base de 1/252 (um inteiro e duzentos e cinquenta e dois avos), observado o valor mínimo mensal de R$ 30.000,00 (trinta mil reais), com vencimento da primeira parcela, tão somente quando da integralização de Cotas do Fundo, valor este que será atualizado anualmente, a partir de 1º de julho de 2014, pela variação positiva do IGP-M (Índice Geral de Preços de Mercado) apurado e divulgado pela Fundação Getúlio Vargas – FGV.</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>Danilo Christófaro Barbieri</Nome>
				<Idade>38</Idade>
				<CPF>28729710847</CPF>
				<Email>dbarbieri@brltrust.com.br</Email>
				<Profissao>Administrador de empresas</Profissao>
				<FormacaoAcademica>Administração de empresas</FormacaoAcademica>
				<DataInicioFuncao>2018-04-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>BRL TRUST DTVM S.A</NomeEmpresa>
						<Periodo>Desde 01/04/2016</Periodo>
						<CargoFuncoes>Sócio-Diretor</CargoFuncoes>
						<AtividadePrincipalEmpresa>Administrador fiduciário</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>BANCO SANTANDER BRASIL S.A</NomeEmpresa>
						<Periodo>de 1999 até 03/2016</Periodo>
						<CargoFuncoes>Superindentente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Country Head da Santander Securities Services</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="10000" percDetidoRelTotal="1" percDetidoPJ="1"/>
		</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>
"