"<?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 - OURINVEST CYRELA - FII</NomeFundo>
		<CNPJFundo>28516650000103</CNPJFundo>
		<DataFuncionamento>2018-03-02</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BROUCYCTF003</CodigoISIN>
		<QtdCotasEmitidas>533916</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>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>Banco Ourinvest S/A</NomeAdministrador>
		<CNPJAdministrador>28516650000103</CNPJAdministrador>
		<Logradouro>Av. Paulista</Logradouro>
		<Numero>1728</Numero>
		<Complemento>SL,1,2 E 11 </Complemento>
		<Bairro>Bela Vista</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>01310-919</CEP>
		<Telefone1>4081-4402</Telefone1>
		<Telefone2>4081-4576</Telefone2>
		<Telefone3>4081-4444</Telefone3>
		<Site>ourinvest.com.br</Site>
		<Email>fundos.imobiliarios@ourinvest.com.br</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Banco Ourinvest S.A.</Nome>
				<CNPJ>78.632.767/0001-20</CNPJ>
				<Endereco>Av. Paulista, 1728 - sobreloja</Endereco>
				<telefone>4081-44444</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Banco Ourinvest S.A.</Nome>
				<CNPJ>78.632.767/0001-20</CNPJ>
				<Endereco>Av. Paulista, 1728 - sobreloja</Endereco>
				<telefone>4081-44444</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>PricewaterhouseCoopers Auditores Independentes</Nome>
				<CNPJ>61.562.112/0001-20</CNPJ>
				<Endereco>Av. Francisco Matarazzo, 1400 - Torre Torino</Endereco>
				<telefone>3674-3399</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>N/A</Nome>
				<CNPJ>N/A</CNPJ>
				<Endereco>N/A</Endereco>
				<telefone>N/A</telefone>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>Ourinvest Distribuidora de Títulos e Valores Mob. S.A.</Nome>
				<CNPJ>00.997.804/0001-07</CNPJ>
				<Endereco>Av. Paulista, 1728-sobreloja</Endereco>
				<telefone>4081-4444</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>Ourinvest Asset Gestora de Recursos Ltda</Nome>
				<CNPJ>01.034.817/0001-43</CNPJ>
				<Endereco>Av. Paulista, 1728-5º andar</Endereco>
				<telefone>3146-8600</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>N/A</Nome>
				<CNPJ>N/A</CNPJ>
				<Endereco>N/A</Endereco>
				<telefone>N/A</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
				<Prestador>
					<Nome>Cyrela Brasil Realty S.A. Empreendimentos Participações</Nome>
					<CNPJ>73.178.600/0001-18</CNPJ>
					<Endereco>R. do Rócio,109 - 2º andar- sala 01</Endereco>
					<telefone>4502-3445</telefone>
				</Prestador>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
					<Ativo>
						<Nome>CRI- Ativo 17f0169507 </Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>10415834.8</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI- Ativo 17d0073654</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>8553262.21</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI- Ativo 17j0098014</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>3761325.46</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI- Ativo 18g0797009</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2500000</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI- Ativo 15f0544486</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2437298.51</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI- Ativo 17f0169507</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2509353.12</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI- Ativo 18j0673053</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2002169.22</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI- Ativo 17k0188743</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2154819.48</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI- Ativo 17g0788003</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2535000</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Compromissada</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>5000000</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>LFT</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2488562.16</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas FII Pedra Dourada</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>9000030</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Cotas FII BTG Corporate Office Fund</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2977002.62</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>LCI - Banco ABC Brasil</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>5000000</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>LCI - Banco Inter</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>3281315.47</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>LCI - Banco BTG Pactual</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>475086.97</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Buscando melhorar a rentabilidade do Fundo, a Administração envidará melhores esforços para ampliar a alocação de recursos em CRIs (Certificado de recebíveis imobiliários)  bem como a aplicação em cotas de fundos de invetimentos imobiliários continuará ocorrendo, de forma pontual e tática, aproveitando o momento de mercado e teses específicas de alguns ativos. Adicionalmente, poderá haver o investimento direto em imóveis, vislumbrando renda e/ou ganhos de capital. 
