"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>01235622000161</CNPJFundo>
		<DataFuncionamento>1996-10-07</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>BRFTCECTF005</CodigoISIN>
		<QtdCotasEmitidas>876521</QtdCotasEmitidas>
		<FundoExclusivo>true</FundoExclusivo>
		<VinculoFamiliarCotistas>true</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Híbrido</Mandato>
			<SegmentoAtuacao>Híbrido</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>BNY MELLON SERVIÇOS FINANCEIROS DTVM S/A</NomeAdministrador>
		<CNPJAdministrador>01235622000161</CNPJAdministrador>
		<Logradouro>AV. PRESIDENTE WILSON</Logradouro>
		<Numero>231</Numero>
		<Complemento>11º ANDAR</Complemento>
		<Bairro>CENTRO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>20030905</CEP>
		<Telefone1>32192554</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.bnymellon.com.br</Site>
		<Email>bnymellon_cvm@bnymellon.com.br</Email>
		<Competencia>2020-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>BNY MELLON SERVIÇOS FINANCEIROS DTVM S/A</Nome>
				<CNPJ>02.201.501/0001-61</CNPJ>
				<Endereco>Av. Presidente Wilson, n.º 231, 11° andar – Parte, Centro - Rio de Janeiro - RJ</Endereco>
				<telefone>21 32192554</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BNY MELLON BANCO S.A.</Nome>
				<CNPJ>42272526000170</CNPJ>
				<Endereco>Av. Presidente Wilson, nº231, 10º andar, Centro - Rio de Janeiro - RJ</Endereco>
				<telefone>21 32192500</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>ERNST &amp; YOUNG AUDITORES INDEPENDENTES S/S </Nome>
				<CNPJ>61366936000206</CNPJ>
				<Endereco>PR DO BOTAFOGO,370 ANDAR 8 </Endereco>
				<telefone>(11) 2573-2565</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>OPPORTUNITY DTVM LTDA</Nome>
				<CNPJ>1582158000180</CNPJ>
				<Endereco>Av. Presidente Wilson, n.º 231, 28° andar – Parte, Centro - Rio de Janeiro - RJ</Endereco>
				<telefone>21 38043872</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>OPPORTUNITY MÉTRICA LTDA.</Nome>
				<CNPJ>29839743000131</CNPJ>
				<Endereco>Avenida Presidente Wilson, nº 231, 28º andar, Centro - Rio de Janeiro - RJ</Endereco>
				<telefone>21 38043700</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>OPPORTUNITY MÉTRICA LTDA.</Nome>
				<CNPJ>29839743000131</CNPJ>
				<Endereco>Avenida Presidente Wilson, nº 231, 28º andar, Centro - Rio de Janeiro - RJ</Endereco>
				<telefone>21 38043700</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
					<Ativo>
						<Nome>Terreno Green Village (Espírito Santo)</Nome>
						<Objetivos>Incorporação residencial</Objetivos>
						<MontantesInvestidos>5300000</MontantesInvestidos>
						<OrigemRecursos>Recursos Próprios</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome> Terreno R. Lineu de Paula Machado (Rio de Janeiro)</Nome>
						<Objetivos>Incorporação residencial</Objetivos>
						<MontantesInvestidos>11400000</MontantesInvestidos>
						<OrigemRecursos>Recursos Próprios</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Para os próximos exercícios o Fundo seguirá com a estratégia de adquirir terrenos em áreas de expansão através de permuta para realizar incorporação residencial e comercial.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O resultado do Fundo para o exercício social findo em 31/12/2020 é de R$-95.856.186,45</ResultadoFundo>
			<ConjunturaEconomica>O ano de 2020 foi marcado pela crise sanitária Coronavírus (COVID-19) que trouxe grandes impactos políticos, sociais, econômicos e sanitários no Brasil. 
Do lado político, vê-se um ambiente conturbado com estratégias divergentes no combate à pandemia entre alguns políticos estaduais e o presidente (Bolsonaro), e, também, diversos movimentos pró-governo e contra o governo.
A economia do país foi profundamente afetada pelas medidas restritivas que ocorreram no país. De acordo com o IBGE, o Brasil teve a sua pior queda do PIB (4,1%) desde 1996, enquanto que o PIB per capita teve queda de 4,8%, mesmo com as medidas de auxílios financeiros governamentais a empresas e famílias durante o ano. Todavia, o setor imobiliário foi uma exceção e apresentou crescimento de 2,5%. 
O país teve aceleração na inflação de 4,4% no ano diminuindo o poder de compras de empresas e famílias, e, como medida expansionista para conter a crise, diminuiu a taxa de juros ao longo do ano em 250 bps chegando ao patamar de taxa de juros mais baixa da história (2,5%) no final do ano. Além disso, é fundamental ressaltar dois pontos: o aumento da dívida pública que alcançou níveis acima de 90% do PIB e aumento acumulado no ano de quase 30% do dólar frente à nossa moeda.
O Brasil teve quase 8 milhões de casos de COVID confirmados e quase 200 mil óbitos no ano. Uma crise que afetou também o modo de vida de todos. O home office se tornou a grande tendência do momento para evitar aglomerações, bem como o consumo em plataformas digitais.
No Rio de Janeiro, onde o Opportunity possui a maior parte dos seus imóveis corporativos, segundo a empresa de consultoria Buildings, a vacância dos escritórios AA&amp;A atingiu 40% principalmente devido ao modelo de Home office adotado pelas empresas e também pela crescente demanda por espaços coworking. De acordo com a incorporadora e consultora JLL, o Rio de Janeiro encerra o ano (4T 2020) com absorção líquida (diferença no volume total ocupado entre dois períodos consecutivos) positiva em 5,9 mil m².
O mercado de incorporação residencial se manteve estável no ano 2020 com pouca variação de preços e volumes de vendas.De acordo com FipeZap de venda, o Rio de Janeiro-RJ (local de maiores empreendimentos do Opportunity) foi a capital com preço médio de venda do m² mais cara do país (9.437/m², aumento de 3,79% em relação ao ano de 2019). Entretanto, o Índice FipeZap no Rio de Janeiro teve alta de 1,60%, menor que a inflação de 4,38% no ano – queda real de 2,98%. Já em Brasília-DF e Vitória-ES, locais onde o Opportunity também possui alguns empreendimentos, tiveram aumento de 9,13% e 7,46% respectivamente, proporcionando, um crescimento real positivo. </ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Para o próximo ano, a expectativa é de estabilidade no mercado corporativo do Rio de Janeiro, devido principalmente à redução gradativa do Home Office pelas empresas e o retorno aos escritórios. Para o mercado residencial, a expectativa é de uma maior demanda e por consequência, aumento de preços por imóveis maiores, principalmente para adaptação ao Home office e por conta dos menores níveis de taxas de juros (mesmo sabendo do seu aumento no futuro). 
Acredita-se que a flexibilidade nas condições de venda deverá ser mantida com perspectiva de leve incremento em volume de vendas e preços. 
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Citta America</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>153190000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0111</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. Marechal Camara, 160 -  Salas 533 e 537</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3330000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0101</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Presidente Antônio Carlos 51</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3170000</Valor>
				<PercentValorizacaoDesvalorizacao>0.01</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Buenos Aires, 48 - Sobrelojas 2º,4º,5º,6º,7º e 8º</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>17440000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0094</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Conde de Bonfim, 149 - Lojas C e D</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4170000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0097</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rio Branco, 45 - Salas 401 a 412</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2380000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0099</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua do Carmo, 55 - 26 vagas de garagem</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1144000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0085</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Colégio São José</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6413000</Valor>
				<PercentValorizacaoDesvalorizacao>0.009</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Citta Office</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>13160000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Dom Gerardo 46</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>16193485.73</Valor>
				<PercentValorizacaoDesvalorizacao>0.0077</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CESBOM</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>21350000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0107</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Dom Gerardo,40/42</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>22753435.12</Valor>
				<PercentValorizacaoDesvalorizacao>0.0096</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. Brasil,20.384</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7680000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0097</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 11</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1000000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0094</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 13</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1030000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 15</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1040000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 17</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1030000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0094</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 19</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1230000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 21</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1240000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 23</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1080000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0096</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 25</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1230000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 27</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1060000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 29</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1480000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 31</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1630000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 33</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1930000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Carioca 53</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2090000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>1 de Março 19,lj,Pav1/Pav2</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4640000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0082</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Travessa do Ouvidor,9</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4670000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Senhor dos Passos,107</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1930000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0094</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Sete de Setembro,155</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1840000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0094</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Largo de Sata Rita,10</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>860000</Valor>
				<PercentValorizacaoDesvalorizacao>0.009</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Mem de sá,102 </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1790000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0105</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Uruguaiana 76</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Uruguaiana 78</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3870000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0093</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Teófilo Otoni,24 APTO - 40,06%</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>408612</Valor>
				<PercentValorizacaoDesvalorizacao>0.0103</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Teófilo Otoni,24 LOJA - 59,94%</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>611388</Valor>
				<PercentValorizacaoDesvalorizacao>0.0103</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Hotel São Francisco</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>36100000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0095</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Teófilo Otoni,82</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>27633240.65</Valor>
				<PercentValorizacaoDesvalorizacao>0.0088</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Miguel Couto</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>18660000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0098</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Metropolitan</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>94900000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0155</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Aretê - Toriba Hotel</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>10300000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0098</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>São Pedro da Aldeia</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>11920000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0096</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Itabira</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>20300000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0112</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Itumbiara</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>12900000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0105</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rainha Guilhermina</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>25850000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0114</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Eleva SBS</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>82900000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0215</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RUA NUTA JAMES, 877 - MAXIN</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>40290724.3</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>TERRENO ITABORAÍ</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>1029714.77</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>PRESIDENTE VARGAS II - ORBIT</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>46745898.7</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>GREEN VILLAGE</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>46139042.63</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>PARQUE GRAGOATÁ</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>2531896.87</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ENSEADA DO SUÁ - NAVEGANTES</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>35659224.41</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - TORIBA I</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>45884029.8</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - TORIBA OESTE</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>20550592.41</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - TORIBA LESTE</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>15921282.84</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - YBIRÁ FASE I</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>47714855.01</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - YBIRA FASE II</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>16538476.15</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - YBIRÁ FASE III</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>14769946.59</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - YBIRA FASE IV</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>15303099.34</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ELESBÃO LINHARES</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>22092892.35</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>HOMEM DE MELO - TIJUCA</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>20855170.13</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CONDE DE IRAJÁ</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>30107390.09</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>LINEU DE PAULA MACHADO</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>18983208.16</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>HOTEL &amp; BUREAL</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>6468.47</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>FUSION WORK &amp; LIVE</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>487000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>DUE CAPRI</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>893737.97</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>TOSCANINI</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>1557297.32</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>SEASONS</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>207798.88</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RUA DO MATOSO - INNOVITÁ</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>3197929.56</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>TOUCH OFFICES</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>12650900.24</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MIRAGGIO CHARITAS</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>9009269.79</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>VISION</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>132987.51</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>HUB - MARRECAS 11 E 13</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>8487150.02</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ENSEADA DO SUÁ - HIGHLINE</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>22342776.07</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>GIFT - 8 DE DEZEMBRO</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>1396344.72</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ÍCONO PARQUE - FLAMENGO</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>13005946.36</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>THE GALLERY - LORENGE</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>37263630.78</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>HIGHLIGHT - QUADRILATERO - BOTAFOGO</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>18366796.37</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>TIJUCA ALL WAYS</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>275558.47</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>COSTA NOVA - ÁREA 09 (COSTA MARE)</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>88533109.97</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ILUMINATO - RAUL FERNANDES - BOTAFOGO</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>3637729.64</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - YBIRÁ FASE I</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>10645321.52</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - TORIBA NORTE</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>19178214.91</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - TORIBA SUL</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>15609729.98</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>LARANJEIRAS, 139</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>10682623.69</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ASSUNÇÃO BOTAFOGO</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>10242244.7</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>ARETÊ - ALTO YBIRÁ</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>6887973.51</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Conforme determina a Associação Brasileira de Normas Técnicas (ABNT), através de sua NBR-14.653-2, que trata dos procedimentos e metodologia aplicáveis na avaliação de imóveis urbanos em todo o território nacional, foram procedidas vistoria no local, consultas junto a Prefeitura Municipal e outras repartições públicas a nível estadual e federal, bem como à ampla pesquisa de mercado, enfocando notadamente o segmento imobiliário em que se inserem as propriedades em exame. A vistoria buscou através do levantamento das características dos imóveis e sua circunvizinhança
