"<?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>13797000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<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 TÍTULOS E VALORES MOBILIÁRIOS 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 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.intrag.com.br</Site>
		<Email>produtosestruturados@itau-unibanco.com.br</Email>
		<Competencia>2017-02-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>KINEA INVESTIMENTOS LTDA</Nome>
				<CNPJ>8604187000144</CNPJ>
				<Endereco>Rua Minas de Prata, 30 - São Paulo, SP</Endereco>
				<telefone>(11) 3073-8700</telefone>
			</Gestor>
			<Custodiante>
				<Nome>ITAÚ UNIBANCO S.A.</Nome>
				<CNPJ>60701190000104</CNPJ>
				<Endereco>Praça Alfredo Egydio de Souza Aranha, nº 100 - São Paulo, SP </Endereco>
				<telefone>(11) 3072-6266</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>PRICEWATERHOUSECOOPERS AUDITORES INDEPENDENTES</Nome>
				<CNPJ>61562112000120</CNPJ>
				<Endereco>Av. Francisco Matarazzo, 1400 - São Paulo, SP</Endereco>
				<telefone>(11) 3674-2000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>BANCO FATOR</Nome>
				<CNPJ>61344196000106</CNPJ>
				<Endereco>Rua Dr. Renato Paes de Barros, 1.017 – 11º e 12º andares - São Paulo, SP</Endereco>
				<telefone>(11) 3049-9100</telefone>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>ITAÚ UNIBANCO S.A.</Nome>
				<CNPJ>60701190000104</CNPJ>
				<Endereco>Av. Brigadeiro Faria Lima, nº 3.500 - São Paulo, SP</Endereco>
				<telefone>(11) 3073 3250</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>Os eventuais recursos a serem captados na 5ª emissão de cotas aprovada em Assembléia realizada em 28/03/2017, serão utilizados, prioritariamente, para a amortização antecipada de determinadas emissões de certificados de recebíveis imobiliários lastreadas em créditos imobiliários decorrentes de determinados ativos imobiliários de titularidade do Fundo, sendo que os eventuais recursos remanescentes serão utilizados em conformidade com o Regulamento do Fundo.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Os resultados apresentados pelo Fundo estão em linha com a nossa expectativa levando em conta a conjuntura econômica nacional bem como o momento do setor imobiliário descrito no item 4.2</ResultadoFundo>
			<ConjunturaEconomica>Após alguns anos de um mercado mais desafiador, a melhoria dos parâmetros macroeconômicos aliada à redução das taxas de juros, indica a retomada do mercado imobiliário para os próximos anos com consequente impacto positivos nos indicadores de mercado. 

Além de concentrarem a maior população e atividade econômica, as cidades de São Paulo e do Rio de Janeiro são os maiores mercados imobiliários do Brasil, com aproximadamente 15 milhões e 8,8 milhões de m² de ABL respectivamente, se considerarmos o estoque classe A+, A, B, e C de escritórios de todas as  regiões e de 7,5 milhões e 1,5 milhões de m² de ABL se considerarmos o mercado de logística no estado de São Paulo e Rio de Janeiro respectivamente. 

O mercado de escritórios da cidade de São Paulo atingiu valores mínimos de locação após um período de queda, desestimulando os incorporadores à iniciarem novos projetos e adiando o ciclo das entregas previstas para os próximos semestres. A redução do novo estoque aliado à recuperação da absorção gera um impacto positivo na retomada dos níveis saudáveis de vacância e consequentemente no aumento dos valores, já sutilmente observado em determinadas regiões da cidade. Já no segmento logístico de São Paulo, a busca pela otimização dos espaços ocupados pelas empresas ocasionou grande devolução de áreas com especificação técnica inferiores e a ocupação de área menores e mais eficientes em empreendimentos mais modernos, que aliado a entrega de novos estoques impactou a taxa de vacância, que apresentou um aumento nos últimos anos.

