"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIÁRIO HUMAITÁ</NomeFundo>
		<CNPJFundo>17035124000105</CNPJFundo>
		<DataFuncionamento>2014-12-15</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>1000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato xsi:nil="true"/>
			<SegmentoAtuacao xsi:nil="true"/>
			<TipoGestao xsi:nil="true"/>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>30/06</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>true</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BANCO FINAXIS S.A.</NomeAdministrador>
		<CNPJAdministrador>17035124000105</CNPJAdministrador>
		<Logradouro>Rua Pasteur</Logradouro>
		<Numero>463</Numero>
		<Complemento>11° andar</Complemento>
		<Bairro>Água Verde</Bairro>
		<Cidade>Curitiba</Cidade>
		<Estado>PR</Estado>
		<CEP>80250 -080</CEP>
		<Telefone1>(41) 3074-0909</Telefone1>
		<Telefone2>(41) 3074-5817</Telefone2>
		<Telefone3>(41) 3074-0928</Telefone3>
		<Site>http://finaxis.com.br/</Site>
		<Email>informacoesfundos@finaxis.com.br</Email>
		<Competencia>2017-06-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>V2 Investimentos Ltda. </Nome>
				<CNPJ>13601663000103</CNPJ>
				<Endereco>Rua Iguatemi, 192, conjunto 222, 22º Andar, São Paulo - SP.</Endereco>
				<telefone>(11) 4301-7845</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Banco Finaxis S.A. </Nome>
				<CNPJ>11758741000152</CNPJ>
				<Endereco>Rua Pasteur, 463, 11º andar, Curitiba-PR</Endereco>
				<telefone>(41) 3074-0909</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Grant Thornton Auditores Independentes </Nome>
				<CNPJ>10830108000165</CNPJ>
				<Endereco>Avenida Engenheiro Luiz Carlos Berrini, 105 - São Paulo</Endereco>
				<telefone>(11) 3886-8977</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</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 xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>O fundo auferiu receita bruta de R$ 20.368.765,78 e as despesas do período totalizaram R$ 5.223.837,58. Portanto o resultado foi de R$ 15.144.928,20.</ResultadoFundo>
			<ConjunturaEconomica>A desaceleração da inflação foi surpreendente durante o primeiro semestre de 2017, influenciado principalmente pelo preço dos alimentos. O IPCA fechou o ano de 2016 em 6,29%, atualmente, a previsão é terminar o ano de 2017 abaixo de 4,0%, haja a vista que a meta do BACEN é 4,50%. Certamente, o fato econômico mais importante foi a queda na taxa de juros. A taxa Selic que fechou o ano de 2016 em 14,0% e está agora em 8,25%. A previsão é terminar o ano de 2017 em 7,25%. Os dados da atividade econômica começam a dar sinais de recuperação, a safra recorde de grãos deve influenciar positivamente o PIB. Estima-se que as atividades industriais e de serviços também contribuam positivamente no crescimento do PIB no ano de 2017. Mesmo com todos os impasses políticos e escândalos deflagrados pela Operação Lava-jato, as reformas anunciadas pelo governo: teto de gastos, reforma trabalhista e a transformação da TJLP em TLP para os empréstimos do BNDES, juntamente com a agenda de privatizações, surtiu efeito e animou os investidores. No ano de 2017, o Ibovespa teve alta de 26% e o IFIX subiu 18%.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>O portfólio do FII Humaitá é composto por três ativos imobiliário no formato Built-to-Suit. Dois imóveis ocupados pela Atento (Santos e Salvador) e um imóvel ocupado pela Ambev (região metropolitana de Belo Horizonte). Ambas empresas continuam financeiramente saudáveis. O valor desses ativos são fortemente correlacionados com a NTN-B, pois seu fluxo de receita são indexados à inflação. A medida que diminui a taxa de juros, o valor desses ativos tendem a aumentar. Dessa forma, a perspectiva é que haja uma valorização nesses ativos no segundo semestre de 2017. A vacância dos imóveis logísticos (Ambev) e comerciais urbanos (Atento) continuam em patamares altos. No entanto, esses imóveis são bem específicos e as multas rescisórias são muito altas, mitigando o risco de devolução dos imóveis.

</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>CD Santa Luzia - MG</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>44000000</Valor>
				<PercentValorizacaoDesvalorizacao>0.17</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Call Center Santos - SP</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>45400000</Valor>
				<PercentValorizacaoDesvalorizacao>0.04</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Call Center Salvador - BA</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>51800000</Valor>
				<PercentValorizacaoDesvalorizacao>0.1</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Método comparativo direto e método de renda. </CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida Paulista, nº 1842, 1º andar, conjunto 17, Bela Vista, CEP 01310-923</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>https://fnet.bmfbovespa.com.br; http://finaxis.com.br/</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Os documentos ou informações estarão disponíveis nos endereços físicos e eletrônicos
do ADMINISTRADOR: na Cidade e Estado de São Paulo na Avenida Paulista nº 1842, Torre Norte, 1º andar, conjunto 17,
Bela Vista, CEP 01310-923 e http://finaxis.com.br/</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Somente poderão votar na assembleia geral os quotistas inscritos no registro de quotistas na data daconvocação da assembleia, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano; As deliberações da Assembleia Geral de Cotistas poderão ser tomadas mediante processo de consulta formalizado em carta, telegrama, correio eletrônico (e-mail) ou fác-símile dirigido pelo ADMINISTRADOR a cada Cotista, para resposta no prazo máximo de 10 (dez) diascontados do recebimento; A resposta dos Cotistas à consulta será realizada mediante o envio, pelo Cotista ao ADMINISTRADOR, de carta com aviso de recebimento, correio eletrônico ou telegrama formalizando o seu respectivo voto.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não se aplica para esse Fundo. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>A Taxa de Administração a ser devida pelo FUNDO será equivalente ao somatório dos seguintes montantes: (i) 0,12% (doze centésimos por cento) ao ano sobre patrimônio líquido do
FUNDO, calculada de forma linear, pro rata die, todo dia útil, com base em um ano de 252(duzentos e cinquenta e dois) dias úteis com base no valor do patrimônio líquido do FUNDO do dia anterior à realização do referido cálculo, com limite mínimo de R$16.448,00 (dezesseis mil, quatrocentos e quarenta e oito reais) corrigido anualmente pelo Indice Geral de Preços - Mercado, divulgado pela Fundação Getulio Vargas (“IGP-M”).</PoliticaRemuneracao>
			<ValorPagoAno xsi:nil="true"/>
			<PercentPatrimonioContabil xsi:nil="true"/>
			<PercentPatrimonioValorMercado xsi:nil="true"/>
		</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>Ricardo Augusto Meira Pedro</Nome>
				<Idade>52</Idade>
				<CPF>4995131850</CPF>
				<Email>ricardo.pedro@finaxis.com.br</Email>
				<Profissao>Bancário </Profissao>
				<FormacaoAcademica>Administrador </FormacaoAcademica>
				<DataInicioFuncao>2014-12-15</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="1000" percDetidoRelTotal="1" percDetidoPJ="1"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante xsi:nil="true"/>
			<PoliticaNegociacaoCotas xsi:nil="true"/>
			<PoliticaExercicioDireitoVoto xsi:nil="true"/>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"