"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIARIO FII SHOPPING WEST PLAZA</NomeFundo>
		<CNPJFundo>09326861000139</CNPJFundo>
		<DataFuncionamento>2012-11-01</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRWPLZCTF004</CodigoISIN>
		<QtdCotasEmitidas>989339</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Passiva</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>Dezembro</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BTG pactual Serviços Financeiros S.A. – DTVM</NomeAdministrador>
		<CNPJAdministrador>09326861000139</CNPJAdministrador>
		<Logradouro>Praia de Botafogo</Logradouro>
		<Numero>501</Numero>
		<Complemento>6º Andar</Complemento>
		<Bairro>Botafogo</Bairro>
		<Cidade>Rio de Janeiro</Cidade>
		<Estado>RJ</Estado>
		<CEP>22250-040</CEP>
		<Telefone1>(11) 3383-3441</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.btgpactual.com</Site>
		<Email>sh-contato-fundoimobiliario@btgpactual.com</Email>
		<Competencia>2016-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</Gestor>
			<Custodiante>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>ERNST &amp; YOUNG TERCO AUDITORES INDEPENDENTES</Nome>
				<CNPJ>61.366.936/0002-06</CNPJ>
				<Endereco>Av. Presidente Juscelino Kubitschek, 1.909 - Vila Olimpia - SP - CEP: 04543-011</Endereco>
				<telefone>11 2573-3000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BANCO OURINVEST</Nome>
				<CNPJ>78.632.767/0001-20</CNPJ>
				<Endereco>AV PAULISTA, 1728 - SOBRELOJA E 2º ANDAR -  SAO PAULO - SP, CEP 01310-200</Endereco>
				<telefone>(55 11) 4081-4444</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>n/a</Nome>
				<CNPJ>n/a</CNPJ>
				<Endereco>n/a</Endereco>
				<telefone>n/a</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Conforme comunicado ao mercado e aos cotistas na data 13/02/2017, a BTG Pactual Serviços Financeiros S.A Distribuidoras de títulos e Valores Mobiliários informou que o orçamento elaborado para o Shopping no ano de 2017, prevê um resultado total, incluindo estacionamento de R$ 19.948.248,00 e o plano de investimetnos do fundo para o ano de 2017 somam um valor de R$ 13.031.827,89 dentre os principais investimentos incluem Pintura da FAchada Bloco B, Teatro, Cinema entre outros.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo distribuiu a título de rendimentos o equivalente a R$2,27 a.a. por cota, o que representa um Dividend Yield de 3,03% considerando a cota de Fechamento de 2016 (R$75,00).</ResultadoFundo>
			<ConjunturaEconomica>O ano de 2016 foi um ano desafiador para o mercado imobiliário assim como foi para todo país. Sobretudo do primeiro semestre, a conjuntura de altas taxas de desemprego, queda da confiança do consumidor, alta taxa de juros e de inflação aliadas a instabilidade político-econômica agravaram o ciclo de aumento de vacância e queda dos valores de locação do mercado imobiliário. Já no segundo semestre pudemos observar uma leve melhora nas expectativas do mercado, que auxiliaram a estabilizar a piora da economia e do setor imobiliário.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A nossa visão é de que para o próximo período já podemos vislumbrar um cenário mais atrativo que o passado, dados indicadores macros. A queda recente da inflação e a sua possível futura estabilização abrem caminho para o corte da taxa de juros no curto e médio prazo, o PIB esperado para o próximo ano já é positiva, assim como  um melhor nível da confiança do consumidor, um maior controle fiscal sinalizado pelo Estado pode gerar um bom humor e gerar boas oportunidades de investimento via confiança no longo prazo no país e também a sinalização de que a taxa de desemprego esta próxima da sua inflexão para redução.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Shopping West Plaza</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>76975000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.127772</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Método utilizado para imóveis: capitalização da renda através do fluxo de caixa descontado</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>.20135001620065000000</Numero>
				<Juizo>Seção Especializada Dissídios Coletivos, TRT, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2006-03-06</DataInstauracao>
				<ValorCausa>80000</ValorCausa>
				<PartesProcesso>Sindicato Dos Empregados Em Empresas De Vigilância, Segurança E Similares De SP - SEEVISP X Fundo de Investimento Imobiliário West Plaza</PartesProcesso>
				<PrincipaisFatos>Representação da categoria profissional.

 07.02.2013 - Autos Distribuidos aguardando julgamento de ADI no STF. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>De acordo com andamento do escritório, em princípio, não tende a haver impacto financeiro direto para o fundo.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0113254-25.2012.8.26.0100</Numero>
				<Juizo>41ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2012-02-10</DataInstauracao>
				<ValorCausa>193601.3</ValorCausa>
				<PartesProcesso>Fundo de Investimento Imobiliário West Plaza, Brookfield Brasil Shopping Center Ltda., Fundo de Investimento Imobiliário Premier Realty e outros X West Spirit Comércio de Jóias Ltda. e outros</PartesProcesso>
				<PrincipaisFatos>Cobrança de débito Ação de execução de título executivo extrajudicial, na qual foi deferida a desconsideração da personalidade jurídica da executada, permitindo a pesquida de INFOJUD em relação à empresa e à pessoa física. A pesquisa do RENAJUD restou infrutífera. Foi expedida carta precatória para citação da executada. Em decisão de 25.06.15 foi rejeitada a exceção de pré-executividade. Ingressamos com petição requerendo BACENJUD e INFOJUD. Em 28.08.15, protocolamos petição requerendo penhora online das contas e/ou aplicações dos Executados e verificação da existência de contratos em nome dos Executados, via sistemas Bacenjud e Infojud. O Executado José Roberto Campanelli Lima apresentou exceção de pré-executividade. Em 13.11.15, foi proferida decisão informando que a exceção encontrava-se apócrifa e deveria ser regularizada no prazo de 10 dias. Autos foram conclusos para decisão em 11.12.15. Em 07.01.16, foi proferido despacho determinando a manifestação do Exequente sobre as alegações. Em 15.02.16, protocolamos Manifestação sobre a Exceção de Pré-Executividade apresentada às fls. 383/390. Em 23.02.16, autos foram conclusos para decisão.  Exceção julgada improcedente. Ingressamos com petição requerendo pesquisas de bens via Infojud, Renajud e Bacenjud. Negado provimento ao AI. No momento, aguarda manifestação da parte. Juiz determinou que nos manifestássemos acerca da certidão de obito juntada aos autos, ingressamos com petição 20.09.16, requerendo que o advogado da parte apresente os dados do inventário e inventariante para representar o espólio nestes autos. No momento, aguarda-se intimação.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0185876-10.2009.8.26.0100 
0043636-85.2015.8.26.0100)</Numero>
				<Juizo>10ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>2ª Instância</Instancia>
				<DataInstauracao>2009-08-14</DataInstauracao>
				<ValorCausa>614469.29</ValorCausa>
				<PartesProcesso>Lojas Americanas S.A. X Fundo de Investimento Imobiliário West Plaza</PartesProcesso>
				<PrincipaisFatos>Ação renovatória de locação 

27.03.2012 – publicado despacho que saneou o feito e deferiu a produção de prova pericial

27.10.2014 – juntado laudo pericial

22.06.2015 – publicada sentença que julgou parcialmente procedente o pedido determinando a renovação do contrato por 10 anos, a partir de 14 de fevereiro de 2010 e fixando o novo valor de aluguel mínimo em R$63.611,00

23.09.2015 – publicada decisão que recebeu a apelação da autora no efeito meramente devolutivo

03.11.2015 – proposta execução provisória da sentença

06.11.2015 – autos da ação principal remetidos ao tribunal para julgamento da apelação

06.11.2015 – (autos da execução) proferida decisão determinando que eventual diferença de aluguel seja cobrada em ação própria
13.11.2015 - (autos da execução) publicada decisão afastando a incidência da multa de 10% do art. 475-J do CPC e intimando a executada a depositar o valor cobrado pela exequente (R$ 1.277.073,57) em de 15 dias

11.02.2016 - (autos da execução) publicada decisão julgando procedente a impugnação e determinando a apresentação de nova planilha de débito pela credora

25.02.2016 – (autos da execução) interposto recurso contra a decisão nos autos do cumprimento de sentença

28.04.2016 – (autos da execução) determinação do juízo para aguardar o julgamento do Agravo

15.12.2016 – publicado acórdão que negou provimento ao recurso </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Classe de demanda que, em princípio, tem como consequência a continuidade da locação e a definição do novo valor de aluguel.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1065845-65.2014.8.26.0100 </Numero>
				<Juizo>10ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>2ª Instância</Instancia>
				<DataInstauracao>2014-07-17</DataInstauracao>
				<ValorCausa>791279.66</ValorCausa>
				<PartesProcesso>BROOKFIELD BRASIL SHOPPING CENTERS LTDA., ALIANSCE SHOPPING CENTERS S.A., Fundo de Investimento Imobiliário West Plaza X Lojas Americanas S.A.</PartesProcesso>
				<PrincipaisFatos>Em 10/01/1989 as partes celebraram um contrato atípico de locação comercial, pelo prazo de 10 anos, iniciando-se a vigência no dia 14/02/1990 e findando-se no dia 13/02/2000. Com a proximidade do término da locação, a autora propôs a competente ação renovatória de contrato de locação, tendo sido o contrato renovado por novo período de 10 anos, fixando a título de aluguel mínimo o valor de R$ 22.614,00, base fevereiro de 2000. Novamente com a proximidade do término da locação, a autora propôs nova ação renovatória, que se encontra em fase de produção de prova pericial de engenharia. No referido instrumento locatício firmado entre as partes, o qual vem sendo renovado judicialmente, constam direitos e deveres das partes, destacando, que se trata de uma locação atípica em shopping center. Em ambas ações renovatórias, foram arguidas preliminares para a extinção das demandas em razão de descumprimento contratual cometido pela ré, ao deixar de pagar o IPTU da loja locada. Todavia, esses questionamentos foram dirimidos pelo TJSP que entendeu pela impossibilidade de discussão de tal matéria em sede de renovatória e que a mesma deveria ser dirimida em ação própria. Dessa forma como as partes não compuseram extrajudicialmente sobre o pagamento do referido imposto.
 Ação ajuizada pelo Shopping para a cobrança do IPTU devidos pela locatária e não pagos. Foi considerada conexa à ação renovatória nº 0185876-10.2009. Tal ação foi julgada improcedente posto que o juiz entendeu que o encargo financeiro do pagamento de IPTU jamais foi repassado ao à ré, mas apenas serviu de motivo para que a autora sustentasse o inadimplemento contratual. Shopping apresentou embargos de declaração para que o juiz corrigisse a sentença e a Ré apresentou embargos de declaração pedindo majoração dos honorários advocatícos. Negado provimento a ambos os embargos. Ingressamos com Recurso de Apelação. bem como as Lojas Americanas. Apresentamos contrarrazões ao recurso da Ré. No momento, aguarda-se julgamento de ambas. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0208663-96.2010.8.26.0100 
