"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>GGR Covepi Renda Fundo de Investimento Imobiliário</NomeFundo>
		<CNPJFundo>26614291000100</CNPJFundo>
		<DataFuncionamento>2017-01-11</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRGGRCCTF002</CodigoISIN>
		<QtdCotasEmitidas>6503028</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Desenvolvimento para Renda</Mandato>
			<SegmentoAtuacao>Logística</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>30/06</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>CM CAPITAL MARKETS DTVM LTDA</NomeAdministrador>
		<CNPJAdministrador>26614291000100</CNPJAdministrador>
		<Logradouro>Rua Gomes de Carvalho</Logradouro>
		<Numero>1195</Numero>
		<Complemento>4º ANDAR</Complemento>
		<Bairro>Vila Olímpia</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04547-004</CEP>
		<Telefone1>(11) 3842-1122</Telefone1>
		<Telefone2>(11) 3044-3547</Telefone2>
		<Telefone3 xsi:nil="true"/>
		<Site>www.cmcapitalmarkets.com.br</Site>
		<Email>fundos@cmcapitalmarkets.com.br</Email>
		<Competencia>2019-06-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>GGR Gestão de Recursos Ltda</Nome>
				<CNPJ>10790817000164</CNPJ>
				<Endereco>Rua Joaquim Floriano, 466 - 5º andar</Endereco>
				<telefone>(11) 4369-6106</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Planner Corretora de Valores S/A</Nome>
				<CNPJ>806535000154</CNPJ>
				<Endereco>Av. Brig. Faria Lima, 3900 - 10º andar</Endereco>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KMPG Auditores Indepentes</Nome>
				<CNPJ>57755217000129</CNPJ>
				<Endereco>Rua Vergueiro, 3111 - Vila Mariana, São Paulo - SP, 04101-300</Endereco>
				<telefone>(11) 3736-1000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>Não Há</Nome>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>Diversos</Nome>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>Não há</Nome>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>Não há</Nome>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
				<Prestador>
					<Nome>ITAÚ CORRETORA DE VALORES S/A</Nome>
					<CNPJ>61194353000164</CNPJ>
					<Endereco>Av. Brig. Faria Lima, 3500 - 3° andar</Endereco>
					<telefone/>
				</Prestador>
				<Prestador>
					<Nome>CM Capital Markets DTVM Ltda</Nome>
					<CNPJ>2671743000119</CNPJ>
					<Endereco>Rua Gomes de Carvalho, 1195 - 4º andar</Endereco>
					<telefone>(11) 3842-1122</telefone>
				</Prestador>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
					<Ativo>
						<Nome>LTN</Nome>
						<Objetivos>Gestão da Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>217281199.1</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>IMÓVEL INDUSTRIAL MOINHO IGUAÇU - SÃO MIGUEL</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>20330000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>IMÓVEL LOGÍSTICO AMBEV</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>29791000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>IMÓVEL INDUSTRIAL MOINHO IGUAÇU - CASCAVEL</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>14303000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>AETHA - IMÓVEL</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>77200000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>IMÓVEL LOGÍSTICO NISSEI</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>30700000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>IMÓVEL INDUSTRIAL AMBEV PELOTAS</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>34415000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CAMARGO COMPANHIA DE EMBALAGENS</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>35783000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CEPALGO EMBALAGENS FLEXIVEIS</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>22140000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>COPOBRAS</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>34020000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>COPOBRAS II</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>36530000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>HERING E SANTA CRUZ</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>51910000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>JEFER PRODUTOS SIDERURGICOS</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>42889000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>TODIMO MATERIAIS PARA CONSTRUÇÃO</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>32110000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>SANTA CRUZ - ANAPOLIS/GO</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>18390000</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>COVOLAN - GALPÃO COMERCIAL RUA DOS PORTUGUESES</Nome>
						<Objetivos>Aluguel</Objetivos>
						<MontantesInvestidos>75054029</MontantesInvestidos>
						<OrigemRecursos>Fluxo de Caixa</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>No exercicio encerrado em 28 de Junho de 2019, o Fundo apresentou um Resultado Operacional de R$ 44.735 mil , apresentou um Lucro Líquido de R$ 41.354 mil. No exercício houve uma valorização /desvalorização de imóveis de R$ 7.630 mil e uma distribuíção de rendimento aos cotistas de R$ 46.843 mil.  </ResultadoFundo>
			<ConjunturaEconomica>A recuperação econômica foi aquém do esperado e os acontecimentos políticos foram os grandes destaques do ano, culminando na não aprovação da reforma da Previdência e na greve dos caminhoneiros. Esse ambiente de instabilidade acabou tornando o cenário econômico de 2018 muito parecido com o observado em 2017. A economia evoluiu num ritmo muito mais lento do que o esperado, de forma que o PIB deve crescer em 2018 metade do previsto no início do ano. Essa recuperação mais gradual levou a ociosidade a se manter em níveis historicamente elevados, o que permitiu que os ítens da inflação mais ligados ao ciclo econômico seguissem uma trajetória ainda mais benigna do que esperávamos. A expectativa para o setor de imóveis logísticos e industriais é de recuperação. Segundo a Cushman &amp; Wakefield, empresa especializada em soluções e serviços imobiliários comerciais, não há mais viés de piora na absorção líquida, índice que considera a absorção bruta no período e as devoluções. Com baixo volume de devoluções, o mercado se mantém crescendo em 2018. Segundo a Consultoria JLL, o volume de absorções nos três trimestres de 2018 foi 42% maior que no mesmo período em 2017. Com aproximadamente 80% das entregas, o estado de São Paulo foi o que recebeu maior parte do novo estoque neste trimestre com quase 124 mil m². Mesmo com o aumento das entregas a taxa de vacância continuou caindo e chegou a 22,7% no ano quebrando o ciclo de sete trimestres consecutivos onde o preço médio de locação caiu 7,5%. Em 3T18 o preço de locação subiu 0.6%; Absorção líquida: 307 mil m². Um baixo volume de devoluções registradas no trimestre fez com que a absorção líquida tivesse seu número mais alto em 2018, impulsionado pelos estados de São Paulo e Paraná, que somados são responsáveis por 210 mil m² absorvidos. O volume de absorções nos três trimestres de 2018 foi 42% maior que o mesmo período em 2017. Desde o início do ano já foram contabilizados 1,5 milhão de m² em novas locações, superando em 440 mil m² o valor em mesmo período do ano anterior. Este fator, aliado ao baixo volume de novas entregas e de devoluções resultou em uma queda acumulada da vacância em 2,28 p.p. no ano. Em 2018, Paraná se destaca como um dos principais estados no cenário de movimentações. Com 89 mil m² de locações no trimestre e 179 mil m² acumulados no ano, o estado foi o terceiro com mais absorções, somente atrás de SP (747mil m²) e RJ (186 mil m²). Os segmentos de Transporte e logística com 73 mil m² (3T) e de Insumos para indústria com 36 mil m² (2T) foram os responsáveis pelas maiores transações.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Não há expectativa de vacância nos imóveis pertencentes ao fundo, devendo os aluguéis recebidos se manter na mesma proporção. Os fluxos de caixa então não devem apresentar variação significativa.  </PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>IMÓVEL INDUSTRIAL MOINHO IGUAÇU - SÃO MIGUEL</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>20330000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IMÓVEL LOGÍSTICO AMBEV</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>29791000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IMÓVEL INDUSTRIAL MOINHO IGUAÇU - CASCAVEL</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>14303000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>AETHA - IMÓVEL</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>77200000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IMÓVEL LOGÍSTICO NISSEI</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>30700000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IMÓVEL INDUSTRIAL AMBEV PELOTAS</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>34415000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CAMARGO COMPANHIA DE EMBALAGENS</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>35783000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CEPALGO EMBALAGENS FLEXIVEIS</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>22140000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>COPOBRAS</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>34020000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>COPOBRAS II</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>36530000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>HERING E SANTA CRUZ</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>51910000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>JEFER PRODUTOS SIDERURGICOS</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>42889000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>TODIMO MATERIAIS PARA CONSTRUÇÃO</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>32110000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>SANTA CRUZ - ANAPOLIS/GO</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>18390000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>COVOLAN - GALPÃO COMERCIAL RUA DOS PORTUGUESES</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>75054029</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>A avaliação dos imóveis é feita por empresas especializadas e segue a Instrução CVM 472. As metodologias utilizadas para avaliação de ativos incluem o Método da Renda, com apoio e aferição através dos Métodos Evolutivo (Custo) e Comparativo. Tendo em vista a finalidade da avaliação, a natureza dos imóveis, sua situação geo-sócio-econômica e a disponibilidade de dados e evidêncas de mercado
