"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>OURINVEST JPP FUNDO DE INVESTIMENTO IMOBILIÁRIO – FII </NomeFundo>
		<CNPJFundo>26091656000150</CNPJFundo>
		<DataFuncionamento>2016-11-30</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRFIIJCTF004</CodigoISIN>
		<QtdCotasEmitidas>720000</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>FINAXIS Corretora</NomeAdministrador>
		<CNPJAdministrador>26091656000150</CNPJAdministrador>
		<Logradouro>Avenida Paulista</Logradouro>
		<Numero>1842</Numero>
		<Complemento>Torre Norte 1º andar cj. 17</Complemento>
		<Bairro>Cerqueira Cesar</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>01310-923</CEP>
		<Telefone1>(11) 3526 9001</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>http://finaxis.com.br/</Site>
		<Email>informacoesfundos@finaxis.com.br</Email>
		<Competencia>2018-06-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>JPP Capital Gestão de Recursos Ltda. </Nome>
				<CNPJ>13516035000120</CNPJ>
				<Endereco>Avenida Paulista, 287, 6º Andar, São Paulo - SP.</Endereco>
				<telefone>(11) 2187-1487</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>Ourinvest Distribuidora de Títulos e Valores Mob S.A.</Nome>
				<CNPJ>997804000107</CNPJ>
				<Endereco>Avenida Paulista, 1728, sobreloja, São Paulo-SP.</Endereco>
				<telefone>(11) 4081-4520</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>Certificados de Recebiveis Imobiliarios</Nome>
						<Objetivos>Ativo Alvo do Fundo - busca de rentabilidade  </Objetivos>
						<MontantesInvestidos>49717433.1837806</MontantesInvestidos>
						<OrigemRecursos>Patrimonio Liquido do Fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Letras de Crédito Imobiliário</Nome>
						<Objetivos>Ativo Alvo do Fundo - busca de rentabilidade  </Objetivos>
						<MontantesInvestidos>11780323.8</MontantesInvestidos>
						<OrigemRecursos>Patrimonio Liquido do Fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Letra do Tesouro Nacional - LTN</Nome>
						<Objetivos>Ativo de Liquidez - previsto no regulamento do Fundo</Objetivos>
						<MontantesInvestidos>13033978.21</MontantesInvestidos>
						<OrigemRecursos>Patrimonio Liquido do Fundo</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>Lucro de R$ 6.685.429,26 </ResultadoFundo>
			<ConjunturaEconomica>A economia brasileira tem apresentado alguns sinais de recuperação, mas em ritmo decepcionante em relação à expectativa que tínhamos no início do ano. Adicionalmente, no segundo trimestre de 2018, a atividade econômica foi impactada negativamente pela greve dos caminhoneiros, que se somou às incertezas relacionadas ao cenário eleitoral.
Nesse ambiente, não houve retomada do mercado imobiliário. Por ora, a expectativa é de melhora apenas em 2019, quando esperamos retomada gradual dos investimentos e da confiança do consumidor, o que deverá se refletir em aumento da taxa de ocupação de galpões e lajes comerciais e aceleração das vendas de imóveis residenciais.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>O fundo tem avançado na estratégia de: (i) maximizar a alocação em CRI; (ii) ampliar a participação de ativos indexados a índices de preços; e (iii) selecionar ativos com taxas elevadas, suportados por estruturas adequadas de garantias. Os ativos que compõem a carteira apresentam rentabilidade média superior aos títulos públicos indexados à inflação, em linha com o objetivo de superar o benchmark do fundo no médio/longo prazo.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Certificados de Recebiveis Imobiliarios</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>65445748.16</Valor>
				<PercentValorizacaoDesvalorizacao>0.3164</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Letras de Crédito Imobiliário</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>317807.7</Valor>
				<PercentValorizacaoDesvalorizacao>-0.973</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Marcação a Mercado.</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 Cotistas inscritos no registro de cotistas na data da convocação da Assembleia Geral, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano; As deliberações da Assembleia Geral poderão ser tomadas, independentemente de convocação, mediante processo de consulta formal, formalizada por carta, correio eletrônico ou telegrama dirigido pelo Administrador aos Cotistas, para resposta no prazo de 30 (trinta) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto. No caso de deliberações a serem tomadas por consulta formal deverão ser aplicados todos os quóruns de deliberação aplicáveis para as Assembleias Gerais, bem como deverão ser observadas as formalidades previstas nos artigos 19, 19-A e 41, incisos (i) e (ii) da Instrução CVM nº 472/08. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não se aplica para esse Fundo. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Regulamento - Artigo 22º. Pela prestação dos serviços de administração, gestão, controladoria e escrituração, nos termos deste Regulamento e em conformidade com a regulação vigente, o Fundo pagará uma remuneração conforme tabela abaixo:

Faixa do Valor de Referência do Fundo Valor Percentual Praticado (ao ano)
R$0,00 a R$50.000.000,00 1,1625%
R$50.000.000,01 a R$100.000.000,00 1,125%
Acima de R$100.000.000,01 1,05%

Parágrafo 1º. Adicionalmente ao percentual aplicável conforme a faixa do Valor de Referência do Fundo, deverá ser respeitado um valor mínimo mensal de: (a) R$ 21.000,00 (vinte e um mil reais), nos primeiros seis meses; (b) R$24.000,00 (vinte e quatro mil reais), do sétimo ao décimo segundo mês; e (c) R$28.250,00 (vinte e oito mil duzentos e cinquenta reais), a partir do 13º (décimo terceiro) mês de atividade do Fundo, corrigido anualmente pelo IGP-M.

Parágrafo 2º. A Taxa de Administração será calculada e provisionada diariamente, por Dia Útil, considerado o ano de 252 (duzentos e cinquenta e dois) Dias Úteis, como despesa do Fundo, e será paga mensalmente até o 5º (quinto) Dia Útil do mês subsequente.
</PoliticaRemuneracao>
			<ValorPagoAno>181101.88</ValorPagoAno>
			<PercentPatrimonioContabil>0.002455</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.002484</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>Ricardo Augusto Meira Pedro</Nome>
				<Idade>52</Idade>
				<CPF>049.951.318-50</CPF>
				<Email>ricardo.pedro@finaxis.com.br</Email>
				<Profissao>Bancário</Profissao>
				<FormacaoAcademica>Administrador </FormacaoAcademica>
				<DataInicioFuncao>2016-11-30</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="451" numCotasDetidas="720000" percDetidoRelTotal="1" percDetidoPF="1"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>http://finaxis.com.br/</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>http://finaxis.com.br/</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>http://finaxis.com.br/</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"