0208663-96.2010.8.26.0100)</Numero>
				<Juizo>15ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2010-11-30</DataInstauracao>
				<ValorCausa>24788.41</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Center Ltda, Fundo de Investimento Imobiliario Premier Realty, Irb-brasil Resseguros S.A., Fundo de Investimento Imobiliário West Plaza, X JRT Ótica Comercio LTDA - ME</PartesProcesso>
				<PrincipaisFatos>Ação de despejo por falta de pagamento cumulada com cobrança

13.12.2012 – publicada sentença que julgou procedente a ação embora prejudicado o despejo pela desocupação do imóvel cabendo pagamento dos valores em aberto

19.04.2013 – início da execução da sentença para cobrança dos valores pendentes restaram infrutíferas as pesquisas pelo BACENJUD

29.10.2015 - protocolada petição requerendo a suspensão do feito, ante a ausência de bens penhoráveis</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020359-42.2012.8.26.0004</Numero>
				<Juizo>2ª Vara Cível, Fórum Regional IV - Lapa, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2012-10-03</DataInstauracao>
				<ValorCausa>15018.52</ValorCausa>
				<PartesProcesso>
Brookfield Brasil Shopping Center Ltda, Irb-brasil Resseguros S.A., Fundo de Investimento Imobiliário West Plaza X JRT Ótica Comercio LTDA - ME - (QTZ) ; Fábio Tavares Teves</PartesProcesso>
				<PrincipaisFatos>Objeto: cobrança de débitos Ação de execução de título extrajudicial em que foi deferida a penhora de 30% do faturamento mensal de valores recebíveis pelos executados. Foi deferida a pesquisa de INFOJUD e BACENJUD, devendo o Requerente recolher custa para tais pesquisas. Aguarda-se a juntada de petição. Em 21.07.15 foram incluídos na contracapa os novos advogados. Proferido despacho em 16.10.2015 determinando ciência às partes da resposta do Banco Citibank ao ofício expedido e determinando citação das Executadas pelas Exequentes e comprovação da citação nos autos. Em 21.10.15, protocolamos petição juntando substabelecimento. Em 23.10.15, foi proferido despacho determinando ciência às partes quanto ao ofício-resposta de Banco Citibank e recolhimento, pelos exequentes, do valor correspondente a duas taxas, para pesquisas via Bacenjud e Infojud e a anotação do nome dos patronos das partes. Em 03.11.15, protocolamos petição requerendo a juntada da guia de bacenjud e infojud. Em 29.07.2016 ingressamos com petição indicando endereços para citação e intimação.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0185183-55.2011.8.26.0100 (583.00.2011.185183-3)</Numero>
				<Juizo>16ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-08-31</DataInstauracao>
				<ValorCausa>130574.4</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Center Ltda, Fundo de Investimento Imobiliario Premier Realty, Irb-brasil Resseguros S.A., Fundo de Investimento Imobiliário West Plaza X All Café Comércio de Alimentos Ltda</PartesProcesso>
				<PrincipaisFatos>Ação de despejo por falta de pagamento 

24.10.2013 – publicação da sentença que homologou o acordo das partes

17.11.2014 – publicada decisão que determinou a intimação da ré para pagamento da dívida, em razão do descumprimento do acordo. 

04.05.2015 – recebida impugnação ao cumprimento de sentença onde foi determinado o pagamento da dívida

10.11.2015 – autos remetidos à contadoria para conferência do valor exequendo

15.06.2016 – decisão rejeitando a impugnação do executado, determinando prosseguimento da execução

25.08.2016 – decisão determinando o bloqueio de bens por meio dos sistemas informatizados 

05.12.2016 – deferimento do requerimento do exequente para penhora dos créditos de Nota Fiscal Paulista
</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0078935-68.2011.8.26.0002</Numero>
				<Juizo>1ª Vara Cível, Fórum Regional II Santo Amaro, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-10-05</DataInstauracao>
				<ValorCausa>196285.92</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Center Ltda, Fundo de Investimento Imobiliario Premier Realty
Irb-brasil Resseguros S.a, Fundo de Investimento Imobiliário West Plaza       X Joseany Martinelli</PartesProcesso>
				<PrincipaisFatos>Cobrança de débitos locatícios Ação de execução de título extrajudicial em que não foi possível localizar bens por meio das pesquisas de BACENJUD e INFOJUD. Ingressamos com petição requerendo expedição de ofício à CNSeg. Em 21.09.2015, foi indeferido nosso pedido e determinado o arquivamento provisório dos autos em vista dos resultados infrutíferos da localização de bens da Executada. Em 22.10.15, protocolamos petição requerendo pesquisa de bens e de contratos em nome da Executada via Infojud e Renajud. Em 30.11.15, foi proferida decisão indeferindo pesquisa de bens através dos sistemas Infojud e Renajud. Em 07.01.16, protocolamos petição informando que a decisão foi devidamente protocolada no Detran e no Banco Central. Em 29.02.16, foi proferido despacho de ciência às partes quanto à resposta ao ofício encaminhado ao DETRAN, a qual foi negativa. Em 07.03.16, protocolamos petição informando que tivemos ciência da resposta negativa do ofício encaminhado ao DETRAN/SP e que aguardaremos até o retorno do ofício encaminhado ao Banco Central do Brasil para nos manifestarmos quanto ao prosseguimento do feito. Processo arquivado provisoriamente ante a ausencia de bens.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0106974-38.2012.8.26.0100</Numero>
				<Juizo>15ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2012-01-26</DataInstauracao>
				<ValorCausa>34093.65</ValorCausa>
				<PartesProcesso>Fundo de Investimento Imobiliário West Plaza X Edgard Rosalino Da Costa - ME</PartesProcesso>
				<PrincipaisFatos>Cobrança de débitos locatícios Ação de execução de título extrajudicial em que restou infrutífera a tentativa de bloqueio on-line de valores, tendo sido localizado automóvel pelo sistema do RENAJUD (Automóvel Marca GM/CELTA 2P Spirit, Placa DWN 6670, Renavam 00926328140, chassi 9BGRX08908G118965). Autos no gabinete do juiz, tendo sido proferida decisão em 21.07.15 para o exequente se manifestar sobre o ofício do DETRAN. Em 16.09.15, foi proferida decisão determinando que, para arresto ou penhora, é necessário que o exequente indique expressamente os dados do veículo, bem como o endereço em que está localizado o bem, e recolha as custas necessárias à realização de diligência pelo oficial de justiça. Em 08.10.15, protocolamos petição nos manifestando sobre o ofício-resposta do DETRAN e requerendo a intimação da Executada para que tome ciência da alienação judicial de seu automóvel. Em 19.10.15, foi publicada decisão determinando que o Exequente indicasse expressamente os dados do veículo a ser penhorado, bem como o endereço em que está localizado o bem, para a efetivação da penhora, e que comprovasse o recolhimento das diligências do oficial de justiça. Em 22.10.2015, protocolamos petição informando que as informações solicitadas ja foram prestadas em petição de 08.10.15. Em 04.02.16, foi proferida decisão determinando a intimação do executado para manifestar-se acerca das fls. 198/199. Protocolamos ofício na ARPEN em 16.08.16. No momento, aguarda-se resposta.Ingressamos com petição em 20.05.16 requerendo expedição de ofício à ARPEN para confirmar a alegação do falecimento. Recebida a resposta da ARPEN, ingressamos com petição em 30.09.16 esclarecendo que tornou-se obrigatório aos juízos a utilização da ferramenta CRC-JUD, e informando que aguarda seja realizada consulta a referido sistema.Recebida a resposta da ARPEN, ingressamos com petição em 30.09.16 esclarecendo que tornou-se obrigatório aos juízos a utilização da ferramenta CRC-JUD, e informando que aguarda seja realizada consulta a referido sistema.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0174150-68.2011.8.26.0100 </Numero>
				<Juizo>7ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-02-18</DataInstauracao>
				<ValorCausa>540490.29</ValorCausa>
				<PartesProcesso>Fundo de Investimento Imobiliário West Plaza X Antônio Jerônimo da Silva, Maria da Paz de Lima, Cláudio Antônio da Silva                              
(Premiatto)</PartesProcesso>
				<PrincipaisFatos>Ação de execução de título extrajudicial dos débitos decorrentes do inadimplemento dos aluguéis e encargos mensais da locação desde janeiro de 2009 até a entrega das chaves em 31.07.2010

30.03.2012 – determinada citação dos devedores e fiadores para pagamento sob pena de penhora

27.03.2013 - bloqueio parcial do valor devido

29.07.2014 - Deferido o pedido para citação do herdeiro da devedora falecida.

14.10.2014 – Expedida certidão para averbação da penhora do imóvel identificado

03.11.2014 - Interposto Agravo de Instrumento

28.08.2015 - Agravo julgado improcedente. Interposto Embargos de Declaração, também rejeitados. Interposto Recurso Especial e Recurso Extraordinário. 

23.09.2016 – Homologado acordo das partes e suspensa a execução até o cumprimento do acordo

19.12.2016 – publicada decisão que julgou extinta a execução da sentença com a satisfação da obrigação, autorizando o levantamento da penhora</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0108798-03.2010.8.26.0100</Numero>
				<Juizo>40ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2010-02-04</DataInstauracao>
				<ValorCausa>128577.84</ValorCausa>
				<PartesProcesso>Fundo de Investimento Imobiliário West Plaza X Wagner de Siqueira Almeida (Star Point)</PartesProcesso>
				<PrincipaisFatos>Objeto: Despejo em razão do não pagamento dos aluguéis mínimos e encargo comum desde agosto de 2009, totalizando uma dívida de R$ 49.101,57, somando-se a isso as custas processuais e honorários que somam o total de R$ 59.076,08. O lojista foi despejado da loja restando apenas a execução de valores devidos. A memória de cálculo já foi apresentada e o réu intimado para pagamento, totalizando o montante de R$ 666.770,98. Nossa minuta de cálculos foi juntada aos autos e ao encaminhar para a conclusão o juiz determinou que o Shopping providenciasse nova minuta de cálculo atualizada, acrescida da multa do artigo 475-J, bem como de honorários advocatícios, os quais foram fixados em 10% do débito principal.