O mercado de escritórios na cidade do Rio de Janeiro que historicamente sempre apresentou taxas de vacância muito baixas, porém com um mercado muito concentrado, atingiu patamares recordes de vacância, grande parte em consequência da desaceleração do setor de óleo e gás e a crise no setor público, que afetou também toda a cadeia de setores relacionados. Apesar dos desafios e do momento favorável para as empresas renegociarem seus contratos ou realizarem uma mudança para espaços melhores e mais eficientes, o mercado tem mostrado sinais de estabilização dos preços de locação, principalmente em regiões mais demandadas como Zona Sul e Centro. No segmento logístico do Rio de Janeiro, apesar da absorção líquida ter se mantido acima da média dos últimos anos, o grande volume de novas entregas superou a demanda e fez com que a taxa de vacância sofresse um aumento significativo.
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Para o próximo período, nossa expectativa é de seguirmos focados na manutenção dos inquilinos atuais, diminuição dos níveis de vacância do Fundo, conforme perspectiva econômica apresentada acima bem como a constante manutenção e atualização física dos imóveis que compõem a carteira do Fundo de modo a mantê-los competitivos em relação a concorrência.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>IRA- Botafogo T. C.</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>137592315</Valor>
				<PercentValorizacaoDesvalorizacao>0.0007</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Buenos Aires</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>80985921.03</Valor>
				<PercentValorizacaoDesvalorizacao>0.0011</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- CD Bandeirante</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>238462673.1</Valor>
				<PercentValorizacaoDesvalorizacao>0.0003</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- CD POUSO ALEGRE</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>220263849.87</Valor>
				<PercentValorizacaoDesvalorizacao>0.0017</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- CD SANTA CRUZ</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>161766431.55</Valor>
				<PercentValorizacaoDesvalorizacao>0.0297</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- E. Madison</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>81342193.54</Valor>
				<PercentValorizacaoDesvalorizacao>0.0105</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Ed. Athenas</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>58300000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Ed.Bela Paulist</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>81424356.58</Valor>
				<PercentValorizacaoDesvalorizacao>0.0028</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Global Jundiaí</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>112296750</Valor>
				<PercentValorizacaoDesvalorizacao>0.0062</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Gomes Freire</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>51713917.2</Valor>
				<PercentValorizacaoDesvalorizacao>0.0003</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Joaq. Floriano</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>36252829.2</Valor>
				<PercentValorizacaoDesvalorizacao>0.0001</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Jundiaí I. Park</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>165600000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Lagoa Corporate</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>250010726.34</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Lavradio</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>237726972.44</Valor>
				<PercentValorizacaoDesvalorizacao>0.0001</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Mogi das Cruzes</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>169000000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IRA- Sumaré PIB</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>21500000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Laudista: Colliers International Brasil.
