"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>VINCI RENDA IMOBILIÁRIA FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>17554274000125</CNPJFundo>
		<DataFuncionamento>2014-03-10</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN xsi:nil="true"/>
		<QtdCotasEmitidas>65177.043906</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>true</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>30/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>true</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BRL TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>17554274000125</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>CONTROLADORIA@BRLTRUST.COM.BR</Email>
		<Competencia>04/2016</Competencia>
		<DataEncerTrimestre>2016-12-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>West Shopping</Nome>
								<Endereco>Estrada do Mendanha, 450 / 550 e 555 – Rio de Janeiro – RJ.</Endereco>
								<Area>41357</Area>
								<NumUnidades>173</NumUnidades>
								<OutrasCaractRelevantes>Inaugurado em 25 de setembro de 1997, com mais de 40.000 m² de área bruta colável, o West Shopping é um centro de convívio vibrante que oferece as melhores opções de lazer, compras e serviços. O centro comercial conta com dois edifícios de compras e um edifício garagem, totalizando 1.356 vagas de estacionamento coberto. </OutrasCaractRelevantes>
								<PercentVacancia>0.0423</PercentVacancia>
								<PercentInadimplencia>0.061</PercentInadimplencia>
								<PercentReceitasFII>0.0075</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Loja de Departamento</SetorAtuacao><PercentReceitaImovel>0.2287</PercentReceitaImovel><PercentReceitasFII>0.0282</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao> Vestuário</SetorAtuacao><PercentReceitaImovel>0.1988</PercentReceitaImovel><PercentReceitasFII>0.0245</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos diversos</SetorAtuacao><PercentReceitaImovel>0.14</PercentReceitaImovel><PercentReceitasFII>0.0173</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.1114</PercentReceitaImovel><PercentReceitasFII>0.0137</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Crystal</Nome>
								<Endereco>Rua Comendador Araujo, 731 - Curitiba - PR.</Endereco>
								<Area>14181</Area>
								<NumUnidades>103</NumUnidades>
								<OutrasCaractRelevantes>Inaugurado em novembro de 1996, o Shopping Crystal se tornou um local icônico por seu estilo e também pela localização privilegiada, no ponto central do bairro Batel. Passou por um processo de revitalização que modernizou a fachada, o Valet e a praça de alimentação. Com o conceito "boutique", possui um seleto mix de marcas, com 136 lojas distribuídas entre os quatro pisos e nas garagens. A praça de alimentação, no piso L3, oferece 11 opções gastronômicas diferentes e tem capacidade para 456 pessoas sentadas. Além de lojas, o piso L1 conta também com um restaurante, um café, uma farmácia e uma brigaderia gourmet. Há lojas do mercado nacional e internacional. O shopping oferece ambulatório, fraldário, conserto de roupas, molduras, pet shop e cinco salas de cinema do Espaço Itaú de Cinema</OutrasCaractRelevantes>
								<PercentVacancia>0.107</PercentVacancia>
								<PercentInadimplencia>0.001</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.217</PercentReceitaImovel><PercentReceitasFII>0.0145</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.134</PercentReceitaImovel><PercentReceitasFII>0.0089</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Jóias</SetorAtuacao><PercentReceitaImovel>0.11</PercentReceitaImovel><PercentReceitasFII>0.0073</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.106</PercentReceitaImovel><PercentReceitasFII>0.0071</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Center Shopping Rio</Nome>
								<Endereco>Avenida Geremario Dantas, 404 - Rio de Janeiro - RJ.</Endereco>
								<Area>15156</Area>
								<NumUnidades>113</NumUnidades>
								<OutrasCaractRelevantes>Inaugurou em 26 de abril de 2001, o maior e mais completo shopping de Jacarepaguá: o CENTER SHOPPING RIO, conta com 2 lojas âncoras (Lojas Americanas e Leader Magazine), 4 megalojas (Casas Bahia, Casa &amp; Vídeo, Centauro e Academia Fórmula) e uma praça de alimentação diversificada. Para o seu lazer, contamos com 4 salas de cinema e o espaço infantil Tempo de Recreio</OutrasCaractRelevantes>
								<PercentVacancia>0.0813</PercentVacancia>
								<PercentInadimplencia>0.0739</PercentInadimplencia>
								<PercentReceitasFII>0.0038</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.1755</PercentReceitaImovel><PercentReceitasFII>0.0089</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos diversos</SetorAtuacao><PercentReceitaImovel>0.1226</PercentReceitaImovel><PercentReceitasFII>0.0062</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.1304</PercentReceitaImovel><PercentReceitasFII>0.0066</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Conveniencia e serviços</SetorAtuacao><PercentReceitaImovel>0.3331</PercentReceitaImovel><PercentReceitasFII>0.0169</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>    Lojas de Departamento</SetorAtuacao><PercentReceitaImovel>0.117</PercentReceitaImovel><PercentReceitasFII>0.0059</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Shopping Paralela</Nome>
								<Endereco>Avenida Luiz Viana, 8544 - Salvador - BA.</Endereco>
								<Area>40253</Area>
								<NumUnidades>275</NumUnidades>
								<OutrasCaractRelevantes>Inaugurado em abril de 2009, o Shopping Paralela é um símbolo do novo vetor de expansão de Salvador: a Avenida Paralela. Oferece um mix de lojas diversificado, um moderno complexo de cinemas e uma variedade de restaurantes e fast-foods.</OutrasCaractRelevantes>
								<PercentVacancia>0.0604</PercentVacancia>
								<PercentInadimplencia>0.1429</PercentInadimplencia>
								<PercentReceitasFII>0.0222</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.134</PercentReceitaImovel><PercentReceitasFII>0.0208</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.133</PercentReceitaImovel><PercentReceitasFII>0.0207</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.129</PercentReceitaImovel><PercentReceitasFII>0.02</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Artigos do Lar</SetorAtuacao><PercentReceitaImovel>0.117</PercentReceitaImovel><PercentReceitasFII>0.0182</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Imóvel Ilha Plaza Shopping Center </Nome>
								<Endereco>Av. Maestro Paulo e Silva, 400 - Rio de Janeiro - RJ.</Endereco>
								<Area>21598</Area>
								<NumUnidades>127</NumUnidades>
								<OutrasCaractRelevantes>Inaugurado em 28 de Abril de 1992, o Ilha Plaza é o único shopping da Ilha do Governador, bairro onde se localiza o aeroporto internacional do Rio de Janeiro, e foi responsável pela mudança dos hábitos de consumo e lazer da região</OutrasCaractRelevantes>
								<PercentVacancia>0.025</PercentVacancia>
								<PercentInadimplencia>0.102</PercentInadimplencia>
								<PercentReceitasFII>0.0455</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Loja de Departamento</SetorAtuacao><PercentReceitaImovel>0.1896</PercentReceitaImovel><PercentReceitasFII>0.0846</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao> Vestuário</SetorAtuacao><PercentReceitaImovel>0.1687</PercentReceitaImovel><PercentReceitasFII>0.0752</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.1204</PercentReceitaImovel><PercentReceitasFII>0.0537</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Imóvel Shopping Belém </Nome>
								<Endereco>Trav. Padre Eutíquio, 1078 – Belém - PA.</Endereco>
								<Area>38075</Area>
								<NumUnidades>189</NumUnidades>
								<OutrasCaractRelevantes>O imóvel localiza-se na Travessa Padre Eutíquio, 1078, Batista Campos - cidade Belém, Estado do Pará. Inaugurado em 27 de Outubro de 1993, o Pátio Belém foi o primeiro shopping da cidade de Belém, localizado no bairro de Batista Campos, no centro da cidade. O shopping é bem atendido por transporte público e facilmente acessado por automóveis. Sua localização estratégica, na região de maior comércio da cidade, faz com que o fluxo de pessoas no shopping seja bastante elevado, atingindo uma média de 1,3 milhão de pessoas por mês</OutrasCaractRelevantes>
								<PercentVacancia>0.0155</PercentVacancia>
								<PercentInadimplencia>0.1061</PercentInadimplencia>
								<PercentReceitasFII>0.0168</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Vestuário</SetorAtuacao><PercentReceitaImovel>0.2553</PercentReceitaImovel><PercentReceitasFII>0.0404</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Calçados</SetorAtuacao><PercentReceitaImovel>0.1028</PercentReceitaImovel><PercentReceitasFII>0.0162</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.1043</PercentReceitaImovel><PercentReceitasFII>0.0165</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.1064</PercentReceitaImovel><PercentReceitasFII>0.0168</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses percentReceitaImovel="0.0455" percentReceitasFII="0.0455"/>
							<TresAteSeisMeses percentReceitaImovel="0.0614" percentReceitasFII="0.0614"/>
							<SeisAteNoveMeses percentReceitaImovel="0.035" percentReceitasFII="0.035"/>
							<NoveAteDozeMeses percentReceitaImovel="0.0408" percentReceitasFII="0.0408"/>
							<DozeAteQuinzeMeses percentReceitaImovel="0.0395" percentReceitasFII="0.0395"/>
							<QuinzeAteDezoitoMeses percentReceitaImovel="0.0278" percentReceitasFII="0.0278"/>
							<DezoitoAteVinteUmMeses percentReceitaImovel="0.0474" percentReceitasFII="0.0474"/>
							<VinteUmAteVinteQuatroMeses percentReceitaImovel="0.0289" percentReceitasFII="0.0289"/>
							<VinteQuatroAteVinteSeteMeses percentReceitaImovel="0.03393" percentReceitasFII="0.03393"/>
							<VinteSeteAteTrintaMeses percentReceitaImovel="0.03166" percentReceitasFII="0.03166"/>
							<TrintaAteTrintaTresMeses percentReceitaImovel="0.0479" percentReceitasFII="0.0479"/>
							<TrintaTresAteTrintaSeisMeses percentReceitaImovel="0.0303" percentReceitasFII="0.0303"/>
							<AcimaTrintaSeisMeses percentReceitaImovel="0.3427" percentReceitasFII="0.3427"/>
							<PrazoIndeterminado percentReceitaImovel="0.1852" percentReceitasFII="0.1852"/>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0.5314" percentReceitasFII="0.5314"/>
							<INPC percentReceitaImovel="0" percentReceitasFII="0"/>
							<IPCA percentReceitaImovel="0.0109" percentReceitasFII="0.0109"/>
							<INCC percentReceitaImovel="0" percentReceitasFII="0"/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Emissão CCI dos recebíveis dos imóveis a serem pagar em 162 parcelas mensais e sucessiveis, após a carência, nos valores descritos  no Compromisso de Venda e Compra, com juros efetivos de 9,85 a.a. e atualização monetária mensal pela TR.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>Contratos comerciais</NomeOuEndereco>
								<CaractContratuais>Contrato de locação comercial.</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>Cabe ao locatário a contratação do seguro.</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
				</FII>
				<CRI>
				</CRI>
				<LCI>
				</LCI>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>12575.64</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados>2721180.48</TitulosPrivados>
				<FundosRendaFixa>10437749.37</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda/>
					<CustoImovEstoque/>
					<AjusteValor/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="9914058.48" financeiro="9914058.48"/>
					<DespManutencaoConservacao contabil="-68245.3" financeiro="-68245.3"/>
					<ReceitasVenda/>
					<CustoPropriedadesVendidas/>
					<AjusteValor contabil="10596187.41"/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="20442000.59" financeiro="9845813.18"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros/>
					<AjusteValor/>
					<ResultadoVenda/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="20442000.59" financeiro="9845813.18"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="717177.85"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes/>
				<ResultadoLiquido contabil="717177.85" financeiro="0"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-545307.36" financeiro="-533797.14"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada contabil="-67163.97" financeiro="-67163.97"/>
				<EmpresaEspecializada/>
				<FormadorMercado/>
				<CustodiaTitulosValores contabil="-28197.01" financeiro="-28197.01"/>
				<AuditoriaIndependente/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-81612.44" financeiro="-79067.89"/>
				<ComissoesEmolumentos/>
				<HonorariosDespesasDefesas/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio contabil="-540.98" financeiro="-540.98"/>
				<OutrasRecOuDesp contabil="-13066630.32" financeiro="-4186647.62"/>
				<Total contabil="-13789452.08" financeiro="-4895414.61"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="7369726.36" financeiro="4950398.57"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>4950398.57</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>4702878.6415</PercentResultFinanLiqAcumulado>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil>0</LucroContabil>
			<RendimentosDeclarados>4702878.6415</RendimentosDeclarados>
			<RendimentosPagosAntec>0</RendimentosPagosAntec>
			<RendimentoPagar>4702878.6415</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.95</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"