Apresentamos nova minuta de cálculo atualizada e já requeremos o bloqueio dos ativos financeiros do executado. 
-  Foi proferido despacho deferindo nosso pedido de bloqueio por meio do sistema Bacenjud. Foi realizado o bloqueio parcial pelo sistema do Bacen, de forma que o saldo bloqueado foi de apenas R$552,10. Foi deferido nosso pedido de expedição de mandado de levantamento do saldo bloqueado e expedição de ofício à DRF para localizar outros bens.
Aguarda-se expedição de tais ofícios.
25/07/2013 - Movimentação processual inalterada. Aguarda-se expedição de ofícios para localização de bens.
20/08/2013 - Movimentação processual inalterada.
20/09/20013 - Aguarda-se expedição de ofício à DRF.
31/10/2013 - Movimentação processual inalterada.
25/11/2013- O escritório juntou nova procuração em nome da BB Adm. para levantamento dos valores bloqueados e repasse ao Shopping.
26/12/2013 - Sem novas movimentações processuais.
29/01/2014 - Movimentação processual inalterada.
25/02/2014 - Foi deferido nosso pedido de expedição de mandado de levantamento do saldo bloqueado e expedição de ofício à DRF para localizar outros bens.
25/04/2014 -  Aguardando expedição de novo mandado.
30/06/2014 - Autos no Serviço de Máquina Urgente para expedição de MLJ.
29/07/2014 - Movimentação processual inalterada.
26/08/2014 - Movimentação processual inalterada.
29/10/2014 - Expedido MLJ.
20/04/2015 - Foi requerida penhora online. Aguarda-se cumprimento.                                                                                                           29/05/2015 - movimentação processual inalterada .                                                                                                                                                       27/08/2015 -  movimentação processual inalterada. 29/02/2016 - autos remetidos ao arquivo em razão da ausência de bens passíveis de penhora. Processo desarquivado com reabertura para tentativa de localização de novos bens. Processo Suspenso desde dezembro de 2016.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>*1537200702602000</Numero>
				<Juizo>26ª Vara Cível, Foro Trabalhista, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2007-08-03</DataInstauracao>
				<ValorCausa>30000</ValorCausa>
				<PartesProcesso>Moisés Vital Zacarias (Delta) X Fundo de Investimento Imobiliário West Plaza</PartesProcesso>
				<PrincipaisFatos>Declaração de vínculo empregatício. 

27.01.2011 - Apresentada impugnação aos cálculos do reclamante.; 

16.03.2012 - Publicação despacho determinando perícia contábil

08.04.2013 - Publicada intimação das partes para se manifestarem sobre laudo</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>De acordo com andamento do escritório, demanda tende a ser arquivada. De todo modo, não há, em princípio, impacto direto para o fundo imobiliário.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>*01138008020095020043</Numero>
				<Juizo>43ª Vara do Trabalho, Foro Trabalhista, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2009-05-27</DataInstauracao>
				<ValorCausa>95000</ValorCausa>
				<PartesProcesso>Priscila Epaminondas de Almeida X Fundo de Investimento Imobiliário West Plaza</PartesProcesso>
				<PrincipaisFatos>Reclamação trabalhista alegando dispensa simulada e requrendo FGTS + 40%; recolhimento previdenciário referente aos cartões de bonificação; comissões pela realização de negócio; diferença a título das verbas rescisórias; uma remuneração a título de bônus anual; pagamento do valor correspondente a cesta básica; multa do art. 477; equiparação salarial   

30.08.2011 -  a empresa não interpôs recurso de revista

14.08.2012 - Impugnados os cálculos de liquidação neste dia 

15.02.2013 – juntada de guia referente ao valor da execução, no importe de R$23.451,15.

21.10.2013 - Publicação do despacho que determinou o pagamento de R$ 5.835,07, sob pena de execução

08.11.2013 - Protocolo de Petição de Embargos à Execução.

15.10.2014 – expedido alvará de levantamento

19.11.2014- Protocolo de Petição de Juntada de G.P.S.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>De acordo com andamento do escritório, demanda tende a ser arquivada. De todo modo, não há, em princípio, impacto direto para o fundo imobiliário.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>*00183200900802000</Numero>
				<Juizo>8ª Vara do Trabalho, Foro Trabalhista, São Paulo, SP</Juizo>
				<Instancia>Verificar (Instancia Superior)</Instancia>
				<DataInstauracao>2009-01-29</DataInstauracao>
				<ValorCausa>25000</ValorCausa>
				<PartesProcesso>Ricardo Araújo de Oliveira X Fundo de Investimento Imobiliário West Plaza</PartesProcesso>
				<PrincipaisFatos>Nulidade do contrato firmado com a cooperativa; vínculo com a rolcan; horas extras e reflexos; verbas rescisórias; multa do art. 477 e 467 da CLT; entrega de guias de seguro desemprego ou indenização equivanlente; diferenças salariais; adicional por acúmulo de funções e honorários de advogado. 24/02/2010 - Publicação à reclamada - apresentar contra-razões ao recurso ordinário.; 26/02/2010 - Os recursos interpostos foram das reclamadas, não há nada a ser contrarrazoado.; 10/02/2011 - O PRESENTE PROCESSO FOI TRANSFERIDO DA E. 18ª TURMA PARA A E. 4ª TURMA; 
18/08/2011 - Aguardando acórdão referente ao RO interposto pela empresa.
28/10/2011 - Publicação às partes para tomarem ciência de que por unanimidade negaram provimento ao recurso do 1º recorrente, e que, por unanimidade deram provimento parcial ao recurso do 2º recorrente.; 
10/11/2011 - Interposto recurso de revista nesta data.;
21/02/2013 - Publicação de distribuição do processo ao TST - 3ª turma.
20/10/2013 - Movimentação processual inalterada.
10/12/2013 - Aguardando o julgamento do recurso de revista.
02/04/2014 - Movimentação processual inalterada.
26/09/2014 - Movimentação processual inalterada.
06/11/2014 - Movimentação processual inalterada.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>De acordo com informação do escritório responsável, a indicação de risco é baseada na atualização do valor atribuído a sentença/acórdão. </AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0246066-07.2007.8.26.0100</Numero>
				<Juizo>26ª Vara Cível,  Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2007-10-31</DataInstauracao>
				<ValorCausa>5280837</ValorCausa>
				<PartesProcesso>Fundação CESP X Plaza Shopping Trust SPCO Ltda.</PartesProcesso>
				<PrincipaisFatos>Trata-se de ação de cobrança movida pela Fundação CESP contra a Plaza Shopping Trust SPCO Ltda. para de obter repasse de 30% dos rendimentos provenientes da expansão do Bloco A do “Shopping Center West Plaza” no período compreendido entre novembro de 2000 e março de 2007. Ação contestada e, atualmente, em fase de instrução probatória.
Os autos estão em carga com o perito, Sr. Arles Denapoli desde o dia 31 de janeiro de 2012 para realização de perícia contábil.
</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>De acordo com o escritório responsável, Na hipótese de total procedência da ação, a Plaza Trust pode ter que pagar à FUNCESP o valor indicado para provisão. Tendo em vista, porém, que a perícia não foi sequer concluída, eventual pagamento (caso haja condenação e não mais seja possível a interposição de recurso com efeito suspensivo), não deverá ser necessário nos próximos 24 meses</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1016736-19.2013.8.26.0100 </Numero>
				<Juizo>29ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-04-05</DataInstauracao>
				<ValorCausa>108511.08</ValorCausa>
				<PartesProcesso>Diwan Fast Food Restaurante Ltda. X Brookfield Brasil Shopping Centers Administradora Ltda., Fundo de Investimento Imobiliario - Shopping West Plaza, Aliansce Shopping Centers S.A.     