seguras, foi utilizado o "Método da Renda" na sua variante de Valor Econômico por Fluxo de Caixa Descontado, para a definição dos valores referenciais e indicadores. Entre os critérios utilizados vale destacar: análise operacional do empreendimento, análise de séries históricas do empreendimento, análise setorial e diagnóstico de mercado, taxas de descontos, análise de sensibilidade e análise de risco. </CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Gomes de Carvalho, 1195</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>Site Fundos Net: fnet.bmfbovespa.com.br/fnet/login - Site administradora: www.cmcapitalmarkets.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Item (i) são utilizados como meios de comunicação aos cotistas:(a) FundosNet; (b) site da Administradora; Item (ii) o endereço físico e eletrônico são disponibilizados no Edital de Convocação;

</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Item (i) são solicitados os documentos societários do cotista, no momento da coleta de assinaturas na Lista de presença;
Item (ii) a Consulta Formal é elaborada nos termos do Regulamento do Fundo e enviada a todos os cotistas, juntamente com a carta resposta;
Item (iii) as manifestações dos cotistas, deverão ocorrer na forma prevista no comunicado até o horário estabelecido;
</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Ao enviarmos a comunicação ao cotista sobre a realização da Assembleia, é disponibilizado o canal eletrônico para retorno da sua manifestação nos termos do Regulamento do Fundo, e quando a o envio desta pelo cotista, procedemos com a apuração do quorum no momento do encerramento do prazo para manifestação.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos servições de administração e gestão do Fundo, a Administradora receberá do Fundo a remuneração equivalente ao maior entre (a) o valor mensal calculado  conforme a fórmula abaixo , ou (b)  (i) nos 3 (três) primeiros  meses a contar da Primeira Data de Integralização das Cotas, R$ 10.000,00 (dez mil reais), (ii) do 4º (quarto) ao 6º (sexto) mês contados da Primeira Data da Integralização das Cotas, R$ 12.500,00 (doze mil e quinhentos reais), e (iii) a partir do 6º (sexto) mês contado da data  da Primeira Data de Integralização das Cotas, R$ 17.000,00 (dezessete mil reais) ("Taxa de Administração"). TA = (((1 + Tx) ^ (1/252) - 1) x VA onde: TA = Taxa de Administração variárvel, calculada todo dia útil;  TX = 1,10% ao ano e VA =  (i) o valor de mercado do Fundo, calculado com base na media diaria da cotacao de Fechamento das cotas de emissao do Fundo no mes anterior ao do pagamento da remuneracao,  caso referidas Cotas tenham integrado ou passado a integrar, nesse periodo, indice de mercado, conforme definido na regulamentacao aplicavel aos fundos de investimento em indices de mercado, cuja metodologia preveja criterios de inclusao que considerem a liquidez das Cotas e criterios de ponderacao que considerem o volume financeiro das Cotas emitidas pelo Fundo, como, por exemplo, o Indice de Fundos de Investimento Imobiliario divulgado pela BM&amp;F Bovespa (IFIX); ou o valor contábil do Patrimônio Líquido do Fundo no último dia anterior, nos demais casos.</PoliticaRemuneracao>
			<ValorPagoAno xsi:nil="true"/>
			<PercentPatrimonioContabil xsi:nil="true"/>
			<PercentPatrimonioValorMercado xsi:nil="true"/>
		</RemuneracaoAdministrador>
		<Governanca>
			<RepresentantesCotistas>
				<Representante1>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal xsi:nil="true"/>
						<CondenacaoProcAdminCVM xsi:nil="true"/>
					</Eventos>
				</Representante1>
				<Representante2>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante2>
				<Representante3>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante3>
				<Representante4>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante4>
				<Representante5>
					<Nome/>
					<Idade/>
					<CPF/>
					<Email/>
					<Profissao/>
					<FormacaoAcademica/>
					<FormaRemuneracao/>
					<ValorPagoAno xsi:nil="true"/>
					<PercentPatrimonioContabil xsi:nil="true"/>
					<PercentPatrimonioValorMercado xsi:nil="true"/>
					<QtdCotasDetidasFII xsi:nil="true"/>
					<QtdCotasFIICompradas xsi:nil="true"/>
					<QtdCotasFIIVendidas xsi:nil="true"/>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal/>
						<CondenacaoProcAdminCVM/>
					</Eventos>
				</Representante5>
			</RepresentantesCotistas>
			<DiretorResponsavel>
				<Nome>Fabio Feola</Nome>
				<Idade>53</Idade>
				<CPF>7705604857</CPF>
				<Email>juridicodtvm@cmcapital.com.br</Email>
				<Profissao>Economista</Profissao>
				<FormacaoAcademica>Economia</FormacaoAcademica>
				<DataInicioFuncao>2017-06-21</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>CM Capital Markets</NomeEmpresa>
						<Periodo>06/2017 até atual</Periodo>
						<CargoFuncoes>Diretor de Administração de Carteiras e Valores Mobiliários e Comercial</CargoFuncoes>
						<AtividadePrincipalEmpresa>Atividade Fiduciária</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>CGD Investimentos Corretora de Valores e Câmbio S.A</NomeEmpresa>
						<Periodo>04/2006 até 04/2013</Periodo>
						<CargoFuncoes>Diretor Executivo</CargoFuncoes>
						<AtividadePrincipalEmpresa>Diretoria Executiva</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Banif Banco de Investimento S.A</NomeEmpresa>
						<Periodo>04/2009 até 02/2011</Periodo>
						<CargoFuncoes>Diretor Executivo</CargoFuncoes>
						<AtividadePrincipalEmpresa>Diretoria Executiva</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Maxima S.A. DTVM</NomeEmpresa>
						<Periodo>09/2003 até 03/2006</Periodo>
						<CargoFuncoes>Superintendente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Gestão</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não há</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não há</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="42784" numCotasDetidas="6503028" percDetidoRelTotal="1" percDetidoPF="0.8884" percDetidoPJ="0.1116"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante xsi:nil="true"/>
			<PoliticaNegociacaoCotas>B3</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>VIDE PROSPECTO ENVIADO</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>VIDE PROSPECTO ENVIADO</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"