"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</NomeFundo>
		<CNPJFundo>22957521000174</CNPJFundo>
		<DataFuncionamento>2016-12-20</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN>BRPRTSCTF002</CodigoISIN>
		<QtdCotasEmitidas>55727500</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Determinado</PrazoDuracao>
		<DataPrazoDuracao>2036-12-20</DataPrazoDuracao>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>true</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>MAF DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS S.A.</NomeAdministrador>
		<CNPJAdministrador>22957521000174</CNPJAdministrador>
		<Logradouro>PRAIA DE BOTAFOGO</Logradouro>
		<Numero>501</Numero>
		<Complemento>5 ANDAR - TORRE PÃO DE AÇÚCAR</Complemento>
		<Bairro>BOTAFOGO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22250040</CEP>
		<Telefone1>2132237700</Telefone1>
		<Telefone2>2132237746</Telefone2>
		<Telefone3 xsi:nil="true"/>
		<Site>www.mafdtvm.com.br</Site>
		<Email>FUNDOS.MODAL@MODAL.COM.BR</Email>
		<Competencia>2021-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>MODAL ADMINISTRADORA DE RECURSOS LTDA.</Nome>
				<CNPJ>1116811000115</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO, 501 - 5º ANDAR - PARTE, BLOCO 1, RIO DE JANEIRO</Endereco>
				<telefone>2132237700</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO MODAL S.A.</Nome>
				<CNPJ>30723886000162</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO, 501 - 5º ANDAR - PARTE, BLOCO 1, RIO DE JANEIRO</Endereco>
				<telefone>2132237700</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KPMG AUDITORES INDEPENDENTES</Nome>
				<CNPJ>57755217000129</CNPJ>
				<Endereco>R Dr Renato Paes De Barros, 62</Endereco>
				<telefone>1137361000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>-</Nome>
				<CNPJ>-</CNPJ>
				<Endereco>-</Endereco>
				<telefone>-</telefone>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>-</Nome>
				<CNPJ>-</CNPJ>
				<Endereco>-</Endereco>
				<telefone>-</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>-</Nome>
				<CNPJ>-</CNPJ>
				<Endereco>-</Endereco>
				<telefone>-</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Fundo realizou a integralização de Créditos de Recebíveis Imobiliários no valor de R$ 47.025.000,00 e para garantia do instrumento de capitalização em questão, o credor obteve Shoppings situados na Região Sul do país e, consequentemente, a rentabilidade do Fundo está associada a esse setor econômico. Foi realizado investimentos de Capex (APPCI) em cada um dos ativos ao longo dos anos de forma a arcar com a exigência dos bombeiros para correto funcionamento dos ativos que estão dentro do fundo. Toda parte estrutural do shopping era revisada anualmente. Assim como o Capex para a entrada de novas negócios que são negociados juntamente com os novos entrantes. Fundo encerrou o ano sem esses ativos, sendo eventuais novas adequações de compromisso do novo proprietário.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O resultado do Fundo está predominantemente relacionado ao ajuste a valor justo das propriedades para investimento que possui.</ResultadoFundo>
			<ConjunturaEconomica>Desde meados dos anos 90, os shoppings centers instalados no Brasil estão passando por uma readequação de layout, incluindo novas configurações que auxiliam na demanda para o consumo, considerando-se os novos conceitos de empreendimentos empregados no Brasil. 