</PartesProcesso>
				<PrincipaisFatos>Renovação do contrato de locação Ação Renovatória, em que houve decisão do juiz para excluir do polo passivo a as corrés Brazilian Mortgages e IRB Brasil S/A. e que se encontra na fase de produção de provas,uma vez que a audiência de conciliação restou infrutífera. Foi deferida a perícia contábil para se chegar ao valor real do imóvel e do aluguel devido pela locação. Aguarda-se o laudo pericial uma vez que Juiz determinou a intimação do perito em 29.05.2015 para dar início aos seus trabalhos. Em 10.07.15, protocolamos petição juntando substabelecimento e custas de mandato. Em 17.09.15, perito foi intimado para dar início aos trabalhos e apresentar laudo pericial. Em 15.01.16, foi expedida certidão de que até então não houve manifestação do perito e autos foram conclusos para despacho. Em 18.02.16, foi proferida decisão determinando nova intimação do perito para iniciar seus trabalhos. Ingressamos com petição requerendo esclarecimentos do perito e nosso assistente técnico protocolou laudo divergente em 19.05.16. No momento, aguarda manifestação do Perito.Houve manifestação do perito.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Classe de demanda que, em princípio, tem como consequência a continuidade da locação e a definição do novo valor de aluguel.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1083274-79.2013.8.26.0100</Numero>
				<Juizo>21ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2013-10-25</DataInstauracao>
				<ValorCausa>52364.04</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Administradora Ltda., Fundo de Investimento Imobiliario - Shopping West Plaza, Aliansce Shopping Centers S.A.     
 X Rodrigo Cardoso Barbalho</PartesProcesso>
				<PrincipaisFatos>Em 01 de novembro de 2012, foi celebrado entre as partes um contrato de locação comercial. Na mesma data foi celebradoum termo aditivo ao contrato de locação, ao qual as partes ajustaram que o locatário ficará obrigado a pagar o aluguel mensal e as taxas de condomínio somente quando ele estiver na emissão da posse. Ocorre que o réu não pagou os aluguéis e demais encargos, sendo o valor do seu débito R$76.702,21.  Ação de despejo por falta de pagamento julgada procedente a fim de declarar rescindido o contrato de locação e ordenar o despejo. Iniciada a fase de execução, foi deferida a pesquida de ativos pelo BACENJUD e pelo INFOJUD. Em decisão de 16.06.15 foi deferida a penhora de quotas sociais indicadas pelos exequentes, bem como de eventuais lucros sociais que cabem ao executado, determinando-se a expedição de mandado de penhora e de ofício à JUCESP, comunicando a constrição das quotas. Em 10.11.15, foi proferido despacho determinando que, para expedição de mandado de penhora, o exequente deveria recolher as custas necessárias à realização da diligência pelo oficial de justiça. Em 12.11.15, protocolamos petição juntando as custas, para fins de que seja expedido o mandado de penhora. Em 10.12.15, foi expedida certidão de emissão do mandado de penhora.  Mandado cumprido negativa. Indicamos novo endereço. No momento, aguarda-se expedição de mandado de intimação.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1006286-86.2014.8.26.0001</Numero>
				<Juizo>8ª Vara Cível, Fórum Regional I - Santana, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-03-06</DataInstauracao>
				<ValorCausa>123364.8</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Administradora Ltda., Fundo de Investimento Imobiliário - Shopping West Plaza, IRB - Brasil Resseguros S.A. X Cosmorama Milkshake e Lanchonete Ltda. – ME e outro</PartesProcesso>
				<PrincipaisFatos>Ação de execução dealuguéis e demais encargos da locação. Os exequentes são credores das executadas pelo valor histórico de R$ 89.935,06 (oitenta e nove mil, novecentos e trinta e cinco reais e seis centavos). O presente débito tem por origem o “instrumento particular de contrato de locação de espaço comercial e outras avenças”, firmado entre as partes no dia 11 de maio de 2012. O contrato locatício prevê como remuneração mensal o pagamento de um aluguel mínimo mensal e aluguel percentual, encargos, custos e despesas condominiais, bem como contribuição para o fundo de promoção. Em 20 de setembro de 2012, as partes resolvem distratar os instrumentos do mencionando em II do instrumento de locação através do “termo de distrato do instrumento particular de contrato de locação de espaço(s) comercial(is) e outras avenças do ‘’West Plaza Shopping’”, como distratados estão para todos os fins de direito, a partir desta data, bem como devolver neste ato a Arco locada às locadoras livre e desembaraçada de pessoas e coisas. Os locatários reconhecem e confessam dever às locadoras a importância total atualizada, oriunda dos instrumentos mencionados em II, o valor de R$ 95.671,06, sendo R$ 78.437,33 correspondente a multa pela rescisão antecipada da locação e R$ 17.233,73, correspondente ao “aluguel” e demais encargos vencidos e não pagos em 05 de Agosto de 2012, 12 de agosto de 2012, 05 de setembro de 2012, 12 de setembro de 2012 e vincendo e, 05 de Outubro de 2012. Ocorre que, a executada não efetuou os pagamentos dos aluguéis e demais encargos vencidos e não pagos nos períodos compreendidos entre os dias 20 de setembro de 2013, 20 de outubro de 2013, 20 de novembro de 2013, 20 de dezembro de 2013, 20 de janeiro de 2014 e 27 de janeiro de 2014. Tem-se, portanto, que o débito total das executadas corrigido na forma acima descrita é de R$123.364,80 (cento e vinte e três mil, trezentos e sessenta e quatro reais e oitenta centavos), atualizado até o dia 27 de Janeiro de 2014. Ação de execução de título extrajudicial em fase de citação, em que foi expedida carta precatória para citação da executada Ana Paula. Aguardando expedição de mandado de citação. Mandado foi expedido em 30.09.15. Em 09.12.15, mandado foi devolvido sem cumprimento. Em 09.12.15, foi proferido despacho determinando que as partes se manifestassem sobre a mandado de citação cumprido negativo. Em 18.12.15, protocolamos petição requerendo pesquisa de endereço pelo Bacenjud. Em 11.01.16, os autos foram conclusos para decisão. Em 19.01.16, foi proferido despacho deferindo a pesquisa de endereços via Bacenjud. Em 16.02.16, protocolamos petição juntando custas para realização de pesquisa de endereços via Bacenjud. Em 22.02.16, os autos foram conclusos para decisão.  Em 29.06.16 ingressamos com petição requerendo a citação da empresa executada, bem como da sócia.  Determinada a expedição de carta de citação. No momento aguarda-se expedição.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1006284-19.2014.8.26.0001</Numero>
				<Juizo>2ª Vara Cível, Fórum Regional I - Santana, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-03-06</DataInstauracao>
				<ValorCausa>67274.14</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Administradora Ltda., Fundo de Investimento Imobiliario - Shopping West Plaza, IRB - Brasil Resseguros S.A.
 X Cosmorama Milkshake e Lanchonete Ltda. – ME</PartesProcesso>
				<PrincipaisFatos>Execução por quantia certa  Ação de execução de título extrajudicial em fase de citação. Carta precatória devolvida negativa. Em 22.10.15, protocolamos petição requerendo o aditamento de CP para citação da Executada Ana Paula Roberto na Rua Paulina Isabel de Queiroz, 443, casa 02, Santo André, SP, bem como penhora on line de contas da Executada Cosmorama. Em 09.11.15, foi proferido despacho abrindo prazo para as partes se manifestarem sobre a devolução da carta precatória sem cumprimento. Em 16.11.15, protocolamos petição indicando novo endereço para citação da Executada, qual seja, Rua José Osvaldo, n° 432, Vila Gustavo, 02250-010, e reiterando o pedido de realização de pesquisa via Bacenjud. Desde 26.11.15, autos foram conclusos para decisão. Em 19.02.16, foi proferida decisão determinando que se proceda à transferência do valor bloqueado, para que seja convertido em penhora, bem como que se intime a Executada, para, querendo, apresentar impugnação. Ingressamos com petição em 22.09.16, requerendo a intimação da Executada, via postal no endereço situado à Rua Mere Amedea, 896, Vila Maria - CEP 02125-001, SP.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1046599-83.2014.8.26.0100 </Numero>
				<Juizo>3ª Vara Cível, Fórum Regional de Santo Amaro , São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-05-20</DataInstauracao>
				<ValorCausa>36949.25</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Carlos Sanches, Conexão West Plaza Ltda., e outro</PartesProcesso>
				<PrincipaisFatos>Ação de execução de título extrajudicial da multa devida em razão da rescisão antecipada da locação

23.05.2014 – determinada redistribuição do feito ao foro regional de Santo Amaro

22.05.2015 – deferida pesquisa de bens do executado

29.09.2015 – decisão liberando para o exequente o valor identificado nas pesquisas e devidamente bloqueado e penhorado 

23.03.2016 – publicação da decisão que determinou o envio dos autos ao contador em razão da discordância das partes com relação ao valor penhorado

07.10.2016 – autos recebidos do contador

12.12.2016 – decisão determinando o desbloqueio dos veículos, dado que o crédito foi integralmente garantido ao juízo</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1063030-95.2014.8.26.0100</Numero>
				<Juizo>30ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-07-10</DataInstauracao>
				<ValorCausa>32742.06</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Allan Jefferson Tadormina de Souza</PartesProcesso>
				<PrincipaisFatos>Resumo: Os exequentes são credores do executado pela quantia de R$27.500,00. O presente débito tem origem no instrumento particular de locação de espaço comercial, firmado em 01/11/2013, tendo por objeto a locação da loja Q2A 03 pelo prazo de 92 dias, iniciando-se no dia 01/11/2013 e findando-se no dia 31/01/2014. O instrumento prevê o pagamento mensal da quantia de R$ 5.500,00 a ser pago da seguinte forma: R$ 5.000,00, a título de aluguel mensal, R$ 400,00 a ser pago de encargos condominais mensais e R$ 100,00 a ser pago de fundo de promoção e propaganda mensal. No dia 31/01/2014, foi assinado um instrumento particular de distrato de outro, através do qual , o executado confessou dever o valor de R$ 27.500,00, a ser pago em 20 parcelas no valor unitário de R$ 1.375,00 com vencimento para o dia 5 de subsequente de cada mês. Contudo, o executado não honrou sequer o pagamento da primeira parcela vencida no dia 05/04/2014, o que ensejou o vencimento antecipado do saldo devedor. Ação de Execução em que foi arrestado o valor de R$ 19,25, houve resposta negativa do RENAJUD, e por isso, conforme decisão proferida dia 17.04.2015, foi deferida a penhora sobre créditos a serem recebidos dos cartões de crédito e débito, configurando-se uma forma aceita de penhora sobre o faturamento. Expedidos ofícios. No momento, aguarda-se volta dos Avisos de Recebimentos. Comprovamos a distribuição dos ofícios e o retorno dos ARs. Ofício a American Express S/A resultou negativo. Proferido despacho do juiz determinando que as partes aguardem o retorno de todos os ofícios para se manifestarem. Em 05.02.16, foi proferido despacho determinando ciência quanto ao retorno do ofício do Itaú. Em 17.02.16, protocolamos petição requerendo obtenção das últimas declarações de imposto de renda do Executado via Infojud. Em 18.02.16, foi proferida decisão deferindo a pesquisa.  Em 09.05.16 protocolamos petição requerendo penhora de nota fiscal paulista, deferido em 12.05.16. Aguardando expedição de ofício. Ofício expedido e distribuído. Aguardando resposta da Secretaria da Fazenda.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1032808-50.2014.8.26.0002 </Numero>
				<Juizo>3ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-07-28</DataInstauracao>
				<ValorCausa>56488.65</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Camila Celandroni Cattucci</PartesProcesso>
				<PrincipaisFatos>Resumo: os exequentes são credores da executada pela quantia de r$49.636,03. O presente débito tem origem de um instrumento particular de locação de espaço comercial e outras avenças, firmado pelas partes em 15/07/2013, tendo por objeto a locação do arco nº 1232, pelo prazo de 60 meses, iniciando-se no dia 13/09/13. O contrato locatício prevê como remuneração mensal o pagamento de um aluguel percentual e aluguel mínimo reajustável, o que for maior dentro do mês, além das contribuições para o fundo de promoção e despesas condominais. No dia 23/06/2014, a executada devolveu o imóvel aos exequentes. Contudo a executada não quitou os aluguéis e demais encargos da locação vencidos no período compreendido entre os dias 12/01/2014 e 12/07/2014. Tem-se portanto, que o débito total da executada é de r$56.488,65, atualizado até o dia 07/07/2014. Ação de execução de título extrajudicial em fase de citação, na qual as pesquisas de BACENJUD e RENAJUD restaram infrutíferas. Em 19.05.2015 foi encaminhado à central de mandados o mandado para citação da Executada. Em 14.09.2015, o mandado foi devolvido cumprido negativo. Em 25.09.15, protocolamos petição requerendo nova tentativa de penhora de contas da Executada via sistema Bacenjud. Em 04.11.2015, o Juiz deferiu o pedido, determinando que, com o retorno da pesquisa via Bacenjud, o Exequente se manifeste sobre o prosseguimento do feito. Desde 05.11.15, autos estão conclusos para decisão. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1032806-80.2014.8.26.0002</Numero>
				<Juizo>6ª Vara Cível, Fórum Regional II Santo Amaro, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-07-28</DataInstauracao>
				<ValorCausa>61484.67</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Camila Celandroni Cattucci</PartesProcesso>
				<PrincipaisFatos>Resumo: Ação de execução de rescisão contratual - objeto contrato de locação firmado em 15 de julho de 2013(com duração de 60 meses) do arco n° 1232. Valor do débito r$ 61.484,67 referente ao pagamento de multa contratual contratual a quantia equivalente a 1/3 do valor apurado pela multiplicação do número de meses a decorrer até o término do prazo da locação.
 Ação de execução de título extrajudicial em fase de citação, uma vez que o mandado de citação teve que ser aditado para citação por hora certa, frente a não localização do executado pelo oficial de justiça. Aguarda-se a citação. Em 31.08.15, o mandado foi devolvido cumprido negativo. Em 23.10.15, protocolamos petição requerendo a inclusão dos nossos nomes no site do TJ/SP e na contracapa dos autos, para recebermos as publicações. Em 14.01.16, os autos foram conclusos para decisão.  Em 10.05.16 protocolamos petição indicando novo endereço para tentativa de citação da executada. Juiz determinou a juntada de custa para realização de pesquisas anteriormente requeridas, o que cumprimos em 29.09.16.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1069270-03.2014.8.26.0100</Numero>
				<Juizo>17ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-07-27</DataInstauracao>
				<ValorCausa>55884.62</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X GTX Telecom Comércio de Telefonia Ltda. e outros</PartesProcesso>
				<PrincipaisFatos>Ação de execução de título extrajudicial referente aos alugueis não pagos do período de abril a julho de 2014