imediata, criar o arcabouço necessário ao desenvolvimento da análise mercadológica. As consultas realizadas junto aos órgãos públicos, esclareceram a situação da propriedade face as restrições impostas pela Lei do Uso do Solo, de forma a apreciar o potencial de utilização do bem. A pesquisa imobiliária dirigida especificamente para imóveis similares aos aqui abordados compulsou as seções de classificados dos principais periódicos, obteve nosso bando de dados as mais recentes informações sobre transações ocorridas na região. Considerou, ainda, o parecer dos mais atuantes operadores do mercado, principalmente aqueles especializados na zona em que se localizam as propriedades aqui enfocadas. O método utilizado nesta análise foi o comparativo, através do qual o valor do bem é obtido pela comparação de dados de mercado, relativos a outros imóveis que guardem similaridade com as propriedades em estudo.
Dentro da escala de confiança da metodologia adotada, este estudo classifica-se como laudo de avaliação expedido.                                                                                                                           Não houve vistoria no local devido ao cenário pandêmico do Covid-19.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>0158123-70.1995.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Pública</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>1995-12-15</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X MUNICIPIO DO RIO DE JANEIRO</PartesProcesso>
				<PrincipaisFatos>Estamos atuando nesta ação unicamente para Impedir a realização de penhora sobre o matrícula do imóvel localizado na Rua General Goés Monteiro, nº 125.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0190483-14.2002.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Pública</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2002-08-09</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X MUNICIPIO DO RIO DE JANEIRO</PartesProcesso>
				<PrincipaisFatos>Estamos atuando nesta ação unifcamente para Impedir a realização de penhora sobre o matrícula do imóvel localizado na Rua General Goés Monteiro, nº 125.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>2004.001.135000-0</Numero>
				<Juizo>50ª VARA CÍVEL</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2004-11-18</DataInstauracao>
				<ValorCausa>339299</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X PATRÍCIA DE ALMEIDA GOMES</PartesProcesso>
				<PrincipaisFatos>TRATA-SE DE EXECUÇÃO, TENDO EM VISTA O INADIMPLEMENTO NO PAGAMENTO DAS PRESTAÇÕES OBJETO DO FINANCIMENTO IMOBILIÁRIO</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0004990-14.2005.8.19.0209 </Numero>
				<Juizo>6º VARA DA BARRA DA TIJUCA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2005-06-10</DataInstauracao>
				<ValorCausa>34953</ValorCausa>
				<PartesProcesso>MARIA ELEONEIDA DE ALBUQUERQUE RIBEIRO X  OPPORTUNITY</PartesProcesso>
				<PrincipaisFatos>DEVEDORA INGRESSOU COM EMBARGOS ALEGANDO QUE OS VALORES COBRADOS NÃO CONDIZEM COM O REAL VALOR QUE ALEGAMOS DEVIDO CONFIRMADO PELO PERITO -R$ 44.063,42, conforme EXTRATO DO CLIENTE; </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101033-84.2007.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2007-07-10</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de medida cautelar de produção antecipada de provas cujo escopo é a realização de prova pericial a ser utilizada em posterior ação judicial ou processo administrativo, visando comprovar que o Município do Rio de Janeiro vem utilizando como base de cálculo de IPTU valor venal acima da realidade mercadológica do imóvel situado na Avenida das Américas, 700, loja 318, Barra da Tijuca.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01043578220078190001</Numero>
				<Juizo>1 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2007-07-16</DataInstauracao>
				<ValorCausa>321436</ValorCausa>
				<PartesProcesso>ANA LUCIA GAJEVSKI X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Rescisão do contrato de compra e venda definitiva do imóvel situado na Av. Dulcídio Cardoso, nº 1.315, apto 202, bloco 01.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0247892-69.2007.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Pública</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2007-12-14</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X O.S. Serviços</PartesProcesso>
				<PrincipaisFatos>Estamos apenas atuando na execução fiscal para dar baixa no 9º Distribuidor.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0225531-24.2008.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2008-08-06</DataInstauracao>
				<ValorCausa>1312498.47</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 318, inscrição imobiliária nº 2972054-7, consubstanciado na CDA nº 01/158.211/2006, referente ao exercício de 2004.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0257272-82.2008.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2008-08-21</DataInstauracao>
				<ValorCausa>2699563.23</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 321, consubstanciados nas CDAs nºs 01/158.212/2006 e 01/140.623/2006, referente exercício de 2004.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0386507-05.2008.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2008-11-27</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de medida cautelar de produção antecipada de provas cujo escopo é a realização de prova pericial a ser utilizada em posterior ação judicial ou processo administrativo, visando comprovar que o Município do Rio de Janeiro vem utilizando como base de cálculo de IPTU valor venal acima da realidade mercadológica do imóvel situado na Avenida das Américas, 700, bloco 8, lojas 115K, 118A, 118B, 118C, 118D, 118E, Barra da Tijuca.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0386504-50.2008.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2008-11-27</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de medida cautelar de produção antecipada de provas cujo escopo é a realização de prova pericial a ser utilizada em posterior ação judicial ou processo administrativo, visando comprovar que o Município do Rio de Janeiro vem utilizando como base de cálculo de IPTU valor venal acima da realidade mercadológica do imóvel situado na Avenida das Américas, 700, bloco 8, lojas. 301 A - 302 A - 302 E - 302 F - 302 G- 302 H - 303 A - 303 B - 303 E - 305 B - 305 C - 305 I - 305 K - 306 A - 306 C - 306 E - 306 F - 309 A - 309 G - 309 H, Barra da Tijuca.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0386500-13.2008.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2008-11-27</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de medida cautelar de produção antecipada de provas cujo escopo é a realização de prova pericial a ser utilizada em posterior ação judicial ou processo administrativo, visando comprovar que o Município do Rio de Janeiro vem utilizando como base de cálculo de IPTU valor venal acima da realidade mercadológica do imóvel situado na Avenida das Américas, 700, bloco 8, lojas 317G - 317H - 317 I - 317J - 317M - 319I - 319J - 320A - 320B - 320C - 320D - 320E - 320F, Barra da Tijuca.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0091608-62.2009.8.19.0001</Numero>
				<Juizo>23ª Vara Cível</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2009-04-14</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X Espólio de Wenceslau Dyminsk Wozniewicz</PartesProcesso>
				<PrincipaisFatos>Estamos atuando nesta ação unifcamente para Impedir a realização de penhora sobre o matrícula do imóvel localizado na Rua General Goés Monteiro, nº 125.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0170900-96.2009.8.19.0001</Numero>
				<Juizo>3ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2009-07-07</DataInstauracao>
				<ValorCausa>5597.76</ValorCausa>
				<PartesProcesso>CONDOMÍNIO DO EDIFÍCIO DA RUA SÃO CLEMENTE 159XBANCO OPPORTUNITY S.A.</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de obrigação de fazer na qual o autor requer que as rés sejam compelidas a promover o pagamento dos IPTUs de 2001 e 2002.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0273775-47.2009.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Pública</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2009-10-07</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X Rio Urbe - Empresa Munic. De Urbanização</PartesProcesso>
				<PrincipaisFatos>Estamos apenas atuando na execução fiscal para dar baixa no 9º Distribuidor sem o pagamento de custas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04033873820098190001</Numero>
				<Juizo>24 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2009-12-18</DataInstauracao>
				<ValorCausa>943026.47</ValorCausa>
				<PartesProcesso>OPP FUNDO X LEA LIMA LOURENÇO e FRANCISCO PINTO DO MONTE</PartesProcesso>
				<PrincipaisFatos>Decretação do despejo e cobrança dos aluguéis e encargos locatícios inadimplidos.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020895-28.2010.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2010-01-18</DataInstauracao>
				<ValorCausa>876408.67</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 318, inscrição imobiliária nº 2972054-7, consubstanciados nas CDAs nºs 01/144.180/2009, 01/120.941/2008 e 01/144.181/2009, referente aos exercícios de 2007 e 2006.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0016515-59.2010.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2010-01-18</DataInstauracao>
				<ValorCausa>4228311.82</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 121, inscrição imobiliária nº 2971692-5, consubstanciados nas CDAs nºs 01/120875/2008, 01/144178/2009 e 01/144177/2009, referentes aos exercícios de 2006 e 2007.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0037387-95.2010.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2010-01-21</DataInstauracao>
				<ValorCausa>861039.3</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 321, consubstanciados nas CDAs nºs 01/144.185/2009, 01/144.184/2009 e 01/120.944/2008, referente aos exercícios de 2006 e 2007.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0026921-08.2011.8.19.0001</Numero>
				<Juizo>3º Juizado Especial Cível</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-01-28</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X Luiz Fernando Gabaglia</PartesProcesso>
				<PrincipaisFatos>Estamos atuando nesta ação unifcamente para Impedir a realização de penhora sobre o matrícula do imóvel localizado na Rua General Goés Monteiro, nº 125.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0224497-09.2011.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-07-11</DataInstauracao>
				<ValorCausa>581439.56</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 318, inscrição imobiliária nº 2972054-7, consubstanciados nas CDAs nºs 01/144.182/2009 e 01/144.183/2009, referente ao exercício de 2007.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0218710-96.2011.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-07-11</DataInstauracao>
				<ValorCausa>227153.48</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 121, inscrição imobiliária nº 2971692-5, consubstanciado na CDA nº 01/144.179/2009, referente ao exercício de 2007.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0278447-30.2011.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-08-05</DataInstauracao>
				<ValorCausa>561076.18</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 321, consubstanciados nas CDAs nºs 01/144186/2009 e 01/144187/2009, referente aos exercícios de 2001 e 2000.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0298642-36.2011.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-08-22</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0298630-22.2011.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-08-22</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0392092-33.2011.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-11-07</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0392100-10.2011.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-11-07</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0092235-61.2012.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2012-03-21</DataInstauracao>
				<ValorCausa>2628083.84</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU  consubstanciados na certidão de dívida ativa nº. 01/123149/2011,  referente ao exercício de 2009.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0285291-59.2012.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2012-07-20</DataInstauracao>
				<ValorCausa>3396521.75</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação ordinária que visa: (i) Inicialmente a concessão da liminar para suspender a exigibilidade destas exações (01/140623/2006; 01/158212/2006; 01/120944/2008; 01/144184/2009; 01/144185/2009; 01/144186/2009; 01/144187/2009); (ii) declarar nulos os lançamentos tributários de IPTU referentes aos exercícios de 2002 a 2012 incidentes sobre o imóvel do Autor, devendo ser calculado o efetivo valor do imposto devido de acordo com o laudo pericial produzido na ação cautelar de produção antecipada de provas); (iii) considerando o valor efetivamente devido a título de IPTU incidente sobre o imóvel do autor nos exercícios de 2002 a 2012 e os pagamentos já efetuados pelo autor nesses mesmos períodos, declarar inexistente qualquer dívida de IPTU sobre o imóvel do autor nesses exercícios ; (iv) condenar o Município a restituir o valor de R$ 1.256.332,47 (hum milhão, duzentos e cinquenta seis mil, trezentos e trinta e dois reais e quarenta e sete centavos), pago a maior a título de IPTU nos exercícios de 2002 a 2012, acrescidos de correção monetária e juros de mora na forma da lei.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0285287-22.2012.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2012-07-20</DataInstauracao>
				<ValorCausa>6199994.88</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação ordinária que visa: (i) a concessão da liminar para suspender a exigibilidade da exação (01/123149/2011), pois ilegal e abusiva, conforme demonstrado no laudo pericial homologado nos autos da cautelar de produção antecipada de prova n° 2007.001.100634-4. (ii) sejam declarados nulos os lançamentos tributários de IPTU referentes aos exercícios de 2002 a 2012 incidentes sobre o imóvel do autor, devendo ser calculado o efetivo valor do imposto devido de acordo com o laudo pericial produzido na ação cautelar de produção antecipada de provas n° 2007.001.100634-4; (iii) seja considerado o valor efetivamente devido a título de IPTU incidente sobre o imóvel do autor nos exercícios de 2002 a 2012 e os pagamentos já efetuados pelo autor nesses mesmos períodos, declarar inexistente qualquer dívida de IPTU sobre o imóvel do autor nesses exercícios; (iv) condenar o Município a restituir o valor de R$ 4.085.728,39 (quatro milhões, oitenta e cinco mil, setecentos e vinte oito reais e trinta e nove centavos), pago a maior a título de IPTU nos exercícios de 2002 a 2012, acrescidos de correção monetária e juros de mora na forma da lei; (v) condenar o Município a observar, também para os exercícios posteriores, os valores apurados no laudo pericial homologado, devidamente corrigidos em consonância com a legislação municipal, de modo a evitar a perpetuação da cobrança indevida nos exercícios futuros.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0285279-45.2012.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2012-07-20</DataInstauracao>
				<ValorCausa>3842732.3</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação ordinária que visa: (i) a concessão da liminar para suspender a exigibilidade destas exações (01/158211/2006; 01/120941/2008; 01/144180/2009; 01/144181/2009; 01/144182/2009; 01/144183/2009), pois ilegais e abusivas, conforme demonstrado no laudo pericial homologado nos autos da cautelar de produção antecipada de prova nº 2007.001.098800-5. (ii) sejam declarados nulos os lançamentos tributários de IPTU referentes aos exercícios de 2002 a 2012 incidentes sobre o imóvel do autor, devendo ser calculado o efetivo valor do imposto devido de acordo com o laudo pericial produzido na ação cautelar de produção antecipada de provas n°2007.001.098800-5; (iii) seja considerado o valor efetivamente devido a título de IPTU incidente sobre o imóvel do autor nos exercícios de 2002 a 2012 e os pagamentos já efetuados pelo autor nesses mesmos períodos, declarar inexistente qualquer dívida de IPTU sobre o imóvel do autor nesses exercícios; (iv) condenar o Município a restituir o valor de R$ 1.421.380,38 (hum milhão, quatrocentos e vinte e um mil, trezentos e oitenta reais e trinta e oito centavos), pago a maior a título de IPTU nos exercícios de 2002 a 2012, acrescidos de correção monetária e juros de mora na forma da lei. (v) condenar o Município a observar, também para os exercícios posteriores, os valores apurados no laudo pericial homologado, devidamente corrigidos em consonância com a legislação municipal, de modo a evitar a perpetuação da cobrança indevida nos exercícios futuros.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0056137-13.2012.8.07.0001</Numero>
				<Juizo>PRIMEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2012-12-19</DataInstauracao>
				<ValorCausa>62113.04</ValorCausa>
				<PartesProcesso>ALFREDO LUIZ CAMPOS JUNIOR E  MICHELINE GOMES CAMPOS DA LUZ X  OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO E  TAO EMPREENDIMENTOS IMOBILIARIOS SA E JOAO FORTES ENGENHARIA SA</PartesProcesso>
				<PrincipaisFatos>Devolução dos valores pagos a título de corretagem em dobro, lucros cessantes, multa contratual, indenização por danos extrapatrimoniais.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0046470-66.2013.8.07.0001</Numero>
				<Juizo>SEGUNDA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-04-12</DataInstauracao>
				<ValorCausa>400000</ValorCausa>
				<PartesProcesso> RICARDO JOSE PATERNOSTRO RODRIGUES X  BANCO OPPORTUNITY S.A. e  JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA e  JOAO FORTES ENGENHARIA SA </PartesProcesso>
				<PrincipaisFatos>Antecipação dos efeitos da tutela; rescisão contratual; devolução integral dos valores pagos e lucros cessantes.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0146316-23.2013.8.19.0001</Numero>
				<Juizo>12º VFP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-05-02</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X MUNICIPIO DO RIO DE JANEIRO</PartesProcesso>
				<PrincipaisFatos>Declaração de nulidade da Nota de Lançamento 634/2011, cobrança de ISS. O depósito foi convertido em renda, requer-se a repetição.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01531330620138190001</Numero>
				<Juizo>33 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-05-09</DataInstauracao>
				<ValorCausa>44718.72</ValorCausa>
				<PartesProcesso>OCEAN DRIVE LANCHONETE LTDA. - ME X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Depósito judicial dos alugueis devidos pela locação da loja, pois alega dúvida quanto a quem deveria efetuaros pagamentos, uma vez que o imóvel era de propriedade da VOT.  </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01676346220138190001</Numero>
				<Juizo>10 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-05-17</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FUNDO X VESÚVIO COMÉRCIO E INDUSTRÍA DE GUARDA CHUVAS LTDA.</PartesProcesso>
				<PrincipaisFatos>Decretação do despejo , com a condenação ao pagamento de aluguel pena. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00210011820138070001</Numero>
				<Juizo>3ª V.EXE.</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-06-10</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FUNDO X FLÁVIO RODRIGUES CALIL DAHER</PartesProcesso>
				<PrincipaisFatos>Cobrança das parcelas do financimento imobiliário pactuados nas promessas de compra e venda das unidades 313 e 614.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00690075620138070001</Numero>
				<Juizo>IV JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-07-05</DataInstauracao>
				<ValorCausa>27661.02</ValorCausa>
				<PartesProcesso>FLAVIO RODRIGUES CALIL DAHER X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Restiuição, em dobro, dos valores pagos a título de comissão de corretagem.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0005399-58.2003.8.19.0209 </Numero>
				<Juizo>6º VARA DA BARRA DA TIJUCA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-07-15</DataInstauracao>
				<ValorCausa>34953</ValorCausa>
				<PartesProcesso> OPPORTUNITY X MARIA ELEONEIDA DE ALBUQUERQUE RIBEIRO</PartesProcesso>
				<PrincipaisFatos>TRATA-SE DE EXECUÇÃO, TENDO EM VISTA O IINADIMPLEMENTO NO PAGAMENTO DAS PRESTAÇÕES OBJETO DO FINANCIMENTO IMOBILIÁRIO</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>425318</Numero>
				<Juizo>Quarta Turma do STJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-10-24</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FUNDO X ANA LUCIA GAJEVSKI</PartesProcesso>
				<PrincipaisFatos>Reformar a decisão que inadmitiu o recurso especial para determinar que a Décima Sética Câmara Cível do Tribunal de Justiça do Rio de Janeiro se manifeste expressamente acerda da omissão e obscuridade apontadas e, caso assim não se entenda, para restabelecer a sentença de primeira instância que corretamente julgou improcedente o pedido, em razão da confessada inadimplência da autora, que tornou incontroversa a mora, bem como porque o procedimento de cobrança estabelecido nos artigos 26 e 27 da Lei 9.514/97 foi absolutamente observado, tendo sido a propriedade fiduciária consolidade por ausência de arrematantes e quitado a dívida, não havendo que se falar em interesse para rescindir contrato já extinto.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>004200995920138070001</Numero>
				<Juizo>25ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-11-04</DataInstauracao>
				<ValorCausa>191722.97</ValorCausa>
				<PartesProcesso>MARCO AURÉLIO LIMA FERNANDES X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Rescisão da promessa de compra e venda da unidade (Apart-hotel) nº 309 Bloco. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00361568320138190209</Numero>
				<Juizo>2 VC-BT</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-11-22</DataInstauracao>
				<ValorCausa>16558348.84</ValorCausa>
				<PartesProcesso>OPP FUNDO X PORCÃO LICENCIAMENTOS E PARTICIPAÇÕES S.A</PartesProcesso>
				<PrincipaisFatos>Decretação do despejo e a cobrança dos alugueis e encargos locatícios, no valor histórico de R$ 7.638.522,56.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00322489320134025101  </Numero>
				<Juizo>26 VF-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-12-18</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>INPI – Instituto Nacional de Propriedade Intelectual  X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Provimento dos embargos à excução por suposta ilegitimidade passiva e ausência de título executivo.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0049271-52.2013.8.07.0001</Numero>
				<Juizo>VIGÉSIMA TERCEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-12-19</DataInstauracao>
				<ValorCausa>81346.21</ValorCausa>
				<PartesProcesso>DELIANA MACHADO VALENTE X  BANCO OPPORTUNITY SA e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual com a devolução dos valores pagos </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0187189-60.2016.8.19.0001</Numero>
				<Juizo>TRIGÉSIMA SEGUNDA VARA CÍVEL DO RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-01-24</DataInstauracao>
				<ValorCausa>10482491.74</ValorCausa>
				<PartesProcesso>NTR EMPREITEIRA DE MÃO DE OBRA LTDA X OPPORTUNITY FII e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA </PartesProcesso>
				<PrincipaisFatos>PRESTAÇÃO DE SERVIÇOS  - empreitada e obra de mão especializada</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00364496120148190001</Numero>
				<Juizo>23 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-02-04</DataInstauracao>
				<ValorCausa>1000</ValorCausa>
				<PartesProcesso>GUSTAVO DE BARROS MACIEIRA E ALYNE DE OLIVEIRA SILVA. X OPP FUNDO E BALASSIANO ENGENHARIA LTDA</PartesProcesso>
				<PrincipaisFatos>Restituição em dobro do que foi repassado para o Banco do Brasil como saldo devedor da portabilidade e o
