"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>KINEA INDICES DE PREÇOS FII</NomeFundo>
		<CNPJFundo>24960430000113</CNPJFundo>
		<DataFuncionamento>2016-09-16</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>BRKNIPCTF001</CodigoISIN>
		<QtdCotasEmitidas>24530886</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Títulos e Valores Mobiliários</Mandato>
			<SegmentoAtuacao>Títulos e Val. Mob.</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>24960430000113</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>relacionamento.intrag@itau-unibanco.com.br</Email>
		<Competencia>2019-06-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>KINEA INVESTIMENTOS LTDA</Nome>
				<CNPJ>8604187000144</CNPJ>
				<Endereco>Rua Minas de Prata 30, Vila Olímpia. 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>61.562.112/0001-20</CNPJ>
				<Endereco>Av Francisco Matarazzo, 1400, S Paulo/SP cep 05401400</Endereco>
				<telefone>(11) 3674 2002</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>Banco Fator</Nome>
				<CNPJ>31344196000106</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 xsi:nil="true"/>
				<CNPJ>60701190000104</CNPJ>
				<Endereco>Av. Brigadeiro Faria Lima, nº 3.500 - São Paulo, SP</Endereco>
				<telefone>(11) 3003-7377</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>
					<Ativo>
						<Nome>CRI - GAIA SECURITIZADORA S.A. Série nº 119 da 4ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>153373290.32</MontantesInvestidos>
						<OrigemRecursos>4ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI - TRUE SECURITIZADORA S.A. - Série nº 182 da 1 ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>237500000</MontantesInvestidos>
						<OrigemRecursos>4ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 206 da 1ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>28942307.68</MontantesInvestidos>
						<OrigemRecursos>3ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 204 da 1ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>136442307.68</MontantesInvestidos>
						<OrigemRecursos>3ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA S.A. - Série nº 167 da 1 ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>143482563.98</MontantesInvestidos>
						<OrigemRecursos>3ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA S.A. - Série nº 166 da 1 ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>153377913.22</MontantesInvestidos>
						<OrigemRecursos>3ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 161 da 1ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>166000000</MontantesInvestidos>
						<OrigemRecursos>3ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 162 da 1ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>110000000</MontantesInvestidos>
						<OrigemRecursos>3ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI - NOVA SECURITIZACAO S.A. - Série nº 29 da 1ª Emissão</Nome>
						<Objetivos>Aquisição de ativos imobiliários através da aquisição de CRI conforme previsto na Política de Investimento do Fundo</Objetivos>
						<MontantesInvestidos>80500000</MontantesInvestidos>
						<OrigemRecursos>3ª Emissão de Cotas</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Gestor está em contínuo contato com os principais participantes do mercado imobiliário e de estruturação de títulos e valores mobiliários, em especial os de CRI, a fim de prospectar e avaliar oportunidades de investimento que atendam a Política de Investimento do Fundo. Dessa forma, baseado nas frequentes conversações mantidas com tais participantes,  espera investir os recursos disponíveis em linha com suas políticas, em CRI de natureza Corporativa e, sempre que possível, com garantias adequadas.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Inicialmente vale destacar que, em maio de 2019, foi iniciado e concluído o processo de distribuição de cotas da 4ª Emissão do Fundo. A oferta resultou na captação de aproximadamente R$ 760 milhões. Essa Emissão contribuiu positivamente para o aumento de liquidez das cotas no mercado secundário, bem como a diversificação da carteira e diluição de riscos através dos novos investimentos a serem realizados com os recursos captados.

Em relação à alocação do portfólio, ao final do mês de julho de 2019, o Fundo apresentava alocação em CRI de aproximadamente 95,8% do PL do Fundo, o que representa um alto patamar de alocação dos recursos. 

No que diz respeito aos indexadores presentes na carteira de ativos do Fundo,  em julho de 2019, o Fundo possuía 93,1% dos ativos indexados ao IPCA, 2,7% ao IGP-M e por fim, 4,2% à Selic. Este perfil de indexação permitiu ao Fundo gerar e distribuir resultados acima da sua meta de rentabilidade. Em termos de rentabilidade, o portfólio de ativos proporcionou distribuição total de R$ 8,90 por cota no período entre 1º de julho de 2018 e dia 30 de junho de 2019.

Em relação ao comportamento do Fundo no mercado secundário da B3, houve negociações em todos os pregões do período, com média diária equivalente a R$ 1,8 milhões, e um volume negociado total de R$ 479 milhões. As cotas encerraram jun/19 com um valor de mercado de R$ 121,50 (unitário), o que representa uma valorização a mercado de 13,6% em relação a cota de fechamento no mesmo mês do ano anterior (jun/18).

