"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>KINEA RENDA IMOBILIARIA FII</NomeFundo>
		<CNPJFundo>12005956000165</CNPJFundo>
		<DataFuncionamento>2010-08-11</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRKNRICTF007</CodigoISIN>
		<QtdCotasEmitidas>17932090</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Híbrido</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>30/06</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>INTRAG DISTR DE TITULOS E VALORES MOBILIARIOS LTDA</NomeAdministrador>
		<CNPJAdministrador>12005956000165</CNPJAdministrador>
		<Logradouro>AV BRIGADEIRO FARIA LIMA</Logradouro>
		<Numero>3400</Numero>
		<Complemento>10º andar</Complemento>
		<Bairro>ITAIM BIBI</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04538-132</CEP>
		<Telefone1>55-(11)30726012</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.intrag.com.br</Site>
		<Email>relacionamento.intrag@itau-unibanco.com.br</Email>
		<Competencia>01/2019</Competencia>
		<DataEncerTrimestre>2019-03-29</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Edifício Lagoa Corporate</Nome>
								<Endereco>Rua Humaitá, 275, Humaitá, Rio de Janeiro - RJ</Endereco>
								<Area>11686.75</Area>
								<NumUnidades>26</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo</OutrasCaractRelevantes>
								<PercentVacancia>0.0367442955645919</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.095661</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.72244</PercentReceitaImovel><PercentReceitasFII>0.069109</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Botafogo Trade Center</Nome>
								<Endereco>Rua Voluntários da Pátria, 113, Botafogo, Rio de Janeiro - RJ</Endereco>
								<Area>8083</Area>
								<NumUnidades>13</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo</OutrasCaractRelevantes>
								<PercentVacancia>0.006228</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.045573</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.746813</PercentReceitaImovel><PercentReceitasFII>0.034034</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Buenos Aires Corporate</Nome>
								<Endereco>Rua Buenos Aires, 15, Centro, Rio de Janeiro - RJ</Endereco>
								<Area>6876.26</Area>
								<NumUnidades>11</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo</OutrasCaractRelevantes>
								<PercentVacancia>0.026158</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.013796</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.842926</PercentReceitaImovel><PercentReceitasFII>0.011629</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CD Santa Cruz</Nome>
								<Endereco>Estrada da Lama Preta, 2.805, Santa Cruz, Rio de Janeiro - RJ</Endereco>
								<Area>64860.17</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo (Centro de distribuição )

