"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>OURO PRETO TRADE INVEST RENDA IMOBILIÁRIA I FUNDO DE INV</NomeFundo>
		<CNPJFundo>19390726000106</CNPJFundo>
		<DataFuncionamento>2014-05-19</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>1000</QtdCotasEmitidas>
		<FundoExclusivo>true</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Híbrido</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>false</MBO>
			<MB>true</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>Planner Corretora de Valores SA </NomeAdministrador>
		<CNPJAdministrador>19390726000106</CNPJAdministrador>
		<Logradouro>Avenida Brigadeiro Faria Lima</Logradouro>
		<Numero>3900</Numero>
		<Complemento>10º andar</Complemento>
		<Bairro>Itaim Bibi</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>04538-132</CEP>
		<Telefone1>(11) 2172-2600</Telefone1>
		<Telefone2>0800 179 444</Telefone2>
		<Telefone3>(11) 2172-2667</Telefone3>
		<Site>www.planner.com.br</Site>
		<Email>investfundos@planner.com.br</Email>
		<Competencia>2017-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Ouro Preto Gestão de Recursos S.A</Nome>
				<CNPJ>11.916.849/0001-26</CNPJ>
				<Endereco>Av. Juscelino Kubitschek, 1.600, 5° andar, conj. 51, Vila Nova Conceição, CEP 04543-000 - São Paulo, SP</Endereco>
				<telefone>(11) 3080-8177</telefone>
			</Gestor>
			<Custodiante>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>BDO RCS Auditores Independentes</Nome>
				<CNPJ>54.276.936/0001-79</CNPJ>
				<Endereco>Rua Major Quedinho, 90 - Consolação - CEP 01050-030 - São Paulo, SP</Endereco>
				<telefone>(11) 3848 5880 </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>
					<Ativo>
						<Nome>PLANNER FDO DE I. MULTIMERCADO</Nome>
						<Objetivos>Gestão de Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>8943.78</MontantesInvestidos>
						<OrigemRecursos>Aporte cotista</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>O fundo ainda não captou os recursos necessários para realizar investimentos imobiliários, portanto, não realizou investimentos no exercício findo. </ResultadoFundo>
			<ConjunturaEconomica>O modesto crescimento de 0,1% na passagem do 2°T para o 3ºT de 2017, encobre o desempenho bastante positivo que a economia brasileira apresentou nesse período. A razão é que a volatilidade do PIB agropecuário, que apresentou crescimento muito expressivo no 1ºT deste ano, vem dificultando a leitura dos dados subsequentes de atividade econômica. Excluindo a agropecuária, o desempenho do PIB no terceiro trimestre foi bastante robusto.