A indústria de Shopping Centers no Brasil, fechou o ano de 2021 com um total de 620 shoppings centers. A perspectiva para 2022 é a inauguração de 13 novos empreendimentos. 
Indústria encerrou o ano com os seguintes dados, segundo a Abrasce:
Área Bruta Locável - 17 milhões/m²
Faturamento - R$ 159.2 billhões
Empregos Gerados - 1.02 milhão
Visitantes/mês - 397 milhões
Total de Lojas - 112,738
Salas de Cinema - 3,019
Vagas para Carro - 1,018,210</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Trabalhar para distribuição dos valores em caixa junto aos cotistas do fundo.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>O Fundo encontra-se  em processo de encerramento em 31/12/2021 não havendo imóveis registrados em carteira.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>0020010-94.2018.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>3100</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A.</PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de 01 DE MARÇO DE 2014, para desempenhar a função de CAMAREIRA tendo sido demitida sem justo motivo em 25 DE SETEMBRO DE 2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00200134620185040812</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>3400</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A.</PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de 15 de Agosto de 2010 para desempenhar a função de servente, tendo sido demitido sem justo motivo em 25 DE SETEMBRO DE 2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>00200109120185040812</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>16450</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A.</PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de 29 de Agosto de 1986, a 25 de setembro de 2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020007-42.2018.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>9000</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A.</PartesProcesso>
				<PrincipaisFatos>Move ação em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBOLMALLlS ADMINISTRAÇÃO DE SHOP CENTER, ÁPICE SECURITIZADORA, Alega que laborou de 02 DE JUNHO DE 2008 a 25 DE SETEMBRO DE 2017. Pleiteia  Complementação dos depósitos do FGTS inclusive com a incidência nas parcelas rescisórias e a íntegra da multa de 40%. Realizada audiência e apresentada defesa.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020008-24.2018.5.04.0812</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-10-31</DataInstauracao>
				<ValorCausa>5000</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A.</PartesProcesso>
				<PrincipaisFatos>Move ação em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBOLMALLlS ADMINISTRAÇÃO DE SHOP CENTER, ÁPICE SECURITIZADORA, Alega que laborou de 24 de março de 2015 a 31 de outubro de 2017. Pleiteia  Complementação dos depósitos do FGTS inclusive com a incidência nas parcelas rescisórias e a íntegra da multa de 40%. Realizada audiência e apresentada defesa. Processo julgado procedente para condenar as reclamadas ao pagamento das diferenças de FGTS, considerando a revelia das reclamadas em audiência (ocorrida apenas em relação a City Hoteis e Globalmalls, Ápice corretamente representada em audiência). Opusemos embargos de declaração para sanear o erro material relativo a revelia e da omissão quanto a documentação juntada com a defesa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>5000</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020009-12.2018.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>2000</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A., </PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de 1º de março de 2010 a 25 DE SETEMBRO DE 2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Sentença JULGOU IMPROCEDENTES OS PEDIDOS formulados por LEONARDO VIEIRA RODRIGUES SILVEIRA em face de APICE SECURITIZADORA S/A e PROCEDENTES os formulados em face de CITY HOTÉIS ADMINISTRAÇÃO S/A e GLOBALMALLS  PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A para CONDENAR as reclamadas a PAGAREM, sendo que a segunda de forma subsidiária, as seguintes parcelas: a) diferenças relativas aos depósitos mensais ao FGTS; e b) multa de 40% do FGTS. Não houve recurso do reclamante quanto a improcedência da ação face a Àpice. Sentença já transitada em julgado.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020011-76.2018.5.04.0812 </Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>6000</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A., </PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de 20 de fevereiro de 2014, demitida em 25 de setembro de 2017 sem justo motivo, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa. Processo julgado procedente para condenar as reclamadas ao pagamento das diferenças de FGTS, considerando a revelia das reclamadas em audiência (ocorrida apenas em relação a City Hoteis e Globalmalls, Ápice corretamente representada em audiência). Opusemos embargos de declaração para sanear o erro material relativo a revelia e da omissão quanto a documentação juntada com a defesa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>6000</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020012-61.2018.5.04.0812</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>6000</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A., </PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de 1º de maio de 2013 para desempenhar a função de recepcionista tendo sido demitida sem justo motivo em 25 DE SETEMBRO DE 2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa. Processo julgado procedente para condenar as reclamadas ao pagamento das diferenças de FGTS, considerando a revelia das reclamadas em audiência (ocorrida apenas em relação a City Hoteis e Globalmalls, Ápice corretamente representada em audiência). Opusemos embargos de declaração para sanear o erro material relativo a revelia e da omissão quanto a documentação juntada com a defesa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>6000</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020065-42.2018.5.04.0812</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>18000</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A., </PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de foi admitido pelo empreendimento reclamado no dia 01/03/2005, e dispensado sem justo motivo, no dia 25/09/2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa. Processo julgado procedente para condenar as reclamadas ao pagamento das diferenças de FGTS, considerando a revelia das reclamadas em audiência (ocorrida apenas em relação a City Hoteis e Globalmalls, Ápice corretamente representada em audiência). Opusemos embargos de declaração para sanear o erro material relativo a revelia e da omissão quanto a documentação juntada com a defesa.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>18000</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020348-65.2018.5.04.0812</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-11-03</DataInstauracao>
				<ValorCausa>2100</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A., </PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de foi admitido em 01 DE NOVEMBRO DE 2013, demissão em 03 DE NOVEMBRO DE 2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020349-50.2018.5.04.0812</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-11-03</DataInstauracao>
				<ValorCausa>12000</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A., </PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de foi admitido em 01 DE NOVEMBRO DE 2013, demissão em 03 DE NOVEMBRO DE 2017, pleiteia Pagamento do adicional de insalubridade no percentual apurado pelo expert nomeado com reflexos em parcelas de férias com 1/3, e 13º salários do período contratual, descansos semanais remunerados, feriados. Realizada audiência e apresentada defesa. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020363-37.2018.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>2800</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A., </PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de 16 de março de 2015 demissão em 25 de setembro de 2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020434-36.2018.5.04.0812</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>3600</ValorCausa>
				<PartesProcesso>CITY HOTEIS ADMINISTRACAO S.A., APICE SECURITIZADORA S.A.E GLOBALMALLS PARTICIPACOES E ADMINISTRACAO DE SHOPPING CENTER S.A., </PartesProcesso>
				<PrincipaisFatos>Ajuizou reclamatória trabalhista em face de CITY HOTÉIS ADMINISTRAÇÃO S/A, GLOBALMALLS PARTICIPAÇÕES E ADMINISTRAÇÃO DE SHOPPING CENTER S/A e APICE SECURITIZADORA S/A, vinculo de 1º de maio de 2013 para desempenhar a função de recepcionista tendo sido demitida sem justo motivo em 25 DE SETEMBRO DE 2017, pleiteia Complementação dos depósitos do FGTS e a íntegra da multa de 40% a incidir sobre os valores liberados e a respectiva complementação. Realizada audiência e apresentada defesa. Processo julgado procedente para condenar as reclamadas ao pagamento das diferenças de FGTS, considerando a revelia das reclamadas em audiência, preposto da Ápice sofreu acidente no dia anterior e não compareceu no ato. Opusemos embargos de declaração para sanear o erro material relativo a revelia e da omissão quanto a documentação juntada com a defesa. Sentença mantida. Interpusemos Recurso Ordinário, com recolhimento de custas e preparo, pendente de processamento.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>3600</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0000023-57.2014.5.04.0732</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>2ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>8472.81</ValorCausa>
				<PartesProcesso>CONDOMÍNIO MAX SHOPPING E OUTROS</PartesProcesso>
				<PrincipaisFatos>A executada Ápice Securitizadora S.A. opõe Embargos à Execução ao direcionamento da execução contra si, pelo reconhecimento de sucessão trabalhista EM RELAÇÃO AO Condomínio Max Shopping Center. Sentença de improcedência, mantida em segunda instancia e objeto de Recurso de Revista, cujo seguimento fora negado. Interposto Agravo de instrumento, este encontra-se pendente de processamento.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>8472.81</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020146-34.2018.5.04.0733</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>1500</ValorCausa>
				<PartesProcesso>APOIO TATICO SERVICOS LTDA - ME e CONDOMINIO DO SHOPPING GERMANI</PartesProcesso>
				<PrincipaisFatos>Ação movida em face de APOIO TATICO SERVICOS LTDA - ME e CONDOMINIO DO SHOPPING GERMANIA em razão da subcontratação de serviços de segurança privada. Julgada PROCEDENTE a ação para condenar a reclamada APOIO TÁTICO SERVIÇOS EM PARTE LTDA - ME e, em caráter subsidiário, o CONDOMÍNIO DO SHOPPING GERMÂNIA, o que segue: a) adicional de 100% sobre o trabalho realizado em feriados, com reflexos em férias com 1/3, natalinas, repousos obrigatórios e FGTS com 40%, abatidos os valores pagos a mesmo título, inclusive aquele pago na audiência; b) diferenças e adicional noturno, observada a hora reduzida noturna, com reflexos em férias com 1/3, natalinas, repousos obrigatórios e FGTS com 40%, observado que, além dos valores pagos com os recibos, também deverá ser abatido o valor pago na audiência. Iniciada a execução, foram apresentados cálculos, pendentes de homologação.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>1500</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>004/1.18.0006040-8</Numero>
				<Juizo>Ação de cancelamento de registro</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>11301.4</ValorCausa>
				<PartesProcesso>RENATO ABDALA KARAM KALIL e outros x ÁPICE SECURITIZADORA S.A, BANCO MODAL S.A. e MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</PartesProcesso>
				<PrincipaisFatos>Ação de cancelamento de registro de consolidação da propriedade e dação em pagamento. Extinto sem julgamento do mérito por falta de pagamento de custas iniciais.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>9002152-64.2018.8.21.0004</Numero>
				<Juizo>Ação Indenizatória</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>14006.81</ValorCausa>
				<PartesProcesso>ROSSANO LUIS LAZZAROTTO x MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO – FII</PartesProcesso>
				<PrincipaisFatos>Ação indenizatória por danos materiais. Ação julgada procedente. Condenação paga. Arquivado.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>1591.26</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>005/1.17.0000503-7</Numero>
				<Juizo>Ação de Reintegração de Posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>150000</ValorCausa>
				<PartesProcesso>ÁPICE SECURITIZADORA S/A x TURTLE COMÉRCIO DE LANCHES LTDA</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse de loja de uso comercial no Shopping Center Bento Gonçalves. Ação julgada procedente. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>005/1.16.0008453-9</Numero>
				<Juizo>Ação de reintegração de posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>160105.36</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII x M BLUE PARTICIPAÇÕES LTDA</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse de salas do Shopping Center Bento Gonçalves.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>005/1.17.0000502-9</Numero>
				<Juizo>Ação de Reintegração de Posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>701468.36</ValorCausa>
				<PartesProcesso>ÁPICE SECURITIZADORA S/A x BAR, RESTAURANTE E CAFÉ DA LU LTDA</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse de lojas de uso comercial do Shopping Center Bento Gonçalves.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>005/1.16.0006234-9</Numero>
				<Juizo>Cautelar Inominada</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>14122.22</ValorCausa>
				<PartesProcesso>ALDEIA SHOP INVESTIMENTOS E PARTICIPAÇÕES SOCIETARIAS LTDA e outros (M. Grupo) x ÁPICE SECURITIZADORA S/A</PartesProcesso>
				<PrincipaisFatos>Ação visando suspensão da eficácia das alienações fiduciárias dadas em garantia e de leilões extrajudiciais. Processo extinto, pois reconheceu competência da Comarca de Sâo Paulo. Arquivado.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>141/1.16.0005373-1</Numero>
				<Juizo>Ação de Reintegração de Posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>24268.06</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII x ALDEIA SHOP INVESTIMENTOS E PARTICIPAÇÕES LTDA. e CYRO SANTIAGO RODRIGUES</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse do Shopping de Xangri-Lá. : Concedida liminar para reintegrar autora na posse do imóvel, incluindo