</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo iniciou suas atividades em março de 2018 e encerrou o ano com cota de mercado no valor de R$ 93,90 e cota patrimonial de R$ 97,71. Durante o período findo, o Fundo distribuiu rendimentos no montante total de R$ 1.987 mil, valor médio pago por cota de R$ 3,72.</ResultadoFundo>
			<ConjunturaEconomica>No encerramento do período foi possível verificar alguma melhora, no segmento imobiliário, com queda nas taxas de vacância e redução dos estoques nas principais cidades.
Ao mesmo tempo em que a melhora do cenário, causada pela manutenção da taxa de juros em baixos níveis históricos, facilitou a concessão de crédito, o cenário de incerteza política, tanto na época de eleição quanto na espera pelas reformas, dificultou a precificação dos ativos e consequente alocação dos recursos dos fundos.
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A Administração trabalha com o cenário de que a taxa Selic permanecerá em níveis baixos com inflação sob controle, propiciando uma melhora no crédito e crescimento econômico e também de que os aluguéis serão pressionados, pela falta de imóveis com qualidade, devido ao descompasso de produção e entrega, as taxas de vacância já vêm apresentando queda nas principais praças, o que não se observou no último ciclo imobiliário.
Desta forma, a Administração procurará se posicionar em ativos que capturem mais rapidamente a melhoria no cenário descrito.
 
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>CRI - 17D0073654</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2013484.19</Valor>
				<PercentValorizacaoDesvalorizacao>-0.00661</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - 17J0098014</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2534766.29</Valor>
				<PercentValorizacaoDesvalorizacao>-0.01737</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - 18J0673053</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2068804.62</Valor>
				<PercentValorizacaoDesvalorizacao>0.02</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - 17K0188743</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1303235.51</Valor>
				<PercentValorizacaoDesvalorizacao>0.0077</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - 18G0797009</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2591951.07</Valor>
				<PercentValorizacaoDesvalorizacao>0.02285</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI - 17G0788003</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2548118.48</Valor>
				<PercentValorizacaoDesvalorizacao>0.00368</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>LCI - Banco ABC</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5114463.35</Valor>
				<PercentValorizacaoDesvalorizacao>0.00061</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>LCI - Banco Inter</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3284506.89</Valor>
				<PercentValorizacaoDesvalorizacao>0.00097</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>LCI - Banco BTG Pactual</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>479730.26</Valor>
				<PercentValorizacaoDesvalorizacao>0.00977</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII Pedra Dourada</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5274500</Valor>
				<PercentValorizacaoDesvalorizacao>0.06383</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cotas FII BTG Pactual Corp. Office Fund</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3102300</Valor>
				<PercentValorizacaoDesvalorizacao>0.0341</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Compromissadas Banco Votorantim</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5005418.75</Valor>
				<PercentValorizacaoDesvalorizacao>0.00108</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Para os certificados de recebíveis imobiliários, a metodologia utilizada está baseada em um modelo de negócio cujo objetivo é coletar os fluxos de caixa atuais, definido no Manual de Apreçamento, que considera principalmente a projeção da taxa de índice de preço e spread de crédito. As Letras de crédito imobiliário e as operações compromissadas o valor contábil equivalia, aproximadamente, ao valor de mercado. As cotas de fundos de investimento imobiliário são ajustadas mensalmente pela variação no valor das cotas dos fundos investidos do último dia útil de cada mês, divulgadas na B3, independente do volume de cotas negociado.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>N/A</Numero>
				<Juizo>N/A</Juizo>
				<Instancia>N/A</Instancia>
				<DataInstauracao>1899-12-31</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>N/A</PartesProcesso>
				<PrincipaisFatos>N/A</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>N/A</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
			<Processo>
				<Numero>N/A</Numero>
				<Valores>0</Valores>
				<CausaContingencia>N/A</CausaContingencia>
			</Processo>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos>Não aplicável</AnaliseImpactos>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. Paulista, 1728 - Sobreloja</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.ourinvest.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Endereço Físico: AVENIDA PAULISTA, 1728, SOBRELOJA, BELA VISTA, SÃO PAULO – SP