Na visão do Gestor, os resultados descritos acima estão aderentes os objetivos de rentabilidade do Fundo e condições de mercado no período. A rentabilidade obtida no passado não representa promessa ou garantia de rentabilidade futura e não há qualquer tipo de garantia, implícita ou explícita, prestada pelo administrador, pelo gestor do Fundo ou por qualquer empresa do Grupo Itaú Unibanco.</ResultadoFundo>
			<ConjunturaEconomica>Anteriormente à exposição relativa à conjuntura econômica, é válido notar que, atualmente, o Fundo apresenta uma concentração em Certificados de Recebíveis Imobiliários de responsabilidade de devedores corporativos, possuindo exposição a 28 CRI. O pagamento da maioria destes títulos é de responsabilidade de empresas atuantes em diversos segmentos da economia, não necessariamente do mercado imobiliário. Consequentemente, o ambiente político-econômico do país como um todo é relevante para a carteira de investimentos do Fundo. 

Em 2019 o ponto focal das discussões sobre a conjuntura econômica no Brasil é o andamento das reformas estruturais brasileiras, as quais o Gestor entende como impreteríveis para melhora do cenário fiscal e consequentemente para os preços nos mercados. 

Em relação à atividade econômica, vimos sinais moderados de recuperação, com ritmo mais lento do que esperado pelo mercado. Pode-se destacar a recuperação da indústria e do mercado imobiliário. O mercado de trabalho também tem apresentado sinais de melhora, mas também com aceleração menor do que a expectativa neste início de ano. Em linha geral, os últimos meses foram de retomada moderada da confiança e atividade, frente às promessas de avanço das reformas brasileiras.

No ambiente externo, os principais temas no período são a (i) os atritos comerciais gerados pelo atual governo dos Estados Unidos em relação a produtos ou países específicos; (ii) continuidade da desaceleração do crescimento da economia mundial; (iii) possível desvalorização do dólar frente ao real, causado principalmente pela menor percepção de risco do Brasil na visão externa e interna.
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Como mencionado, o Fundo possui atualmente exposição a 28 CRI relacionados a diversos segmentos da economia. Assim, a saúde e boa perspectiva econômica como um todo, é fator relevante para o comportamento da carteira de investimentos do Fundo. Dessa forma, entendemos importante trazer nossa visão sobre as perspectivas econômicas de forma ampla.

No ambiente interno, esperamos: (i) redução do atual patamar de juros e da inflação pelos próximos anos; (ii) continuação da lenta melhora da atividade econômica no país; bem como (iii) avanço do processo de aprovação das reformas em 2019/2020. Entendemos que uma recuperação mais robusta da economia brasileira passaria por um cenário de aprovação das reformas estruturais propostas, com destaque para a da Previdência e a Tributária.