administração, vigente até o momento.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>141/1.15.0003930-3</Numero>
				<Juizo>Ação Declaratória</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>15157.55</ValorCausa>
				<PartesProcesso>ALDEIA SHOP INVESTIMENTOS E PARTICIPAÇÕES SOCIETARIAS LTDA e outros (M. Grupo) x MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FI</PartesProcesso>
				<PrincipaisFatos>Ação de declaração de nulidade de garantias prestadas em contrato ajustado com a ré em operação financeira que originou a emissão de Cédulas de Créditos Imobiliários</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>141/1.17.0002671-0</Numero>
				<Juizo>Ação de Reintegração de Posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>30799.93</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII x DAJ GASTRONOMIA LTDA-ME</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse de loja de uso comercial. Concedida liminar pelo TJRS em julgamento do Agravo de Instrumento
n° 70075114850, determinando a reintegração de posse do imóvel pretendido pela autora. Ação julgada procedente.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.17.0000120-9</Numero>
				<Juizo>Ação Renovatória de Locação</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>23321.54</ValorCausa>
				<PartesProcesso>MARCIELI GRASEL PAULUS - ME x ÁPICE SECURITIZADORA S/A</PartesProcesso>
				<PrincipaisFatos>Ação renovatória de loja de uso comercial. Ação julgada procedente, condenando a Ápice em honorários de sucumbência.</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>3257.86</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.17.0008837-1</Numero>
				<Juizo>Ação de reintegração de posse</Juizo>
				<Instancia>2ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>29608.8</ValorCausa>
				<PartesProcesso>APICE SECURITIZADORA S/A  x MR. BEAN COMÉRCIO ALIMENTOS LTDA - ME</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse de loja de uso comercial do Shopping Germânia, Concedida liminar</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.17.0008836-3</Numero>
				<Juizo>Ação de reintegração de posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>29608.8</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII x LUCAS AUGUSTO FONTANA DO BRASIL - ME</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse de loja de uso comercial do Shopping Germânia, Ação julgada procedente.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.17.0007695-0</Numero>
				<Juizo>Ação ordinária</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>13143.74</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII x IMOBELL ADMINISTRAÇÃO DE IMÓVEIS LTDA. EM RECUPERAÇÃO JUDICIAL, ROQUE DICK, VALECAR VEÍCULOS E PEÇAS LTDA</PartesProcesso>
				<PrincipaisFatos>Ação discutindo utilização do estacionamento do imóvel vizinho ao Shopping Germânia</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>13143.74</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.17.0005519-8</Numero>
				<Juizo>Ação de reintegração de posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>30788.03</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIOS- FII x IMOBEL ADMINISTRADORA DE IMÓVEIS LTDA.</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse de loja de uso comercial do Shopping Germânia. Ação julgada procedente.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.18.0004129-6</Numero>
				<Juizo>Ação ordinária</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>26551777.92</ValorCausa>
				<PartesProcesso>IMIGRANTE EMPREENDIMENTOS IMOBILIÁRIOS LTDA "EM RECUPERAÇÃO JUDICIAL" x ÁPICE SECURITIZADORA S/A</PartesProcesso>
				<PrincipaisFatos>Ação que busca a declaração de nulidade da operação de alienação fiduciária envolvendo o imóvel referente ao Shopping Germânia.Concedida liminar  para determinar a anotação da existência da ação na matrícula n.º 10.043 do Registro de Imóveis de Santa Cruz do Sul. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>26551777.92</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.18.0005781-8</Numero>
				<Juizo>Ação anulatória</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>566357.92</ValorCausa>
				<PartesProcesso>MATEUS FALEIRO DA CUNHA e RENATA FALEIRO DA CUNHA x ÁPICE SECURITIZADORA S.A, BANCO MODAL S/A, IMIGRANTE EMPREENDIMENTOS IMOBILIÁRIOS LTDA, M INFINITY PARTICIPAÇÕES LTDA</PartesProcesso>
				<PrincipaisFatos>Ação que busca a declaração de nulidade da operação de alienação fiduciária envolvendo o imóvel referente ao Shopping Germânia. Concedida liminar para determinar a anotação da existência da ação na matrícula n.º 10.043 do Registro de Imóveis de Santa Cruz do Sul. </PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>566357.92</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.16.0010299-2</Numero>
				<Juizo>Ação de reintegração de posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>160105.36</ValorCausa>
				<PartesProcesso>ÁPICE SECURITIZADORA S/A x M INFINITY PARTICIPAÇÕES LTDA</PartesProcesso>
				<PrincipaisFatos>Ação de reintegração de posse do Shopping Germânia. Ação julgada procedente. Arquivada.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>026/1.15.0009126-3</Numero>
				<Juizo>Ação de Consignação em Pagamento</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-09-25</DataInstauracao>
				<ValorCausa>12926.8</ValorCausa>
				<PartesProcesso>ACTIO ASSESSORIA LTDA e outras x MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII e outros</PartesProcesso>
				<PrincipaisFatos>Ação de consignação de pagamento de aluguéis de lojas de uso comercial do Shopping Germânia. Ação julgada procedente, reconhecendo a legitimidade do MULTI para recebimento dos aluguéis depositados em juízo. </PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>9002093-73.2019.8.21.0026</Numero>
				<Juizo>Ação de cobrança</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-06-03</DataInstauracao>
				<ValorCausa>8550</ValorCausa>
				<PartesProcesso>JAQUELINE LUCKE x SHOPPING GERMÂNIA</PartesProcesso>
				<PrincipaisFatos>Ação de cobrança decorrete de serviço de reparo de ar condicionado no Shopping Germânia. Condenação em R$ 6.100,30 já paga. Arquivado.</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>6100.3</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>001/1.17.0051999-0        </Numero>
				<Juizo>Embargos de terceiro</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-12</DataInstauracao>
				<ValorCausa>8000000</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIÁRIO-FII x IMIGRANTE EMPREENDIMENTOS IMOBILIÁRIOS LTDA e M. Grupo</PartesProcesso>
				<PrincipaisFatos>Embargos de terceiro da anotação na matrícula n.º 10.043 do Registro de Imóveis de Santa Cruz do Sul (imóvel do Shopping Germânia).</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020718-13.2019.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-09-25</DataInstauracao>
				<ValorCausa>10000</ValorCausa>
				<PartesProcesso>City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações e Adriano Hobuss de Quadro</PartesProcesso>
				<PrincipaisFatos>Ação proposta contra City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações. Alega o reclamante ter trabalhado para a reclamada City de 15/08/2010 a 15/11/2017 na função de manutenção, prestando serviços para as demais reclamadas e ao final requer a condenação das reclamadas no pagamento de adicional de insalubridade ou periculosidade, com reflexos em férias + 1/3, 13º salário, aviso prévio, FGTS + 40%, dsr's e horas extras, totalizando R$10.000,00 . Essa é a 2ª ação trabalhista proposta pelo reclamante sobre o mesmo contrato de trabalho (processo nº 0020013-46.2018.5.04.0812)</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020717-28.2019.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-09-25</DataInstauracao>
				<ValorCausa>20000</ValorCausa>
				<PartesProcesso>City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações</PartesProcesso>
				<PrincipaisFatos>Ação proposta contra City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações. Alega o reclamante ter trabalhado para a reclamada City de 01/10/2013 a 03/11/2019 na função de recepcionista, em seguida alega que em razão do exercicio da função de manutenção de caldeira, caixa dágua e bomba de agua, prestando serviços para as demais reclamadas, requer ao final requer a condenação das reclamadas no pagamento de adicional de insalubridade ou periculosidade, com reflexos em férias + 1/3, 13º salário, aviso prévio, FGTS + 40%, dsr's e horas extras no total de R$10.000,000; horas extras pela não concessão de intervalo de alimentação e descanso de 1h com reflexos em férias + 1/3, 13º salários, FGTS +40% no valor de R$3.000,00; horas extras em razão da hora noturna reduzida no valor de R$3.000,00; diferenças salarias em razão de desvio de função de recepcionista para manutenção de bombas e caixa d' agua de R$4.000,00. Essa é a 2ª ação trabalhista proposta pelo reclamante sobre o mesmo contrato de trabalho (processo nº 0020012-61.2018.5.04.0812)</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020711-21.2019.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-09-24</DataInstauracao>
				<ValorCausa>21000</ValorCausa>
				<PartesProcesso>City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações</PartesProcesso>
				<PrincipaisFatos>Ação proposta contra City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações. Alega o reclamante ter trabalhado para a reclamada City de 29/08/1986 a 25/09/2017 na função de serviços gerais, prestando serviços para as demais reclamadas e ao final requer a condenação das reclamadas no pagamento de adicional de insalubridade ou periculosidade pelo exercicio de funções de limpeza e manutenção de caldeira, elétrica e hidraulica com reflexos em férias + 1/3, 13º salário, aviso prévio, FGTS + 40%, dsr's e horas extras no valor de R$10.000,00, requer também a condenação das reclamadas no pagamento de diferenças salárias pela integração de valor pago extra recibo no total de R$11.000,00 . Essa é a 2ª ação trabalhista proposta pelo reclamante sobre o mesmo contrato de trabalho (processo nº 0020010-91.2018.5.04.0812)</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020726-87.2019.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-09-26</DataInstauracao>
				<ValorCausa>1000</ValorCausa>
				<PartesProcesso>City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações</PartesProcesso>
				<PrincipaisFatos>Ação proposta contra City Hoteis, Multi Propoerties, Globalmalls e Magazine Incoporações. Alega a reclamante ter trabalhado para a reclamada City de 22/11/2016 a 25/10/2017 na função de secretaria, prestando serviços para as demais reclamadas, requer ao final diferenças de FGTS +40% no valor total de R$1.000,00</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0020713-88.2019.5.04.0811</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-09-24</DataInstauracao>
				<ValorCausa>24000</ValorCausa>
				<PartesProcesso>City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações</PartesProcesso>
				<PrincipaisFatos>Ação proposta contra City Hoteis, Globalmalls, Multi Properties e Magazine Incorporações. Alega o reclamante ter trabalhado para a reclamada City de 02/06/2008 a 21/11/2017 na função de serviços gerais, prestando serviços para as demais reclamadas e ao final requer a condenação das reclamadas no pagamento de adicional de insalubridade ou periculosidade pelo exercicio de funções de oficial de manutenção, instalador ihidraulico e elétrica, manutenção de caldeira, produto quimico óleo, soda caustica, pintura e limpezade limpeza e manutenção de caldeira, elétrica e hidraulica com reflexos em férias + 1/3, 13º salário, aviso prévio, FGTS + 40%, dsr's e horas extras no valor de R$10.000,00, requer também a condenação das reclamadas no pagamento de horas de sobreaviso no valor de R$6.000,00, indenização com despesas pelo seu deslocamento no valor de R$3.000,00 e pela depreciação de suas ferramentas no total de R$4.000,00 . Essa é a 2ª ação trabalhista proposta pelo reclamante sobre o mesmo contrato de trabalho (processo nº 0020007-42.2018.5.04.0811)</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0021000-42.2017.5.04.0772</Numero>
				<Juizo>Reclamatória Trabalhista</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-08-08</DataInstauracao>
				<ValorCausa>48000</ValorCausa>
				<PartesProcesso>ÁPICE, CONDOMÍNIO DO SHOPPING LAJEADO E MAGAZINE INCORPORAÇÕES</PartesProcesso>
				<PrincipaisFatos>Ação proposta contra Cond. Shop. Lajeado - 1ª reclamada, Ápice - 2ª reclamada, Magazine - 3ª reclamada, União Federal (PGF) – terceiro interessado. Alega que manteve contrato de trabalho com a 1ª reclamada de 01/04/2014 em vigor até 24/07/2017, na função de vigia. Pleiteia a rescisão indireta do contrato de trabalho com pagamento dos salários atrasados em dobro, férias e gratificações natalinas de todo período, aviso prévio, computo do período de afastamento como de serviço efetivo, férias em dobro, verbas rescisórias, recolhimento do FGTS em atraso e pagamento da multa de 40%, adicional de risco de vida, multas dos artigo 467 e 477 da CLT, honorários advocatícios. Em 25/09/2018 realizada audiência, com proposta de acordo do reclamante e do Juízo em R$15.000,00 e da 1ª reclamada de R$10.500,00. Ação julgada improcedente em relação a Ápice e parcialmente procedente com a condenação das demais reclamadas de forma solidária e declarando a rescisão indireta do contrato de trabalho em 18.09.2017 e determinando o pagamento de férias em dobro de 2014/2015 e 2015/2016, e de forma simples de 2016/2017, todas com adicional de 1/3; saldo de salários até 18.09.2017; aviso prévio indenizado, proporcional ao tempo de serviço; décimo terceiro salário de 2017 (10/12 avos), já considerada a projeção do aviso prévio; férias simples de 2016/2017 e proporcionais (7/12 avos) do período 2017/2018, todas com o terço constitucional; adicional de risco de vida de 10% sobre o salário-base, até 31.01.2017, e de 15% sobre o salário-base, a partir de 01.02.2017, conforme CBO 5174-20; multa do art. 477, § 8º da CLT, pela 1ª reclamada, recolhimento das diferenças de FGTS do contrato de trabalho, sobre as parcelas remuneratórias deferidas com a multa de 40% sobre o FGTS. Novo valor atribuído à causa de R$25.000,00 e ofício ao Ministério do Trabalho. Negado provimento aos Embargos de declaração pela 2ª reclamada. Interposto recurso ordinário pela 2ª reclamada  e pelo reclamante sendo mantida a improcedência da ação em relação à Ápice.</PrincipaisFatos>
				<ChancePerda>remota</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5006260-07.2016.04.7111 </Numero>
				<Juizo>Excecução Fiscal</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-11-08</DataInstauracao>
				<ValorCausa>43203.88</ValorCausa>
				<PartesProcesso>ÁPICE E UNIÃO FEDERAL</PartesProcesso>
				<PrincipaisFatos>Execução fiscal -  débitos relativos ao FGTS do CONDOMÍNIO MAX SHOPPING</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>43203.88</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5002888-79.2018.4.04.0711</Numero>
				<Juizo>Excecução Fiscal</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2018-05-21</DataInstauracao>
				<ValorCausa>65891.02</ValorCausa>
				<PartesProcesso>ÁPICE E UNIÃO FEDERAL</PartesProcesso>
				<PrincipaisFatos>Execução fiscal -  débitos relativos ao INSS do CONDOMÍNIO MAX SHOPPING</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>65891.02</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0010358-08.2015.8.21.0141</Numero>
				<Juizo>Declaratória</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2015-10-07</DataInstauracao>
				<ValorCausa>7765</ValorCausa>
				<PartesProcesso>ALDEIA SHOP INVESTIMENTOS E PARTICIPACOES SOCIETARIAS LTDA (AUTOR); MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (REU)</PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>7765</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0073294-33.2017.8.21.0001</Numero>
				<Juizo>Embargos de terceiro</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-05-12</DataInstauracao>
				<ValorCausa>8000000</ValorCausa>
				<PartesProcesso>APICE SECURITIZADORA SA (AUTOR); MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO-FII (AUTOR)</PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0011121-72.2016.8.21.0141</Numero>
				<Juizo>Reitegração de posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-02</DataInstauracao>
				<ValorCausa>100000</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (AUTOR); CYRO SANTIAGO RODRIGUES (REU)</PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5000527-26.2020.8.21.0026</Numero>
				<Juizo>Cumprimento de sentença</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2020-02-07</DataInstauracao>
				<ValorCausa>1799.42</ValorCausa>
				<PartesProcesso> A D V NEGOCIOS LTDA (EXEQUENTE); M INFINITY PARTICIPACOES LTDA (EXECUTADO); M RENTAL PARTICIPACOES LTDA (EXECUTADO); MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (EXECUTADO)</PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>1799.42</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5000858-13.2017.8.21.0026</Numero>
				<Juizo>Esbulho/turbação</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-07-20</DataInstauracao>
				<ValorCausa>20000</ValorCausa>
				<PartesProcesso>IMOBELL ADMINISTRACAO DE IMOVEIS LTDA (REU); TRUE SECURITIZADORA SA (AUTOR); MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (AUTOR); LETICIA </PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5000084-80.2016.8.21.0005</Numero>
				<Juizo>Esbulho/turbação</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-02</DataInstauracao>
				<ValorCausa>100000</ValorCausa>
				<PartesProcesso>M BLUE PARTICIPACOES LTDA (REU); MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (AUTOR);</PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5003294-37.2019.8.21.0005</Numero>
				<Juizo>Execução Fiscal</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2019-12-17</DataInstauracao>
				<ValorCausa>37145.51</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (EXECUTADO); MUNICIPIO DE BENTO GONCALVES (EXEQUENTE)</PartesProcesso>
				<PrincipaisFatos>Execução Fiscal</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>37145.51</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5000070-76.2016.8.21.0141</Numero>
				<Juizo>Esbulho/turbação</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-02</DataInstauracao>
				<ValorCausa>100000</ValorCausa>
				<PartesProcesso>CYRO SANTIAGO RODRIGUES (REU);  IMOBILIARIO - FII (AUTOR);</PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5000640-19.2016.8.21.0026</Numero>
				<Juizo>Execução de Título Extrajudicial</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-03</DataInstauracao>
				<ValorCausa>35150.97</ValorCausa>
				<PartesProcesso>MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (EXECUTADO); ROSEMARA KLAFKE HOPPE (ADVOGADO); CERT LTDA (EXEQUENTE); </PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>35150.97</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>5000101-62.2017.8.21.0141</Numero>
				<Juizo>Esbulho/turbação</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2017-07-06</DataInstauracao>
				<ValorCausa>20000</ValorCausa>
				<PartesProcesso>DAJ GASTRONOMIA LTDA (REU); MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (AUTOR); </PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0015970-10.2016.8.21.0005</Numero>
				<Juizo>Reitegração de posse</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-12-02</DataInstauracao>
				<ValorCausa>100000</ValorCausa>
				<PartesProcesso>M BLUE PARTICIPACOES LTDA (REU); MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (AUTOR)</PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>0</AnaliseImpactoPerda>
			</Processo>
			<Processo>
				<Numero>0008782-97.2016.8.21.0026</Numero>
				<Juizo>Execução de Título Extrajudicial</Juizo>
				<Instancia>1ª Instância</Instancia>
				<DataInstauracao>2016-06-03</DataInstauracao>
				<ValorCausa>35150.97</ValorCausa>
				<PartesProcesso>CERT LTDA (EXEQUENTE); MULTI PROPERTIES FUNDO DE INVESTIMENTO IMOBILIARIO - FII (EXECUTADO)</PartesProcesso>
				<PrincipaisFatos>Ação pelo procedimento comum</PrincipaisFatos>
				<ChancePerda>possível</ChancePerda>
				<AnaliseImpactoPerda>35150.97</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
			<Processo>
				<Numero>não se aplica</Numero>
				<Valores>não se aplica</Valores>
				<CausaContingencia>não se aplica</CausaContingencia>
			</Processo>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Praia de Botafogo, nº 501 - 6º andar</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.mafdtvm.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>(i) correspondência física ou eletrônica / em sua página na rede mundial de computadores, na data de convocação da Assembleia Geral, e mantê-los lá até a sua realização; no Sistema de Envio de Documentos, disponível na página da CVM na rede mundial de computadores; na página da entidade administradora do mercado organizado em que as Cotas do Fundo sejam admitidas à negociação.