Endereço Eletrônico: fundos.imobiliarios@ourinvest.com.br
</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Poderão participar da Assembleia os cotistas inscritos no registro de cotistas do Fundo na data da convocação da respectiva Assembleia, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano. Para tanto, é necessário apresentar documento de identificação válido, no caso de cotista pessoa física, ou em caso de pessoa jurídica ou fundo de investimento, documento de identificação válido do(s) representante(s) acompanhado de cópia autenticada do estatuto/contrato social ou cópia simples do regulamento e procuração específica para comprovar poderes. Em caso de cotista representado por procurador, a procuração deve trazer poderes específicos para prática do voto e estar com firma reconhecida. No caso de consultas formais, deverão ser observados os prazos e condições específicas a cada consulta conforme detalhado em seu edital, observado sempre o prazo mínimo previsto em regulamento e na regulamentação. O procedimento para verificação da qualidade de cotista e sua representação acima descrita também é aplicável neste caso. Não há possibilidade de voto à distância. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>O administrador não tem como prática a realização de assembleias por meio eletrônico.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O ADMINISTRADOR receberá por seus serviços uma taxa de administração calculada (a) sobre o valor contábil do patrimônio líquido do FUNDO; ou (b) caso as cotas do FUNDO tenham integrado ou passado a integrar, no período, índices de mercado, cuja metodologia preveja critérios de inclusão que considerem a liquidez das cotas e critérios de ponderação que considerem o volume financeiro das cotas emitidas pelo FUNDO, como por exemplo, o IFIX, sobre o valor de mercado do FUNDO, calculado com base na média diária da cotação de fechamento das cotas de emissão do FUNDO no mês anterior ao do pagamento da remuneração (“Base de Cálculo da Taxa de Administração”) o percentual de (i) 1,05% (um inteiro e cinco centésimos por cento) à razão de 1/12 avos e que deverá ser pago diretamente ao ADMINISTRADOR, observado o valor mínimo mensal de R$ 65.000,00 (sessenta e cinco mil reais), atualizado anualmente segundo a variação do IGPM/FGV, ou índice que vier a substituí-lo, a partir do mês subsequente à data de encerramento da oferta das cotas da Primeira Emissão do FUNDO; e (ii) o percentual de até 0,10% (dez centésimos por cento) ao ano, à razão de 1/12 avos, correspondente aos serviços de escrituração das cotas, a ser pago a terceiros. 
A taxa de administração será calculada mensalmente por período vencido e quitada até o 5º (quinto) Dia Útil do mês subsequente ao mês em que os serviços forem prestados.
O valor integrante da taxa de administração correspondente à escrituração das cotas descrito no caput deste artigo, poderá variar exclusivamente em função da movimentação de cotas e quantidade de cotistas que o FUNDO tiver, sendo que nesta hipótese, o valor da taxa de administração irá refletir em imediata e igual proporção à variação comprovada da taxa de escrituração.
</PoliticaRemuneracao>
			<ValorPagoAno>153961.38</ValorPagoAno>
			<PercentPatrimonioContabil>0.003</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.003</PercentPatrimonioValorMercado>
		</RemuneracaoAdministrador>
		<Governanca>
			<RepresentantesCotistas>
				<Representante1>
					<Nome>N/A</Nome>
					<Idade>0</Idade>
					<CPF>0</CPF>
					<Email>N/A</Email>
					<Profissao>N/A</Profissao>
					<FormacaoAcademica>N/A</FormacaoAcademica>
					<FormaRemuneracao>N/A</FormaRemuneracao>
					<ValorPagoAno>0</ValorPagoAno>
					<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
					<PercentPatrimonioValorMercado>0</PercentPatrimonioValorMercado>
					<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
					<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
					<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
					<DataEleicaoAssembleia>1899-12-31</DataEleicaoAssembleia>
					<TerminoMandato>1899-12-31</TerminoMandato>
					<ExperienciasProfUltimosCincoAnos>
						<Experiencia>
							<NomeEmpresa>N/A</NomeEmpresa>
							<Periodo>N/A</Periodo>
							<CargoFuncoes>N/A</CargoFuncoes>
							<AtividadePrincipalEmpresa>N/A</AtividadePrincipalEmpresa>
						</Experiencia>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
						<Fundo>
							<Nome>N/A</Nome>
							<DataEleicaoAssembGeral>1899-12-31</DataEleicaoAssembGeral>
							<TerminoMandato>1899-12-31</TerminoMandato>
						</Fundo>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal>N/A</CondenacaoCriminal>
						<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
					</Eventos>
				</Representante1>
				<Representante2>
					<Nome>N/A</Nome>
					<Idade>0</Idade>
					<CPF>0</CPF>
					<Email>0</Email>
					<Profissao>N/A</Profissao>
					<FormacaoAcademica>N/A</FormacaoAcademica>
					<FormaRemuneracao>N/A</FormaRemuneracao>
					<ValorPagoAno>0</ValorPagoAno>
					<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
					<PercentPatrimonioValorMercado>0</PercentPatrimonioValorMercado>
					<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
					<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
					<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
					<DataEleicaoAssembleia>1899-12-31</DataEleicaoAssembleia>
					<TerminoMandato>1899-12-31</TerminoMandato>
					<ExperienciasProfUltimosCincoAnos>
						<Experiencia>
							<NomeEmpresa>N/A</NomeEmpresa>
							<Periodo>N/A</Periodo>
							<CargoFuncoes>N/A</CargoFuncoes>
							<AtividadePrincipalEmpresa>N/A</AtividadePrincipalEmpresa>
						</Experiencia>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
						<Fundo>
							<Nome>N/A</Nome>
							<DataEleicaoAssembGeral>1899-12-31</DataEleicaoAssembGeral>
							<TerminoMandato>1899-12-31</TerminoMandato>
						</Fundo>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal>N/A</CondenacaoCriminal>
						<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
					</Eventos>
				</Representante2>
				<Representante3>
					<Nome>N/A</Nome>
					<Idade>0</Idade>
					<CPF>0</CPF>
					<Email>N/A</Email>
					<Profissao>N/A</Profissao>
					<FormacaoAcademica>N/A</FormacaoAcademica>
					<FormaRemuneracao>N/A</FormaRemuneracao>
					<ValorPagoAno>0</ValorPagoAno>
					<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
					<PercentPatrimonioValorMercado>0</PercentPatrimonioValorMercado>
					<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
					<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
					<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
					<DataEleicaoAssembleia>1899-12-31</DataEleicaoAssembleia>
					<TerminoMandato>1899-12-31</TerminoMandato>
					<ExperienciasProfUltimosCincoAnos>
						<Experiencia>
							<NomeEmpresa>N/A</NomeEmpresa>
							<Periodo>N/A</Periodo>
							<CargoFuncoes>N/A</CargoFuncoes>
							<AtividadePrincipalEmpresa>N/A</AtividadePrincipalEmpresa>
						</Experiencia>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
						<Fundo>
							<Nome>N/A</Nome>
							<DataEleicaoAssembGeral>1899-12-31</DataEleicaoAssembGeral>
							<TerminoMandato>1899-12-31</TerminoMandato>
						</Fundo>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal>N/A</CondenacaoCriminal>
						<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
					</Eventos>
				</Representante3>
				<Representante4>
					<Nome>N/A</Nome>
					<Idade>N/A</Idade>
					<CPF>0</CPF>
					<Email>N/A</Email>
					<Profissao>N/A</Profissao>
					<FormacaoAcademica>N/A</FormacaoAcademica>
					<FormaRemuneracao>N/A</FormaRemuneracao>
					<ValorPagoAno>0</ValorPagoAno>
					<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
					<PercentPatrimonioValorMercado>0</PercentPatrimonioValorMercado>
					<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
					<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
					<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
					<DataEleicaoAssembleia>1899-12-31</DataEleicaoAssembleia>
					<TerminoMandato>1899-12-31</TerminoMandato>
					<ExperienciasProfUltimosCincoAnos>
						<Experiencia>
							<NomeEmpresa>N/A</NomeEmpresa>
							<Periodo>N/A</Periodo>
							<CargoFuncoes>N/A</CargoFuncoes>
							<AtividadePrincipalEmpresa>N/A</AtividadePrincipalEmpresa>
						</Experiencia>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
						<Fundo>
							<Nome>N/A</Nome>
							<DataEleicaoAssembGeral>1899-12-31</DataEleicaoAssembGeral>
							<TerminoMandato>1899-12-31</TerminoMandato>
						</Fundo>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal>N/A</CondenacaoCriminal>
						<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
					</Eventos>
				</Representante4>
				<Representante5>
					<Nome>N/A</Nome>
					<Idade>0</Idade>
					<CPF>0</CPF>
					<Email>N/A</Email>
					<Profissao>N/A</Profissao>
					<FormacaoAcademica>N/A</FormacaoAcademica>
					<FormaRemuneracao>N/A</FormaRemuneracao>
					<ValorPagoAno>0</ValorPagoAno>
					<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
					<PercentPatrimonioValorMercado>0</PercentPatrimonioValorMercado>
					<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
					<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
					<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
						<Experiencia>
							<NomeEmpresa>N/A</NomeEmpresa>
							<Periodo>N/A</Periodo>
							<CargoFuncoes>N/A</CargoFuncoes>
							<AtividadePrincipalEmpresa>N/A</AtividadePrincipalEmpresa>
						</Experiencia>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
						<Fundo>
							<Nome>N/A</Nome>
							<DataEleicaoAssembGeral>1899-12-31</DataEleicaoAssembGeral>
							<TerminoMandato>1899-12-31</TerminoMandato>
						</Fundo>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal>N/A</CondenacaoCriminal>
						<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
					</Eventos>
				</Representante5>
			</RepresentantesCotistas>
			<DiretorResponsavel>
				<Nome>David Assine</Nome>
				<Idade>62</Idade>
				<CPF>769483078-68</CPF>
				<Email>fundos.imobiliarios@ourinvest.com.br</Email>
				<Profissao>Diretor</Profissao>
				<FormacaoAcademica>Administração de empresas</FormacaoAcademica>
				<DataInicioFuncao>1991-05-17</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Ourinvest Participações S.A.</NomeEmpresa>
						<Periodo>1992-atual</Periodo>
						<CargoFuncoes>Diretor</CargoFuncoes>
						<AtividadePrincipalEmpresa>Holding de instituições não financeiras</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Ourinvest Metais Comercial Exportadora</NomeEmpresa>
						<Periodo>2003-atual</Periodo>
						<CargoFuncoes>Diretor</CargoFuncoes>
						<AtividadePrincipalEmpresa>Comércio atacadista de extração mineral</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Suppliercard Administradora de Cartões</NomeEmpresa>
						<Periodo>05/2004-09/2010</Periodo>
						<CargoFuncoes>Presidente Conselho de Administração</CargoFuncoes>
						<AtividadePrincipalEmpresa>Administração de cartão de crédito</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Assine DTVM</NomeEmpresa>
						<Periodo>1978-1985</Periodo>
						<CargoFuncoes>Sócio-gerente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Distribuidora de títulos e valores mobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>N/A</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="559" numCotasDetidas="533916" percDetidoRelTotal="1" percDetidoPF="0.888" percDetidoPJ="0.112"/>
			<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>
			<Ativo>
				<AtivoNegociado>CRI - 17D0073654</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-06-07</DataTransacao>
				<ValorEnvolvido>5740135.2534894</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 17F0169507</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-06-07</DataTransacao>
				<ValorEnvolvido>10415834.8</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 17J0098014</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-06-29</DataTransacao>
				<ValorEnvolvido>2258422.1865</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 17J0098014 </AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-07-27</DataTransacao>
				<ValorEnvolvido>1502903.29</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 17F0169507</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-09-04</DataTransacao>
				<ValorEnvolvido>2509353.12</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 18J0673053</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-10-22</DataTransacao>
				<ValorEnvolvido>2002169.22</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 17K0188743</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-11-13</DataTransacao>
				<ValorEnvolvido>1238402</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 17D0073654</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-11-22</DataTransacao>
				<ValorEnvolvido>812893.4603</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 17K0188743</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-11-27</DataTransacao>
				<ValorEnvolvido>916417.48</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
			<Ativo>
				<AtivoNegociado>CRI - 17D0073654</AtivoNegociado>
				<NaturezaTransacao>aquisição</NaturezaTransacao>
				<DataTransacao>2018-11-29</DataTransacao>
				<ValorEnvolvido>2000233.5</ValorEnvolvido>
				<DataAssembleia>2018-06-06</DataAssembleia>
				<Contraparte>Ourinvest DTVM</Contraparte>
			</Ativo>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>Caberá ao Administrador zelar para que o Ato ou Fato Relevante ocorrido seja divulgado ao mercado na forma prevista na legislação específica e nesta Política, de forma clara e precisa, em linguagem acessível, bem como zelar pela sua ampla e imediata disseminação, simultânea em todos os mercados em que as cotas sejam negociadas.