</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.105028</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.105028</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Edifício Madison</Nome>
								<Endereco>Rua Gomes de Carvalho, 1.195, Vila Olimpia, São Paulo - SP</Endereco>
								<Area>8431.64</Area>
								<NumUnidades>13</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.03516</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.551148</PercentReceitaImovel><PercentReceitasFII>0.019378</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Indústria</SetorAtuacao><PercentReceitaImovel>0.136077</PercentReceitaImovel><PercentReceitasFII>0.004784</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Edifício Bela Paulista</Nome>
								<Endereco>Avenida Paulista, 2.421, Bela Vista, São Paulo - SP</Endereco>
								<Area>6520.56</Area>
								<NumUnidades>14</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.037652</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.803551</PercentReceitaImovel><PercentReceitasFII>0.030255</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Edifício Athenas</Nome>
								<Endereco>Rua Dr. Fernandes Coelho, 64, Pinheiros, São Paulo - SP</Endereco>
								<Area>6229.6</Area>
								<NumUnidades>25</NumUnidades>
								<OutrasCaractRelevantes>Proprietário de 25 conjuntos</OutrasCaractRelevantes>
								<PercentVacancia>0.001199</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.031228</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.566104</PercentReceitaImovel><PercentReceitasFII>0.017678</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Indústria</SetorAtuacao><PercentReceitaImovel>0.145994</PercentReceitaImovel><PercentReceitasFII>0.004559</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Edifício Joaquim Floriano</Nome>
								<Endereco>Rua Joaquim Floriano, 913, Itaim Bibi, São Paulo - SP</Endereco>
								<Area>3196.63</Area>
								<NumUnidades>13</NumUnidades>
								<OutrasCaractRelevantes>Proprietário de 13 conjuntos</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0.15818</PercentInadimplencia>
								<PercentReceitasFII>0.018927</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.594475</PercentReceitaImovel><PercentReceitasFII>0.011252</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Indústria</SetorAtuacao><PercentReceitaImovel>0.167251</PercentReceitaImovel><PercentReceitasFII>0.003166</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CD Bandeirantes</Nome>
								<Endereco>Rodovia dos Bandeirantes, km 69, Louveira - SP</Endereco>
								<Area>99278.63</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Proprietário de 76,7% do ativo (Centro de distribuição)</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.125508</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.125507</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CD Mogi das Cruzes</Nome>
								<Endereco>Rodovia Mogi-Dutra (SP-088), 11.100 (km 41,4), Mogi das Cruzes - SP</Endereco>
								<Area>69113.25</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo (Centro de distribuição )</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.091587</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Indústria</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.091587</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Jundiaí Industrial Park</Nome>
								<Endereco>Rodovia Vice Prefeito Hermenegildo Tonolli, km 2, Jundiaí - SP</Endereco>
								<Area>75975.6</Area>
								<NumUnidades>2</NumUnidades>
								<OutrasCaractRelevantes>Proprietário de 90% do ativo (Centro de distribuição)</OutrasCaractRelevantes>
								<PercentVacancia>0.012952</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.065681</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.398825</PercentReceitaImovel><PercentReceitasFII>0.026195</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>0.601175</PercentReceitaImovel><PercentReceitasFII>0.039486</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Global Jundiaí</Nome>
								<Endereco>Avenida Caminho de Goiás, 100, Rodovia Anhanguera, km 66, Jundiaí - SP</Endereco>
								<Area>41468.12</Area>
								<NumUnidades>31</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo (Centro de distribuição )</OutrasCaractRelevantes>
								<PercentVacancia>0.008186</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.037452</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.234107</PercentReceitaImovel><PercentReceitasFII>0.008768</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Indústria</SetorAtuacao><PercentReceitaImovel>0.732262</PercentReceitaImovel><PercentReceitasFII>0.027425</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Pib Sumaré</Nome>
								<Endereco>Avenida Parque Industrial, 580, Sumaré - SP</Endereco>
								<Area>13600</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo (Centro de distribuição )</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>-</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CD Pouso Alegre</Nome>
								<Endereco>Rodovia Fernão Dias, km 863, Algodão, Pouso Alegre - MG</Endereco>
								<Area>87750</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo (Centro de distribuição )

</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.124972</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Indústria</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.124972</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CD Itaqua</Nome>
								<Endereco>Rua do Níquel, 205, Parque Industrial, Itaquaquecetuba - SP</Endereco>
								<Area>30698</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Proprietário do ativo (Centro de distribuição )

</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.056057</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.056057</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Boulevard Corporate Tower</Nome>
								<Endereco>Avenida dos Andradas, 3000, Santa Efigênia, Belo Horizonte - MG</Endereco>
								<Area>15620.02</Area>
								<NumUnidades>52</NumUnidades>
								<OutrasCaractRelevantes>Proprietário de X conjuntos</OutrasCaractRelevantes>
								<PercentVacancia>0.002333</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.059923</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Serviços</SetorAtuacao><PercentReceitaImovel>0.78101</PercentReceitaImovel><PercentReceitasFII>0.0468</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses percentReceitaImovel="0.009756" percentReceitasFII="0.009212"/>
							<TresAteSeisMeses percentReceitaImovel="0.00292" percentReceitasFII="0.002757"/>
							<SeisAteNoveMeses percentReceitaImovel="0.015048" percentReceitasFII="0.014209"/>
							<NoveAteDozeMeses percentReceitaImovel="0.015874" percentReceitasFII="0.014988"/>
							<DozeAteQuinzeMeses percentReceitaImovel="0.004242" percentReceitasFII="0.004005"/>
							<QuinzeAteDezoitoMeses percentReceitaImovel="0.156999" percentReceitasFII="0.148239"/>
							<DezoitoAteVinteUmMeses percentReceitaImovel="0.007463" percentReceitasFII="0.007046"/>
							<VinteUmAteVinteQuatroMeses percentReceitaImovel="0.058064" percentReceitasFII="0.054824"/>
							<VinteQuatroAteVinteSeteMeses percentReceitaImovel="0.040979" percentReceitasFII="0.038693"/>
							<VinteSeteAteTrintaMeses percentReceitaImovel="0.00924" percentReceitasFII="0.008724"/>
							<TrintaAteTrintaTresMeses percentReceitaImovel="0.00833" percentReceitasFII="0.007866"/>
							<TrintaTresAteTrintaSeisMeses percentReceitaImovel="0" percentReceitasFII="0"/>
							<AcimaTrintaSeisMeses percentReceitaImovel="0.661378" percentReceitasFII="0.624476"/>
							<PrazoIndeterminado percentReceitaImovel="0.009707" percentReceitasFII="0.009166"/>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0.415627" percentReceitasFII="0.392437"/>
							<INPC percentReceitaImovel="0" percentReceitasFII="0"/>
							<IPCA percentReceitaImovel="0.584373" percentReceitasFII="0.551768"/>
							<INCC percentReceitaImovel="0" percentReceitasFII="0"/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Cláusula de reajuste padrão