28.07.2014 – publicada decisão que determinou a citação e intimação para pagamento do débito em 03 dias sob pena de penhora

21.05.2015 - expedida carta precatória para a citação

22.10.15 - proferido despacho intimando o exequente a se manifestar sobre a devolução negativa da carta precatória

13.11.15 - foi expedida Carta Precatória de citação, penhora e avaliação 

15.07.2016 – despacho determinando manifestação do exequente sobre resultado negativo da precatória

22.07.2016 – juntada do pedido de diligência em novo endereço</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1085829-35.2014.8.26.0100 </Numero>
				<Juizo>36ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-09-05</DataInstauracao>
				<ValorCausa>61556.76</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Westcoffee Cafés e Sorvetes Gourmet Ltda. - EPP</PartesProcesso>
				<PrincipaisFatos>No dia 21/03/12 foi celebrado entre as partes o instrumento particular de contrato atípico de locação  tendo por objeto a arco nº 2311/12 pelo prazo de 60 meses, iniciando-se no dia 01/04/2012. O contrato  locatício prevê como remuneração mensal o pagamento de um aluguel mínimo reajustável e aluguel percentual, o que for maior dentro do mês, cabendo ainda á locatária o pagamento dos encargos e  fundo de promoção. No dia 22/07/2013, a empresa cedeu e transferiu todos os direitos e obrigações  derivados do contrato através do instrumento particular de cessão de direitos locatícios, tendo os  autores figurados como intervenientes anuentes. Ocorre que, a ré não pagou pontualmente os aluguéis  mensais e demais encargos da locação, sendo o valor histórico de seu débito R$28.314,67. Ação de despejo por falta de pagamento cumulada com pedido de cobrança por débitos em aberto, oriundos do contrato de locação. Em contestação, a Ré alega que, uma vez que transferiu seu ponto comercial, por meio de um contrato de compra e venda, não deveria fazer parte do polo passivo da demanda. Em 22.05.2015, o juiz pediu para que a Ré regularizasse a sua representação na presente demanda. Em 03.05.2015, o Shopping apresentou petição pleiteando o prosseguimento do feito, uma vez que a Ré é sim parte legítima para configurar na presente ação. Em sentença, ação foi JULGADA PROCEDENTE, declarado rescindido o contrato de locação, decretado o despejo da ré, a qual deveria desocupar o imóvel voluntariamente em 15 dias, contados da respectiva notificação. A Ré arcará com o pagamento das custas, despesas processuais e honorários advocatícios, fixados por equidade, em R$ 2.000,00. No momento, aguarda-se interposição de Apelação. Não houve interposição de Apelação e a sentença transitou em julgado em 18/08/15. Aguardando início da fase de execução. No prazo para juntarmos planilha de cálculo atualizada. Protocolamos petição instaurando a execução em 18.11.15. Autos do Cumprimento de Sentença (1118748-43.2015.8.26.0100) foram distribuídos por dependência aos autos principais. Em 24.11.15, foi proferida decisão intimando a parte devedora, na pessoa de seu advogado, a pagar o valor do débito em 15 dias, sob pena de incidência de multa de 10% sobre o valor em execução. Em 30.11.15, foram opostos embargos de declaração para que seja determinada a expedição de mandado de desocupação voluntária do imóvel. Em 24.02.16, foi proferida decisão determinando a expedição de mandado de despejo. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1056060-79.2014.8.26.0100 </Numero>
				<Juizo>22ª Vara Cível, São Paulo, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-06-16</DataInstauracao>
				<ValorCausa>51674.52</ValorCausa>
				<PartesProcesso>Pirajibes Comercio de Tenis e Artigos Esportivos Ltda X Fundo de Investimento Imobiliario - Shopping West Plaza e outros</PartesProcesso>
				<PrincipaisFatos>Ação de consignação em pagamento de alugueis devidos, cumulada com entrega de chaves

18.06.2014 – proferida decisão que deferiu a antecipação de tutela para autorizar a consignação das chaves do imóvel condicionada ao prévio depósito da multa 

28.05.2015 – prolatada sentença julgando procedente a ação com resolução do mérito para declarar a extinção do contrato de locação 

24.07.2015 – certificado o trânsito em julgado da decisão

16.09.2015 - início da execução 

26.11.2015 - proferida decisão que julgou extinta a execução, nos termos do art. 794, inciso I, do Código de Processo Civil

01.02.2016 - nos autos principais, foi publicada certidão de expedição de guia de levantamento</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Não há risco de perda financeira, apenas de se ter de aceitar valor consignado pela autora nos autos.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1014885-71.2015.8.26.0100</Numero>
				<Juizo>23ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-02-20</DataInstauracao>
				<ValorCausa>819654.84</ValorCausa>
				<PartesProcesso>Aliansce Shopping Centers S.A., Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiliário West Plaza       X Lojas Americanas S.A.</PartesProcesso>
				<PrincipaisFatos>Ação de despejo Ação de despejo ajuizada devido à infração contratual da Ré. Mandado de citação expedido. Aguardando cumprimento. Mandado devolvido cumprido positivo e juntado em 04.11.15. Contestação juntada em 20.11.15.  Apresentamos réplica em 28.08.2016</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1001040-23.2016.5.02.0013</Numero>
				<Juizo>13ª Vara Cível, Foro Trabalhista, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-09</DataInstauracao>
				<ValorCausa>40739</ValorCausa>
				<PartesProcesso>Marizete de Jesus Reis X Empresa Brasileira de Serviços Gerais; Fundo de Investimento Imobiliário; Hyundai Caoa do Brasil LTDA; Bio Ritmo Academia Shopping Santana Parque.</PartesProcesso>
				<PrincipaisFatos> Processo distribuído com marcação de audiência para o dia 17/10/2016 às 10h10.18/10/2016 A Reclamante peticiona requerendo que a pericia seja realizada no Shopping West Plaza. 18/11/2016 Despacho determinando que a reclamante renove o requerimento de perícia na audiência. 10/01/2017 Andamento inalterado.08/02/2017 - Juntado substabelecimento sem reserva de poderes em nome de leandro duarte.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, não há impacto direto no fundo imobiliário.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1080082-36.2016.8.26.0100</Numero>
				<Juizo>37ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-07-29</DataInstauracao>
				<ValorCausa>198899.77</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiliário - FII Shopping West Plaza X Rogerio Uliana de Oliveira, Carlos Hideki Nanami, Cláudia Yoshiko Takahashi Nanami</PartesProcesso>
				<PrincipaisFatos>Execução Ação de execução para cobrança das verbas locatícias em atraso, derivadas do Contrato de Locação</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1095933-18.2016.8.26.0100</Numero>
				<Juizo>31ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-08-29</DataInstauracao>
				<ValorCausa>128725.72</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Laurício Alves da Silva</PartesProcesso>
				<PrincipaisFatos>Execução de título extrajudicial Ação de cobrança de aluguéis, encargos e fundo de promoção</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0078933-98.2011.8.26.0002</Numero>
				<Juizo>5ª Vara Cível, Foro Regional de Santo Amaro, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2011-11-21</DataInstauracao>
				<ValorCausa>37372.59</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda. 
[Fundo de Investimento Imobiliário Premier Realty
IRB - Brasil Resseguros S.A. - Constam como parte]
 X Joseany Martinelli</PartesProcesso>
				<PrincipaisFatos> Ação de execução de título extrajudicial que, após inúmeras diligências frustradas, acabou sendo arquivada por falta de bens penhoráveis. Em 16.04.2015, os autos foram desarquivados. Autos estão conclusos com o juiz, para este proferir decisão, desde 21.07.2015. Em 11.09.2015, foi determinado o bloqueio de contas e ativos financeiros da Executada e a expedição de ofício à Delegacia da Receita Federal e ao Detran para localização de bens da Executada. Protocolamos petição pedindo a expedição de ofício a CNSeg para averiguar a existência de contratos em nome da Executada. Respostas do RENAJUD, INFOJUD e BACENJUD negativas. Em 22.10.2015, protocolamos petição requerendo penhora de nota fiscal paulista. Em 15.12.15, foi proferida decisão deferindo a penhora de créditos relativos à nota fiscal paulista. Em 17.12.15, foi expedido ofício ao Secretaria de Estado dos Negócios da Fazenda. Em 03.03.16, protocolamos petição comprovando distribuição do ofício expedido em 17.12.15. Com a resposta, ingressamos com petição requerendo a suspensão da ação, em 18.07.16, o que foi deferido.Processo suspenso.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1126409-10.2014.8.26.0100</Numero>
				<Juizo>18ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-12-12</DataInstauracao>
				<ValorCausa>42007.68</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Rodrigo Cardoso Barbalho e Luis Fernando Tartaglioni</PartesProcesso>
				<PrincipaisFatos> Ação de execução de título extrajudicial que o executado Luis foi devidamente citado, apresentando exceção de pré-executividade, a qual foi rejeitada, conforme decisão proferida em 09.04.2015. Foi deferida a tentativa de localização de endereços do executado RODRIGO pelos sistemas INFOJUD, BACENJUD e RENAJUD. Em 15.07.2015 foi juntado o mandado cumprido negativo de citação do executado RODRIGO. O executado LUIS interpôs Agravo de Instrumento (2094844-83.2015.8.26.0000) contra a decisão que rejeitou a exceção de pré-executividade.  Requeremos citação por edital. Pedido de citação por edital juntado em 18.08.15. Na mesma data, autos foram conclusos para decisão. Em 22.09.15, protocolamos contrarrazões ao Agravo. No Agravo de Instrumento (2094844-83.2015.8.26.0000), em 09.10.15, foi negado seguimento ao recurso especial. Em 11.12.15, foi expedida certidão de trânsito em julgado e de encaminhamento dos autos ao arquivo. Em 18.11.15, em 1ª instância, requeremos o desarquivamento dos autos, juntando guia para pesquisa via infojud, renajud e bacenjud. Em 27.11.15, foi proferida decisão deferindo a citação por edital, bem como a realização de contas e/ou aplicações em nome dos Executados via Bacenjud, bem como obtenção das ultimas declarações dos Executados via Infojud e de seus bens via Renajud. Em 07.12.15, protocolamos petição requerendo penhora de imóvel de titularidade do Executado Luis Tartaglioni (matrícula às fls. 151-152). Em 15.12.15, foi proferida decisão deferindo a penhora do bem imóvel indicado pela autora e determinando a intimação do executado quanto ao deferimento da penhora e sua nomeação como depositário. Ainda, determinou a averbação da penhora via ARISP e determinou a expedição de mandado de avaliação do imóvel, a ser cumprido pelo Oficial de Justiça. Por fim, o Juízo determinou a intimação de eventual cônjuge, terceiro titular de garantia hipotecária e detentor de penhora averbada anteriormente, expedindo-se o necessário. Em 17.12.15, foi proferido despacho informando a remessa dos autos à fila, para cumprimento da decisão.   Penhora prenotada. No momento, aguarda-se providencias do cartório.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1126532-08.2014.8.26.0100</Numero>
				<Juizo>18ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-12-12</DataInstauracao>
				<ValorCausa>233105.22</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Rodrigo Cardoso Barbalho e Luis Fernando Tartaglioni</PartesProcesso>
				<PrincipaisFatos> Ação de execução de título extrajudicial em que a parte restou citada, conforme mandado cumprido positivo em 12.02.2015. Em decisão de 01.04.2015, restou rejeitada a exceção de pré-executividade apresentada por um dos executados. Executado ingressou com Agravo de Instrumento (processo nº 2075810-25.2015.8.26.0000), o qual foi negado provimento, e contra tal decisão foi interposto Embargos de Declaração, que foram rejeitados. Em 10.09.15, o Agravante interpôs recurso especial. Na mesma data, os autos foram encaminhados ao Serviço de Processamento de