O Administrador deve comunicar o Ato ou Fato Relevante à CVM, às Bolsas de Valores e também divulgá-lo através do site do Administrador, no endereço http://www.ourinvest.com.br/pt/fundos-imobiliarios. O acesso a sistemas e arquivos, inclusive em relação à guarda de documentos de caráter confidencial, é restrito à equipe dedicada pela administração de tais fundos, sendo possível o compartilhamento de informações às equipes jurídicas e de compliance que atendam tal área de negócio. Adicionalmente, o Administrador tem como política interna a exigência de termos de confidencialidade com todos os seus funcionários, no momento de sua contratação. 
Sempre que possível, a divulgação de qualquer Ato ou Fato Relevante ocorrerá após o encerramento dos negócios nas Bolsas de Valores e entidades do mercado de Balcão Organizado, onde as cotas do FII sejam negociadas.

Caso seja necessário que a divulgação ocorra durante o horário de negociação, o Administrador poderá, ao comunicar o Ato ou Fato Relevante, solicitar a suspensão das negociações pelo tempo necessário à adequada disseminação da informação relevante. 

Sempre que for veiculado Ato ou Fato Relevante por qualquer meio de comunicação, inclusive informação à imprensa ou em reuniões de entidades de classe, investidores, analistas ou público selecionado, no País ou no exterior, o Ato ou Fato Relevante deverá ser simultaneamente divulgado à CVM, às Bolsas de Valores, entidade do mercado de Balcão Organizado e ao mercado em geral.
</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>https://www.ourinvest.com.br/fii/ourinvest-cyrela</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.ourinvest.com.br/fii/ourinvest-cyrela</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Administração de fundos: Mary Harumi Takeda
Jurídico: Edilson Ciro Romor Guidini
Compliance: Vanessa Fernandes Guardachoni
</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Conforme previsto no artigo 18 do Regulamento do Fundo, o Administrador, poderá, considerada a recomendação dos consultores, realizar novas emissões de cotas no montante total de até quinhentos milhões de reais, para atender à política de investimentos do Fundo, independentemente de prévia aprovação da assembleia geral de cotistas ("Nova Emissão"). A decisão relativa à eventual Nova Emissão de cotas será comunicada aos cotistas formalmente pelo Administrador. </RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"