"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIARIO CJ - FII</NomeFundo>
		<CNPJFundo>23582914000103</CNPJFundo>
		<DataFuncionamento>2016-01-21</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN xsi:nil="true"/>
		<QtdCotasEmitidas>31800000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Híbrido</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>BRKB DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS S.A.</NomeAdministrador>
		<CNPJAdministrador>23582914000103</CNPJAdministrador>
		<Logradouro>RUA LAURO MULLER</Logradouro>
		<Numero>116</Numero>
		<Complemento>SL 2101 A 2108</Complemento>
		<Bairro>BOTAFOGO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22290-160</CEP>
		<Telefone1>(21) 37257708</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>WWW.BRKBDTVM.COM.BR</Site>
		<Email>JOLIVEIRA@BROOKFIELDBR.COM</Email>
		<Competencia>1/2017</Competencia>
		<DataEncerTrimestre>2017-03-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Emprendimento Cidade Jardim</Nome>
								<Endereco>Avenida Cidade Jardim, 803, Itaim Bibi, São Paulo/SP</Endereco>
								<Area>7458.14</Area>
								<NumUnidades>10</NumUnidades>
								<OutrasCaractRelevantes>. Foi emitido um Certificado de Recebíveis Imobiliários ("CRI"), 133ª Série da 1ª emissão da RB Capital Companhia de Securitização, adquirido em sua totalidade pelo quotista exclusivo do FII, denominado BR7 Fundo de Investimento Multimercado Crédito Privado (FIM). Em garantia dos pagamentos deste CRI, foi outorgado alienação fiduciária do imóvel em favor do vendedor do imóvel na escritura de compra e venda.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>1</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Financeiro</SetorAtuacao><PercentReceitaImovel>0.8</PercentReceitaImovel><PercentReceitasFII>0.8</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.2</PercentReceitaImovel><PercentReceitasFII>0.2</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses/>
							<TresAteSeisMeses/>
							<SeisAteNoveMeses/>
							<NoveAteDozeMeses/>
							<DozeAteQuinzeMeses/>
							<QuinzeAteDezoitoMeses/>
							<DezoitoAteVinteUmMeses/>
							<VinteUmAteVinteQuatroMeses/>
							<VinteQuatroAteVinteSeteMeses/>
							<VinteSeteAteTrintaMeses/>
							<TrintaAteTrintaTresMeses/>
							<TrintaTresAteTrintaSeisMeses/>
							<AcimaTrintaSeisMeses percentReceitaImovel="1" percentReceitasFII="1"/>
							<PrazoIndeterminado/>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0.602659" percentReceitasFII="0.602659"/>
							<INPC/>
							<IPCA/>
							<INCC/>
							<OutrosIndicadores>
								<Indicador nome="IPC-FIPE" percentReceitaImovel="0.397341" percentReceitasFII="0.397341"/>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Prazo de locação de 60 meses, reajustado anualmente pela variação positiva do IGPM e IPC-FIPE. O contrato de locação deve ser cumprido integralmente, sob penas de pagamento de indenização e multa por desistência da locação ou por rescisão, ou resiliçao antecipada. Para grande parte dos locatários, a garantia é obtida através de carta fiança ou depósito caução ou depósito antecipado.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>A locadora contratará seguro para o imóvel, considerando seu valor real e este custo será reembolsado pela locatária. Tal seguro inclui as dependências e instalações comuns, elevadores, ar condicionado, ou outros equipamentos, contemplando Riscos Operacionais e Responsabilidade Civil.</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>4828.1</Disponibilidades>
				<TitulosPublicos>958816.91</TitulosPublicos>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa xsi:nil="true"/>
			</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="3125020.6" financeiro="3075780.61"/>
					<DespManutencaoConservacao/>
					<ReceitasVenda/>
					<CustoPropriedadesVendidas/>
					<AjusteValor contabil="10936767.29"/>
					<OutrasRecOuDesp contabil="-10698.74"/>
					<ResultadoLiquido contabil="14051089.15" financeiro="3075780.61"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros/>
					<AjusteValor contabil="-3518544.12"/>
					<ResultadoVenda/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="-3518544.12" financeiro="0"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="10532545.03" financeiro="3075780.61"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="46948.19" financeiro="38400.72"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes/>
				<ResultadoLiquido contabil="46948.19" financeiro="38400.72"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos contabil="0" financeiro="0"/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-33043.32" financeiro="-120308.73"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada/>
				<EmpresaEspecializada/>
				<FormadorMercado/>
				<CustodiaTitulosValores contabil="-23049.48" financeiro="-23049.48"/>
				<AuditoriaIndependente/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-12550.68" financeiro="-9913.67"/>
				<ComissoesEmolumentos/>
				<HonorariosDespesasDefesas/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes financeiro="-7012"/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio/>
				<OutrasRecOuDesp contabil="-37183.8" financeiro="-30370.59"/>
				<Total contabil="-105827.28" financeiro="-190654.47"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="10473665.94" financeiro="2923526.86"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>2923526.86</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>2777350.517</PercentResultFinanLiqAcumulado>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<RendimentosDeclarados>2777350.517</RendimentosDeclarados>
			<RendimentosPagosAntec>-2023926.9</RendimentosPagosAntec>
			<RendimentoPagar>753423.617</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.95</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"