Recursos dos Tribunais Superiores de Direito Privado 3. Em 16.11.15, foi proferida decisão negando seguimento ao recurso especial. Em 29.01.16, foi expedida certidão informando o trânsito em julgado à Vara de Origem e a remessa dos autos ao arquivo. Em 1ª instância, em 06.11.15 os autos foram arquivados provisoriamente. Em 11.02.16, os autos foram conclusos para decisão. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1088230-07.2014.8.26.0100</Numero>
				<Juizo>17ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2014-09-12</DataInstauracao>
				<ValorCausa>27291.6</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Adriano dos Reis Souza Júnior</PartesProcesso>
				<PrincipaisFatos> Ação de despejo julgada procedente para condenar a Ré no pagamento dos encargos locatícios em aberto e para rescindir a locação. Em 13.05.2015 transitou em julgado a sentença. Aguarda-se a expedição de mandado de despejo e o início da fase de cumprimento de sentença. Em 28.09.15, mandado foi expedido. Em 09.10.15, mandado foi devolvido cumprido negativo. Em 21.10.15, protocolamos petição requerendo instauração da execução e juntando planilha de cálculos. Em 04.11.15, foi proferida decisão deferindo instauração da execução e determinando a expedição do mandado de despejo do Executado. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1047318-31.2015.8.26.0100</Numero>
				<Juizo>14ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-05-15</DataInstauracao>
				<ValorCausa>149553.84</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Tex Barred´s Moda Ltda.</PartesProcesso>
				<PrincipaisFatos> Ação de despejo ajuizada por falta de pagamento da locatária. Em 11.08 foi expedido mandado de citação e despejo. Aguarda-se a citação. Mandado devolvido cumprido positivo em 25.09.15 e juntado na mesma data. Contestação juntada em 14.10.15. Em 11.02.16, os autos foram conclusos para despacho. Em 16.02.16, foi determinada a manifestação doa autor sobre a contestação apresentada e intimadas as partes a especificarem as provas que pretendem produzir. Nossa réplica foi juntada aos autos em 29.02.16.Ingressamos com petição em 02.06.16 requerendo o julgamento procedente com condenação de sucumbência, tendo em vista a entrega das chaves.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1005332-73.2015.8.26.0011</Numero>
				<Juizo>2ª Vara Cível, Foro Regional de Pinheiros, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-06-02</DataInstauracao>
				<ValorCausa>92144.74</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Adriano dos Reis Souza Júnior e outros</PartesProcesso>
				<PrincipaisFatos> Ação de execução de título executivo extrajudicial (cobrança de aluguéis e demais encargos da locação). Ingressamos com petição em 07.08.15 indicando novos endereços para citação e intimação por hora certa do Executado Adriano Reis, bem como citação e intimação das Executadas Thalia e Camila. Mandado devolvido cumprido negativo em 08.10.15. Em 27.10.15, foi proferido despacho intimando o Exequente a se manifestar no prazo de 30 dias. Em 09.12.15, foi proferido despacho intimando os Exequentes a se manifestarem sobre os mandados devolvidos sem cumprimento. Em 18.12.15, protocolamos petição requerendo citação por hora certa do Executado Adriano dos Reis (juntando custas) e expedição de Carta Precatória para citação das Executadas Thaila Vieira e Camila Vieira. Em 11.01.16, foi expedida Carta Precatória para citação, penhora e avaliação e expedido Mandado de Citação. Em 13.01.16, foi proferido despacho informando que foi expedida Carta Precatória à Comarca de Taboão da Serra, devendo o exequente instruí-la com as principais peças e comprovar sua distribuição no prazo legal. Em 19.01.16, comprovamos a distribuição da Carta Precatória à Comarca de Taboão da Serra, a qual foi juntada em 21.01.16. Em 23.02.16, foi juntado mandado cumprido negativo. Em 24.02.16, o juiz determinou a manifestação dos Exequentes sobre a certidão negativa relativa ao coexecutado Adriano no prazo legal. Em 03.03.16, foi juntado aos autos nosso pedido de citação por hora certa do Coexecutado. Em 07.03.16, foi proferido despacho determinando a complementação das custas recolhidas pelo exequente. Em 16.03.16, protocolamos petição recolhendo custas complementares. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1005371-70.2015.8.26.0011</Numero>
				<Juizo>2ª Vara Cível, Foro Regional de Pinheiros, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-06-02</DataInstauracao>
				<ValorCausa>36480.73</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Adriano dos Reis Souza Júnior e outros</PartesProcesso>
				<PrincipaisFatos> Ação de execução por quantia certa. Ingressamos com petição de 07.08.15 indicando novo endereço para citação e intimação por hora certa do Executado Adriano Reis. Em 26.08.15, protocolamos petição requerendo citação e intimação das Executadas,  com os benefícios do art. 172, §2°, uma vez que o próprio oficial de justiça certificou que as Executadas residem no endereço. Mandado devolvido cumprido negativo em 01.10.15. Em 06.11.15, proferido despacho intimando o Exequente a se manifestar sobre o não cumprimento do mandado. Em 16.11.15, protocolamos petição requerendo a citação e intimação por hora certa das executadas, tendo em vista provável suspeita de ocultação. Houve juntada de ARs positivos em 19.11.15 e 27.11.15 e, em 19.11.15 e 25.11.15, foram expedidos mandados aditados. Em 12.01.16, foi expedida certidão do Oficial de Justiça informando que o mandado expedido em 25.11.15 foi cumprido negativo. Na mesma data, foi proferido despacho determinando ciência ao exequente da certidão negativa, para que se manifeste no prazo legal. Em 19.01.16, foi juntado AR positivo, referente à citação da BTG Pactual. Em 01.02.16, protocolamos petição requerendo a citação e intimação por hora certa do executado, tendo em vista provável suspeita de ocultação. Em 04.02.16, foi expedido mandado de citação, o qual restou cumprido negativo em 22.02.16. Na mesma data, foi proferido despacho determinando a manifestação dos exequentes. Em 29.02.16, foi juntado nosso novo pedido de citação por hora certa do executado. Em 04.03.16, foi proferido despacho determinando o desentranhamento e aditamento do mandado. Em 06.06.16 ingressamos com petição requerendo o aditamento do mandado. Em 08.03.16, o mandado foi expedido.  Ingressamos com petição requerendo pesquisa bacenjud para Adriano e indicando novos endereços para Camila e Thaila, em 29.08.16.Deferido. No momento, aguarda-se expedição de cartas e realização de pesquisa Bacenjud.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1013018-09.2016.8.26.0100</Numero>
				<Juizo>6ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-02-12</DataInstauracao>
				<ValorCausa>216280.42</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Q1 Comercial de Roupas S.A. ("Upper")
Alvaro Jabour Maluf Junior</PartesProcesso>
				<PrincipaisFatos>Pagamento das verbas locatícias em atraso, derivadas de Contrato de Locaçãode Espaço Comercial e Outras Avenças Em 12.02.16, distribuímos a petição inicial. Em 08.03.16, foi proferida decisão determinando que o Exequente recolha as custas necessárias à citação da empresa executada. Em 16.03.16, protocolamos petição juntando custas para realização de citação da executada pelo oficial de justiça.  Em 28.07.16 ingressamos com petição indicando novo endereço.Ingressamos com petição em 23.05.16 informando que as custas, para cumprimento de citação da empresa executada já foram recolhidas às fls. 52/54. Outrossim, requer a desistência da expedição de CP para a Comarca do Guarujá, tendo em vista já ter sido cumprida negativa em outro processo, que tramita na 7° vara cível da comarca de Santos, sob o n° 1033421-05.2015.8.26.0562, o qual o executado Álvaro também figura como parte. Assim, em atenção ao princípio da celeridade e economia processual, informa que aguardará a tentativa de citação deste Executado, no processo supracitado e, após, indicará novo endereço para citação dele nestes autos. Em 28.07.16 ingressamos com petição indicando novo endereço</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1039484-90.2015.8.26.0224</Numero>
				<Juizo>8ª Vara Cível, Foro de Guarulhos, Guarulhos, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-11-25</DataInstauracao>
				<ValorCausa>188836.05</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Westzushi Restaurante Ltda. - ME (Kame Sushi)</PartesProcesso>
				<PrincipaisFatos>Pagamento das verbas locatícias em atraso, derivadas de Contrato de Locaçãode Espaço Comercial e Outras Avenças Em 25.11.15, protocolamos petição instaurando a Execução. Em 18.01.16, foi proferida decisão determinando que o Shopping esclareça o motivo para proposição da demanda na Comarca de Guarulhos. Em 02.02.16, protocolamos petição esclarecendo as razões para proposição da demanda em tal Comarca. Autos foram conclusos para decisão em 17.03.16.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1021715-19.2016.8.26.0100 </Numero>
				<Juizo>6ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-03-04</DataInstauracao>
				<ValorCausa>639628.2</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Q1 Comercial de Roupas S.A. , Álvaro Jabour Maluf Junior</PartesProcesso>
				<PrincipaisFatos>Pagamento das verbas locatícias em atraso, derivadas de Contrato de Locaçãode Espaço Comercial e Outras Avenças Em 04.03.16, distribuímos a petição inicial. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1039235-89.2016.8.26.0100</Numero>
				<Juizo>23ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-04-19</DataInstauracao>
				<ValorCausa>467805.4</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shopping Center S.A. X Tex Barreds Moda Ltda. e outos</PartesProcesso>
				<PrincipaisFatos>Execução Ação de cobrança de encargo locatício</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0108181-19.2005.8.26.0100 </Numero>
				<Juizo>2ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>2ª Instância</Instancia>
				<DataInstauracao>2005-09-29</DataInstauracao>
				<ValorCausa>30000</ValorCausa>
				<PartesProcesso>Marcelo Carezzato                                  X Condomínio Shopping Paulista ( não consta Fundo de Investimento Imobiliário West Plaza )    