Diante do cenário acima, sob a ótica dos riscos incorridos pelo Fundo, a continuidade da recuperação econômica aliada a aprovação das reformas, são elementos que devem propiciar um melhor cenário para as empresas e fundos. Em virtude disso e, em conjunto com (i) a melhora no mercado de crédito e (ii) um maior apetite dos financiadores, esperamos que as empresas e ativos às quais o Fundo é exposto continuem a apresentar melhores resultados, com incremento de sua capacidade de redução de alavancagem e rolagem de seus passivos de forma saudável. Em suma, esperamos uma melhora na capacidade das empresas de honrar suas obrigações, o que é positivo sob a perspectiva do Fundo.  
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>CRI - CIBRASEC-CIA BRASILEIRA DE SECURITIZAÇÃO - Série nº 285 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>16402624.1</Valor>
				<PercentValorizacaoDesvalorizacao>-0.00173724752277082</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - CIBRASEC-CIA BRASILEIRA DE SECURITIZAÇÃO - Série nº 286 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>25784605.44</Valor>
				<PercentValorizacaoDesvalorizacao>0.0770515418322908</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - CIBRASEC-CIA BRASILEIRA DE SECURITIZAÇÃO - Série nº 287 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>25784605.44</Valor>
				<PercentValorizacaoDesvalorizacao>0.0770515418322908</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - CIBRASEC-CIA BRASILEIRA DE SECURITIZAÇÃO - Série nº 284 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>16402624.1</Valor>
				<PercentValorizacaoDesvalorizacao>-0.00173724752155613</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - GAIA SECURITIZADORA S.A. Série nº 01 da 6ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>8143135.71</Valor>
				<PercentValorizacaoDesvalorizacao>-0.000691830241336788</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA S.A. - Série nº 99 da 1 ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>73235181.29</Valor>
				<PercentValorizacaoDesvalorizacao>0.135218271540417</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA S.A. - Série nº 101 da 1 ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>29291114.96</Valor>
				<PercentValorizacaoDesvalorizacao>0.135561281997111</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA S.A. - Série nº 100 da 1 ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>73235181.29</Valor>
				<PercentValorizacaoDesvalorizacao>0.135218271540417</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 133 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>64968043.47</Valor>
				<PercentValorizacaoDesvalorizacao>0.0975324356551119</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 163 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>64968044.11</Valor>
				<PercentValorizacaoDesvalorizacao>0.0976077605072325</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 175 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>81122269.56</Valor>
				<PercentValorizacaoDesvalorizacao>0.138857214466443</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 176 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>81122269.56</Valor>
				<PercentValorizacaoDesvalorizacao>0.138857214466443</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - ISEC SECURITIZADORA S.A. - Série nº 11 da 4ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>68669984.86</Valor>
				<PercentValorizacaoDesvalorizacao>0.079753976933765</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - ISEC SECURITIZADORA S.A. - Série nº 12 da 4ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>68669984.86</Valor>
				<PercentValorizacaoDesvalorizacao>0.079753976933765</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - CIBRASEC-CIA BRAS DE SECURITIZAÇÃO - Série nº 302 da 2ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>45769796.13</Valor>
				<PercentValorizacaoDesvalorizacao>0.24968874686675</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - CIBRASEC-CIA BRAS DE SECURITIZAÇÃO - Série nº 300 da 2ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>47970417.08</Valor>
				<PercentValorizacaoDesvalorizacao>0.248692611850968</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - CIBRASEC-CIA BRAS DE SECURITIZAÇÃO - Série nº 295 da 2ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>37460423.44</Valor>
				<PercentValorizacaoDesvalorizacao>0.122200344485788</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - NOVA SECURITIZACAO S.A. - Série nº 29 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>95365479.26</Valor>
				<PercentValorizacaoDesvalorizacao>0.18466433863354</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 162 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>122234302.05</Valor>
				<PercentValorizacaoDesvalorizacao>0.111220927727273</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 161 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>184462674</Valor>
				<PercentValorizacaoDesvalorizacao>0.111220927710844</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA S.A. - Série nº 167 da 1 ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>162509077.6</Valor>
				<PercentValorizacaoDesvalorizacao>0.132605057313111</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA S.A. - Série nº 166 da 1 ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>173716600.19</Valor>
				<PercentValorizacaoDesvalorizacao>0.132605057292877</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 204 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>144516064.29</Valor>
				<PercentValorizacaoDesvalorizacao>0.0591734099729204</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 206 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>30617571.39</Valor>
				<PercentValorizacaoDesvalorizacao>0.0578828657521895</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - TRUE SECURITIZADORA S.A. - Série nº 182 da 1 ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>244738082.17</Valor>
				<PercentValorizacaoDesvalorizacao>0.0304761354526315</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - GAIA SECURITIZADORA S.A. Série nº 119 da 4ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>154507907.12</Valor>
				<PercentValorizacaoDesvalorizacao>0.00739774701079132</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA SA - Série nº 87 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>36650142.61</Valor>
				<PercentValorizacaoDesvalorizacao>0.0474343118154958</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - APICE SECURITIZADORA IMOBILIARIA SA - Série nº 88 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>36650142.61</Valor>
				<PercentValorizacaoDesvalorizacao>0.0474343118154958</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - RB CAPITAL COMPANHIA DE SECURITIZAÇÃO - Série nº 163 da 1ª Emissão</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>64968044.11</Valor>
				<PercentValorizacaoDesvalorizacao>0.0976077605072325</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os Ativos e os Ativos de Liquidez serão precificados de acordo com procedimentos para registro e avaliação de títulos e valores mobiliários, conforme estabelecido na regulamentação em vigor (tais como o critério de marcação a mercado) e de acordo com o manual de precificação adotado pelo Custodiante. O manual está disponível para consulta no website http://www.itau.com.br/_arquivosestaticos/SecuritiesServices/defaultTheme/PDF/ManualPrecificacao.pdf.