que deveria ter sido o correto, acrescido de encargos legais (correção monetária e juros de mora) a contar da assinatura do contrato de portabilidade, bem como a condenção ao pagamento de indenização por danos morais.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00512447220148190001</Numero>
				<Juizo>15 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-02-12</DataInstauracao>
				<ValorCausa>368163.82</ValorCausa>
				<PartesProcesso>OPP FUNDO X CULINÁRIA ALEMÃ BAR E RESTAURANTE LTDA EPP</PartesProcesso>
				<PrincipaisFatos>Decretação do despejo e a cobrança dos alugueis e encargos locatícios. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00056802820148190209</Numero>
				<Juizo>2 VC-BT</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-02-24</DataInstauracao>
				<ValorCausa>1873200</ValorCausa>
				<PartesProcesso>OPP FUNDO X A!BODYTECH PARTICIPAÇÕES S.A</PartesProcesso>
				<PrincipaisFatos>Revisional de aluguel das lojas 119 e 120; 121 e 122, do Bloco 07. A. das Américas, Condomínio Cittá América para majorar o aluguel para R$ 360.000,00.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0011209-06.2014.8.07.0001</Numero>
				<Juizo>OITAVA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-03-31</DataInstauracao>
				<ValorCausa>99800</ValorCausa>
				<PartesProcesso> CRISTIANO CURADO GUEDES e IONE PEIXOTO GUEDES X BANCO OPPORTUNITY S.A. e  JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Lucros cessantes e danos morais.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0011972-07.2014.8.07.0001</Numero>
				<Juizo>VIGÉSIMA QUARTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-04-04</DataInstauracao>
				<ValorCausa>222082.41</ValorCausa>
				<PartesProcesso> ITALO TELLES E VASCONCELOS  X  BANCO OPPORTUNITY S.A. e  JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual; lucros cessantes</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 0011908-94.2014.8.07.0001</Numero>
				<Juizo>PRIMEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-04-04</DataInstauracao>
				<ValorCausa>49500</ValorCausa>
				<PartesProcesso>LEONARDO CESAR MENDES REIS X  BANCO OPPORTUNITY S.A. e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Antecipação dos efeitos da tutela; entrega do imóvel e da carte de habite-se; lucros cessantes; danos morais; pagamento em dobro do valor referente a corretagem;</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00169953120148070001</Numero>
				<Juizo>15ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-04-30</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>FLÁVIO RODRIGUES CALIL DAHER X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Rescisão da promessa de compra e venda das unidades 313/614 e 1.618</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01602458920148190001</Numero>
				<Juizo>12 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-05-05</DataInstauracao>
				<ValorCausa>10575</ValorCausa>
				<PartesProcesso>FRANCISCO DOS SANTOS MOREIRA E MARIZE ABRANTES X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Restituição em dobro dos valores pagos a título de comissão de corretagem no valor de R$ 10.575,00 por ocasião da aquisição da unidade 202, Bloco 2. Bella Tijuca, situada na Barão de Mesquita, 164</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00211051020134025101</Numero>
				<Juizo>26 VF-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-05-16</DataInstauracao>
				<ValorCausa>2531927.3</ValorCausa>
				<PartesProcesso>OPP FUNDO X INPI – Instituto Nacional de Propriedade Intelectual </PartesProcesso>
				<PrincipaisFatos>Execução dos aluguéis pagos em valor infeior ao pactuado no contrato de locação.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020880-53.2014.8.07.0001</Numero>
				<Juizo>VIGÉSIMA QUARTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-06-10</DataInstauracao>
				<ValorCausa>153243.81</ValorCausa>
				<PartesProcesso>ANDRE LUIZ DIAS DE OLIVEIRAX JFE EMPREENDIMENTOS IMOBILIARIOS LTDA e  BANCO OPORTUNITY S.A.</PartesProcesso>
				<PrincipaisFatos>Antecipação dos efeitos da tutela; entrega imediata do imóvel; lucros cessantes; danos morais; devolução integral dos valores pagos injustamente pelo autor.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/373.376/2014</Numero>
				<Juizo>Gerência de Recadastramento e Atualização Cadastral (CIP-5)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-06-12</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de Inclusão Predial e legalização de modificação dos imóveis localizados na Rua Barão de Mesquita, nº 164, Tijuca, de acordo com a Certidão de Habite-se concedido em agosto de 2014.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 0021506-72.2014.8.07.0001</Numero>
				<Juizo>DECIMA SEGUNDA VARA CIVEL DE BRASILIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-06-13</DataInstauracao>
				<ValorCausa>280000</ValorCausa>
				<PartesProcesso>RENATA GRACIOSO BORGESX BANCO OPPORTUNITY DE INVESTIMENTO S.A. </PartesProcesso>
				<PrincipaisFatos>Antecipação dos efeitos da tutela; rescisão contratual; devolução integral dos valores pagos e danos morais.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0027461-84.2014.8.07.0001</Numero>
				<Juizo>VIGÉSIMA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-07-30</DataInstauracao>
				<ValorCausa>29124.32</ValorCausa>
				<PartesProcesso> ELVENILA DE LIMA E SILVA MACEDO X  BANCO OPPORTUNITY S.A. e  JOAO FORTES EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Lucros Cessantes e Multa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0029381-93.2014.8.07.0001</Numero>
				<Juizo>PRIMEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-08-13</DataInstauracao>
				<ValorCausa>206151.76</ValorCausa>
				<PartesProcesso>LINDA MANSUR MENDES X  BANCO OPPORTUNITY SA e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual com a devolução dos valores pagos e indenização por lucros cessantes.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 0030188-16.2014.8.07.0001</Numero>
				<Juizo>DECIMA VARA CIVEL DE BRASILIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-08-19</DataInstauracao>
				<ValorCausa>222028.9</ValorCausa>
				<PartesProcesso> BERNARDO LUIZ BRAGA COELHO JUNIOR X  BANCO OPPORTUNITY S.A. e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Restituição dos Valores Pagos, Rescisão Contratual e Lucros Cessantes.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0031102-80.2014.8.07.0001</Numero>
				<Juizo>OITAVA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-08-25</DataInstauracao>
				<ValorCausa>40000</ValorCausa>
				<PartesProcesso> LUCIANO MADURO ALVES DE LIMA X  BANCO OPPORTUNITY S.A. e  JFE2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Lucros cessantes</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00439414020148070001</Numero>
				<Juizo>15ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-09-05</DataInstauracao>
				<ValorCausa>177844.07</ValorCausa>
				<PartesProcesso>GUSTAVO SILVEIRA LEÃO X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Ação de rescisão contratual com pedido de nulidade de cláusulas contratuais e restituição da importância de R$ 177.828,67. Restiuição de R$ 15.40,00 referente aos lucros cessantes de sete meses de aluguel; danos morais no valor de R$ 10.000,00. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07026593320148070016</Numero>
				<Juizo>I JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-09-16</DataInstauracao>
				<ValorCausa>28960</ValorCausa>
				<PartesProcesso>LUIS OLÍVIO MANSO DE BARROS X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Restituição, em dobro, dos valores pagos a título de comissão de corretagem</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0702659-33.2014.8.07.0016</Numero>
				<Juizo>1º Juizado Especial Cível de Brasília</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-09-16</DataInstauracao>
				<ValorCausa>28960</ValorCausa>
				<PartesProcesso>LUIS OLIVIO MANSO DE BARROS e ALESSANDRA ZAK CALVARIO BARROS  X BANCO OPPORTUNITY DE INVESTIMENTO S.A. e JFE 21 EMPREENDIMENTOS IMOBILIARIOS LTDA e LPS BRASILIA CONSULTORIA DE IMOVEIS LTDA</PartesProcesso>
				<PrincipaisFatos>Autor requer a restituição, em dobro, do valor pago a título de taxa de Corretagem</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00049713420158070001</Numero>
				<Juizo>24ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-09-20</DataInstauracao>
				<ValorCausa>197067.37</ValorCausa>
				<PartesProcesso>LINA AREDES COUTINHO X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Rescisão de contrato com pedido de restituição dos valores pagos, inclusive comissão de corretagem e multa contratual. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 0038797-85.2014.8.07.0001</Numero>
				<Juizo>VIGÉSIMA SEGUNDA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-10-14</DataInstauracao>
				<ValorCausa>90000</ValorCausa>
				<PartesProcesso> FLAVIO NOGUEIRA DA GAMA CORDEIRO X  BANCO OPPORTUNITY S.A. e  OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA e JOAO FORTES ENGENHARIA SA</PartesProcesso>
				<PrincipaisFatos>Lucros Cessantes.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0403966-10.2014.8.19.0001</Numero>
				<Juizo>44ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-11-04</DataInstauracao>
				<ValorCausa>195827.14</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X Stussi Neves Advogados</PartesProcesso>
				<PrincipaisFatos>Execução de Título Extrajudicial</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04124553620148190001</Numero>
				<Juizo>Vara de Resgistros Públicos</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-11-11</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>CARTÓRIO DO 9º OFÍCIO DE REGISTRO DE IMÓVEIS X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Dúvida quantos às exigências formuladas pelo 9º RGI quando da averbação da dação em pagamento.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00450993320148070001</Numero>
				<Juizo>5ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-11-14</DataInstauracao>
				<ValorCausa>158184.44</ValorCausa>
				<PartesProcesso>JOMAR MIRANDA RODRIGUES X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Rescisão de contrato com pedido de devolução das parcelas pagas no montante de R$ 144.584,44; devolução do sinal, R$ 24.967,25, em dobro e mais os alugueis mensais no valor de R$ 1.700,00; subsidiariamente, a condenação das rés ao pagamento dos aluguéis desde 30.09.14 até a data da rescisão, cumulado com multa moratória pelo inadimplemento; danos materiais no valor de R$ 5.000,00; eventualmente, a fixação da multa contratual no percentual de 10% sobre o valor pago;</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00466591020148070001</Numero>
				<Juizo>9ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-11-25</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>RAMIRO ROCHA DE OLIVEIRA X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Rescisão de contrato com pedido de restituição dos valores pagos, inclusive comissão de corretagem. Unidade 111-A Due Capri.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0511384-07.2014.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-12-19</DataInstauracao>
				<ValorCausa>4494471.49</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação ordinária que visa: (i)  sejam declarados nulos os lançamentos tributários de IPTU referentes aos exercícios de 2007 a 2014 incidentes sobre o imóvel do autor e em relação aos exercícios anteriores a propositura de medida cautelar de produção antecipada de provas nº 0102975-54.2007.8.19.0001; (ii)  seja determinado a retificação dos referidos lançamentos para apontar o valor correto do imposto de todos os exercícios financeiros ainda em cobrança administrativa ou judicial de acordo com o laudo pericial produzido na ação cautelar de produção antecipada de provas n° 0102975-54.2007.8.19.0001; (iii)  seja considerado o valor efetivamente devido a título de IPTU incidente sobre os imóveis do autor nos exercícios de 2007 a 2014 e os pagamentos já efetuados nesses mesmos períodos, declarar inexistente qualquer dívida de IPTU sobre esses imóveis em relação a esses exercícios e em relação aos exercícios anteriores a propositura de medida cautelar de produção antecipada de provas nº 0102975-54.2007.8.19.0001; (iv)  condenar o Município a restituir o valor de R$ 2.316.614,26, pago a maior a título de IPTU nos exercícios de 2007 a 2014, acrescidos de correção monetária e juros de mora na forma da lei, sem prejuízo de outros valores que sejam apurados como passíveis de restituição no curso do processo ou mediante liquidação ou arbitramento. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0511339-03.2014.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-12-19</DataInstauracao>
				<ValorCausa>4414045.7</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação ordinária que visa a obtenção de isenção de IPTU a partir de 2000 para o imóvel situado à Rua Barão de Mesquita, nº 164, Tijuca, Rio de Janeiro, inscrição imobiliária 3139651-8 (antiga 0145429-7), em razão do tombamento efetuado pelo Estado do Rio de Janeiro, através da Lei nº 3.317/99, e pelo Município do Rio de Janeiro, por meio do Decreto nº 19.342/2000.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0051390-49.2014.8.07.0001</Numero>
				<Juizo>VIGÉSIMA SEGUNDA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-12-19</DataInstauracao>
				<ValorCausa>239289.84</ValorCausa>
				<PartesProcesso> OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e JFE 22 EMPREENDIMENTOS IMOBILIARIOS LTDA e  JOAO FORTES ENGENHARIA X  FABRICIO TORTURRO DE MORAES</PartesProcesso>
				<PrincipaisFatos>O Autor Requer; A recisão contratual; A restituição a integralidade dos valores pagos; Lucros cessantes.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00354369020158190001</Numero>
				<Juizo>7 VFAZ- RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-02-04</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>MUNICÍPIO DO RIO DE JANEIRO X OPP FUNDO </PartesProcesso>
				<PrincipaisFatos>Desapropriação do imóvel situado na Rua da Carioca nº 39, tendo por fundamento o risco de despejo do restaurante (Culinária Alemã), objetivando manter a atividade econômica desenvolvida no local. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/550.130/2015</Numero>
				<Juizo>Preferitura do Rio de Janeiro</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-02-04</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>MUNICÍPIO DO RIO DE JANEIRO X OPP FUNDO </PartesProcesso>
				<PrincipaisFatos>Desapropriação do imóvel situado na Rua da Carioca nº 39, tendo por fundamento o risco de despejo do restaurante (Culinária Alemã), objetivando manter a atividade econômica desenvolvida no local. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00049826320158070001</Numero>
				<Juizo>3ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-02-19</DataInstauracao>
				<ValorCausa>412000</ValorCausa>
				<PartesProcesso>JOSÉ LEÔNCIO NOGUEIRA JR. X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Rescisão do contrato de compra e venda com a restituição dos valores pagos (R$ 440.971,07); devolução das arras (R$ 40.099,18); Danos morais (R$ 5.000,00); Lucros cessantes (R$ 27.500,00); Multa rescisória (R$ 87.987,02); Tutela antecipada para suspender eventual cobrança de condomínio e cotas condominiais. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00075530720158070001</Numero>
				<Juizo>9ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-11</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>LUIZA MARIA MORAES DE OLIVEIRA X OPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual c/c restituição de quantias pagas, em dobro, tanto em relação à comissão de corretagem, quanto em relação aos valores pagos a título de financiamento. Multa penal equivalente a 10%. Inversão da cláusula 6.9.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0008071-94.2015.8.07.0001</Numero>
				<Juizo>PRIMEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-16</DataInstauracao>
				<ValorCausa>74250</ValorCausa>
				<PartesProcesso> VANESSA DE SOUZA VELOSO BECKENKAMP e  ERITON ORLANDO DE OLIVEIRA BECKENKAMP X JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA e  BANCO OPPORTUNITY S.A. e JOAO FORTES ENGENHARIA SA</PartesProcesso>
				<PrincipaisFatos>Restituição dos Valores Pagos, Multa, Lucros Cessantes e Danos Morais.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 0007231-78.2015.8.07.0003</Numero>
				<Juizo>PRIMEIRA VARA CÍVEL DE CEILÂNDIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-18</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso> JFE 22 EMPREENDIMENTOS IMOBILIARIOS LTDA e LPS BRASILIA CONSULTORIA DE IMOVEIS LTDA X CARLOS RAFAEL DE ARAUJO BEZERRA</PartesProcesso>
				<PrincipaisFatos>O Autor requer: Rescisão; Restituição dos valores pagos a título de comissão e corretagem. </PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00087405020158070001</Numero>
				<Juizo>17ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-20</DataInstauracao>
				<ValorCausa>558688.73</ValorCausa>
				<PartesProcesso>OPP FUNDO E JFE21 X KAREN VASCONCELOS FERREIRA</PartesProcesso>
				<PrincipaisFatos>Devolução da integralidade dos valores pagos incluindo a comissão de corretagem.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0093743-37.2015.8.19.0001 </Numero>
				<Juizo>14ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-25</DataInstauracao>
				<ValorCausa>60000</ValorCausa>
				<PartesProcesso>Elaine Lima de Miranda X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição das cotas condominiais desde dezembro de 2013 até março de 2015, bem como lucros cessantes e danos morais, referente ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0009695-81.2015.8.07.0001</Numero>
				<Juizo>DÉCIMA TERCEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-27</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso> EDMILSON RODRIGUES XAVIER X  BANCO OPPORTUNITY S.A. e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA e  H PLUS ADMINISTRACAO E HOTELARIA LTDA</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual, Restituição dos Valores Pagos, Corretagem, Lucros Cessantes e Multa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0116184-12.2015.8.19.0001 </Numero>
				<Juizo>48ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-31</DataInstauracao>
				<ValorCausa>640</ValorCausa>
				<PartesProcesso>Elaine Lima de Miranda X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0114835-71.2015.8.19.0001</Numero>
				<Juizo>45ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-31</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Guilherme Corrêa Sá X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0114591-45.2015.8.19.0001</Numero>
				<Juizo>12ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-31</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>João Hugo da Rocha e Raimunda Batalha da Rocha X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0114662-47.2015.8.19.0001</Numero>
				<Juizo>14ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-31</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Emília Valinho Ferreira X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0010419-85.2015.8.07.0001</Numero>
				<Juizo>QUARTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-03-31</DataInstauracao>
				<ValorCausa>409279.5</ValorCausa>
				<PartesProcesso> OZIAS DE CASTRO JUNIOR X  JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA e  JOAO FORTES ENGENHARIA S.A. e BANCO OPORTUNITY S.A.</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual, Restituição dos Valores Pagos, Corretagem, Multa, Lucros Cessantes.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0006654-09.2015.8.07.0001</Numero>
				<Juizo>VIGÉSIMA QUINTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-03</DataInstauracao>
				<ValorCausa>170998.23</ValorCausa>
				<PartesProcesso> GUSTAVO DE SOUZA FOSSE e  PRISCILA COSTA DE SOUZA X  BANCO OPPORTUNITY S.A. e  JFE2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual, Restituição dos Valores Pagos, Corretagem e Lucros Cessantes e Multa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0134299.81.2015.8.19.0001</Numero>
				<Juizo>13ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-07</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Solange de Mello Mattos X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0168587-55.2015.8.19.0001</Numero>
				<Juizo>49ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-07</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Afranio Felipe de Castro Dornas X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0133739-42.2015.8.19.0001</Numero>
				<Juizo>52ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-07</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Raphael Constant da Costa e Maíra Andrade Rodrigues X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0151054-83.2015.8.19.0001</Numero>
				<Juizo>27ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-09</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Roberta Pereira Vianna Sarquis X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0151338-91.2015.8.19.0001</Numero>
				<Juizo>7ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-09</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Daniela Henriques Louback e Rogério Caporali Junior X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0157301-80.2015.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-10</DataInstauracao>
				<ValorCausa>6812652.95</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 218, inscrição imobiliária nº 2971881-4, consubstanciados nas CDAs nºs CDAs 01/213557/2014 e 01/182932/2014, referente aos exercícios de 2011 e 2012.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0157774-66.2015.8.19.0001</Numero>
				<Juizo>12ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-10</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Eloine Ana Trindade Borges e Julio Pereira Borges X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0168679-33.2015.8.19.0001</Numero>
				<Juizo>21ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-13</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Girleu Oliveira Asevedo Junior e Flavia Lopes Araujo
 X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0171310-47.2015.8.19.0001</Numero>
				<Juizo>10ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-14</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Fatima Aparecida Pires Miguel X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0176635-03.2015.8.19.0001</Numero>
				<Juizo>31ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-15</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Monique Cristine Mattos de Mesquita  X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0180975-87.2015.8.19.0001</Numero>
				<Juizo>14ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-16</DataInstauracao>
				<ValorCausa>3594.7</ValorCausa>
				<PartesProcesso>Luiz Jorge da Costa Fontes X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0190583-12.2015.8.19.0001</Numero>
				<Juizo>47ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-22</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Fabio de Oliveira Machado e Marta Verônica dos Santos Maria Machado X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0012952-17.2015.8.07.0001</Numero>
				<Juizo>VIGÉSIMA QUINTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-22</DataInstauracao>
				<ValorCausa>283421.25</ValorCausa>
				<PartesProcesso> OTACILIO BORGES JUNIOR X BANCO OPPORTUNITY INVESTIMENTO SA e  JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA e JOAO FORTES ENGENHARIA SA</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual, Restituição dos Valores Pagos, Corretagem, Multa, Lucros Cessantes e Danos Morais.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0195186-31.2015.8.19.0001</Numero>
				<Juizo>4ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-27</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Luciane Dias dos Santos X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0281180-27.2015.8.19.0001</Numero>
				<Juizo>21ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-28</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Jonivaldo Santos Souza X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0196792-94.2015.8.19.0001</Numero>
				<Juizo>41ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-28</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Adriano Fernandes de Pinho Vinagre e Luciana Lopes Batista Vinagre X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero> 0014181-12.2015.8.07.0001</Numero>
				<Juizo>SEGUNDA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-04-30</DataInstauracao>
				<ValorCausa>570528.15</ValorCausa>
				<PartesProcesso>BANCO OPPORTUNITY AS e JFE22 EMPREENDIMENTOS IMOBILIARIOS LTDA  X  THYAGO NASCIMENTO DE PAIVA e  ERICA DAUFENBACH AMARAL</PartesProcesso>
				<PrincipaisFatos>Possibilidade de efetuar composição nesse caso. Vamos aguardar o julgamento do IRDR - processo ainda não sentenciado. Classificado como "contato posterior" , Determinada a remessa dos autos para a digitalização.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0205322-87.2015.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-06</DataInstauracao>
				<ValorCausa>765982.32</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação ordinária para discutir a cobrança de IPTU dos imóveis situados à Av. das Américas, 700, lojas 115K, 118A, 118B, 118C, 118D, 118E, 301A, 302A, 302E, 302F, 302G, 302H, 303A, 303B, 303E, 305B, 305C, 305I, 305K, 306A, 306C, 306E, 306F, 309A, 309G, 309H, 317G, 317H, 317I, 317J, 317M, 319I, 319J, 320A, 320B, 320C, 320D, 320E, 320F, 316C, 316D, 316E, 316F, 316G, 316H, 317A, 317B, 317C, 317D, 317E, 317F, 202J, 203B, 203J, 204F, 204Q, 205H, 206D, 207L, 209E, 210A, 214C, 216A, 217I e 217O, referentes às inscrições imobiliárias nºs 2971654-5, 3065022-0, 3065023-8, 3065024-6, 3065025-3, 3065026-1, 2971906-9, 2971907-7, 2971911-9, 2971912-7, 2971913-5, 2971914-3, 2971915-0, 2971916-8, 2971919-2, 2971938-2, 2971939-0, 2971945-7, 2971947-3, 2971954-9, 2971956-4, 2971957-2, 2971971-3, 2971977-0, 2971978-8, 2972040-6, 2972041-4, 2972042-2, 2972043-0, 2972046-3, 2972063-8, 2972064-6, 2972074-5, 2972075-2, 2972076-0, 2972077-8, 2972078-6, 2972079-4, 2972029-9, 2972030-7, 2972094-3, 2972031-5, 2972032-3, 2972033-1, 2972034-9, 2972035-6, 2972036-4, 2972037-2, 2972038-0, 2972039-8, 2971709-7, 2971715-4, 2971723-8, 2971729-5, 2971740-2, 2971753-5, 2971771-7, 2971789-9, 2972802-0, 2971806-1, 2971836-8, 2971854-1, 2971870-7 e 2971876-4,</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0205657-09.2015.8.19.0001</Numero>
				<Juizo>44ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-07</DataInstauracao>
				<ValorCausa>195827.14</ValorCausa>
				<PartesProcesso>Stussi Neves Advogados X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO</PartesProcesso>
				<PrincipaisFatos>Embargos a Execução de Título Extrajudicial</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00147622720158070001</Numero>
				<Juizo>13ª</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-07</DataInstauracao>
				<ValorCausa>90000</ValorCausa>
				<PartesProcesso>JOSÉ DE RIBAMAR SOUSA PEREIRA E GLORIA MARIA PEREIRAXOPP FUNDO E JFE 22</PartesProcesso>
				<PrincipaisFatos>Rescisão do contrato com pedido de devolução da importãncia paga a título de financiamento (R$ 92.916,98) e mais (R$ 16.488,50) correspondente ao sinal (em dobro) reversão da clásusula 6.1 para fixar multa no valor de 2% do valor da dívida vencida com juros 1% a.m.Lucros cessantes no valor de R$ 1.705,24 (0,5%) do valor do imóvel para mês de atraso desde 31/01/2015. Multa de 20% sobre o preço ou ainda sobre o preço pago. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0015064-56.2015 pje</Numero>
				<Juizo>22ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-08</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>ABRAHÃO TOLENTINO SOARES DE FIGUEIREDOXOPP FUNDO E JFE 21</PartesProcesso>
				<PrincipaisFatos>Rescisão conrtatual c/c restituição de quantias pagas, atítulo de sinal, indenização dos alugueis mensais para o perídodo do atraso das obras; dano moral e restituição, em dobro, tanto da comissão de corretageme  da taxa SATI. Ressarcimento dos honorarios contratuais e multa moratória de 2% sobre o valor do imóvel. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00152715520158070001 </Numero>
				<Juizo>22ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-11</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>DARLAN ARAUJO DA SILVA X OPP FUNDO E JFE22 </PartesProcesso>
				<PrincipaisFatos>Restituição da integralidade dos valores pagos; multa rescisória e comissão de corretagem.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00154161420158070001 pje</Numero>
				<Juizo>7ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-12</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>CAMILA PEIXOTO PESSOA GUERRAXOPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual c/c devolução da integralidade dos valores pagos, comissão de corretagem, lucros cessantes e dano moral.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0216529-83.2015.8.19.0001</Numero>
				<Juizo>48ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-13</DataInstauracao>
				<ValorCausa>320</ValorCausa>
				<PartesProcesso>Mauricio Melo Cavalcante e Isabel Cristina dos Reis Correia Cavalcante
 X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0015750-48.2015.8.07.0001</Numero>
				<Juizo>QUARTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-14</DataInstauracao>
				<ValorCausa>169870.31</ValorCausa>
				<PartesProcesso>LEONARDO TAVARES MUNDIM BAESSE X  JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA e BANCO OPPORTUNITY S.A.</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual e Restituição dos Valores Pagos.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>20150110601514</Numero>
				<Juizo>9ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-25</DataInstauracao>
				<ValorCausa>80000</ValorCausa>
				<PartesProcesso>ALINE REGINA FERNANDES X OPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual c/c pedido de restituição integral das parcelas do financimento, reversão da clausula 6.1, sinal em dobro, comissão de corretagem, declarar que a obrigação de pagar o condomínio é da vendedora, sucessivamente, rescisão do contrato com declaração de nulidade da cláusula 6.9; devolução de 90% dos valores pagos; restituição da comissão de corretagem, em dobro; custas processuais e honorários fixados em 20%. Inversão do ônus da prova</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0237353-63.2015.8.19.0001</Numero>
				<Juizo>32ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-29</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Davi Ferreira de Sousa e Renata de Almeida Pacheco X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0242893-92.2015.8.19.0001</Numero>
				<Juizo>3ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-06-03</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Regina da Costa Pereira X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0018910-81.2015.8.07.0001</Numero>
				<Juizo>SEGUNDA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-06-09</DataInstauracao>
				<ValorCausa>780000</ValorCausa>
				<PartesProcesso> TEREZINHA DE SOUZA LEMOS ARAUJO e AILTON RODRIGUES DE ARAUJO
 X BANCO OPPORTUNITY SA e  JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual com a devolução dos valores pagos e indenização por lucros cessantes</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0250968-23.2015.8.19.0001</Numero>
				<Juizo>20ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-06-11</DataInstauracao>
				<ValorCausa>13203.72</ValorCausa>
				<PartesProcesso>Fatima Aparecida Pires Miguel X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO
 BALASSIANO ENGENHARIA LTDA.
 DATAMANAGE SISTEMAS IMOBILIÁRIOS LTDA. (IMÓVEL ON)
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0253797-74.2015.8.19.0001</Numero>
				<Juizo>2ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-06-12</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Marcelo Bruno Zampirolo e Andrea Fialho Bruno Zampirolo X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0266555-85.2015.8.19.0001</Numero>
				<Juizo>33ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-06-24</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Denise de Carvalho Kaufmann e Carlos Eduardo Pereira Gonçalves X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0270386-44.2015.8.19.0001</Numero>
				<Juizo>8ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-06-26</DataInstauracao>
				<ValorCausa>120237.8</ValorCausa>
				<PartesProcesso>SIMONE DOS SANTOS DIAS X  OPPORTUNITY FUNDO DE INVESTIMENTOS IMOBILIÁRIO</PartesProcesso>
				<PrincipaisFatos>Rescisão da Promessa de Compra e Venda e devolução da comissão de corretagem.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0275400-09.2015.8.19.0001</Numero>
				<Juizo>25ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-01</DataInstauracao>
				<ValorCausa>17899.03</ValorCausa>
				<PartesProcesso>Solange de Mello Mattos X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0022206-14.2015.8.07.0001</Numero>
				<Juizo>VIGÉSIMA PRIMEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-02</DataInstauracao>
				<ValorCausa>328323.56</ValorCausa>
				<PartesProcesso>RODRIGO GORETTI PIEDADE e DANIELE ALVES DE SOUSA X JOÃO FORTES ENGENHARIA SA  e BANCO OPPORTINITY SA </PartesProcesso>
				<PrincipaisFatos>Rescisão contratual com a devolução dos valores pagos, indenização por lucros cessantes e danos materiais</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02810772020158190001</Numero>
				<Juizo>37 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-05</DataInstauracao>
				<ValorCausa>10000</ValorCausa>
				<PartesProcesso>BARBARA DE OLIVEIRA BRASIL CORRÊA e CARLOS AUGUSTO SOARES X OPP FUNDO e  BALASSIANO ENGENHARIA LTDA</PartesProcesso>
				<PrincipaisFatos>Condenação dos réus, solidariamente, ao pagamento de indenização por danos morais e restituição da quantia de R$8.475,00, paga a título de comissão de corretagem.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0014738-96.2015.8.07.0001</Numero>
				<Juizo>VIGÉSIMA TERCEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-05</DataInstauracao>
				<ValorCausa>186859.18</ValorCausa>
				<PartesProcesso>ELVENILA DE LIMA E SILVA MACEDO X BANCO OPPORTUNITY S.A. e JOAO FORTES EMPREENDIMENTOS IMOBILIARIOS LTDA JEF2</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual, Restituição dos Valores Pagos, Multa, Arras e Corretagem.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0282082-77.2015.8.19.0001</Numero>
				<Juizo>33ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-06</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Thiago Luiz Salles Monteiro X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0285014-38.2015.8.19.0001</Numero>
				<Juizo>1ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-08</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Vanessa Ariadne Sarlas Ribeiro X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02854153720158190001</Numero>
				<Juizo>23 JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-08</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>ALESSANDRA DE SOUZA ZAMBONI X OPP FUNDO </PartesProcesso>
				<PrincipaisFatos>Restituição em dobro da importância de R$ 10.500,00, paga a título de corretagem e condenação do réu ao pagamento de indenização por danos morais.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0285901-22.2015.8.19.0001</Numero>
				<Juizo>32ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-09</DataInstauracao>
				<ValorCausa>16802</ValorCausa>
				<PartesProcesso>Davi Ferreira De Sousa e Renata De Almeida Macedo X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0288469-11.2015.8.19.0001</Numero>
				<Juizo>31ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-10</DataInstauracao>
				<ValorCausa>13926.07</ValorCausa>
				<PartesProcesso>Luciane Dias dos Santos X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0292247-86.2015.8.19.0001</Numero>
				<Juizo>9ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-14</DataInstauracao>
				<ValorCausa>17264.36</ValorCausa>
				<PartesProcesso>Fabio de Oliveira Machado e Marta Verônica dos Santos Maria Machado X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0023895-93.2015.8.07.0001</Numero>
				<Juizo>VIGÉSIMA QUINTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-14</DataInstauracao>
				<ValorCausa>379239.42</ValorCausa>
				<PartesProcesso> ANDRE SIMOES VASSOLER e ADRIANA CARDOSO RODRIGUES X  BANCO OPPORTUNITY SA e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Devolução integral dos valores pagos </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0294808-83.2015.8.19.0001</Numero>
				<Juizo>8ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-15</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Eduardo da Rocha Francellino e Luciana Maria de Arruda Francellino X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00245428820158070001</Numero>
				<Juizo>15ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-17</DataInstauracao>
				<ValorCausa>566956.8</ValorCausa>
				<PartesProcesso>MARCELO AUGUSTO SALES DA SILVA E FRANCELINO DARCY B. JUNIOR X OPP FUNDO E JFE21</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual com a devolução dos valores pagos (R$106.787,29); lucros cessantes no valor de r4 26.248,00 referentes ao periodo considerando a data de 31.08.14 ou, alternativamente, R$ 10.499,20 com termo inicial em 28/02/2015 até a data da rescisão do contrato. Reversão da cláusula 6.1 para obter multa e mora pelo inadimplemento contratual. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0296670-89.2015.8.19.0001</Numero>
				<Juizo>23ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-17</DataInstauracao>
				<ValorCausa>16578.95</ValorCausa>
				<PartesProcesso>Eloine Ana Trindade Borges e Julio Pereira Borges X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0296665-67.2015.8.19.0001</Numero>
				<Juizo>14ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-17</DataInstauracao>
				<ValorCausa>17716.3</ValorCausa>
				<PartesProcesso>Adriano Fernandes de Pinho Vinagre e Luciana Lopes Batista Vinagre X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0301663-78.2015.8.19.0001</Numero>
				<Juizo>8ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-07-21</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Eduardo da Rocha Francellino e Luciana Maria de Arruda Francellino X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0334684-45.2015.8.19.0001</Numero>
				<Juizo>37ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-07</DataInstauracao>
				<ValorCausa>18062.34</ValorCausa>
				<PartesProcesso>Mauro Yuji Hayashi e Suzana Hisako Deguchi Hayashi X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0023162-30.2015.807.0001 </Numero>
				<Juizo>SEGUNDA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-07</DataInstauracao>
				<ValorCausa>58320.04</ValorCausa>
				<PartesProcesso> HUDSON VENANCIO DE MORAES X OPPORTUNITY FII E JOAO FORTES ENGENHARIA AS</PartesProcesso>
				<PrincipaisFatos>Lucros cessantes, indenização, multa contratual.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0343820-66.2015.8.19.0001</Numero>
				<Juizo>29ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-11</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Rafael Gonçalves Kenupp Pereira e Maria Graziela de Fátima Alvarez Kenupp X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>03471723220158190001</Numero>
				<Juizo>49 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-13</DataInstauracao>
				<ValorCausa>55069.41</ValorCausa>
				<PartesProcesso>SIDNEY REGEN e MONICA TEIXEIRA VAIRO   X OPP FUNDO E BALASSIANO ENGENHARIA LTDA</PartesProcesso>
				<PrincipaisFatos>Declaração do (i)  inadimplemento contratual consistente no atraso da obtenção "habite-se", o que teria impedido os autores de contratar financiamento bancário para quitação da dívida e de cobrança indevida na aplicação de juros e correção monetária.  Requerem a  ccndenação dos réus ao pagamento de danos morais e a devolverem, em dobro, a quantia de R$ 14.466,89, supostamente cobrada indevidamente. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0353118-82.2015.8.19.0001</Numero>
				<Juizo>4ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-18</DataInstauracao>
				<ValorCausa>8627.28</ValorCausa>
				<PartesProcesso>Leonardo Salgado De Brito Batista e Juliane Bacellar Ribas Rodriguez X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0352136-68.2015.8.19.0001</Numero>
				<Juizo>7ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-18</DataInstauracao>
				<ValorCausa>13981.52</ValorCausa>
				<PartesProcesso>Felipe Ferreira Marzullo X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0358872-05.2015.8.19.0001</Numero>
				<Juizo>33ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-24</DataInstauracao>
				<ValorCausa>13981.52</ValorCausa>
				<PartesProcesso>Thiago Luiz Salles Monteiro X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0362000-33.2015.8.19.0001</Numero>
				<Juizo>44ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-26</DataInstauracao>
				<ValorCausa>1000</ValorCausa>
				<PartesProcesso>Condomínio do Edifício Residencial Stilo X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de obrigação de fazer na qual o autor requer que as rés sejam compelidas a realizar reparos no Condomínio, ou alternativamente, indenizar os custos com mão-de-obra e materiais.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0367399-43.2015.8.19.0001</Numero>
				<Juizo>46ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-31</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Raphael Constant Da Costa e Maíra Andrade Rodrigues X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0367466-08.2015.8.19.0001</Numero>
				<Juizo>18ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-08-31</DataInstauracao>
				<ValorCausa>28281.43</ValorCausa>
				<PartesProcesso>Wesley William Vitor de Souza e Viviane Vieira de Miranda X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00305334520158070001</Numero>
				<Juizo>18ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-09-04</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>DIOGO DE MELLO BRITTO DA SILVA X OPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual com devolução de valores pagos; devolução do sinal e mais o equivalente totalizando (R$ 73.421,56); devolução da comissão de corretagem; lucros cessantes no percentual de 0,5% do valor do contrato; restituição, em dobro, das taxas conodminiais referentes a maio e junho; reversão da cláusula 6.1 a título de multa moratória; na hipótese de não receber a integralidade dos valores, pleiteia a nulidade da cláusula 6.9;</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>03850837820158190001</Numero>
				<Juizo>27 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-09-15</DataInstauracao>
				<ValorCausa>10000</ValorCausa>
				<PartesProcesso>RODRIGO DIAS DE PINHO GOMES  X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Ação de repetição de indébito em que se pede a devolução em dobro de todas as quantias pagas indevidamente, de acordo com memória de cálculo apresentada pelo autor e com prova pericial a ser produzida, incluindo seguro de vida, acrescidos de juros e correção monetária da data da cobrança e com juros e correção monetária do desembolso de cada parcela. Também há pedido de declaração de nulidade da cláusula 5.17 da escritura de compra e venda e de inversão do ônus da prova.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00319832320158070001</Numero>
				<Juizo>8ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-09-22</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>MEIRELUCE FERNANDES DA SILVA e JOSÉ CARLOS FERREIRA BRITO X OPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Ação de cobrança c/c indenização a título de danos materiais e morais com fundamento no atraso da entrega da unidade. Pleiteiam lucros cessantes (R$ 18.000,00); danos morais (R$ 10.000,00) reversão da clásula 6.1 para obter multa no valor de R4 79.025,34.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02721921720158190001</Numero>
				<Juizo>44 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-09-26</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>SUPER MATRIZ AÇOS LTDA. X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Renovação do contrato de locação não residencial do imóvel situado na Rua Conde do Bonfim, n° 149, lojas C e D, iniciado em 01/11/2011, com previsão de término para 01/01/2016, pelo prazo de 60 meses e no valor valor mensal de R$ 27.272,17.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0402342-86.2015.8.19.0001</Numero>
				<Juizo>33ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-09-29</DataInstauracao>
				<ValorCausa>13981.52</ValorCausa>
				<PartesProcesso>Denise de Carvalho Kaufmann e Carlos Eduardo Pereira Gonçalves X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>6098935-39.2015.8.13.0024</Numero>
				<Juizo>1ª (Primeira) Vara Cível de Belo Horizonte/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-10-06</DataInstauracao>
				<ValorCausa>151211.084292642</ValorCausa>
				<PartesProcesso>Rodrigo de Souza Paim e Jaqueline Vilela Araújo Paim X Opportunity Fundo de Investimento Imobiliário</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual com Devolução dos Valores Pagos</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>N/A</Numero>
				<Juizo>4º Ofício de RGI de Belo Horizonte/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-10-27</DataInstauracao>
				<ValorCausa>332590.55</ValorCausa>
				<PartesProcesso>Opportunity Fundo de Investimento Imobiliário X Rodrigo de Souza Paim e Jaqueline Vilela Araújo Paim</PartesProcesso>
				<PrincipaisFatos>Execução Extrajudicial da Alienação Fiduciária</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>03846042720118190001</Numero>
				<Juizo>2 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-10-31</DataInstauracao>
				<ValorCausa>2196441.07</ValorCausa>
				<PartesProcesso>OPP FUNDO X DBA ENGENHARIA DE SISTEMA LTDA.</PartesProcesso>
				<PrincipaisFatos>Decretação do despejo e cobrança dos aluguéis e encargos locatícios inadimplidos.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04616271020158190001</Numero>
				<Juizo>37 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-11-18</DataInstauracao>
				<ValorCausa>1000</ValorCausa>
				<PartesProcesso>OPP FUNDO e  BALASSIANO ENGENHARIA LTDA X BARBARA DE OLIVEIRA BRASIL CORRÊA e CARLOS AUGUSTO SOARES</PartesProcesso>
				<PrincipaisFatos>Impugnação do valor da causa para que passe a ser o valor do contrato (R$ 565.000,00) ou, caso assim não se entenda que seja o proveito econômico dos autos em caso de condenação dos réus ao pagamento da taxa de corretagem em dobro.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00402724220158070001</Numero>
				<Juizo>4ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-12-04</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>IZABELLE TORRES AZEVEDO E CLAUDIO TALA DE SOUZA X OPP FUNDO  E JFE21</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual com pedido de antecipação dos efeitos da tutela para suspender a cobrança das parcelas do financimento em aberto; no mérito, a procedência dos pedidos para  declarar a rescisão contratual; nulas as cobranças de taxas condominiais; nulidade da cláusula 6.9; lucros cessantes na base de 0,5% dos valores pagos  que corresponde ao valor de R$ 2.038,79 por mês, com incidência desde 30/03/2014 até a data da rescisão do contrato; multa rescisória na proporção de 15% do valor pago; 1,5% sobre o valor do imóvel; multa moratória de 2%  mais juros de 1% a.m pelo atraso no pagamento dos lucros cessantes; restituição da comissão de corretagem no valor de R$ 17.030,50; danos morais para cada autor no valor de R$ 15.000,00; inversão do ônus da prova e honorários de 20% sobre o valor da condenação;</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0027273-57.2015.8.07.0001</Numero>
				<Juizo>DÉCIMA SEGUNDA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-12-08</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>RAFAELA ALVES SOARES ANTUNES X JFE 2 EMPREENDIMENTO IMOBILIARIO LTDA e  BANCO OPPORTUNITTY S.A.</PartesProcesso>
				<PrincipaisFatos>Rescisão contratual; devolução dos valores pagos e lucros cessantes</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>05115873220158190001</Numero>
				<Juizo>40 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-12-23</DataInstauracao>
				<ValorCausa>24246830.29</ValorCausa>
				<PartesProcesso>OPP FUNDO X COMPANHIA MODERNOS HOTÉIS DO BRASIL e outros</PartesProcesso>
				<PrincipaisFatos>Intimação do réu para purga da mora, sob pena decretação de despejo, bem como a sua condenação ao pagamento dos alugueis e encargos contratuais, além das custas e honorários de sucumbência.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04294912820138190001</Numero>
				<Juizo>14 CCTJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-01-19</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>ENINCO ENGENHARIA E INDÚSTRIA COMÉRCIO LTDA X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>O apelante requer, preliminarmente, a nulação da sentença por negativa de prestação jurisdicional em decorrencia de omissão e, no mérito, determinar o abatimento da garantia fidejussória consubstanciada em nota promissória no valor de R$ 462.000,00, apreciar o pedido de revisão dos alugueis e conceder prazo de 6 mees para desocupação do imóvel. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07017043120168070016</Numero>
				<Juizo>III JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-01-28</DataInstauracao>
				<ValorCausa>35200</ValorCausa>
				<PartesProcesso>GUSTAVO SOARES ARAUJO e MARIANA MULLER X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Ação indenizatória em que se pleiteia indenização a título de cláusula penal moratória no valor de R$ 55.741,66 (1% sobre o valor do imóvel - 5 meses- de 31/01/2015 a 08/07/2015); lucros cessantes no valor de R$ 15.000,00 mais os acréscimos legais; R$ 766,67 pagos a título de cotas condominais antes a entrega das chaves; R$ 18.461,73 referentes aos juros da obra;</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00036108520168190203</Numero>
				<Juizo>01  VCJAC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-01-28</DataInstauracao>
				<ValorCausa>15148.6</ValorCausa>
				<PartesProcesso>ANTONIO SABADIN E GERALDA DE FÁTIMA VIEIRA CUNHA SABADIN X BNY MELLON E DOMINUS 10 EMPREENDIMENTOS</PartesProcesso>
				<PrincipaisFatos>Condenar a ré Dominus 10 Empreendimentos Imobiliários Ltda. a restituir R$ 10.297,20, correspondente ao dobro dos valores de condomínio pagos antes da entrega das chaves, que somente teria ocorrido depois de 06/08/2016. No tocante à BNY, requer a condenação, de forma soliária com a Dominus 10, ao pagamento de indenização por danos morais, no valor de R$ 30.000,00.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0032513-57.2016.8.19.0001</Numero>
				<Juizo>45ª Vara Cível da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-02-01</DataInstauracao>
				<ValorCausa>14436.38</ValorCausa>
				<PartesProcesso>Regina da Costa Pereira X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a devolução, em dobro, e indenização por danos morais, referente à suposta diferença de metragem do imóvel do empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.345/2016</Numero>
				<Juizo>Gerência de Fiscalização e Revisão do Lançamento (CIP-1)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-02-02</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de Impugnação ao Lançamento do IPTU de 2016, objetivando a redução da área construída do imóvel de 3.291 m² para 2.793 m².</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.344/2016</Numero>
				<Juizo>Gerência de Fiscalização e Revisão do Lançamento (CIP-1)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-02-02</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de Impugnação ao Lançamento do IPTU de 2016, objetivando a redução da área construída do imóvel de 7.035 m² para 6.929m².</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1.0000.16.006378-0/001 (baixado)</Numero>
				<Juizo>10ª Câmara Cível do Tribunal de Justiça do Estado de MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-02-03</DataInstauracao>
				<ValorCausa>151211.084292642</ValorCausa>
				<PartesProcesso>Rodrigo de Souza Paim e Jaqueline Vilela Araújo PaimXOpportunity Fundo de Investimento Imobiliário</PartesProcesso>
				<PrincipaisFatos>Recurso contra a decisão que indeferiu a antecipação de tutela para suspender a cobrança das parcelas vincendas</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0049414-03.2016.8.19.0001</Numero>
				<Juizo>33ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-02-18</DataInstauracao>
				<ValorCausa>234000</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X RESTAURANTE DO PAÇO IMPERIAL LTDA</PartesProcesso>
				<PrincipaisFatos>Despejo com Cobrança de Aluguéis </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0049382-95.2016.8.19.0001</Numero>
				<Juizo>42ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-02-18</DataInstauracao>
				<ValorCausa>288000</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X CONFEITARIA NOVA CARIOCA LTDA</PartesProcesso>
				<PrincipaisFatos>Despejo com Cobrança de Aluguéis </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01026766220168190001</Numero>
				<Juizo>27º JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-03-28</DataInstauracao>
				<ValorCausa>35200</ValorCausa>
				<PartesProcesso>RAFAEL BEZERRA HERCULANO X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>O autor requer a devolução em dobro de R$ 9.346,49, valor pago à titulo de taxa de corretagem. Caso não se entenda pela devolução em dobro, requer que a restituição se dê de maneira simples. Além disso, requer a condenação do réu ao pagamento de indenização por danos morais, no importe de 10 salários mínimos. .</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5051393-08.2016.8.13.0024</Numero>
				<Juizo>14ª (Décima Quarta) Vara Cível de Belo Horizonte/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-04-11</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de Investimento Imobiliário X Rodrigo de Souza Paim</PartesProcesso>
				<PrincipaisFatos>Notificação Judicial</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00158890620168190203</Numero>
				<Juizo>02 VCJAC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-04-13</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>FERNANDO ARAÚJO GUEDES X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Declaração de nulidade da escritura de dação em pagamento firmada entre a SPE Segredo II e o Opportunity, referente à unidade 303 do imóvel situado na Rua Ituverava, n° 634.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00123335320168070001</Numero>
				<Juizo>15ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-05-02</DataInstauracao>
				<ValorCausa>106536.19</ValorCausa>
				<PartesProcesso>IVAR GOMES X OPP FUNDO </PartesProcesso>
				<PrincipaisFatos>rescisão contratual com o intuito de obter (i)liminarmente: (a) a suspensão das parcelas vincendas; (b) a liberação do imóvel para revenda; (c) que as rés se abstenham de incluir o seu nome dos cadastros de inadimplentes; (ii) No mérito, (a) a rescisão do contrato com a devolução de R$ 125.336,69 em parcela única e atualizados desde o desembolso; a nulidade da cláusula 5.9; (c) seja declarado como valor máximo a ser retido pelo vendedor, 10% a título de taxa de administração; (d) que o contrato seja declarado contrato de adesão; (e) sejam computados os juros desde a citação; (f) ônus sucumbenciais na proporção de 20% da condenação; (iii) por fim, informa não ter interesse na audiência preliminar de que trata o art. 334 do NCPC. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07110483620168070016</Numero>
				<Juizo>VII JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-05-17</DataInstauracao>
				<ValorCausa>26002.29</ValorCausa>
				<PartesProcesso>MARALISE ORNELAS MONCAIO DA SILVEIRA X JFE21</PartesProcesso>
				<PrincipaisFatos>Ação de revisão de distrato. A autora pretente reaver o percentual retido em favor do vendedor, na proporção de 17,5% dos valores pagos. Sustentata que o fundamento do distrato é o atraso e, portanto, faz jus à integralidade dos valores pagos. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/373.454/2016</Numero>
				<Juizo>Gerência de Recadastramento e Atualização Cadastral (CIP-5)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-10</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de Inclusão Predial dos imóveis localizados na Avenida Presidentes Vargas, nº 1.121, Centro, de acordo com a Certidão de Habite-se concedida em junho de 2016.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0017771-60.2016.8.07.0001</Numero>
				<Juizo>VIGÉSIMA QUINTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-17</DataInstauracao>
				<ValorCausa>307565.36</ValorCausa>
				<PartesProcesso>SANRA ELIZABETE JORGE LANDIM X JFE 21 EMPREENDIMENROS IMOBILIÁRIOS LTDA</PartesProcesso>
				<PrincipaisFatos>O Autor requer a resolução do contrato com devolução integral dos valores pagos, além da condenação em indenização por lucros cessantes</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0705133-33.2016.8.07.0007</Numero>
				<Juizo>SEGUNDO JUIZADO ESPECIAL CÍVEL DE TAGUATINGA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-22</DataInstauracao>
				<ValorCausa>35200</ValorCausa>
				<PartesProcesso>JOSE WERICK DE CARVALHO X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO, JOÃO FORTES ENGENHARIA S/A e JFE 2 EMPREENDIMENTOS IMOBILIÁRIOS</PartesProcesso>
				<PrincipaisFatos>O Autor requer a condenação em indenização por lucros cessantes, inversão da multa moratória e restituição dos valores pagos a título de taxa condominial</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02098364920168190001</Numero>
				<Juizo>02 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-24</DataInstauracao>
				<ValorCausa>601876</ValorCausa>
				<PartesProcesso>GLAUCIO MONTEIRO ROSA e ÚRSULA VERA RODRIGUES X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Ação pelo rito comum na qual a autora requer a anulação das cláusulas 2.3, 4.1, 4.1.2, 4.3, 5.7, .5.7.1, 5.7.2, 5.8.2, 6.1, 6.4, 6.7, 11.2 da promessa de compra e venda, com a aplicação de multa de R$ 8.600,00 pelo atraso na entrega do imóvel; devolução em dobro da comissão de corretagem (R$ 18.603,44); restituição em dobro da cota condominial paga antes da entrega das chaves (R$ 776,86); condenação da ré ao pagamento em dobro dos juros nominativos de 264% e efetivos de 288% referentes à diferença de financiamento do saldo devedor entre o Itau, instituição com a qual  os autores teriam sido obrigados a financiar, e a Caixa Econômica e, caso assim não se entenda, de forma simples; condenação do réu ao pagamento de indenzação por danos morais a serem arbitrados.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02148830420168190001</Numero>
				<Juizo>018 JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-29</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>SIDNEY REGEN e MONICA TEIXEIRA VAIRO   X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Condenação da ré ao pagamento a restituir o valor de R$ 1.369,37, pago a título de IPTU da unidade, bem como ao pagamento de danos morais no valor de R$ 10.000,00.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02250472820168190001</Numero>
				<Juizo>04 JECRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-07-07</DataInstauracao>
				<ValorCausa>34000</ValorCausa>
				<PartesProcesso>CARLOS HENRIQUE PEREIRA DE OLIVEIRA E ALINE GOMES DE MELLO DE OLIVEIRA X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Condenar o réu a restituir em dobro a quantia de R$ 8.730,00 (R$ 17.460,00), paga a título de comissão de corretagem, bem como indenização por danos morais.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02282422120168190001</Numero>
				<Juizo>50 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-07-11</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>MIGUEL ANTONIO GRANATO e ANA CRISTINA DA SILVA BARROSO X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Ação visando a anulação da execução extrajudicial que culminou no leilão com a consequente arrematação do imóvel, cancelando todos os atos que implicaram em transferência de domínio.
