"<?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 JK D - FII</NomeFundo>
		<CNPJFundo>23533796000143</CNPJFundo>
		<DataFuncionamento>2015-12-01</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN xsi:nil="true"/>
		<QtdCotasEmitidas>64451924.81</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>23533796000143</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>4/2017</Competencia>
		<DataEncerTrimestre>2017-12-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>WTORRE JK - TORRE D</Nome>
								<Endereco>Avenida Juscelino Kubitscheck, 2041, Vila Olímpia, São Paulo/SP</Endereco>
								<Area>12206.88</Area>
								<NumUnidades>18</NumUnidades>
								<OutrasCaractRelevantes>. A Sibenik Empreendimentos e Participações S.A possui a nua propriedade do imóvel. O Fundo de Investimento Imobiliário JKD (FII) possui o usufruto de tal imóvel.
. Foi emitido um Certificado de Recebíveis Imobiliários ("CRI"), 131ª 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, a Sibenik outorgou alienação fiduciária da nua propriedade do imóvel em favor do vendedor do imóvel na escritura de compra e venda.</OutrasCaractRelevantes>
								<PercentVacancia>0.111111</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>1</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.875</PercentReceitaImovel><PercentReceitasFII>0.875</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Financeiro</SetorAtuacao><PercentReceitaImovel>0.125</PercentReceitaImovel><PercentReceitasFII>0.125</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="1" percentReceitasFII="1"/>
							<INPC/>
							<IPCA/>
							<INCC/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Prazo de locação de 60 e 120 meses, reajustado anualmente pela variação positiva do IGPM. 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, carta garantia, fiador ou depósito caução.</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>
					<Emissor>
						<Sociedade>Sibenik Empreendimentos e Participações S.A. </Sociedade>
						<CNPJ>23104709000132</CNPJ>
						<Quantidade>21000499</Quantidade>
						<Valor>17204342.84</Valor>
					</Emissor>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>6547</Disponibilidades>
				<TitulosPublicos>1321906.82</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="2285266.87" financeiro="2841226.07"/>
					<DespManutencaoConservacao contabil="-192062.09" financeiro="-222792.09"/>
					<ReceitasVenda contabil="0" financeiro="0"/>
					<CustoPropriedadesVendidas contabil="0" financeiro="0"/>
					<AjusteValor contabil="6658264.83" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="-3985790.44"/>
					<ResultadoLiquido contabil="8751469.61" financeiro="-1367356.46"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros/>
					<AjusteValor contabil="-3075291.89"/>
					<ResultadoVenda/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="-3075291.89" financeiro="0"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="5676177.72" financeiro="-1367356.46"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="12828.44" financeiro="56814.07"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes/>
				<ResultadoLiquido contabil="12828.44" financeiro="56814.07"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos contabil="0" financeiro="0"/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-34360.72" financeiro="-34360.72"/>
				<TaxaDesempenho contabil="0" financeiro="0"/>
				<ConsultoriaEspecializada contabil="0" financeiro="0"/>
				<EmpresaEspecializada contabil="0" financeiro="0"/>
				<FormadorMercado contabil="0" financeiro="0"/>
				<CustodiaTitulosValores contabil="-23049.48" financeiro="-23049.48"/>
				<AuditoriaIndependente contabil="-43504.78" financeiro="-21752.77"/>
				<RepresentantesCotistas contabil="0" financeiro="0"/>
				<TaxasImpostosContribuicoes contabil="-12938.41" financeiro="-12938.41"/>
				<ComissoesEmolumentos contabil="0" financeiro="0"/>
				<HonorariosDespesasDefesas contabil="-80695" financeiro="-695"/>
				<GastosContratosSeguros contabil="0" financeiro="0"/>
				<DespesasAvaliacoes contabil="-12083.34" financeiro="0"/>
				<TaxasIngressoSaidaFundos contabil="0" financeiro="0"/>
				<DespesasRegistroCartorio contabil="0" financeiro="0"/>
				<OutrasRecOuDesp contabil="-151773.19" financeiro="-669118.35"/>
				<Total contabil="-358404.92" financeiro="-761914.73"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="5330601.24" financeiro="-2072457.12"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>-1303740.81</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>0</PercentResultFinanLiqAcumulado>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<RendimentosDeclarados>0</RendimentosDeclarados>
			<RendimentosPagosAntec>0</RendimentosPagosAntec>
			<RendimentoPagar>0</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"