A precificação dos Ativos e dos Ativos de Liquidez será feita pelo valor de mercado com base no manual de precificação do CUSTODIANTE. No entanto, caso o ADMINISTRADOR e/ou o GESTOR não concordem com a precificação baseada no manual de precificação do CUSTODIANTE, o ADMINISTRADOR e o GESTOR, em conjunto com o CUSTODIANTE, deverão decidir de comum acordo o critério a ser seguido.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. Brigadeiro Faria Lima, nº 3.400 - 10º andar - São Paulo/SP - CEP. 04538-132</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.intrag.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>CONFORME ESTABELECIDO NO REGULAMENTO: CORRESPONDÊNCIA ELETRÔNICA. Considera-se o correio eletrônico forma de correspondência válida entre o ADMINISTRADOR e o Cotista, inclusive para convocação de assembleias gerais de Cotistas e procedimento de consulta formal.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>CONFORME ESTABELECIDO NO REGULAMENTO: 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 cabendo para cada Cota um voto, exceto com relação às matérias previstas no Regulamento, que dependem da aprovação de Cotistas que representem, no mínimo, a maioria de votos dos Cotistas presentes e que representem: (i) 25%, 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 até 100 (cem) Cotistas. A Assembleia Geral de Cotistas poderá ser instalada com a presença de um único Cotista, de modo que apenas considerar-se-á não instalada a Assembleia Geral de Cotistas na hipótese de não comparecimento de nenhum Cotista à respectiva assembleia. Os percentuais 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 quorum 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. 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, observados os quoruns previstos no Regulamento. 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 Regulamento e desde que sejam observadas as formalidades previstas neste Regulamento e na regulamentação aplicável.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>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 Regulamento e desde que sejam observadas as formalidades previstas neste Regulamento e na regulamentação aplicável.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>CONFORME ESTABELECIDO NO REGULAMENTO: Pela administração do FUNDO, nela compreendida as atividades do ADMINISTRADOR, do GESTOR, do ESCRITURADOR e do CUSTODIANTE, o FUNDO pagará ao ADMINISTRADOR uma taxa de administração (“Taxa de Administração”) equivalente a 1,00% (um por cento) ao ano sobre o patrimônio líquido do FUNDO. Considera-se patrimônio líquido do FUNDO a soma algébrica do montante disponível com os Ativos e os Ativos de Liquidez integrantes da carteira do FUNDO, mais os valores a receber dos Ativos e dos Ativos de Liquidez, menos as exigibilidades do FUNDO. A Taxa de Administração é calculada, apropriada e paga em Dias Úteis, mediante a divisão da taxa anual por 252 (duzentos e cinquenta e dois) Dias Úteis. A Taxa de Administração será provisionada diariamente e paga mensalmente ao ADMINISTRADOR, por período vencido, até o 5º (quinto) Dia Útil do mês subsequente ao dos serviços prestados.</PoliticaRemuneracao>
			<ValorPagoAno>19302095.58</ValorPagoAno>
			<PercentPatrimonioContabil>0.00988096301168668</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.00944948106259511</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>Eduardo Estefan Ventura</Nome>
				<Idade>39 anos</Idade>
				<CPF>21827149876</CPF>
				<Email>eduardo.estefan@itau-unibanco.com.br</Email>
				<Profissao>Engenheiro</Profissao>
				<FormacaoAcademica>Engenharia Mecênica de Aeronáutica (ITA)</FormacaoAcademica>
				<DataInicioFuncao>2018-10-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Itaú Unibanco S.A.</NomeEmpresa>
						<Periodo>desde 04/2011</Periodo>
						<CargoFuncoes>Diretor</CargoFuncoes>
						<AtividadePrincipalEmpresa> Ingressou no Itaú Unibanco como advisor do segmento Ultra High do Private Bank em 2011. Em 2014, se tornou superintendente da mesa de investors do Private Bank. Em 2018  foi convidado para assumir a cadeira de diretor da DARP, que englobam as área de Administração Fiduciária, Gestão de Riscos, de Planejamento, Qualidade e Inovação da WMS. </AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>N/A</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="15527" numCotasDetidas="24530886" percDetidoRelTotal="1" percDetidoPF="0.99" percDetidoPJ="0.01"/>
			<AcimaCincoAteDezPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuinzeAteVintePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaVinteAteTrintaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuarentaAteCinquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCiquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>http://www.intrag.com.br/intrag-pt/documentos/</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>N/A</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>http://www.kinea.com.br/wp-content/uploads/2018/05/politica-poltica-de-voto-fundos-imobilirios-poltica-de-voto-fundos-imobilirios-201804.pdf</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>
"