Pedido de liminar para suspender os efeitos do leilão e, consequentemente, da arrematação realizada em 31/05/2016.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/373.869/2016</Numero>
				<Juizo>Coordenadoria do ISS (CIS-1)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-07-19</DataInstauracao>
				<ValorCausa>1048335.11</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de litígio tributário instaurado com a apresentação de impugnação à Nota de Lançamento nº 1807/2016, emitida em agosto de 2016 contra o sujeito passivo, relativa ao ISS supostamente devido pela construção de imóvel.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0021830-91.2016.8.07.0001</Numero>
				<Juizo>PRIMEIRA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-07-22</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>ENOS BARBOSA DE SOUZA e MARIA JOSÉ RODRIGUES DE SOUSA BARBOSA X JFE 21 EMPREENDIMENTOS IMOBILIÁRIOS LTDA.</PartesProcesso>
				<PrincipaisFatos>O Autor requer a resolução do contrato com devolução integral dos valores pagos, além da condenação em indenização por lucros cessantes</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0022382-56.2016.8.07.0001</Numero>
				<Juizo>DÉCIMA SEXTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-07-28</DataInstauracao>
				<ValorCausa>52000</ValorCausa>
				<PartesProcesso>MILENY OLIVEIRA SILVA  X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e  JOÃO FORTES ENGENHARIA S/A</PartesProcesso>
				<PrincipaisFatos>x</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00358222520168070000</Numero>
				<Juizo>2ªturma</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-08-02</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FUNDO E JFE21 X IZABELLE TORRES AZEVEDO E CLAUDIO TALA DE SOUZA</PartesProcesso>
				<PrincipaisFatos>Agravo contra a decisão que na forma do art. 355 I e 356, II julgou parcilamente eo mérito e condenou as rés  devolverem a integralidade dos valores pagos (com exceção do valores pagos a título de comissão de corretagem); lucros cessantes na proporção de 0,5% (meio por cento) a título de lucros cessantes enre 30.09.14 até o transito em julgado; multa moratória de 2%, e juros de 1%, sobre a quantia a ser restituída, conforme cláusula 6.1. Honorários na proporção de 10%; </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02695746520168190001</Numero>
				<Juizo>50 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-08-25</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>RUY PEDRO GIRON JUNIOR X MIGUEL ANTONIO GRANATO e ANA CRISTINA DA SILVA BARROSO GRANATO</PartesProcesso>
				<PrincipaisFatos>Ação de imissão na posse proposta pelo arrematante em face do devedor, onde se requer seja liminarmente concedida a imissão na posse, a ser confirmada ao final da demanda, bem como a condenação do réu ao pagamento dos aluguéis e e taxas inerentes à utilização.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/374.354/2016</Numero>
				<Juizo>Coordenadoria do ISS (CIS-1)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-09-15</DataInstauracao>
				<ValorCausa>270587.87</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de impugnação à Nota de Lançamento nº 2061/2016, tendo em vista o indevido arbitramento da base de cálculo.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>03181119220168190001</Numero>
				<Juizo>31 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-10-06</DataInstauracao>
				<ValorCausa>36119</ValorCausa>
				<PartesProcesso>CREGINALDO IVO DE MORAES e GILVANETE MARIA DA SILVA DE MORAES X OPP FUNDO, BNY, MÉTRICA e MATOSO</PartesProcesso>
				<PrincipaisFatos>Anulação da cláusula 4.1.3, que prevê a correção monetária mensal das parcelas e do saldo devedor, sob o argumento de que não foram devidamente informados, bem como a revisão do contrato, no período de outubro de 2015 a dezembro de 2015, em razão de suposta aplicação de anatocismo. Diante disso, requerem a condenação dos réus a devolverem em dobro dos valores pagos a maior a título de juros e ligações definitivas (R$ 14.765,06) e ao pagamento de indenização por danos morais no valor de R$ 20.000,00. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0321034-91.2016.8.19.0001</Numero>
				<Juizo>9ª VC da Capital</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-10-07</DataInstauracao>
				<ValorCausa>187000</ValorCausa>
				<PartesProcesso>Jomar Deias da Cruz e Maria Nícia Barbosa Dias da Cruz  X 1º Réu: Opportunity Fundo de Investimento Imobiliário; 2º Réu: Matoso Empreendimentos Imobiliários SPE LTDA</PartesProcesso>
				<PrincipaisFatos>Rescisão da PCV; nulidade de cláusula contratual; devolução das importâncias desembolsadas (exceto comissão de corretagem) com deságio de 15%, além de honorários e custas judiciais</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0731680-83.2016.8.07.0016</Numero>
				<Juizo>QUINTO JUIZADO ESPECIAL CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-10-18</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>ANNA PAULA OSORIO BARBOSA  X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO,   JOÃO FORTES ENGENHARIA S/A e JFE 10 EMPREENDIMENTOS IMOBILIÁRIOS</PartesProcesso>
				<PrincipaisFatos>A Autora requer a baixa da hipoteca e a condenação em perdas e danos</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0345194-83.2016.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-10-23</DataInstauracao>
				<ValorCausa>14248.52</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de suposta multa administrativa, lavrada pela Secretaria Municipal de Urbanismo em face ESTACAO BARRA - SPORT E LAZER LTDA/OPPORTUNITY F. I. IMOBILIARIO, relativos ao imóvel situado à Av. das Américas, 700, loja 121, consubstanciado na CDA nº 63/000947/2015.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5156015-41.2016.8.13.0024</Numero>
				<Juizo>25ª (Vigésima Quinta) Vara Cível de Belo Horizonte/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-10-25</DataInstauracao>
				<ValorCausa>357536.41</ValorCausa>
				<PartesProcesso>Adriano Gomes Peixoto e Marta AlmeidaPeixoto X Toscanini Empreendimentos Imobiliários Ltda. e Opportunity HDF Participações S/A</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual com Devolução dos Valores Pagos</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00320461420168070001</Numero>
				<Juizo>19ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-10-28</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>RODRIGO BARBOSA DE CASTILHO E GIOVANA LIMA X OPP FUNDO e JFE22</PartesProcesso>
				<PrincipaisFatos>Ação de Obrigação de fazer c/c com pedido de tutela provisória de urgência e indenização por danos morais. Pedem a antecipação de tutela  para que os reus realizem o reparo do vazamento e infiltrações constantes do andar superior do imóvel sob pena de multa diária; Danos morais no montante de R$ 50.000,00; a condenação ao pagamento de honorários na Unidade 623, Due Murano.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5158685-52.2016.8.13.0024</Numero>
				<Juizo>31ª (Trigésima Primeira) Vara Cível de Belo Horizonte</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-10-28</DataInstauracao>
				<ValorCausa>321223.55</ValorCausa>
				<PartesProcesso>Rafael Almeida Peixoto X Opportunity Fundo de Investimentos Imobiliários e Toscanini Empreendimentos Imobiliários Ltda.</PartesProcesso>
				<PrincipaisFatos>Rescisão Contratual com Devolução de Valores</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0372721-10.2016.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-10-28</DataInstauracao>
				<ValorCausa>18705114.06</ValorCausa>
				<PartesProcesso>Município do Rio de Janeiro X Banco Opportunity S/A</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que objetiva a cobrança de supostos débitos de IPTU consubstanciados nas CDAs nºs 01/016641/2015, 01/073694/2015, 01/073695/2015, 01/188963/2015 e 01/197237/2015, guias 2013/11/02; 2013/14/03; 2013/14/04; 2014/03/01 e 2014/06/02, referentes aos exercícios financeiros de 2008, 2010, 2005, 2011 e 2007, respectivamente.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5160474-86.2016.8.13.0024</Numero>
				<Juizo>11ª (Décima Primeira) Vara Cível de Belo Horizonte/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-11-01</DataInstauracao>
				<ValorCausa>329952.85</ValorCausa>
				<PartesProcesso>Júlio Vilela da Silva Neto X Opportunity Fundo de Investimentos Imobiliários e Toscanini Empreendimentos Imobiliários Ltda.</PartesProcesso>
				<PrincipaisFatos>Agravo contra decisão que determinou ao Autor o recolhimento das custas iniciais remanescentes, visto que o valor da causa foi alterado para R$ 753.382,30. Rescisão Contratual com Devolução dos Valores Pagos</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>53001001160066654</Numero>
				<Juizo>PROCON/DF</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-11-03</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>SANDRA MARIA DA COSTA RICCIARDI X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Reclamação em que a compradora pleiteiava a o reparo do vidro externo da janela, bem como, cópia do laudo de vistoria das áreas comuns. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00336536220168070001</Numero>
				<Juizo>2ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-11-11</DataInstauracao>
				<ValorCausa>49000.76</ValorCausa>
				<PartesProcesso>ARMINDO RIEDEL E ELUZIA FEREIRA XOPP FUNDO e JFE22</PartesProcesso>
				<PrincipaisFatos>Ação indenizatória por danos materiais e morais em face do atraso para conclusão da undiade. Lucros Cessantes: R$ 11.800,00, Multa moratória: R$ 27.200,76 e Danos morais de R$ 20.000,00 </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0407191-67.2016.8.19.0001</Numero>
				<Juizo>9º Juizado Especial Cível - Vila Isabel</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-11-28</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Leylane Porto BittencourtXOPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e BALASSIANO ENGENHARIA LTDA.