IRB Brasil Resseguros S.A. </PartesProcesso>
				<PrincipaisFatos>Indenização por danos morais 29/11/2011 - Sentença: "Pelo exposto, JULGO PROCEDENTE o pedido da lide principal e o faço para condenar o Réu Plaza Paulista a pagar ao Autor indenização no valor de R$ 207.949,96, a título de danos materiais e lucros cessantes, atualizada desde o ajuizamento da ação pela tabela prática do E. Tribunal de Justiça e acrescida de juros de mora de 1% ao mês, contados da citação. Condeno também o Réu a pagar ao Autor indenização no valor de R$ 5.000,00 a título de danos morais, atualizada desde esta data (verbete 362 da súmula do Superior Tribunal de Justiça) conforme cálculo supra. Sucumbente, arcará o Réu Plaza com as custas processuais e honorários advocatícios do patrono do Autor, arbitrados em 10% do valor da condenação de sua condenação"
30/11/2012 - Proferida decisão determinando a manifestação em contrarrazões ao Recurso Adesivo.
03/12/2012 - Protocolizada contrarrazões ao Recuso Adesivo.
30/06/2014 - Aguardando o julgamento do recurso.
30/09/2014 - Movimentação processual inalterada.
29/06/2015 - Protocolizada contrarrazões ao Recuso Adesivo. 31/07/2015 - Proferido acórdão negando provimento aos recursos interpostos. Em 22/09/2015, proferida decião negando provimento aos Embargos opostos. 03/06/2016 - Recursal.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>Risco em condenação que determine ao réu o pagamento de valoures ou o cumprimento de obrigações de fazer, não fazer e outras  pleiteados na inicial, com a consequente condenação em custas e honorários advocatícios.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1039139-74.2016.8.26.0100</Numero>
				<Juizo>43ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-04-19</DataInstauracao>
				<ValorCausa>181960.07</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shooping Center S.A. X Ridar Mooca - Comércio de Roupas e Acessórios Eireli – EPPe outro</PartesProcesso>
				<PrincipaisFatos>Execução Ação de cobraça para pagamento das verbas locatícias em atraso, derivadas de Contrato de Locaçãode Espaço Comercial e Outras Avenças. Em 28.06.16 requeremos remessa dos autos ao Foro de Santo Amaro.  Processo redistribuído. Aguarda-se expedição de carta de citação.Juiz determinou em despacho de 25.11.16, a pesquisa de endereços da empresa Executada via BACENJUD e INFOJUD, mediante juntada de custas, o que cumprimos em 05.12.16.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1058313-69.2016.8.26.0100</Numero>
				<Juizo>37ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-08</DataInstauracao>
				<ValorCausa>675390.51</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shooping Center S.A. X Westcoffee Cafés e Sorvetes Gourmet Ltda. – EPP e outros</PartesProcesso>
				<PrincipaisFatos>Execução Pagamento das verbas locatícias em atraso, derivadas do Contrato de Locação.Citação realizada, mas restaram negativas. Ingressamos com petição em 07.11.16 requerendo a citação postal e indicando endereços.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1064085-13.2016.8.26.0100</Numero>
				<Juizo>25ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-23</DataInstauracao>
				<ValorCausa>161160.03</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shooping Center S.A. X Drogarias Qualipharma Ltda. – ME e outros </PartesProcesso>
				<PrincipaisFatos>Execução Ação de execução para cobrança das verbas locatícias em atraso decorrente do contrato de locação</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1064105-04.2016.8.26.0100</Numero>
				<Juizo>25ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-23</DataInstauracao>
				<ValorCausa>32965.04</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shooping Center S.A. X Drogarias Qualipharma Ltda - ME e outros</PartesProcesso>
				<PrincipaisFatos>Execução Pagamento de multa em razão das verbas locatícias em atraso, derivadas do Contrato de Locação</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1065688-24.2016.8.26.0100</Numero>
				<Juizo>22ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-28</DataInstauracao>
				<ValorCausa>326479.68</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, Alliansce Shooping Center S.A.
 X Empório da Gravata Ltda. - ME</PartesProcesso>
				<PrincipaisFatos>Execução Ação de cobraça para pagamento das verbas locatícias em atraso, derivadas de Contrato de Locaçãode Espaço Comercial e Outras Avenças</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1007455-68.2015.8.26.0100</Numero>
				<Juizo>6ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-01-28</DataInstauracao>
				<ValorCausa>124114.92</ValorCausa>
				<PartesProcesso>Big Star SWP Comércio de Alimentos Ltda. - EPP X Brookfield Brasil Shopping Centers Ltda., Fundo de Investimento Imobiário - FII Shopping West Plaza, IRB - Brasil Resseguros S.A.</PartesProcesso>
				<PrincipaisFatos>Renovação do Contrato Atípico de Locação Comercial e Instrumento de Transferência e Cessão de Direitos e Obrigações, com pagamento dos alugueres no valor  e nas condições fixadas na exordial  Ação renovatória de locação comercial. Apresentamos a defesa em 26.10.2015. Em 25.11.15, foi proferido despacho determinando que o autor se manifeste sobre a contestação e documentos de fls. 111/200. Em 10.12.15, houve juntada de réplica. Em 08.01.16, os autos foram conclusos para decisão. Na mesma data, foi proferida decisão determinando que as partes especificassem as provas que pretendiam produzir no prazo de 10 dias, e informassem se possuíam interesse na realização de audiência de conciliação, sem prejuízo da possibilidade de julgamento antecipado da lide. Em 27.01.16, protocolamos petição especificando provas (perícia de engenharia) e manifestando desinteresse na designação de audiência conciliatória. Em 02.02.16, houve juntada da petição.  Em 01.03.16, foi proferida sentença homologando a renovação do contrato de locação nos termos acordados entre as partes e julgando extinto o feito.  Em 09.03.16, opusemos embargos de declaração em face da sentença. Embargos foram rejeitados. Protocolamos apelação em 12.04.2016. Parte contrária apresentou contrarrazões. Aguarda-se remessa à 2ª Instância. Autos remetidos à 2ª Instância. No momento, aguarda-se data pra julgamento.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>Classe de demanda que, em princípio, tem como consequência a continuidade da locação e a definição do novo valor de aluguel.</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>1105211-77.2015.8.26.0100</Numero>
				<Juizo>27ª Vara Cível, Foro Central, São Paulo, SP</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-10-14</DataInstauracao>
				<ValorCausa>93309.25</ValorCausa>
				<PartesProcesso>Brookfield Brasil Shopping Centers Ltda. 
Shopping West Plaza (Fundo de Investimento Imobiliário) X Kingster Comércio de Acessório e Vestuário EIRELLI (EPP)</PartesProcesso>
				<PrincipaisFatos>Execução Ação de execução para pagamento das verbas locatícias em atraso, derivadas do Contrato de Locação de Espaço Comercial e seu aditamento, com aplicação de multa, juros e penalidades contratuais</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
			<Processo>
				<Numero>0113254-25.2012.8.26.0100</Numero>
				<Valores>193601.3</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1105211-77.2015.8.26.0100</Numero>
				<Valores>93309.25</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1007455-68.2015.8.26.0100</Numero>
				<Valores>124114.92</Valores>
				<CausaContingencia>Classe de demanda que, em princípio, tem como consequência a continuidade da locação e a definição do novo valor de aluguel.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1065688-24.2016.8.26.0100</Numero>
				<Valores>326479.68</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1064105-04.2016.8.26.0100</Numero>
				<Valores>32965.04</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1064098-12.2016.8.26.0100</Numero>
				<Valores>5123.33</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1064085-13.2016.8.26.0100</Numero>
				<Valores>161160.03</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1058313-69.2016.8.26.0100</Numero>
				<Valores>675390.51</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1039139-74.2016.8.26.0100</Numero>
				<Valores>181960.07</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0108181-19.2005.8.26.0100</Numero>
				<Valores>30000</Valores>
				<CausaContingencia>Risco em condenação que determine ao réu o pagamento de valoures ou o cumprimento de obrigações de fazer, não fazer e outras  pleiteados na inicial, com a consequente condenação em custas e honorários advocatícios.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1039235-89.2016.8.26.0100</Numero>
				<Valores>467805.4</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1021715-19.2016.8.26.0100</Numero>
				<Valores>639628.2</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1039484-90.2015.8.26.0224</Numero>
				<Valores>188836.05</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1013018-09.2016.8.26.0100</Numero>
				<Valores>216280.42</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1109861-70.2015.8.26.0100</Numero>
				<Valores>14920.53</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1005371-70.2015.8.26.0011</Numero>
				<Valores>36480.73</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1005332-73.2015.8.26.0011</Numero>
				<Valores>92144.74</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1047318-31.2015.8.26.0100</Numero>
				<Valores>149553.84</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1088230-07.2014.8.26.0100</Numero>
				<Valores>27291.6</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1126532-08.2014.8.26.0100</Numero>
				<Valores>233105.22</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1126409-10.2014.8.26.0100</Numero>
				<Valores>42007.68</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0078933-98.2011.8.26.0002</Numero>
				<Valores>37372.59</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1015949-70.2016.8.26.0007</Numero>
				<Valores>11901.46</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1095933-18.2016.8.26.0100</Numero>
				<Valores>128725.72</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1080082-36.2016.8.26.0100</Numero>
				<Valores>198899.77</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1001040-23.2016.5.02.0013</Numero>
				<Valores>40739</Valores>
				<CausaContingencia>Em princípio, não há impacto direto no fundo imobiliário.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1014885-71.2015.8.26.0100</Numero>
				<Valores>819654.84</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1056060-79.2014.8.26.0100</Numero>
				<Valores>51674.52</Valores>
				<CausaContingencia>Não há risco de perda financeira, apenas de se ter de aceitar valor consignado pela autora nos autos.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1085829-35.2014.8.26.0100</Numero>
				<Valores>61556.76</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1069270-03.2014.8.26.0100</Numero>
				<Valores>55884.62</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1032805-95.2014.8.26.0002</Numero>
				<Valores>14273.97</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1032806-80.2014.8.26.0002</Numero>
				<Valores>61484.67</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1032808-50.2014.8.26.0002</Numero>
				<Valores>56488.65</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1063030-95.2014.8.26.0100</Numero>
				<Valores>32742.06</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1046599-83.2014.8.26.0100</Numero>
				<Valores>36949.25</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1006284-19.2014.8.26.0001</Numero>
				<Valores>67274.14</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1006286-86.2014.8.26.0001</Numero>
				<Valores>123364.8</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>019/1.13.0016104-0</Numero>
				<Valores>0</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping busca habilitação de crédito em autos de recuperação judicial.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1083274-79.2013.8.26.0100</Numero>
				<Valores>52364.04</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>1016736-19.2013.8.26.0100</Numero>
				<Valores>108511.08</Valores>
				<CausaContingencia>Classe de demanda que, em princípio, tem como consequência a continuidade da locação e a definição do novo valor de aluguel.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0105865-86.2012.8.26.0100 (583.00.2012.105865-0)</Numero>
				<Valores>36737.88</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0005531-10.2013.8.26.0100</Numero>
				<Valores>Preencher</Valores>
				<CausaContingencia>Sem contingência, Fundo no pólo ativo</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>183200900802000</Numero>
				<Valores>25000</Valores>
				<CausaContingencia>De acordo com informação do escritório responsável, a indicação de risco é baseada na atualização do valor atribuído a sentença/acórdão.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>*01138008020095020043</Numero>
				<Valores>95000</Valores>
				<CausaContingencia>De acordo com andamento do escritório, demanda tende a ser arquivada. De todo modo, não há, em princípio, impacto direto para o fundo imobiliário.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>*01537200702602003</Numero>
				<Valores>30000</Valores>
				<CausaContingencia>De acordo com andamento do escritório, demanda tende a ser arquivada. De todo modo, não há, em princípio, impacto direto para o fundo imobiliário.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0108798-03.2010.8.26.0100</Numero>
				<Valores>128577.84</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0174150-68.2011.8.26.0100</Numero>
				<Valores>540490.29</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0106974-38.2012.8.26.0100</Numero>
				<Valores>34093.65</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0078935-68.2011.8.26.0002</Numero>
				<Valores>196285.92</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0185183-55.2011.8.26.0100 (583.00.2011.185183-3)</Numero>
				<Valores>130574.4</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0020359-42.2012.8.26.0004</Numero>
				<Valores>15018.52</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0208663-96.2010.8.26.0100 