Os indicadores de confiança voltaram a subir no final de 2017, refletindo a consolidação da retomada da economia. A confiança empresarial retornou aos níveis médios de 2014, influenciada pelo bom momento da indústria, ao passo que a confiança dos consumidores também continuou avançando no último trimestre. 
Sobre o mercado de trabalho, as últimas pesquisas divulgadas apontam continuidade na trajetória de recuperação do emprego. Esperamos que esse quadro de retomada do emprego se reverta em 2018, quando devemos observar um crescimento mais intenso da atividade, capaz inclusive de permitir uma recuperação mais forte da ocupação formal. 
Quanto à inflação, os dados coletados durante a primeira quinzena de dezembro indicam que a inflação do ano ficará abaixo dos 3%, terreno em que se encontra desde julho. Mais de dois terços da desaceleração inflacionária ocorrida em 2017 se explicam pela redução de quase 15 pontos de percentagem da taxa de variação dos preços dos alimentos. 
Terminamos o ano de 2017 com os juros básicos em 7,0%, o mais baixo patamar atingido durante toda a vigência do regime de metas de inflação. Os sinais emitidos pelo Banco Central, sobre a política monetária, deixam clara a possibilidade de nova redução de 25 pontos da taxa Selic para o mês de março.
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Em conformidade com o Regulamento do Fundo, a política de investimentos seguirá inalterada para o exercício seguinte. O Fundo tenta buscar possibilidades de ampliação de seu patrimônio e que depende do sucesso da oferta de cotas que ainda será realizada.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Não possui informação apresentada.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida Brigadeiro Faria Lima, 3.900 - 10º andar - Itaim Bibi - CEP 04538-132 - São Paulo - SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>Site Fundos Net: fnet.bmfbovespa.com.br/fnet/login - Site administradora: www.planner.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Item (i) são utilizados como meios de comunicação aos cotistas:(a) FundosNet; (b) site da Administradora; (iii) escrita; e (iv) e-mail 
Item (ii) o endereço físico e eletrônico são disponibilizados no Edital de Convocação
</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Item (i) são solicitados os documentos societários do cotista, no momento da coleta de assinaturas na Lista de presença;
Item (ii) a Consulta Formal é elaborada nos termos do Regulamento do Fundo e enviada a todos os cotistas, juntamente com a carta resposta;
Item (iii) as manifestações dos cotistas, deverão ocorrer na forma prevista no comunicado até o horário estabelecido.
</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Ao enviarmos a comunicação ao cotista sobre a realização da Assembleia, é disponibilizado o canal eletrônico para retorno da sua manifestação nos termos do Regulamento do Fundo, e quando a o envio desta pelo cotista, procedemos com a apuração do quorum no momento do encerramento do prazo para manifestação.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos serviços de administração o Fundo pagará a quantia equivalente a um percentual do patrimônio líquido do Fundo, calculada na metodologia de cascata de acordo com a tabela abaixo:
a)   Até que o PL atinja R$ 150.000.000,00                                                              1,00%
b)  Sobre o que exceder a R$ 150.000.000,00 até R$ 300.000.000,00           0,80%
c)   Sobre o que exceder a R$ 300.000.000,00                                                       0,60%
Será observado o valor mínimo mensal de R$25.000,00 (vinte e cinco mil reais), corrigido anualmente pela variação positiva do Índice Geral de Preços do Mercado, calculado e divulgado pela Fundação Getúlio Vargas, ou por outro índice que vier a substituí-lo.
A taxa de administração será calculada à base de 1/252 (um duzentos e cinquenta e dois avos) sobre o valor descrito no caput deste artigo 21 e será paga diretamente pelo Fundo à Administradora até o 5º (quinto) dia útil do mês subsequente.
A Administradora, conforme o caso, terá o direito de receber a taxa de administração descrita neste Art. 21 durante todo o período em que exercer suas funções no Fundo, desde a data de início até a data do encerramento de suas atividades no Fundo.
A taxa de administração será dividida entre a Administradora, a Gestora e a Consultora de Investimentos Imobiliários nos termos dos respectivos contratos de prestação de serviços. Cada um desses prestadores de serviços receberá diretamente do Fundo.
Não será cobrada taxa de performance.
</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>Artur Martins de Figueiredo</Nome>
				<Idade>53</Idade>
				<CPF>073.813.338-80</CPF>
				<Email>afigueiredo@planner.com.br</Email>
				<Profissao>Administrador de Empresas</Profissao>
				<FormacaoAcademica>PUC</FormacaoAcademica>
				<DataInicioFuncao>1999-06-07</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Banco Bandeirantes de Investimentos S/A</NomeEmpresa>
						<Periodo>1986/1999</Periodo>
						<CargoFuncoes>Analista de Investimento </CargoFuncoes>
						<AtividadePrincipalEmpresa>Realizava acompanhamento de empresas de capital aberto, bem como o mercado financeiro de um modo geral, objetivando a elaboração de relatórios diários para definição de estratégias na administração de recursos de terceiros.  </AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Planner Corretora de Valores S/A</NomeEmpresa>
						<Periodo>1999/2000</Periodo>
						<CargoFuncoes>Gerente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Coordenação da Área de Agente Fiduciário, realizando entre outras atividades, o acompanhamento diário dos preços unitários das debêntures, controle dos “covenants” financeiros constantes da escritura de emissão, bem como avaliação das providências a serem adotadas nas emissões que encontram-se inadimplentes.</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Banco Bradesco S/A</NomeEmpresa>
						<Periodo>2000/2001</Periodo>
						<CargoFuncoes>Gerente de Underwriting</CargoFuncoes>
						<AtividadePrincipalEmpresa>Realização de prospecção de operações, nas quais as empresas utilizam o mercado de capitais como fonte de recursos para suportar investimentos e/ou alongamento de outros financiamentos / empréstimos.  O trabalho consistia na prospecção propriamente dita, ou seja, visitas / reuniões com os potenciais emissores, bem como o acompanhamento do processo de registro da operação junto à CVM – Comissão de Valores Mobiliário e do procedimento de venda dos títulos ao mercado (basicamente investidores institucionais).</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Grupo Planner </NomeEmpresa>
						<Periodo>2001/ Atual</Periodo>
						<CargoFuncoes>Diretor / Conselheiro</CargoFuncoes>
						<AtividadePrincipalEmpresa>Responsável pela administração fiduciária de Fundos de Investimento</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não </CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="1000" percDetidoRelTotal="1" percDetidoPF="0" percDetidoPJ="0"/>
		</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>
"