</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança requerendo a restituição dos valores pagos a título de “ligações definitivas”, referentes ao empreendimento Stilo Tijuca Residence.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101870-11.2016.5.01.0023</Numero>
				<Juizo>23</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-01</DataInstauracao>
				<ValorCausa>15000</ValorCausa>
				<PartesProcesso>JOSE MACIEL DE SOUSA X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101922-67.2016.5.01.0003</Numero>
				<Juizo>3</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-05</DataInstauracao>
				<ValorCausa>20000</ValorCausa>
				<PartesProcesso>MAURICIO BEZERRA DA SILVA X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101873-57.2016.5.01.0025</Numero>
				<Juizo>25</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-05</DataInstauracao>
				<ValorCausa>40000</ValorCausa>
				<PartesProcesso>LEONARDO SILVA CABRAL X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00363522620168070001</Numero>
				<Juizo>4ª Vara Cível</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-06</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>IZABELLE TORRES AZEVEDO E CLAUDIO TALA DE SOUZA X OPP FUNDO e JFE21</PartesProcesso>
				<PrincipaisFatos>Cumprimento parcial de sentença em que os autores executam os valores incontroversos (90% dos valores pagos e honorários sucumbenciais)</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101892-10.2016.5.01.0075</Numero>
				<Juizo>75</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-06</DataInstauracao>
				<ValorCausa>20000</ValorCausa>
				<PartesProcesso>SYLAS COELHO ALVES X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0422581-77.2016.8.19.0001</Numero>
				<Juizo>3ª Vara Empresarial da Comarca da Capital/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-09</DataInstauracao>
				<ValorCausa>3194545</ValorCausa>
				<PartesProcesso>RCFA ENGENHARIA LTDA e outro(s)... X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e OPPORTUNITY FUNDO DE INVESTIMENTO EM DIREITOS CREDITÓRIOS e outras</PartesProcesso>
				<PrincipaisFatos>Trata-se de recuperação judicial do Grupo RCFA, que engloba as empresas: DOMINUS 10 EMPREENDIMENTOS LTDA., DOMINUS 11 EMPREENDIMENTOS IMOBILIÁRIOS LTDA., DOMINUS 14 EMPREENDIMENTOS IMOBILIÁRIOS SPE LTDA., DEL 15 EMPREENDIMENTOS IMOBILIÁRIOS LTDA., LA SETE EMPREENDIMENTOS IMOBILIÁRIOS LTDA., LAGOA SANTA SPE EMPREENDIMENTOS IMOBILIÁRIOS LTDA., TOSCANINI EMPREENDIMENTOS IMOBILIÁRIOS LTDA., SPE MG 01 EMPREENDIMENTOS IMOBILIÁRIOS LTDA.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00412009020158070001</Numero>
				<Juizo>14ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-11</DataInstauracao>
				<ValorCausa>99549.96</ValorCausa>
				<PartesProcesso>GIORDANO BRUNO CURADO CAMARGO X OPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Indenização pelo atraso na entrega da unidade e nulidade da cláusula que prevê prorrogação por 180 dias;  multa moratória na proporção de 2% sobre o valor do imóvel; lucros cessantes no valor de R$ 24.000,00; honorários fixados em 20% sobre o valor da causa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101980-87.2016.5.01.0062</Numero>
				<Juizo>62</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-13</DataInstauracao>
				<ValorCausa>39508.78</ValorCausa>
				<PartesProcesso>LARISSA MARQUES ROCHA X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101942-44.2016.5.01.0040</Numero>
				<Juizo>40</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-13</DataInstauracao>
				<ValorCausa>30000</ValorCausa>
				<PartesProcesso>ISABELLA SOUSA DE OLIVEIRA X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04271303320168190001</Numero>
				<Juizo>15 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-14</DataInstauracao>
				<ValorCausa>8393.82</ValorCausa>
				<PartesProcesso>RENATO MARTINEZ GERACI E GIOVANA COSTA GAGLIANONE X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Ação de resolução contratual na qual se requer liminarmente, (i) a suspensão da exigibilidade da última parcela das ligações definitivas, no valor de R$ 2.980,20; (ii) a supensão da exigibilidade da cobrança das cotas condominiais; (iii) que o réus se abstenham de cobrar qualquer valor decorrente da compra e venda e incluir os menos dos autos nos cadastros restritivos de crédito. Ao final requerem, além da confirmação da antecipação da tutela, (i) a rescisão do contrato por culpa exclusiva dos réus; (ii) condenação dos réus a devolverem o montante pago (R$ 123.963,73) ou pelo menos 90% dos valores pagos (R$ 111.567,33); (iii) a devolução dos valores pagos a título de cotas condominiais, no valor de R$ 1.681,80; (iv) condenação dos réus ao pagamento de indenização dos materiais contratados para o projeto de arquitetura que os autores estavam fazendo para o imóvel, no valor de R$ 3.801,00; (iv) condenação dos réus ao pagamento de indenização em razão da compra de uma cama, no valor de R$ 5.950,00; (v) condenação dos réus ao pagamento de indenização por danos morais, na quantia de R$ 10.000,00.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04290564920168190001</Numero>
				<Juizo>50 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-15</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>MARCUS VINICIUS SAMPAIO GENN X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Renovação do contrato de locação pelo prazo de 5 anos, com vigência de maio de 2018 a maio de 2023, com a fixação de aluguel provisório e definitivo no valor de R$ 8.500,00.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07316100320158070016</Numero>
				<Juizo>VII JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-18</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>ANTONIO LINO BELLING e MARGARET DA SILVA BELING X OPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos> Reparação por danos materiais e razão do atraso na conclusão das obras em que se pleiteia indenizaçãoa título de lucros cessantes no valor de R$ 8.475,00; reversão da cláusula 6.1 para obter multa na proporção de 2% de juros de mora e 1% a.m, no importe de R$ 22.966,56. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04366623120168190001</Numero>
				<Juizo>15 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-23</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>RENATO MARTINEZ GERACI E GIOVANA COSTA GAGLIANONE X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Liminar deferida no plantão judiciário para suspender a exigibilidade da cobrança: a) da última parcela referente às ligações definitivas cobradas nas cláusulas 4.1.2 e 4.1. 2.1 , no valor de R$ 2.980,20, com vencimento em 25 de dezembro de 2016 e b) das mensalidades referentes às cotas condominiais da unidade.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100009-86.2017.5.01.0012</Numero>
				<Juizo>12</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-09</DataInstauracao>
				<ValorCausa>30000</ValorCausa>
				<PartesProcesso>FRANCISCO JOSE DOS REIS FILHO X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO, BANCO OPPORTUNITY LTDA - ME</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100004-13.2017.5.01.0029</Numero>
				<Juizo>29</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-09</DataInstauracao>
				<ValorCausa>37500</ValorCausa>
				<PartesProcesso>JOSE CARLOS DE SOUZA BENJAMIM X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO, BANCO OPPORTUNITY LTDA - ME</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100005-86.2017.5.01.0032</Numero>
				<Juizo>32</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-09</DataInstauracao>
				<ValorCausa>20000</ValorCausa>
				<PartesProcesso>DAMIÃO DA SILVA COSTA X RCFA ENGENHARIA LTDA, HOTEL PESTANA RIO BARRA SCP, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO, BANCO OPPORTUNITY LTDA - ME</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100013-18.2017.5.01.0047</Numero>
				<Juizo>47</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-09</DataInstauracao>
				<ValorCausa>39508.78</ValorCausa>
				<PartesProcesso>RAFAEL AVELINO DA SILVA X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO, BANCO OPPORTUNITY LTDA - ME</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100009-09.2017.5.01.0070</Numero>
				<Juizo>7</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-09</DataInstauracao>
				<ValorCausa>32000</ValorCausa>
				<PartesProcesso>FRANCISCO DAS CHAGAS DE SOUZA ARAUJO X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO, BANCO OPPORTUNITY LTDA - ME</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100036-69.2017.5.01.0012</Numero>
				<Juizo>12 RIO DE JANEIRO</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-10</DataInstauracao>
				<ValorCausa>38000</ValorCausa>
				<PartesProcesso>CESAR MACHADO ROBERTO, PRIMA VERÃO AR CONDICIONADO CENTRAL LTDA, CONCREJATO SERVIÇOS TÉCNICOS DE ENGENHARIA S.A., OPPORTUNITY FUNDO DE