0208663-96.2010.8.26.0100)</Numero>
				<Valores>24788.41</Valores>
				<CausaContingencia>Em princípio, sem contingência passiva, na medida em que Fundo/Condomínio do Shopping/Seus antecessores não estão no pólo passivo da demanda. Custas e Honorários Advocatícios podem ser considerados devidos em caso de julgamento à favor do réu/executado.</CausaContingencia>
			</Processo>
			<Processo>
				<Numero>0185876-10.2009.8.26.0100 
0043636-85.2015.8.26.0100)</Numero>
				<Valores>614469.29</Valores>
				<CausaContingencia>Classe de demanda que, em princípio, tem como consequência a continuidade da locação e a definição do novo valor de aluguel.</CausaContingencia>
			</Processo>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida Brigadeiro Faria Lima, 3477 - 14º andar - Itaim Bibi - São Paulo/SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>Os documentos relativos à Assembleia Geral estarão disponíveis nas filiais do Administrador bem como no site da Bovespa e do Banco BTG Pactual conforme endereços abaixo:
http://www.bmfbovespa.com.br/pt_br/produtos/listados-a-vista-e-derivativos/renda-variavel/fundos-de-investimentos/fii/fiis-listados/
https://www.btgpactual.com/home/asset-management/fundos-btg-pactual</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Disponibilizamos aos cotistas o endereço de e-mail abaixo para solicitações referentes as assembleias bem como dúvidas em geral:
Sh-contato-fundoimobiliario@btgpactual.com</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>(i) O cotista é apto ao voto caso conste da base de cotistas na data da convocação da AGC. No dia da AGC, a qualidade de cotista é comprovada através de documento de identificação com foto (RG, RNE, CNH) para PF. No caso da PJ, é exigido (1)Cópia autenticada do último estatuto ou contrato social consolidado e da documentação societária outorgando poderes de representação (ata de eleição dos diretores e/ou procuração com firma reconhecida);(2)Documento de identificação com foto do(s) representante(s) legal(is);(c) no caso de Fundos de Investimento é exigido (1)Cópia autenticada do último regulamento consolidado do fundo e estatuto social do seu administrador, além da documentação societária outorgando poderes de representação (ata de eleição dos diretores e/ou procuração); (2)Documento de identificação com foto do(s) representante(s) legal(is); (d)caso o Cotista seja representado, o procurador deverá estar munido de procuração válida, com poderes específicos e firma reconhecida pelo cotista outorgante. Adotamos, ainda, o procedimento de verificar a Base de cotistas antes da assembleia buscando identificar possíveis cotistas impedidos de votar para que possamos informar caso estejam presentes na AGC. Adicionalmente, iniciamos questionando se algum cotista presente se considera conflitado. Ainda relacionado a plateia, caso exista um convidado de cotista ou outro presente apenas telespectador, solicitamos aos cotistas presentes autorização para que o mesmo assista a AGC. Previamente ainda, verificamos se o Fundo possui representantes de cotistas eleitos para que possamos identificá-los. 
(ii)  Quando previsto em regulamento, é possível a realização de consultas formais. Tais consultas são realizadas por meio do envio de uma carta consulta para toda a base de cotistas, na qual consta a exposição do Administrador sobre os itens a serem deliberados, data limite para manifestação do voto, prazo para apuração dos votos e orientação sobre o envio da manifestação bem como documentos que devem ser anexados. Além disso, segue uma carta resposta modelo com os itens em deliberação, campo para voto e itens para preenchimento de dados do cotistas e assinatura. Estabelecemos um mínimo de 5 dias após o prazo final para apuração dos votos dos cotistas que postaram seus votos dentro do prazo mas que por algum motivo tenham demorado um pouco mais para chegar até a Administradora. 
(iii) Para AGCs não realizamos o operacional de participação à distância, uma vez que tais procedimentos ainda não estão previstos no regulamento do Fundo e as entidades nas quais as cotas do Fundo estão registradas ainda não disponibilizaram sistemas e operacionais para tanto. Caso o cliente deseje, pode fornecer procuração concedendo a um procurador, ou mesmo à Administradora, o direito de exercer seu voto em Assembleia presencial, sendo certo que de tal procuração pode constar expressa a declaração de voto do cotista (o que no caso de procurações à Administradora é mandatório).</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não realizamos assembleias por meio eletrônico para os fundos imobiliários dado que entendemos que não é do perfil de grande parte dos cotistas que acabariam prejudicados pelo modelo eletrônico</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>A ADMINISTRADORA receberá por seus serviços uma taxa de administração composta de: (a) valor equivalente a 0,250% (duzentos e cinqüenta milésimos por cento) à razão de 1/12 avos, aplicados sobre o valor total dos ativos que integrarem o patrimônio do FUNDO vigente no último dia útil do mês anterior, observado o valor mínimo de R$ 15.000,00 (quinze mil reais), valor este que será corrigido anualmente pela variação do IGP-M (Índice Geral de Preços de Mercado), apurado e divulgado pela Fundação Getúlio Vargas – FGV, e que deverá ser pago diretamente ao Administrador; e (b) o valor variável aproximado de R$ 5000,00 (cinco mil reais), correspondente aos serviços de escrituração das cotas do FUNDO, incluído na remuneração do Administrador a ser pago a terceiros, nos termos dos artigos 17, §5º e 51, §2º deste regulamento.
§ 1º - A taxa de administração será calculada e paga a ADMINISTRADORA mensalmente, por período vencido, até o 5º (quinto) dia útil do mês subsequente ao mês em que os serviços forem prestados.
§ 2º - O valor integrante da taxa de administração correspondente à escrituração de cotas do FUNDO descrito na letra (b) do caput da presente, poderá variar em função da movimentação de cotas e quantidade de cotistas que o FUNDO tiver, sendo que nesta hipótese, o valor da taxa
de administração será majorado em imediata e igual proporção à variação comprovada da taxa de escrituração.</PoliticaRemuneracao>
			<ValorPagoAno>299459.34</ValorPagoAno>
			<PercentPatrimonioContabil>0.003842</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.004036</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>Allan Hadid</Nome>
				<Idade>41 anos</Idade>
				<CPF>071.913.047-66</CPF>
				<Email>ol-reguladores@btgpactual.com</Email>
				<Profissao>Economista</Profissao>
				<FormacaoAcademica>Graduado em ciências econômicas pela Pontifícia Universidade Católica do Rio de Janeiro em dezembro de 1997. Certificado como CFA (Chartered Financial Analyst), certificado de distinção do mercado financeiro.</FormacaoAcademica>
				<DataInicioFuncao>2016-09-29</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Banco BTG Pactual S.A</NomeEmpresa>
						<Periodo>De julho de 2014 até hoje</Periodo>
						<CargoFuncoes>Ingressou como partner no Banco BTG Pactual S.A. na posição de COO (Chief Operations Officer) da área de Merchant Banking e, atualmente, ocupa o cargo de COO (Chief Operations Officer) da área de Global Asset Management</CargoFuncoes>
						<AtividadePrincipalEmpresa>Atualmente, ocupa o cargo de COO (Chief Operations Officer) da área de Global Asset Management.</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>BRZ Investimentos</NomeEmpresa>
						<Periodo>De junho de 2011 até junho de 2014</Periodo>
						<CargoFuncoes>CEO (Chief Executive Officer)</CargoFuncoes>
						<AtividadePrincipalEmpresa>Atuou na área de gestão de recursos</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não há</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não há</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="701" numCotasDetidas="395941" percDetidoRelTotal="0.4002" percDetidoPF="0.3698" percDetidoPJ="0.0304"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento numCotistas="2" numCotasDetidas="257090" percDetidoRelTotal="0.2599" percDetidoPF="0" percDetidoPJ="0.2599"/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="1" numCotasDetidas="336308" percDetidoRelTotal="0.3399" percDetidoPF="0" percDetidoPJ="0.3399"/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>De acordo com o previsto na IN CVM 472 nossa política de divulgação define prioritariamente como fato relevante eventos significativos de vacância que possam representar 5% ou mais da Receita do Fundo na data da divulgação. Para outras situações, todas são devidamente analisadas para que se confirme se devem ou não ser classificadas como um fato relevante e consequentemente serem divulgadas de acordo com nossa política.
A divulgação é feita antes da abertura ou depois do fechamento do mercado através dos seguintes canais:
http://www.bmfbovespa.com.br/pt_br/produtos/listados-a-vista-e-derivativos/renda-variavel/fundos-de-investimentos/fii/fiis-listados/
https://www.cvm.gov.br/menu/regulados/fundos/consultas/fundos/fundos.html
https://www.btgpactual.com/home/asset-management/fundos-btg-pactual</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>https://www.btgpactual.com/home/asset-management/fundos-btg-pactual</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.btgpactual.com/home/asset-management/fundos-btg-pactual</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Bruno Duque Horta Nogueira</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Será de acordo com estabelecido em Assembleia Geral Extraordinária respeitando as regras do regulamento.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"