Tanto para contratos típicos quanto os atípicos é previsto que o valor do aluguel será corrigido monetariamente a cada período de 12 (doze) meses contatos a partir do início do contrato, ou em período menor, caso a legislação assim o permita.
 Os reajustes previstos são de automática aplicação. Eles se referem tão somente às hipóteses de inflação, sendo que, no caso de ocorrência de deflação, o valor avençado entre as partes para o aluguel em moeda corrente nacional será mantido.
Indexadores
Atualmente só possuímos 2 índices de reajustes na carteira do Fundo Kinea Renda: IGPM  e IPCA e a definição do índice depende da negociação comercial entre as partes.
Cláusula de rescisão padrão
Para os contratos típicos de locação:
Em caso de solicitação pelo inquilino de rescisão do contrato antes do decurso de seu prazo, deverá fazê-lo respeitando o aviso prévio,quando aplicável, e também deverá  pagar a multa por rescisão antecipada, conforme o caso. O inquilino poderá optar por não cumprir o aviso prévio estabelecido devendo neste caso efetuar o pagamento do valor equivalente a aluguel e encargos do período não cumprido. Além disso, caso aplicável, deverá devolver eventuais valores referentes aos aluguéis que foram isentos ou sofreram desconto temporários de maneira integral ou proporcional. 
Os contratos estabelecem ainda que o andar deve ser devolvido da mesma forma como estava no início da locação.
Para os contratos atípicos de locação:
A cláusula de rescisão estabelece que o inquilino precisa efetuar o pagamento do saldo remanescente do contrato.
Garantias exigidas
A garantia do contrato de locação é definida em negociação comercial entre as partes. Exemplificativamente poderão ser aceitos: fiança bancária, seguro fiança, caução, fiador, entre outros.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>NA</NomeOuEndereco>
								<CaractContratuais>NA</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>O procedimento atual prevê que, sempre que comercialmente acordado, o inquilino fica responsável pela contratação dos seguros aplicáveis. O gestor do Fundo acompanha e valida referidas contratações.Para os demais casos, o Fundo realiza a contratação assessorado por corretora de seguros de primeira linha .</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
							<Imovel>
								<Nome>CD Santa Cruz</Nome>
								<Endereco>Estrada da Lama Preta, 2.805, Santa Cruz, Rio de Janeiro - RJ</Endereco>
								<Area>15554.22</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Reforma para expansão da área do galpão</OutrasCaractRelevantes>
								<PercentLocado>1</PercentLocado>
								<PercentConclusaoObras realizado="0.995" previsto="1"/>
								<CustoConstrucao realizado="18813590.6" previsto="20220486.01"/>
							</Imovel>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
							<Imovel>
								<NomeOuEndereco>CD Santa Cruz</NomeOuEndereco>
								<JustEvolucaoInferior>Obra concluída, aguardando assinatura do Termo de Entrega</JustEvolucaoInferior>
								<JustCustoSuperior>NA</JustCustoSuperior>
							</Imovel>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro>O procedimento atual prevê que o seguro de obra seja contratado diretamente pelo construtor. O gestor do Fundo acompanha e valida referidas contratações.</PoliticaContratacaoSeguro>
					</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>
					<Emissor>
						<Nome>BCO RODOBENS SA</Nome>
						<CNPJ>33603457000140</CNPJ>
						<Vencimento>2022-08-22</Vencimento>
						<Quantidade>20056</Quantidade>
						<Valor>20032901.88</Valor>
					</Emissor>
					<Emissor>
						<Nome>BCO RODOBENS SA</Nome>
						<CNPJ>33603457000140</CNPJ>
						<Vencimento>2022-09-12</Vencimento>
						<Quantidade>25000</Quantidade>
						<Valor>25077724.28</Valor>
					</Emissor>
					<Emissor>
						<Nome>BCO RODOBENS SA</Nome>
						<CNPJ>33603457000140</CNPJ>
						<Vencimento>2028-03-27</Vencimento>
						<Quantidade>45000</Quantidade>
						<Valor>45021489.18</Valor>
					</Emissor>
				</LCI>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
					<Emissor>
						<Sociedade>ITAQUAQ INVEST IMOBIL E PARTICIPACOES</Sociedade>
						<CNPJ>16657308000144</CNPJ>
						<Quantidade>7949466</Quantidade>
						<Valor>107735.42</Valor>
					</Emissor>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>227676.38</Disponibilidades>
				<TitulosPublicos>336249771.31</TitulosPublicos>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa xsi:nil="true"/>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
					<Imovel>
						<Nome>Boulevard Corporate Tower</Nome>
						<Endereco>Avenida dos Andradas, 3000, Santa Efigênia, Belo Horizonte - MG</Endereco>
						<Area>4806.16</Area>
						<NumUnidades>16</NumUnidades>
						<OutrasCaractRelevantes>NA</OutrasCaractRelevantes>
						<PercentTotalInvestido>1</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
				</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="44408061.4" financeiro="43509550.785"/>
					<DespManutencaoConservacao contabil="-130606.78" financeiro="-108356.78"/>
					<ReceitasVenda/>
					<CustoPropriedadesVendidas/>
					<AjusteValor/>
					<OutrasRecOuDesp contabil="-1425392.13" financeiro="-1506158.04"/>
					<ResultadoLiquido contabil="42852062.49" financeiro="41895035.965"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="1311906.32" financeiro="1311906.32"/>
					<AjusteValor contabil="4519.88" financeiro="0"/>
					<ResultadoVenda/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="1316426.2" financeiro="1311906.32"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="44168488.69" financeiro="43206942.285"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="1243407.13" financeiro="1243407.13"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes contabil="-66504.04" financeiro="-66504.04"/>
				<ResultadoLiquido contabil="1176903.09" financeiro="1176903.09"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos contabil="0" financeiro="0"/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-7438817.85" financeiro="-7243463.97"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada contabil="-380684.4" financeiro="-379949.87"/>
				<EmpresaEspecializada/>
				<FormadorMercado/>
				<CustodiaTitulosValores contabil="-22.89" financeiro="-22.56"/>
				<AuditoriaIndependente contabil="-16483.43" financeiro="0"/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-28506.82" financeiro="-35188.81"/>
				<ComissoesEmolumentos/>
				<HonorariosDespesasDefesas contabil="-36835.52" financeiro="-30702.52"/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio contabil="-280.34" financeiro="-207.4"/>
				<OutrasRecOuDesp contabil="-119463.37" financeiro="-6563.57"/>
				<Total contabil="-8021094.62" financeiro="-7696098.7"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="37324297.16" financeiro="36687746.675"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>36687746.68</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>34853359.346</PercentResultFinanLiqAcumulado>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil>2415225.88</LucroContabil>
			<RendimentosDeclarados>37268585.226</RendimentosDeclarados>
			<RendimentosPagosAntec>-23998751.3</RendimentosPagosAntec>
			<RendimentoPagar>13269833.926</RendimentoPagar>
			<ResultadoLiquidoDeclarado>1.015832</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"