(ii) correspondência física ou eletrônica.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>(i) Somente poderão votar na Assembleia Geral os Cotistas inscritos no registro de cotistas na data da convocação da Assembleia Geral os Cotistas, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano.
(ii)As deliberações da Assembleia Geral poderão ser tomadas, mediante processo de consulta, formalizada por carta, correio eletrônico ou telegrama dirigido pelo Administrador aos Cotistas, para resposta no prazo de 30 (trinta) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto;
(iii) Os Cotistas poderão votar por meio de comunicação escrita ou eletrônica, desde que recebida pelo Administrador em até 24 (vinte e quatro) horas antes do início da assembleia, no endereço físico ou eletrônico do Administrador por ele informado na convocação para a Assembleia Geral de Cotistas.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Os Cotistas poderão votar por meio de comunicação escrita ou eletrônica, desde que recebida pelo Administrador em até 24 (vinte e quatro) horas antes do início da assembleia, no endereço físico ou eletrônico do Administrador por ele informado na convocação para a Assembleia Geral de Cotistas.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pelos serviços de administração, gestão e custódia qualificada dos ativos integrantes
do patrimônio do Fundo, será devida pelo Fundo uma taxa de administração (“Taxa de
Administração”), correspondente a 0,25% (vinte e cinco centésimos por cento) ao ano,
calculada sobre o valor do patrimônio líquido do Fundo, a qual será apropriada por dia útil
como despesa do Fundo, com base em um ano de 252 (duzentos e cinquenta e dois) dias
úteis, observado o valor mínimo mensal de R$ 55.000,00 (cinquenta e cinco mil reais),
corrigido anualmente pelo IGPM-FGV a partir da data de concessão do registro para
funcionamento do Fundo pela CVM, e paga mensalmente, no 5º (quinto) dia útil de cada mês
subsequente, sendo que, da referida remuneração será devida ao Gestor parcela definida
no Contrato de Gestão.</PoliticaRemuneracao>
			<ValorPagoAno>482898.81</ValorPagoAno>
			<PercentPatrimonioContabil>0.1287</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.1287</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>EDUARDO CENTOLA</Nome>
				<Idade>53</Idade>
				<CPF>151.840.668-88</CPF>
				<Email>eduardo.centola@modal.com.br</Email>
				<Profissao>Administrador</Profissao>
				<FormacaoAcademica>Administração de Empresas</FormacaoAcademica>
				<DataInicioFuncao>2021-02-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Banco Modal S.A.</NomeEmpresa>
						<Periodo>a partir de 2012</Periodo>
						<CargoFuncoes>sócio CO-CEO</CargoFuncoes>
						<AtividadePrincipalEmpresa>Banco de investimentos com atuação em estruturação e coordenação de operações no mercado nacional</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>N/A</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="9" numCotasDetidas="8404588" percDetidoRelTotal="0.1508" percDetidoPF="0.0117" percDetidoPJ="0.1391"/>
			<AcimaCincoAteDezPorcento numCotistas="1" numCotasDetidas="3025000" percDetidoRelTotal="0.0543" percDetidoPJ="0.0543"/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="44297912" percDetidoRelTotal="0.7949" percDetidoPJ="0.7949"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>Site do administrador (www.mafdtvm.com.br) e sistema Fundos.net</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>Adimite-se a negociação no mercado secundário.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>A política de exercício de direito de voto em Assembleias a ser praticada pelo Gestor
com relação às participações societárias detidas pelo Fundo é aquela disponível, em sua
versão integral e atualizada, na rede mundial de computadores, no seguinte endereço
eletrônico: https://capitaniainvestimentos.com.br/.</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>O ADMINISTRADOR notificará o Cotista, por escrito e com antecedência mínima de 2 (dois) dias corridos, da chamada de capital referente ao capital comprometido no Boletim de Subscrição e respectiva integralização de cotas que tenham que ser feitas pelo Cotista (“Requerimento de Integralização”). O Requerimento de Integralização será enviado ao endereço do Cotista constante no preâmbulo do Boletim de Subscrição, por meio de carta ou correio eletrônico, na qual constará a data em que o aporte deverá ser recebido e as instruções para transferência dos aportes requeridos para o Fundo.
A integralização de Cotas do FUNDO deverá ser feita em moeda corrente nacional, em uma conta de titularidade do FUNDO junto ao ADMINISTRADOR, podendo ser efetuada por meio de débito em conta corrente, por meio de documento de ordem de crédito, transferência eletrônica disponível ou por qualquer outro mecanismo de transferência de recursos autorizado pelo Banco Central do Brasil – BACEN.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"