Data do Laudo: 06/2016
Os estudos foram realizados por duas metodologias: o valor de locação foi estimado através da comparação direta com imóveis semelhantes e inseridos na mesma região socioeconômica, já o valor de venda foi estimado pelo Método da Renda, onde o imóvel foi considerado como um gerador de renda por um período de dez anos em um fluxo de caixa descontado.
Foram consideradas na avaliação as práticas e padrões profissionais aplicáveis de acordo com a Norma Brasileira de Avaliações NBR 14.653 da ABNT – Associação Brasileira e Normas Técnicas, em todas as suas partes, além dos padrões de conduta e ética profissionais estabelecidos no Red Book em sua edição 2014 editada pelo Royal Institute of Chartered Surveyors (“RICS”) e nas normas do International Valuation Standards Council (“IVSC”), nos seus pronunciamentos 101 – Scope of Work, 102 – Implementation e 103 – Reporting.
A base de valor adotada foi a do Valor de Mercado, definido pelo Red Book como o valor estimado pelo qual um ativo ou passivo devem ser negociados na data da avaliação entre um comprador e um vendedor dispostos, em uma transação normal de mercado, depois de um tempo de marketing adequado e em que as partes atuaram de forma esclarecida, com prudência e sem compulsão.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. Brig. Faria Lima, 3400 - 10º Andar - São Paulo/SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>http://www.intrag.com.br/Fundos.aspx/Prospectos_Regulamentos | Informações aos Cotistas</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Conforme descrito no item 18 do regulamento, considera-se o correio eletrônico como forma de correspondência válida entre o Administrador e o Cotista, inclusive para convocação de Assembléias Gerais e procedimento de consulta formal, desde que o Cotista manifeste expressamente interesse na sua utilização.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>A assembleia geral de Cotistas instalar-se-á com qualquer número de Cotistas e as deliberações serão tomadas por maioria simples das Cotas presentes à assembleia geral de Cotistas ou, caso aplicável, pela maioria simples das respostas à consulta formal realizada na forma do item 10.4 abaixo, cabendo para cada Cota um voto, exceto com relação às matérias previstas no item 15.2 do regulamento, alíneas (b), (c), (d), (f), (g), (i), (k) e (l), que dependem da aprovação de Cotistas que representem, no mínimo, a maioria de votos dos Cotistas presentes e que representem: (i) 25% (vinte e cinco por cento), no mínimo, das Cotas emitidas, se o Fundo tiver mais de 100 (cem) Cotistas, ou (ii) metade, no mínimo, das Cotas emitidas, se o Fundo tiver menos de 100 (cem) Cotistas. 
Os percentuais de que trata o item acima deverão ser determinados com base no número de Cotistas do Fundo indicados no registro de Cotistas na data de convocação da assembleia,
cabendo ao Administrador informar no edital de convocação qual será o percentual aplicável nas assembleias que tratem das matérias sujeitas à deliberação por quórum qualificado.
Somente podem votar na assembleia geral de Cotistas os Cotistas inscritos no registro de Cotistas na data da convocação da assembleia geral de Cotistas, seus representantes legais ou procuradores constituídos há menos de 1 (um) ano.
A critério do Administrador, que definirá os procedimentos a serem seguidos, as deliberações da assembleia geral de Cotistas poderão ser tomadas por meio de consulta formal, sem reunião de Cotistas, em que (i) os Cotistas manifestarão seus votos por correspondência, correio eletrônico ou telegrama; e (ii) as decisões serão tomadas com base na maioria dos votos recebidos, observados os quoruns previstos no item acima, e desde que sejam observadas as formalidades previstas neste Regulamento e na regulamentação aplicável.
Os Cotistas poderão enviar seu voto por correspondência e/ou por correio eletrônico, desde que a convocação indique essa possibilidade e estabeleça os critérios para essa forma de voto, que não exclui a realização da reunião de Cotistas, no local e horário estabelecidos, cujas deliberações serão tomadas pelos votos dos presentes e dos recebidos por correspondência.
</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Coforme regulamento do Fundo, a critério do Administrador, os Cotistas poderão enviar seu voto por correspondência e/ou por correio eletrônico, desde que a convocação indique essa possibilidade e estabeleça os critérios para essa forma de voto, que não exclui a realização da reunião de Cotistas, no local e horário estabelecidos, cujas deliberações serão tomadas pelos votos dos presentes e dos recebidos por correspondência.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O Administrador receberá remuneração (“Taxa de Administração”), fixa e anual, de (i) 1,25% ao ano do patrimônio liquido do Fundo enquanto o Fundo não possuir valor de mercado atribuído pela negociação de suas cotas na BM&amp;FBovespa; ou (ii) 1,25% ao ano sobre o valor de mercado da somatória das Cotas do Fundo a partir do momento em que as Cotas do Fundo possuírem valor de mercado atribuído pela negociação de suas Cotas na BM&amp;FBovespa, observado que será devido o valor mínimo mensal equivalente a R$ 125.000,00 (cento e vinte e cinco mil reais).
A Taxa de Administração compreende as remunerações devidas ao Administrador e ao Gestor do Fundo, sendo calculada apropriada e paga nos dias úteis, mediante a divisão da taxa anual por 252 dias. 
A Taxa de Administração será provisionada diariamente e paga mensalmente ao Administrador, por período vencido, até o 5º dia útil do mês subsequente ao dos serviços prestados.
Considera-se patrimônio a soma algébrica do disponível com o valor da carteira, mais os valores a receber, menos as exigibilidades.
Tendo em vista que o Fundo admite a aplicação em cotas de fundos de investimento e de fundos de investimento em cotas de fundos de investimento que também cobram taxa de administração, a Taxa de Administração prevista no item 7 contemplará quaisquer taxas de administração cobradas na realização de tais investimentos pelo Fundo.
</PoliticaRemuneracao>
			<ValorPagoAno>15941276.96</ValorPagoAno>
			<PercentPatrimonioContabil>0.0079</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0083</PercentPatrimonioValorMercado>
		</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>FERNANDO MATTAR BEYRUTI</Nome>
				<Idade>39 ANOS</Idade>
				<CPF>288.351.088-10</CPF>
				<Email>fernanda-r.felipe@itau-unibanco.com.br</Email>
				<Profissao>ADMINISTRADOR</Profissao>
				<FormacaoAcademica>ADMINISTRAÇÃO - MACKENZIE</FormacaoAcademica>
				<DataInicioFuncao>2016-06-06</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>ITAÚ UNIBANCO S.A</NomeEmpresa>
						<Periodo>DESDE 2004</Periodo>
						<CargoFuncoes>SUPERINTENDENTE</CargoFuncoes>
						<AtividadePrincipalEmpresa>CUSTÓDIA LOCAL,CONTROLADORIA, ADMINISTRAÇÃO FIDUCIÁRIA, ESCRITURAÇÃO DE ATIVOS,  AGENTES DE GARANTIAS</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="16402" numCotasDetidas="13797000" percDetidoRelTotal="1" percDetidoPF="0.9498" percDetidoPJ="0.0502"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>http://www.intrag.com.br/Fundos.aspx/Download_Arquivo?idArquivo=1297&amp;nome=Poli%C3%ADtica%20de%20Divulga%C3%A7%C3%A3o%20de%20Fatos%20Relevantes%20-%20Final.pdf</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>N/A</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>http://www.kinea.com.br/pdf/montaPdf.htm?politicaVotoKinea_FundosImobiliarios</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Fabio Sonoda - Av. Brigadeiro Faria Lima, 3400 – 10º andar - São Paulo/SP CEP. 04538-132 - fabio.sonoda@itau.sonoda.com.br - Tel. (11) 3072-6089</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>N/A</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"