INVESTIMENTO IMOBILIÁRIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESCISÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00602284020178190001</Numero>
				<Juizo>40 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-17</DataInstauracao>
				<ValorCausa>5351775.62</ValorCausa>
				<PartesProcesso>OPP FUNDO X ENINCO ENGENHARIA E INDÚSTRIA COMÉRCIO LTDA</PartesProcesso>
				<PrincipaisFatos>Execução provisória dos alugueis e encargos vencidos de dezembro de 2013, no valor de R$ 5.315.576,24.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0001250-06.2017.8.07.0001</Numero>
				<Juizo>QUINTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-23</DataInstauracao>
				<ValorCausa>338184</ValorCausa>
				<PartesProcesso>MAILYM NEVES MAGALHÃES X BANCO OPPORTUNITY AS, JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA e JOÃO FORTES ENGENHARIA S/A</PartesProcesso>
				<PrincipaisFatos>UNIDADE LEILOADA - Rescisão contratual com a devolução dos valores pagos e indenização por lucros cessantes</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0001251-88.2017.8.07.0001</Numero>
				<Juizo>QUINTA VARA CÍVEL DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-23</DataInstauracao>
				<ValorCausa>338184</ValorCausa>
				<PartesProcesso>ZAIRA CRISTINA NEVES MAGALHÃES X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILÁRIO e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA </PartesProcesso>
				<PrincipaisFatos>UNIDADE LEILOADA - Rescisão contratual com a devolução dos valores pagos e indenização por lucros cessantes</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.208/2017</Numero>
				<Juizo>Gerência de Fiscalização e Revisão do Lançamento (CIP-1)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-01-30</DataInstauracao>
				<ValorCausa>120943.64</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de restituição do IPTU de 2014, reconhecida no processo administrativo nº 04/66/302.952/2013.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0005827-94.2017.8.19.0000</Numero>
				<Juizo>22ª Câmara Cível do Tribunal de Justiça do RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-02-13</DataInstauracao>
				<ValorCausa>3194545</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO e OPPORTUNITY FUNDO DE INVESTIMENTO EM DIREITOS CREDITÓRIOS e outras X RCFA ENGENHARIA LTDA e outro(s)...</PartesProcesso>
				<PrincipaisFatos>Agravo de instrumento interposto contra a decisão que deferiu o processamento da recuperação judicial das empresas do Grupo RCFA, suspendendo todas as ações e execuções que envolvem as recuperandas, inclusive aquelas previstas no art. 49, §§ 3º e 4º da Lei 11.101/05</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00029666820178070001</Numero>
				<Juizo>6ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-02-14</DataInstauracao>
				<ValorCausa>124351.58</ValorCausa>
				<PartesProcesso>RODRIGO GONCZAROWSKA GOMES XOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Revisão de distrato com pedido de restituição dda integralidade dos valores pagos (R$ 119.976,64); Lucros cessantes no valor de R$ 1.700,00 por mes de atraso para o período de 19 meses. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100284-02.2017.5.01.0023</Numero>
				<Juizo>23</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-03-02</DataInstauracao>
				<ValorCausa>38000</ValorCausa>
				<PartesProcesso>DEYVYD DA SILVA ANACLETO X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>DIFERENÇA SALARIAL</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100289-87.2017.5.01.0002</Numero>
				<Juizo>2 RIO DE JANEIRO</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-03-02</DataInstauracao>
				<ValorCausa>40000</ValorCausa>
				<PartesProcesso>BRUNO MOREIRA EMIDIOXJC JESUS NO CORACAO PRESTACAO DE SERVICO LTDA, BACKSTOP SERVICOS DE APOIO LTDA ME, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITORIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0008126-75.2017.8.08.0024</Numero>
				<Juizo>VITÓRIA - 3ª VARA CÍVEL</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-03-31</DataInstauracao>
				<ValorCausa>580000</ValorCausa>
				<PartesProcesso>GLAYLTON MARCIO MERLOS PENNA E JULIANA IRENE GATTI PENNA X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO </PartesProcesso>
				<PrincipaisFatos>RESCISÃO DE INSTRUMENTO PARTICULAR DE PROMESSA DE COMPRA E VENDA, CUMULADA COM PEDIDO DE RESTITUIÇÃO DE VALORES PAGOS E INDENIZAÇÃO POR DANOS MORAIS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100624-46.2017.5.01.0022</Numero>
				<Juizo>22</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-04-27</DataInstauracao>
				<ValorCausa>40000</ValorCausa>
				<PartesProcesso>JOSE MARIA PEDROSA HARDMAN VIANNA X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO, BNY MELLON SERVIÇOS FINANCEIROS DTVM S.A., OPPORTUNITY HDP PARTICIPAÇÕES S.A.</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0013269-66.2017.8.19.0209</Numero>
				<Juizo>3ª VARA CÍVEL BARRA DA TIJUCA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-02</DataInstauracao>
				<ValorCausa>10000</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X MARIA DA GRAÇA BERNARDONI CAPELINI GELSI e JOSÉ MARIA GELSI</PartesProcesso>
				<PrincipaisFatos>TRATA-SE DE AÇÃO DE OBRIGAÇÃO FAZER OBJETIVANDO A CELEBRAÇÃO DE ESCRITURA DEFINITIVA DE COMPRA E VENDA, REGISTRO E TRANSFERÊNCIA DE PROPRIEDADE JUNTO AO SPU</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0013277-43.2017.8.19.0209</Numero>
				<Juizo>2ª VARA CÍVEL BARRA DA TIJUCA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-02</DataInstauracao>
				<ValorCausa>10000</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X MARIA CRISTINA ANDRADE SOUZA</PartesProcesso>
				<PrincipaisFatos>TRATA-SE DE AÇÃO DE OBRIGAÇÃO FAZER OBJETIVANDO A CELEBRAÇÃO DE ESCRITURA DEFINITIVA DE COMPRA E VENDA, REGISTRO E TRANSFERÊNCIA DE PROPRIEDADE JUNTO AO SPU</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01017391820178190001</Numero>
				<Juizo>41 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-02</DataInstauracao>
				<ValorCausa>20000</ValorCausa>
				<PartesProcesso>RODRIGO RODRIGUES DE AGUIAR E DANIEL CAMPOS GUIMARÃES DE CUNHAXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Condenação do réu à devolução em dobro de todos os valores pagos a maior a título de cotas condominiais e IPTU, em razão da diferença entre a fração ideal que constou na escritura e a registrada. Requer, ainda, que seja declarada nula a cláusula do contrato e da convenção de condomínio que unilateralmente isentou o réu de parte das cotas condominiais.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0013337-16.2017.8.19.0209</Numero>
				<Juizo>4ª VARA CÍVEL BARRA DA TIJUCA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-03</DataInstauracao>
				<ValorCausa>10000</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO X CRISÓLOGO LACERDA PEREIRA</PartesProcesso>
				<PrincipaisFatos> TRATA-SE DE AÇÃO DE OBRIGAÇÃO FAZER OBJETIVANDO O REGISTRO DA ESCRITURA DE COMPRA E VENDA E TRANSFERÊNCIA DE PROPRIEDADE JUNTO AO SPU</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04116865720168190001</Numero>
				<Juizo>46 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-03</DataInstauracao>
				<ValorCausa>476122.7</ValorCausa>
				<PartesProcesso>NOVEMP INDÚSTRIA E COMÉRCIO LTDA. X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Condenação do réus, de forma solidária, ao pagamento de indenização por perdas e danos no valor de R$ 476.122,70, em razão do cancelamento da compra de 8 painéis elétricos por alteração de projeto.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100761-66.2017.5.01.0074</Numero>
				<Juizo>74</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-08</DataInstauracao>
				<ValorCausa>8000</ValorCausa>
				<PartesProcesso>IGOR NUNES ALVES X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO, BANCO OPPORTUNITY LTDA - ME</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01174055920178190001</Numero>
				<Juizo>48 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-17</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>MERLON LANCHONETE E PASTELARIA LTDA. MA X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Renovação do contrato de locação pelo prazo de cinco anos (janeiro de 2018 a dezembro de 2022) pelo valor mensal de aluguel de R$ 10.000,00. Na hipótese de não renovação do contrato, o autor requer a fixação de indenzação por perdas e danos e lucros cessantes, em razão da interrupção das suas atividades. Requer, ainda, a condenação dos réus ao pagamento de custas e honorários de 20% sobre o valor da causa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0100761-54.2017.5.01.0078</Numero>
				<Juizo>78</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-19</DataInstauracao>
				<ValorCausa>20000</ValorCausa>
				<PartesProcesso>JANDIVALDO PEREIRA DE ARAUJO X RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0121729-92.2017.8.19.0001</Numero>
				<Juizo>24ª VC da Capital</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-22</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de Investimentos Imobiliários e SOMAR 02 EMPREENDIMENTOS LTDA X JORGE EDSON PEREIRA FIRMINO DE JESUS e I .S.V. COMÉRCIO DE MATERIAL DE CONSTRUÇÃO CIVIL LTDA-ME</PartesProcesso>
				<PrincipaisFatos>Imissão de posse da loja situada na Rua Dois de Dezembro</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0008819-59.2017.8.08.0024</Numero>
				<Juizo>VITÓRIA - 7ª VARA CÍVEL</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-06-04</DataInstauracao>
				<ValorCausa>99392.67</ValorCausa>
				<PartesProcesso>LAMAISON LUIZ DA SILVA SILVEIRA E ELIZABETH DANTAS SILVEIRA X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO </PartesProcesso>
				<PrincipaisFatos>RESCISÃO DE INSTRUMENTO PARTICULAR DE PROMESSA DE COMPRA E VENDA, CUMULADA COM PEDIDO DE RESTITUIÇÃO DE VALORES PAGOS.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01512334620178190001</Numero>
				<Juizo>10 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-06-19</DataInstauracao>
				<ValorCausa>103727.1</ValorCausa>
				<PartesProcesso>ENINCO ENGENHARIA E INDÚSTRIA COMÉRCIO LTDA X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Condenação da ré ao pagamento de indenização pelos danos ambientais consistentes na contaminação do imóvel do autor pelas substâncias poluentes usadas em sua atividade industrial, no valor necessário para realizar a descontaminação do imóvel, conforme se apurar em liquidação da sentença por arbitramento, os quais deverão ser corrigidos e acrescidos de juros de mora desde a constatação dos danos até a data do efetivo pagamento; e ao pagamento da multa por infração contratual, no valor de R$ 103.727,10, corrigido monetariamente até a data do efetivo pagamento e acrescidos de juros de mora desde a constatação dos danos.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1113853</Numero>
				<Juizo>Quarta Turma do STJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-07-04</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>ENINCO ENGENHARIA E INDÚSTRIA COMÉRCIO LTDA X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Reforma do acórdão que negou provimento à apelaçao  sob o fundamento de que violaria os arts. 157, 478, 479 e 480, todos do Código Civil. Requer-se a reforma do acórdão para reconhecer a onerosidade excessiva e incidência da teoria da imprevisão, modificando equitativamente as obrigações.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0019332-87.2017.808.0347</Numero>
				<Juizo>4º JEC DE VITÓRIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-07-20</DataInstauracao>
				<ValorCausa>37480</ValorCausa>
				<PartesProcesso>EDUARDO VERVLOET MOYSES E IZABELA CRISTIANE TOLEDO DINIZ MOYSES X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO </PartesProcesso>
				<PrincipaisFatos>RESCISÃO DE INSTRUMENTO PARTICULAR DE PROMESSA DE COMPRA E VENDA, CUMULADA COM PEDIDO DE RESTITUIÇÃO EM DE VALORES PAGOS A TÍTULO DE TAXA DE CORRETAGEM E CUSTAS PROCESSUAIS </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07249164720178070016</Numero>
				<Juizo>V JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-07-20</DataInstauracao>
				<ValorCausa>21994.32</ValorCausa>
				<PartesProcesso>JOANA SARMENTO DE MATOS X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Indenização a título de lucros cesantes no valor de R$ 13.20,00 referente a 186 dias de atraso na entrega das chaves e mais a inversão da cláusula 6.1 para obter multa na proporção de 2% sobre o valor do contrato;</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01835535220178190001</Numero>
				<Juizo>27 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-07-20</DataInstauracao>
				<ValorCausa>10530000</ValorCausa>
				<PartesProcesso>OPP FUNDO X ASSOCIAÇÃO LAR SÃO FRANSCISCO DE ASSIS NA PROVIDÊNCIA DE DEUS</PartesProcesso>
				<PrincipaisFatos>Reconhecimento do direito do autor ser ressarcido pela evicção decorrente da peda dos imóveis da Rua da Carioca números 35,37,39,43 e 47, adquiridos da ré, embora houvesse desaspropriação dos mesmos pelo Estado do Rio de Janeiro, condenando a ré ao pagamento do valor de mercado atual dos bens , acrescidos de juros de mora, nos termos da lei, bem como nos custos com projeto de restauração dos imóveis, no valor de R$ 184.138,00.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00437315120178190000</Numero>
				<Juizo>Seção Cível do Consumidor</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-08-07</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FUNDO  X ALESSANDRA DE SOUZA ZAMBONI</PartesProcesso>
				<PrincipaisFatos>Reforma do acórdão que manteve a sentença que condenou o OPP a devolver de maneira simples a comissão de corretagem, violando à jurisprudência do STJ firmada em sede de recurso repetitivo. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07206749020178070001</Numero>
				<Juizo>25 VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-08-08</DataInstauracao>
				<ValorCausa>34615</ValorCausa>
				<PartesProcesso>LUIS OLIVIO MANSO DE BARROS E ALESSANDRA ZAK CALVÁRIO BARROS X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Nulidade das cláusulas 5.7.1 e 5.7.2; lucros cessantes no valor de R$ 1.650,00 a partir de 30/09/2014 até o recebimento das chaves; inversão de multa penal moratória (cláusula 11ª) para fixar multa na proporção de 10% acrescidos de juros de 1% a incidir sobre o preço pago; danos emergentes para restituir todos os valores pagos a título de juros de obra a partir do témino de tolerância (90/09/14) até o recebimento do imóvel;declarar como data de efeitva entrega a data em que o habite-se foi averbado ou ainda que seja considerada a data do habite-se provisório, 02.05.2016; declarar abusiva a imposição de taxas de condomínio e IPTU por período anterior à averbação do habite-se; condenar a requerida ao pagamento das taxas condominiais dos meses de fev/2015; jun/2015 a dez/2015; jan/2016 a mar/2016</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07211710720178070001</Numero>
				<Juizo>19ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-08-10</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>TATIANA CORREA LIMA GALVÃO X OPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Depósito das parcelas vencidas e vincendas a partir de 10 de julho de 2017</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0221451-02.2017.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-08-25</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101359-37.2017.5.01.0036</Numero>
				<Juizo>36</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-08-29</DataInstauracao>
				<ValorCausa>39000</ValorCausa>
				<PartesProcesso>LUCAS FELIPE ONOFRE GASPAR X PRT VIANA SERVIÇOS DE CONSTRUÇÕES LTDA, RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101425-47.2017.5.01.0026</Numero>
				<Juizo>26</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-01</DataInstauracao>
				<ValorCausa>39000</ValorCausa>
				<PartesProcesso>LEONARDO DE SOUZA FERREIRA X PRT VIANA SERVIÇOS DE CONSTRUÇÕES LTDA, RCFA ENGENHARIA LTDA, OPPORTUNITY GESTORA DE RECURSOS LTDA</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0010496-27.2017.8.08.0024</Numero>
				<Juizo>VITÓRIA - 9ª VARA CÍVEL</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-04</DataInstauracao>
				<ValorCausa>95327.19</ValorCausa>
				<PartesProcesso>GRAZIELA PREST MIRALHA X OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO </PartesProcesso>
				<PrincipaisFatos>RESCISÃO DE INSTRUMENTO PARTICULAR DE PROMESSA DE COMPRA E VENDA, CUMULADA COM PEDIDO DE RESTITUIÇÃO DE VALORES PAGOS.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07320563520178070016</Numero>
				<Juizo>VI JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-08</DataInstauracao>
				<ValorCausa>35774.16</ValorCausa>
				<PartesProcesso>ADRIANO COLODETTE MACHADO X OPP FUNDO, MELLON, MÉTRICA E JFE21</PartesProcesso>
				<PrincipaisFatos>Indenizatória para obter lucros cessantes na proporção de 1% sobre o valor atualizado do imóvel; multa na proporção de 2% mais 1% de juros sobre o valor atualizado do imóvel para o período de 29.03.2015 a 08.05.2015.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101421-65.2017.5.01.0040</Numero>
				<Juizo>40 RIO DE JANEIRO</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-13</DataInstauracao>
				<ValorCausa>40000</ValorCausa>
				<PartesProcesso>DINIZ BARBOSA CABRAL, RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITORIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0028959-17.2017.8.08.0024</Numero>
				<Juizo>VITÓRIA - 6ª VARA CÍVEL</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-27</DataInstauracao>
				<ValorCausa>18083.16</ValorCausa>
				<PartesProcesso>DULCE MARIA OLIVEIRA DOMINGUES CANALI E ANTONIO CARLOS CANALIXOPPORTUNITY FII, BNY MELLON SERVIÇOS FINANCEIROS DTVM E TREVISO EMPREENDIMENTOS LTDA </PartesProcesso>
				<PrincipaisFatos>REPARAÇÃO POR ALEGADOS DANOS MATERIAIS E MORAIS ORIUNDOS DE ATRASO NA ENTREGA DAS CHAVES DO IMÓVEL ADQUIRIDO. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07277532320178070001</Numero>
				<Juizo>1ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-28</DataInstauracao>
				<ValorCausa>100000</ValorCausa>
				<PartesProcesso>OPP FUNDO X TATIANA CORREA LIMA GALVAO</PartesProcesso>
				<PrincipaisFatos>Rescisão de Contratato com pedido de retenção na proporção de 25% dos valores pagos.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1.0000.17.027189-4/002 (baixado)</Numero>
				<Juizo>11ª Câmara Cível do TJ/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-10-16</DataInstauracao>
				<ValorCausa>329952.85</ValorCausa>
				<PartesProcesso>Júlio Vilela da Silva Neto X Opportunity Fundo de Investimentos Imobiliários e Toscanini Empreendimentos Imobiliários Ltda.</PartesProcesso>
				<PrincipaisFatos>Recurso contra descisão que  indeferiu o pedido de tutela de urgência visando excluir o seu nome do cadastro de inadimplentes, bem como impedir que as rés agravadas levassem o imóvel a leilão.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>N/A </Numero>
				<Juizo>4º Ofício de RGI de Belo Horizonte/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-10-17</DataInstauracao>
				<ValorCausa>271150</ValorCausa>
				<PartesProcesso>Lincoln Nunes Moura X Opportunity Fundo de Investimentos Imobiliários e Toscanini Empreendimentos Imobiliários Ltda.</PartesProcesso>
				<PrincipaisFatos>Execução Extrajudicial da Alienação Fiduciária</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0322850-74.2017.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-12-15</DataInstauracao>
				<ValorCausa>1284157.21</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 321, consubstanciados nas CDAs nºs 01/073697/2015 e 01/073698/2015.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0323673-48.2017.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-12-15</DataInstauracao>
				<ValorCausa>1238301.29</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 318, inscrição imobiliária nº 2972054-7, consubstanciados nas CDAs nºs 01/197238/2015 e 01/073696/2015.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0324102-15.2017.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-12-15</DataInstauracao>
				<ValorCausa>2053697.81</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700, loja 121, inscrição imobiliária nº 2971692-5, consubstanciado na CDA nº 01/073691/2015 e 01/133492/2017.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0323463-94.2017.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do TJ/RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-12-15</DataInstauracao>
				<ValorCausa>1005841.84</ValorCausa>
				<PartesProcesso>Banco Opportunity S/A X Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de execução fiscal que visa a cobrança de supostos débitos de IPTU, relativos ao imóvel situado à Av. das Américas, 700,  loja 122, inscrição imobiliária nº 2971693-3, consubstanciado nas CDAs nºs 01/073693/2015, 01/073692/2015, 01/005318/2015, 01/005317/2015, 01/005316/2015 e 01/005315/2015.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0102096-53.2017.5.01.0064</Numero>
				<Juizo>64 RIO DE JANEIRO</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-12-15</DataInstauracao>
				<ValorCausa>426925.03</ValorCausa>
				<PartesProcesso>ALEX FABIANI PASSOS DA CRUZ, RCFA ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIARIO</PartesProcesso>
				<PrincipaisFatos>HORAS EXTRAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07518694820178070016</Numero>
				<Juizo>II JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-12-18</DataInstauracao>
				<ValorCausa>25257.08</ValorCausa>
				<PartesProcesso>DIOGO BOGHOSSIAN DOS SANTOSXOPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Indenização a título de lucros cessantes pelo período do atraso no recebimento das chaves, que apenas ocorreu em junho de 2015.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00103744320188190001</Numero>
				<Juizo>08 JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-01-16</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>AMANDA CAMPOS GOBBOXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Condenação do réu à devolução em dobro do valor de R$ 1.304,79, pago a título de IPTU de 2015, anterior à imissão na posse, bem como indenização por danos morais no valor de R$ 5.000,00.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.362/2018</Numero>
				<Juizo>Gerência de Controle Cadastral e Inclusão Predial (CIP-4)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-02-06</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de impugnação ao lançamento do IPTU de 2018, visto que a base de calculo utilizada no lançamento do imposto foi equivocada e deverá ser revista.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.363/2018</Numero>
				<Juizo>Gerência de Controle Cadastral e Inclusão Predial (CIP-4)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-02-06</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de impugnação ao lançamento do IPTU de 2018, visto que o imóvel foi objeto de tombamento pelo Estado do Rio de Janeiro, através da Lei nº 3.317/99, e no mesmo sentido, o Município reconheceu o imóvel como Patrimônio Cultural e também determinou o seu tombamento.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.364/2018</Numero>
				<Juizo>Gerência de Controle Cadastral e Inclusão Predial (CIP-4)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-02-06</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de impugnação ao lançamento do IPTU de 2018, visto o erro no cálculo que aumentou a base de cálculo do imposto.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.367/2018</Numero>
				<Juizo>Gerência de Controle Cadastral e Inclusão Predial (CIP-4)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-02-06</DataInstauracao>
				<ValorCausa>302616.05</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de impugnação ao lançamento do IPTU de 2018, visto o erro no cálculo que aumentou a base de cálculo do imposto.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07056166520188070016</Numero>
				<Juizo>CCJECB</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-02-15</DataInstauracao>
				<ValorCausa>17682.51</ValorCausa>
				<PartesProcesso>JOSÉ EASTON MATOS NETOXOPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Inversão da cláusula 6.1 (multa) e condenação dos réus ao pagamento de multa contratual de 2%, no valor de R$ 7.109,18, em razão de atraso na entrega das chaves.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0005556-06.2018.8.19.0209</Numero>
				<Juizo>QUINTA VARA CÍVEL BARRA DA TIJUCA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-02-27</DataInstauracao>
				<ValorCausa>10000</ValorCausa>
				<PartesProcesso>BARBARA PAZ PASCHOA FARINHA X OPPORTUNITY FII</PartesProcesso>
				<PrincipaisFatos>AÇÃO DISTRIBUÍDA. JUIZ DECLINOU DA COMPETÊNCIA PARA JACAREPAGUÁ. PROCESSO COM O JUIZ. ESTIVEMOS COM O JUIZ POR DUAS VEZES. FICOU DE ANALISAR O PEDIDO LIMINIAR. PROCESSO AINDA SE ENCONTRA COM O JUIZ PARA ANALISAR O PEDIDO DE LIMINAR.PROCESSO COM O JUIZ. CONCEDIDA A LIMINAR. MANDADO DE INTIMAÇÃO PARA DESOCUPAÇÃO VOLUNTÁRIA EXPEDIDO. AGUARDANDO CUMPRIMENTO DO MANDADO. MANDADO JUNTADO AOS AUTOS</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07060267120188070001</Numero>
				<Juizo>9ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-03-10</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>RAMIRO ROCHA DE OLIVEIRAXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Cumprimento provisório de sentença pelo qual o autor executa o valor de R$ 282.348,53, referente à condenação no processo principal. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00576125820188190001</Numero>
				<Juizo>27 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-03-13</DataInstauracao>
				<ValorCausa>948267.33</ValorCausa>
				<PartesProcesso>OPP FUNDOXVESUVIO COMÉRCIO E INDÚSTRIA DE GUARDA CHUVAS LTDA. e ARMANDO LAURIA JUNIOR</PartesProcesso>
				<PrincipaisFatos>Execução da dívida de aluguéis e encargos em atraso no valor de R$ 842.902,29, que acrescido de honorários é de R$ 948.267,33.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01095136520188190001</Numero>
				<Juizo>08 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-05-10</DataInstauracao>
				<ValorCausa>38160</ValorCausa>
				<PartesProcesso>RTT INFORMÁTICA E TELECOMUNICAÇOES LTDA. XOPP FUNDO e Modernos Hotéis</PartesProcesso>
				<PrincipaisFatos>Devolução dos equipamentos de central eletrônica e cobrança de multa contratual.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0479909-62.2018.8.13.0000</Numero>
				<Juizo>13a Câmara Cível do TJMG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-05-10</DataInstauracao>
				<ValorCausa>321223.55</ValorCausa>
				<PartesProcesso>Opportunity Fundo de Investimentos Imobiliários XRafael Almeida Peixoto</PartesProcesso>
				<PrincipaisFatos>Recurso contra decisão que deferiu a tutela anrtecipada ao Agravado para rescindir o contrato celebrado e coibir a negativação de seu nome</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07143591220188070001</Numero>
				<Juizo>3ª V.EXE.</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-05-24</DataInstauracao>
				<ValorCausa>15842.32</ValorCausa>
				<PartesProcesso>COND. ED. FUSION WORK &amp; LIVEXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Cobrança de Cotas Condominiais Vencidas entre 01/09/2016 a 01/05/2017 e ASP Newpred Sala 308.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0015927-09.2018.8.08.0347</Numero>
				<Juizo>2º JEC DE VITÓRIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-06-01</DataInstauracao>
				<ValorCausa>38160</ValorCausa>
				<PartesProcesso>GUSTAVO MERÇONXOPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO</PartesProcesso>
				<PrincipaisFatos>REPARAÇÃO POR ALEGADOS DANOS MATERIAIS E MORAIS ORIUNDOS DE ATRASO NA ENTREGA DAS CHAVES DO IMÓVEL ADQUIRIDO. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07051722620188070018</Numero>
				<Juizo>07 FAZ-DF</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-06-04</DataInstauracao>
				<ValorCausa>100000</ValorCausa>
				<PartesProcesso>OPP FUNDO, DUE CAPRI E DUE MURANOXGDF</PartesProcesso>
				<PrincipaisFatos>Reconhecer o direito de regresso dos autores em face do GDF por conta do atraso na concessão do "habite-se" dos empreendimentos Due Capri e Due Murano, condenando o réu ao ressarcimento dos valores arcados a título de indenizações e rescisões aos promitentes compradores, a ser apurado por meio de perícia.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01327356220188190001</Numero>
				<Juizo>31 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-06-06</DataInstauracao>
				<ValorCausa>142622.92</ValorCausa>
				<PartesProcesso>OPP FUNDOXOI TNL</PartesProcesso>
				<PrincipaisFatos>Execução  dos débitos de aluguel de julho de 2016 a outubro de 2017, no total de R$ 142.622,92.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00268757520188190000</Numero>
				<Juizo>07 CCTJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-06-21</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>COMPANHIA MODERNOS HOTÉIS e outrosXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Reforma da decisão interlocutória que indeferiu o pedido de gratuidade de justiça feito pela Modernos Hotéis.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0683799-25.2018.8.13.0000 (baixado)</Numero>
				<Juizo>11ª Câmara Cível do TJ/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-07-02</DataInstauracao>
				<ValorCausa>329952.85</ValorCausa>
				<PartesProcesso>Opportunity Fundo de Investimentos Imobiliários XJúlio Vilela da Silva Neto </PartesProcesso>
				<PrincipaisFatos>Recurso contra decisão que determinou a expedição de ofício ao Cartório do 4o Ofício de Imóveis de Belo Horizonte para averbar as margens da matrícula do imóvel adquirido pelo Sr. Júlio a existência da lide</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07188315620188070001</Numero>
				<Juizo>16ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-07-05</DataInstauracao>
				<ValorCausa>500000</ValorCausa>
				<PartesProcesso>CONDOMÍNIO DUE MURANOXOPP FUNDO e JFE22</PartesProcesso>
				<PrincipaisFatos>Ação de Obrigação de fazer com pedido de tutela de urgência para a realização de reparos no Condomínio, dentre eles, problemas estruturais, anomalias endôgenas e infiltrações.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0720674-90.2017.8.07.0001</Numero>
				<Juizo>25ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-08-08</DataInstauracao>
				<ValorCausa>34615</ValorCausa>
				<PartesProcesso>LUIS OLIVIO MANSO DE BARROS E ALESSANDRA ZAK CALVÁRIO BARROSXOPP FUNDO E JFE21</PartesProcesso>
				<PrincipaisFatos>Ação indenizatória em que se pleiteia lucros cessantes em raão do atraso no recebimento das chaves, inclusive, em razão de entraves burocráticos entre a instituição financeira e o vededor. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01907797420188190001</Numero>
				<Juizo>31 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-08-13</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OI TNLXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Reconhecimento de excesso  de execução de R$ 16.206,17.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01918718720188190001</Numero>
				<Juizo>8º JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-08-15</DataInstauracao>
				<ValorCausa>21290.52</ValorCausa>
				<PartesProcesso>LUANA DE LIMA CARNEIROXOPP FUNDO, BNY, MÉTRICA e MATOSO</PartesProcesso>
				<PrincipaisFatos>Condenação dos réus a restituir em dobro o valor de R$ 8.424,71, consistente no valor supostamente pago a maior a título de multa moratória de 2%, que corrigido totalizaria R$ 21.209,52, bem como a condenação em danos morais de R$ 5.000,00.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07236702720188070001</Numero>
				<Juizo>9ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-08-16</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>LUIZA MARIA MORAES DE OLIVEIRAXOPP FUNDO </PartesProcesso>
				<PrincipaisFatos>Liquidação de Sentença</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01972337020188190001</Numero>
				<Juizo>29 VC-RJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-08-28</DataInstauracao>
				<ValorCausa>360991.54</ValorCausa>
				<PartesProcesso>SIMONE DRINCKWATER SALGADO e ALEXANDRE GERALDO DE ANDRADE LACERDAXOPP FDIC</PartesProcesso>
				<PrincipaisFatos>Rescisão do contrato definitivo de compra e venda com alienação fiduciária, bem como a  devolução de 90% dos valores pagos, afastando a cobrança da multa contratual sobre as parcelas em atraso e, ainda, a condenação do réu ao pagamento das custas e honorários advocatícios de 20% sobre o valor da causa. Também foi requerida a antecipação de tutela para  suspender os efeitos do contrato e determinar que o réu se abstenha de incluir o nome dos autores nos cadastros restritivos de crédito.  </PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07392704320188070016</Numero>
				<Juizo>II JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-08-30</DataInstauracao>
				<ValorCausa>33223.85</ValorCausa>
				<PartesProcesso>ANDRÉ FONSECA DE PAULA LEITEXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Indenização em razão da diferença na metragem da sala adquirida</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07392712820188070016</Numero>
				<Juizo>VI JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-08-30</DataInstauracao>
				<ValorCausa>17347.07</ValorCausa>
				<PartesProcesso>ANDRÉ FONSECA DE PAULA LEITEXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Indenização em razão da diferença na metragem da sala adquirida</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07255496920188070001</Numero>
				<Juizo>1ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-08-30</DataInstauracao>
				<ValorCausa>58377.38</ValorCausa>
				<PartesProcesso>ANDRÉ FONSECA DE PAULA LEITEXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Indenização em razão da diferença na metragem da sala adquirida</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0213678-66.2018.8.19.0001</Numero>
				<Juizo>6ª Vara Cível</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-09-06</DataInstauracao>
				<ValorCausa>152822.44</ValorCausa>
				<PartesProcesso>Opportunity Fundo de Investimento Imobiliário XMARISOL RIO LANCHES LTDA; ARMED NEMR SARIEDDINE E MARGARETH REGIS SARIEDDINE</PartesProcesso>
				<PrincipaisFatos>Execução de título extrajudicial, por quantia certa (aluguéis, encargos e transação não paga)</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0213625-85.2018.8.19.0001</Numero>
				<Juizo>31ª Vara Cível</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-09-06</DataInstauracao>
				<ValorCausa>86400</ValorCausa>
				<PartesProcesso>Opportunity Fundo de Investimento Imobiliário XMARISOL RIO LANCHES LTDA</PartesProcesso>
				<PrincipaisFatos>Despejo por falta da pagamento</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>MA 9090</Numero>
				<Juizo>1ª Promotoria do Meio Ambiente e Patrimônio Cultural</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-09-10</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>MINISTÉRIO PÚBLICO DO RIO DE JANEIROXOPP FUNDO e  ENINCO</PartesProcesso>
				<PrincipaisFatos>Instauração de inquérito civil com o objetivo de investigar a contaminação do solo, conforme portaria 18/2018.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>01174055920178190001 </Numero>
				<Juizo>13 CCTJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-09-19</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>MERLON LANCHONETE E PASTELARIA LTDA. MAXOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Apelação contra a sentença que julgou parcialmente procedente a ação para renovar o contrato de locação e fixou os aluguéis em R$ 17.900,00.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07178251720188070000</Numero>
				<Juizo>7 TURMA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-10-05</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FUNDOXRAMIRO ROCHA DE OLIVEIRA</PartesProcesso>
				<PrincipaisFatos>Agravo contra a decisão proferida nos autos do cumprimento de sentença que determinou que os juros moratórios sobre as parcelas do financimanto imobiliário serão computados do desembolso, quando deveriam incidir desde a citação.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07189459520188070000AI</Numero>
				<Juizo>6 ª TU</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-10-25</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>DAN HEBERT XOPP FUNDO e JFE22</PartesProcesso>
				<PrincipaisFatos>Agravo contra a decisão que antecipou os efeitos da tutela e determinou reparos necessários nos itens 49 e 97 do laudo apresentado, no prazo de 45 dias corridos , sob pena de multa ,242,247 e 248 do laudo técnico. A Danh Hebert Sustenta que não restaram comprovados, os pressupostos autorizadores da liminar (coexistência de prova inequívoca, bem como, o dano irreparável ou de difícil reparação.  </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101092-91.2018.5.01.0016</Numero>
				<Juizo>16 RIO DE JANEIRO</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-10-26</DataInstauracao>
				<ValorCausa>102128.12</ValorCausa>
				<PartesProcesso>JOSE CAROS DA SILVA LIMA, RCFA ENGENHARIA LTDA, DOMINUS 14 EMPREENDIMENTOS IMOBILIARIOS SPE LTDA</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>02557142620188190001</Numero>
				<Juizo>46 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-10-26</DataInstauracao>
				<ValorCausa>461395.45</ValorCausa>
				<PartesProcesso>NOVEMP INDÚSTRIA E COMÉRCIO LTDA.XOPP FUNDO</PartesProcesso>
				<PrincipaisFatos>Cumprimento provisório de sentença referente ao valor dos 08 painéis  não entregues. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0011518-27.2018.5.15.0094</Numero>
				<Juizo>7 CAMPINAS/SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-11-16</DataInstauracao>
				<ValorCausa>133251.71</ValorCausa>
				<PartesProcesso>JAILSON RODRIGUES DA ROCHA, GEODRILL ENGENHARIA LTDA, GRUPO CCR, CONSORCIO PORTO RIO, CONSORCIO LINHA 4 SUL, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO</PartesProcesso>
				<PrincipaisFatos>VERBAS RESILITÓRIAS</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/305.019/2018</Numero>
				<Juizo>Gerência de Controle Cadastral e Inclusão Predial (CIP-4)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-11-21</DataInstauracao>
				<ValorCausa>1821214.5</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de pedido de revisão de dados cadastrais, para que a área edificada seja alterada para 6.236 m² e fator tipologia 0,60, retificando os lançamentos dp IPTU de 2016 e 2018, e após, aplicado o benefício da Lei nº 3.895/2005, reduzindo o imposto em 40%.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07211812020188070000AI</Numero>
				<Juizo>6ª TU</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-12-07</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>CONDOMINIO DUE MURANOXOPP FUNDO e JFE22</PartesProcesso>
				<PrincipaisFatos>Agravo contra a decisão que indeferiu a apliação da tutela antecipada para que a decisão de obigação de fazer alcance o acesso ao 1º subsolo da garagem, bem como, as infiltrações no forro do gesso do térreo.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101352-15.2018.5.01.0067</Numero>
				<Juizo>67 RIO DE JANEIRO</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-12-20</DataInstauracao>
				<ValorCausa>31463.31</ValorCausa>
				<PartesProcesso>FABRICIO RODRIGUES DA SILVA, RIOS DO RIO DE JANEIRO ENGENHARIA LTDA, OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO</PartesProcesso>
				<PrincipaisFatos>NULIDADE DA DEMISSÃO</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>07380886720188070001</Numero>
				<Juizo>15ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-12-26</DataInstauracao>
				<ValorCausa>150000</ValorCausa>
				<PartesProcesso>ANA CAROLINA GOMES ALZIRI E OUTROSXOPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Indenização por danos materiais ref. Ao abatimento proporcional ao valor pago pelo pátio contemplativo e não construído, a ser apurado em liquidação de sentença e danos morais no valor de R$ 15.000,00 para cada autor. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/305.239/2018</Numero>
				<Juizo>Gerência de Fiscalização e Revisão do Lançamento (CIP-1)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-12-28</DataInstauracao>
				<ValorCausa>173700.86</ValorCausa>
				<PartesProcesso>Opportunity Fundo de InvestimentoXMunicípio do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de restituição do IPTU de 2014, em razão do pagamento a maior realizado, conforme expressamente reconhecido pela Secretaria Municipal de Fazenda no processo administrativo nº 04/373.376/2014.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.345/2019</Numero>
				<Juizo>Gerência de Controle Cadastral e Inclusão Predial (CIP-4)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-02-06</DataInstauracao>
				<ValorCausa>1702545.19</ValorCausa>
				<PartesProcesso>OPP FII x Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de pedido de revisão de dados cadastrais, para que a área edificada seja alterada para 6.086 m² </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>04/66/302.347/2019</Numero>
				<Juizo>Gerência de Controle Cadastral e Inclusão Predial (CIP-4)</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-02-06</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FII x Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de impugnação ao lançamento do IPTU de 2019 para aplicação do benefício da Lei nº 3.895/2005, reduzindo o imposto em 40%.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0702970-93.2019.8.07.0001</Numero>
				<Juizo>9ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-02-11</DataInstauracao>
				<ValorCausa>15000</ValorCausa>
				<PartesProcesso>LUIZA MARIA MORAES DE OLIVEIRA X OPP FUNDO E JFE22</PartesProcesso>
				<PrincipaisFatos>Indenização por lucros cessantes durante o período de atraso na entrega das chaves e danos morais (no valor considerado, consta o valor aproximado dos lucros cessantes)</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5022168-35.2019.8.13.0024</Numero>
				<Juizo>17ª (Vigésima Quinta) Vara Cível de Belo Horizonte/MG</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-02-18</DataInstauracao>
				<ValorCausa>153156.51</ValorCausa>
				<PartesProcesso>OPP FII x Lincoln Nunes Moura</PartesProcesso>
				<PrincipaisFatos>Ação Declaratória de Desfazimento de negócio Jurídico com Restituição dos Valores Pagos</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0706058-42.2019.8.07.0001</Numero>
				<Juizo>1ª vc</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-03-18</DataInstauracao>
				<ValorCausa>181383</ValorCausa>
				<PartesProcesso>LINDA MANSUR MENDES X  BANCO OPPORTUNITY SA e JFE 2 EMPREENDIMENTOS IMOBILIARIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Distrato motivado pelo atraso na entrega das chaves, movido em desfavor da JFE2. Em razão do não pagamento da condenação,  foi deferido o pedido da autora para constar o nome do OPP HDF no polo passivo da demanda  sob o fundamento de que se trata de empresa consorciada ao mesmo grupo.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0017844-29.2019.8.08.0347</Numero>
				<Juizo>9º JEC DE VITÓRIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-06-25</DataInstauracao>
				<ValorCausa>36669</ValorCausa>
				<PartesProcesso>GERACI PESSOTTI BASTOS  ADRIANA PESSSOTTI BASTOS LUCIANA PESSOTTI BASTOS AMARO PESSOTTI BASTOS  LUCILDNEY BASTOS SAADE EDUARDO BASTOS SAADE JULIANA BASTOS SAADE LUCIMAR BASTOS ALVES    RENATA ALVES                                       JOSE RENATO ALVES                    MIRABEU MARTINS BASTOS     ALBA LUCIA MARTINS BASTOS DEZAN x OPP FII</PartesProcesso>
				<PrincipaisFatos>REPARAÇÃO POR ALEGADOS DANOS MATERIAIS E MORAIS ORIUNDOS DE PENDENCIAS FINANCEIRAS RELACIONADAS ÀS TAXAS CONDOMINIAIS </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0158468-93.2019.8.19.0001</Numero>
				<Juizo>6 JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-07-02</DataInstauracao>
				<ValorCausa>39961</ValorCausa>
				<PartesProcesso>Bruno de Paula Soares e Marta Sundfeld x Opp FII - Opportunity Fundo De Investimento Imobiliario, Métrica e Icono</PartesProcesso>
				<PrincipaisFatos>Condenação dos réus, solidariamente, ao pagamento de (i) indenização por danos morais no valor de R$ 36.900,00; (ii) lucros cessantes de R$ 672,61 e (iii) pagamento das diferenças de R$ 2.171,98 (referente à compensação do cheque de R$ 31.920,00) e de R$ 216,87 (referente à compensação do cheque de R$ 5.616,00). </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0726509-88.2019.8.07.0001</Numero>
				<Juizo>2ª VETE</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-07-05</DataInstauracao>
				<ValorCausa>3092</ValorCausa>
				<PartesProcesso>Condomínio Vision Work &amp; Live x OPP FII</PartesProcesso>
				<PrincipaisFatos>Execução de título extrajudicial para cobrança das cotas condomianiais das garagens referidas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0023590-92.2019.8.19.0209</Numero>
				<Juizo>7ª VARA CÍVEL DA BARRA DA TIJUCA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-07-16</DataInstauracao>
				<ValorCausa>10000</ValorCausa>
				<PartesProcesso>OPP FII x José Roberto Fagundes Barbosa</PartesProcesso>
				<PrincipaisFatos> TRATA-SE DE AÇÃO DE OBRIGAÇÃO FAZER OBJETIVANDO A LAVRATURA E REGISTRO DA ESCRITURA DE COMPRA E VENDA, BEM COMO A TRANSFERÊNCIA DE TITULARIDADE JUNTO AO SPU</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0004295-69.2019.8.19.0209</Numero>
				<Juizo>5ª Vara Cível Regional da Barra da Tijuca</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-08-09</DataInstauracao>
				<ValorCausa>35845.22</ValorCausa>
				<PartesProcesso>XX de Novembro Investimentos e Participações S.A. x Café Bar Spicy Salads LTDA ME e outros</PartesProcesso>
				<PrincipaisFatos>Execução de título extrajudicial, por quantia certa (aluguéis, encargos e transação não paga)</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0199768-35.2019.8.19.0001</Numero>
				<Juizo>3 JEC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-08-15</DataInstauracao>
				<ValorCausa>19960</ValorCausa>
				<PartesProcesso>Marlúcia Regina Cascardo x Opp FII - Opportunity Fundo De Investimento Imobiliario e ImobPro</PartesProcesso>
				<PrincipaisFatos>Cobrança de comissão de corretagem, no valor de R$ 19.690,00 (5% do valor da venda).</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0725478-33.2019.8.07.0001</Numero>
				<Juizo>18ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-08-28</DataInstauracao>
				<ValorCausa>1354021</ValorCausa>
				<PartesProcesso>Condomínio Due Capri x OPP FII</PartesProcesso>
				<PrincipaisFatos>Obrigação de fazer para reparar os vícios constritivos sanáveis, com a fixação de astreintes; caso não a obrigação não seja realizada em tempo, sejas as astreintes convertidas em perdas e danos no valor de R$ 1.152.336,88, acrescidos de juros e mora e correção moratória a conta da expedição da carta de "habite-se";</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0726491-67.2019.8.07.0001</Numero>
				<Juizo>2ª VARA DE EXECUÇÃO DE TÍTULOS EXTRAJUDICIAIS E CONFLITOS ARBITRAIS DE BRASÍLIA</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-09-05</DataInstauracao>
				<ValorCausa>1546.15</ValorCausa>
				<PartesProcesso>CONDOMINIO DO EDIFICIO VISION WORK &amp; LIVE x BNY MELLON SERVICOS FINANCEIROS DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS S/A </PartesProcesso>
				<PrincipaisFatos>Trata-se de Execução de título extrajudicial referente aos débitos condominiais em atraso vinculados a vaga de garagem G4 0277 (Período de setembro/2017 a Julho/2019). Após emenda à inicial, figura no polo passivo apenas a BNY Mellon. Aguarda-se a citação da Executada para pagamento.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0004473-18.2019.8.19.0209</Numero>
				<Juizo>5ª Vara Cível Regional da Barra da Tijuca</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-09-13</DataInstauracao>
				<ValorCausa>95226.85</ValorCausa>
				<PartesProcesso>XX de Novembro Investimentos e Participações S.A. x Café Bar Spicy Salads LTDA ME e outros</PartesProcesso>
				<PrincipaisFatos>Execução de título extrajudicial, por quantia certa (aluguéis, encargos e transação não paga)</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0247912-40.2019.8.19.0001</Numero>
				<Juizo>10 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-10-04</DataInstauracao>
				<ValorCausa>43273559.75</ValorCausa>
				<PartesProcesso>Companhia Modernos Hotéis do Brasil e outros x OPPFII</PartesProcesso>
				<PrincipaisFatos>Reconhecimento da violação do direito de preferência na aquisição do imóvel e condenação do OPP e da VOT, solidariamente, ao pagamento de indenização de R$ 43.273.559,75. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0067461-23.2019.8.19.0000</Numero>
				<Juizo>3ª Vice Presidência</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-10-18</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Somar 02 Empreendimentos LTDA e OPP FII x Telemar e Instituto Telemar</PartesProcesso>
				<PrincipaisFatos>Reintegração da posse das Autoras da área invadida e consequente remoção do painel.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0287256-28.2019.8.19.0001</Numero>
				<Juizo>48 VCRJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-11-18</DataInstauracao>
				<ValorCausa>25731.51</ValorCausa>
				<PartesProcesso>OPP FII - Opportunity Fundo De Investimento Imobiliario x Simone Drinckwater Salgado e Alexandre Geraldo de Andrade Lacerda</PartesProcesso>
				<PrincipaisFatos>Reintegração de posse com pedido liminar cumulada com cobrança de taxa de ocupação desde a consolidação da propriedade (18/07/2019), no valor de R$ 25.731,51. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0052480-83.2019.8.19.0001</Numero>
				<Juizo>1ª Vara de Fazenda Pública</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-11-27</DataInstauracao>
				<ValorCausa>800000</ValorCausa>
				<PartesProcesso>Ministério Público x Somar 02 Empreendimentos LTDA, Opportunity Fundo de Investimento Imobiliário, Estado do Rio de Janeiro e Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>A condenação solidárias dos réus a obrigação de não autorizar, licenciar, edificar, construir,
por si ou terceiros, as obras do empreendimento imobiliário “Icono Full Life”, até que seja
modificado o projeto e obtida pelos empreendedores nova licença de obras para o projeto
modificado e invalidação da licença de obras nº 220135/2018</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0007245-51.2019.8.19.0209</Numero>
				<Juizo>7ª Vara Cível Regional da Barra da Tijuca</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-12-18</DataInstauracao>
				<ValorCausa>54000</ValorCausa>
				<PartesProcesso>XX de Novembro Investimentos e Participações S.A. x Café Bar Spicy Salads LTDA ME e outros</PartesProcesso>
				<PrincipaisFatos>Despejo por falta da pagamento. Execução do acordo</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0429056-49.2016.8.19.0001</Numero>
				<Juizo>27 CCTJ</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-01-17</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FII - Opportunity Fundo De Investimento Imobiliario x Culinária Alemã Bar e Restaurante Ltda. EPP</PartesProcesso>
				<PrincipaisFatos>Recurso de apelação requerendo a anulação da sentença e a realização de nova prova pericial em razão da  ausência de intimação das partes sobre os esclarecimentos do perito ou a reforma da sentença para fixar o aluguel em R$ 19.681</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0051244-72.2014.8.19.0001</Numero>
				<Juizo>1ª Vara Empresarial</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-02-06</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FII - Opportunity Fundo De Investimento Imobiliario x Culinária Alemã Bar e Restaurante Ltda. EPP</PartesProcesso>
				<PrincipaisFatos>Processo de recuperação judicial ajuizado por Culinária Alemã e Bar Luiz Ltda. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0027210-23.2020.8.19.0001</Numero>
				<Juizo>1ª Vara Empresarial</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-02-06</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>OPP FII - Opportunity Fundo De Investimento Imobiliario x Culinária Alemã Bar e Restaurante Ltda. EPP</PartesProcesso>
				<PrincipaisFatos>Processo de recuperação judicial ajuizado por Culinária Alemã e Bar Luiz Ltda. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0708126-28.2020.8.07.0001</Numero>
				<Juizo>25ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-03-16</DataInstauracao>
				<ValorCausa>22000</ValorCausa>
				<PartesProcesso>LEONARDO DE ALMEIDA x OPP FII E JFE22</PartesProcesso>
				<PrincipaisFatos>Indenização a título de dano moral em razão de infiltração/defeitos da obra</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0706508-51.2020.8.07.0000</Numero>
				<Juizo>3 TU</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-03-18</DataInstauracao>
				<ValorCausa>113212</ValorCausa>
				<PartesProcesso>OPP FII - Opportunity Fundo De Investimento Imobiliario x ANA CAROLINA RIBEIRO SILVA</PartesProcesso>
				<PrincipaisFatos>Agravo de instrumento contra a decisão que determinou a desconsideração da personalidade juridica em desfavor do OPP FUNDO</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0711382-76.2020.8.07.0001</Numero>
				<Juizo>5ª Vara Cível de Brasília</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-04-17</DataInstauracao>
				<ValorCausa>271395.64</ValorCausa>
				<PartesProcesso>SANDRA HELENA CARESIA GUSTAVO x JFE2 EMPREENDIMENTOS IMOBILIÁRIOS LTDA</PartesProcesso>
				<PrincipaisFatos>Nulidade de cláusula contratual, restituição de valores pagos e lucros cessantes </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0000996-55.2020.8.19.0078</Numero>
				<Juizo>1ª Vara</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-04-18</DataInstauracao>
				<ValorCausa>320000000</ValorCausa>
				<PartesProcesso>LUIS CARLOS ROSA PEREIRA x OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO</PartesProcesso>
				<PrincipaisFatos>O Autor se diz dono da terra onde edifica-se o empreendimento Aretê Búzios, e em razão disso pede indenização pelos danos sofridos no imóvel.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0101237-30.2020.5.01.0000</Numero>
				<Juizo>SEDI-1 TRT 1ª REGIÃO</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-05-13</DataInstauracao>
				<ValorCausa>50000</ValorCausa>
				<PartesProcesso>OPP FII - Opportunity Fundo De Investimento Imobiliario x SYLAS COELHO ALVES</PartesProcesso>
				<PrincipaisFatos>CAPITULO DA DECISÃO TRANSITADA EM JULGADO NOS AUTOS DA RT 0101892-10.2016.5.01.0075, QUE CONDENA A EMPRESA SUBISIDIÁRIAMENTE PELA COISA JULGADA.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0095532-95.2020.8.19.0001</Numero>
				<Juizo>28ª Vara Cível da Comarca da Capital</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-05-14</DataInstauracao>
				<ValorCausa>134587.5</ValorCausa>
				<PartesProcesso>HRUG Comércio de Moda Eirelli x Opportunity Fundo de Investimento Imobiliário</PartesProcesso>
				<PrincipaisFatos>Revisão de alugueres em razão da pandemia.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0714696-30.2020.8.07.0001</Numero>
				<Juizo>3ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-05-19</DataInstauracao>
				<ValorCausa>1095196</ValorCausa>
				<PartesProcesso>JOSÉ LEÔNCIO NOGUEIRA JR. x OPP FII</PartesProcesso>
				<PrincipaisFatos>Cumprimento provisório de sentença em que os autores pleiteiam diferença do valor depositado, a título de parcelas incontroversas, e cujo montante apontado foi de R$ 168.000,00.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0714720-58.2020.8.07.0001</Numero>
				<Juizo>18ª VC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-05-20</DataInstauracao>
				<ValorCausa>226072</ValorCausa>
				<PartesProcesso>DIOGO DE MELLO BRITO DA SILVA x OPP FII/JFE22</PartesProcesso>
				<PrincipaisFatos>Execução Provisória</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5038933-84.2020.4.02.5101</Numero>
				<Juizo>5ª Vara Federal da Seção Judiciária do Rio de Janeiro</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-06-29</DataInstauracao>
				<ValorCausa>249394.81</ValorCausa>
				<PartesProcesso>Banco Opportunity x União Federal</PartesProcesso>
				<PrincipaisFatos>Ação cautelar/anulatória ajuizada com o objetivo de desconstituir a cobrança realizada pela União Federal/Secretaria de Patrimonio da União a título de taxa de ocupação, diante da indevida  majoração de 1034% feita com base em dados geográficos desatualizados, que não refletem as reais características do terreno no qual foi construído o Città América.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0043443-98.2020.8.19.0000</Numero>
				<Juizo>19ª Câmara Cível </Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-07-03</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>HRUG Comércio de Moda Eirelli x Opportunity Fundo de Investimento Imobiliário</PartesProcesso>
				<PrincipaisFatos>Agravo contra decisão de indeferimento da gratuidade de justiça do autor</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0001602-83.2020.8.19.0078</Numero>
				<Juizo>2ª Vara</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-07-23</DataInstauracao>
				<ValorCausa>3480000</ValorCausa>
				<PartesProcesso>OPPORTUNITY FUNDO DE INVESTIMENTO IMOBILIÁRIO, BAIA FORMSA EXPORTAÇÃO LTDA E MARINA CINCO ILHAS SPE LTDA x EGON PACHECO FONTES JUNIOR E LUIS CARLOS ROSA PEREIRA</PartesProcesso>
				<PrincipaisFatos>Interdito proibitório movido em face do Luis Carlos e Egon Pacheco tendo como objeto os imóveis: Área 01 da gleba B e lotes 13 a 15 da quadra 68 do Loteamento Baia Blanca ante as recentes invasões dos dias 17.09.19, 16.10.19, 27.04.20 e 30.04.20.

</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0728136-48.2020.8.07.0016</Numero>
				<Juizo>SEJUSC</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-07-24</DataInstauracao>
				<ValorCausa>12000</ValorCausa>
				<PartesProcesso>GUSTAVO ZILLIG DE PAIVA x OPP FII E JFE 22</PartesProcesso>
				<PrincipaisFatos>Indenização  - defeito de obra, infitração.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0102493-08.2020.5.01.0000</Numero>
				<Juizo>SEDI-1 TRT 1ª REGIÃO</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-07-31</DataInstauracao>
				<ValorCausa>55000</ValorCausa>
				<PartesProcesso>OPP FII - Opportunity Fundo De Investimento Imobiliario x LARISSA MARQUES ROCHA</PartesProcesso>
				<PrincipaisFatos>CAPITULO DA DECISÃO TRANSITADA EM JULGADO NOS AUTOS DA RT 0101980-87.2016.5.01.0062, MAIS PRECISAMENTE QUANTO À CONDENAÇÃO SUBSIDIÁRIA QUE LHE FOI IMPOSTA PELA COISA JULGADA.
A DECISÃO RESCINDENDA É O V. ACÓRDÃO REGIONAL PROFERIDO PELA E. 05ª TURMA DO TRT DA PRIMEIRA REGIÃO.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0737732-07.2020.8.07.0000</Numero>
				<Juizo>5 tu</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-09-02</DataInstauracao>
				<ValorCausa>181383</ValorCausa>
				<PartesProcesso>Banco Opportunty S.A x LINDA MANSUR MENDES </PartesProcesso>
				<PrincipaisFatos>Agravo contra a decisão que determinou a desconsideração da personalidade juridica da JFE2 para alcançar os bens do OPP HDF. Aguardando julgamento do agravo. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0072966-29.2018.8.19.0000</Numero>
				<Juizo>3ª Vice Presidência</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-09-03</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Somar 02 Empreendimentos LTDA e Opportunity Fundo de Investimento Imobiliário x Telemar e Instituto Telemar</PartesProcesso>
				<PrincipaisFatos>Reintegração da posse das Autoras da área invadida e consequente remoção do painel.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0728772-59.2020.8.07.0001</Numero>
				<Juizo>2ª VETE</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-09-09</DataInstauracao>
				<ValorCausa>3092</ValorCausa>
				<PartesProcesso>OPP FII - Opportunity Fundo De Investimento Imobiliario x CONDOMÍNIO VISION WORK &amp; LIVE</PartesProcesso>
				<PrincipaisFatos>Embargos à Execução</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0183104-89.2020.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do Tribunal de Justiça do Estado do Rio de Janeiro</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-09-14</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity x Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0197555-22.2020.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do Tribunal de Justiça do Estado do Rio de Janeiro</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-09-30</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity x Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0198140-74.2020.8.19.0001</Numero>
				<Juizo>12ª Vara de Fazenda Publica da Comarca da Capital do Tribunal de Justiça do Estado do Rio de Janeiro</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-10-01</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity x Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0198178-86.2020.8.19.0001</Numero>
				<Juizo/>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-10-01</DataInstauracao>
				<ValorCausa>0</ValorCausa>
				<PartesProcesso>Banco Opportunity x Município do Rio de Janeiro</PartesProcesso>
				<PrincipaisFatos>Trata-se de embargos à execução que visa desconstituir as CDAs ora executadas.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Perda dos valores relacionados</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Os documentos estão disponíveis na sede social do Administrador</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>https://www.bnymellon.com.br/sf/AppPages/investimentfunds/fund.aspx?iditem=2086</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Requerimento escrito enviado via carta endereçada à sede social do Administrador ou através de e-mail enviado ao endereço eletrônico: sac@bnymellon.com.br.
</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>(I) Os cotistas presentes devem apresentar documento de identificação na Assembleia. Somente poderão votar os cotistas do Fundo inscritos no registro de cotistas na data da Convocação da Assembleia, seus representantes legais ou procuradores constituídos há menos de um ano. 
(II) As deliberações da Assembleia Geral poderão ser tomadas mediante processo de consulta formalizada em carta ou telegrama dirigido pelo Administrador a cada cotista para resposta no prazo máximo de 30 (trinta) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício do direito de voto. 
(III) Os cotistas poderão votar por meio de comunicação escrita ou eletrônica, desde que recebida pelo Administrador até o dia anterior à data da Assembleia Geral. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não aplicável</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Os prestadores dos serviços de administração, dentre eles o Administrador e a Consultora Especializada, perceberão, pela prestação de seus serviços de gestão e administração, a remuneração de 1% (um por cento) ao ano, incidente sobre o valor do patrimônio líquido do Fundo. cada mês.</PoliticaRemuneracao>
			<ValorPagoAno>19717560.63</ValorPagoAno>
			<PercentPatrimonioContabil>0.0086</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0086</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>CARLOS ALBERTO SARAIVA</Nome>
				<Idade>60</Idade>
				<CPF>624.698.947-00</CPF>
				<Email>carlos.saraiva@bnymellon.com.br</Email>
				<Profissao>DIRETOR EXECUTIVO/ADVOGADO</Profissao>
				<FormacaoAcademica>Mestre em Gestão pela Universidade Federal Fluminense  - UFF/11; Pós Graduado em Comércio Exterior  pela Universidade Federal do Rio de Janeiro - UFRJ/94; Especialista em Administração Financeira – PDG/IBMEC (97); Graduado em Direito pela Universidade do Estado do Rio de Janeiro - UERJ /85.</FormacaoAcademica>
				<DataInicioFuncao>2013-02-14</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>BNY Mellon Serviços Financeiros DTVM</NomeEmpresa>
						<Periodo>2013 -Atualmente</Periodo>
						<CargoFuncoes>Diretor Executivo</CargoFuncoes>
						<AtividadePrincipalEmpresa>Responsável pelo negócio de Administração Fiduciária/ Banco</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não aplicável</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não aplicável</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="50" numCotasDetidas="93867" percDetidoRelTotal="0.1071" percDetidoPF="0.0223" percDetidoPJ="0.0848"/>
			<AcimaCincoAteDezPorcento numCotistas="5" numCotasDetidas="313941" percDetidoRelTotal="0.3582" percDetidoPF="0" percDetidoPJ="0.3582"/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="116751" percDetidoRelTotal="0.1332" percDetidoPF="0" percDetidoPJ="0.1332"/>
			<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="1" numCotasDetidas="351962" percDetidoRelTotal="0.4015" percDetidoPF="0" percDetidoPJ="0.4015"/>
			<AcimaCiquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" 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>
"