"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>MULTIGESTÃO RENDA COMERCIAL FII</NomeFundo>
		<CNPJFundo>10456810000100</CNPJFundo>
		<DataFuncionamento>2008-10-24</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRDRITCF009</CodigoISIN>
		<QtdCotasEmitidas>463277</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Outros</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BANCO DAYCOVAL S/A</NomeAdministrador>
		<CNPJAdministrador>62232889000190</CNPJAdministrador>
		<Logradouro>AV. PAULISTA</Logradouro>
		<Numero>1793</Numero>
		<Complemento>2° andar</Complemento>
		<Bairro>Bela Vista</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>01311200</CEP>
		<Telefone1>(11) 3138-0921</Telefone1>
		<Telefone2>(11) 3138-1678</Telefone2>
		<Telefone3>(11) 3138-1678</Telefone3>
		<Site>www.daycoval.com.br</Site>
		<Email>middlesmc@bancodaycoval.com.br</Email>
		<Competencia>2021-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Daycoval Asset Management</Nome>
				<CNPJ>72027832000102</CNPJ>
				<Endereco>Avenida Paulista, nº 1.793,
Bela Vista, CEP 01.311-200,</Endereco>
				<telefone>(11) 3138-0790</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BANCO DAYCOVAL S.A.</Nome>
				<CNPJ>62232889000190</CNPJ>
				<Endereco>Avenida Paulista, nº 1.793,
Bela Vista, CEP 01.311-200,</Endereco>
				<telefone>(11) 3138-0504</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>ERNST &amp; YOUNG Auditores Independentes S.S.</Nome>
				<CNPJ>61366936001105</CNPJ>
				<Endereco>Avenida Mostardeiro, 322, Andar 3 Andar 6 Andar 10, Moinhos de Vento, Porto Alegre, RS</Endereco>
				<telefone>(11) 2573-3000</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</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 tem por objeto a realização de investimentos de longo prazo em bens imóveis não residenciais, podendo, ainda, adquirir cotas de outros fundos de investimento imobiliário – FII, certificados de recebíveis imobiliários, letras de crédito imobiliário e letras imobiliárias garantidas (“Ativos Imobiliários”).</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo o apresentou um lucro de R$ (543.905,20)</ResultadoFundo>
			<ConjunturaEconomica>O ano de 2021  apresentou diversos desafios aos fundos imobiliários. A alta taxa de inflação obrigou o Banco Central a adotar uma política monetária restritiva, aumentando os juros e penalizando os demais ativos de renda variável. Nesse cenário, a classe de fundos que apresentou maior rentabilidade no ano foi a de fundos de recebíveis, que aplicam majoritariamente em títulos de renda fixa atrelada ao mercado imobiliário, como CRIs (Certificado de Recebíveis Imobiliários) e LCIs (Letra de Crédito Imobiliário).Em face desses eventos, no mês de dezembro os investidores aproveitaram um grande desconto das cotas negociadas no mercado secundário em relação ao valor patrimonial dos fundos Imobiliários. Em função disso, o IFIX, índice de referência dos fundos imobiliários, fechou o mês com ganhos de 8,78%. Conforme nossos relatórios mensais, vimos que o fluxo vendedor não representa os fundamentos observados no mercado de lajes corporativas.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>O fundo encerra um ano desafiador com uma taxa de vacância física inferior ao período de início da pandemia do COVID-19, com todos seus locatários adimplentes e em negociação dos contratos com vencimento curto. Não tivemos nenhuma compra ou venda de ativos no ano e permanecemos com a visão otimista para o longo prazo, com crescimento dos rendimentos mensais e portfólio diversificado para enfrentar os possíveis desafios.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Ed Torre Sul</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>9153000</Valor>
				<PercentValorizacaoDesvalorizacao>0.12</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ed. Nações Unidas 20.000</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5524000</Valor>
				<PercentValorizacaoDesvalorizacao>0.08</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ed. Pedra Grande</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>9546000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.3</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ed. Pedra Grande loja</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>14702000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.04</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ed. Platinum</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>9239000</Valor>
				<PercentValorizacaoDesvalorizacao>0.06</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ed. Atrium</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6177000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.12</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ed. Minneapolis</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4630000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.07</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao> A metodologia adotada para este trabalho fundamenta-se nos seguintes critérios e preceitos: NBR 14653; Parte 1 – Procedimentos Gerais; Parte 2 - Imóveis Urbanos e Parte 4 - Empreendimentos, da ABNT (Associação Brasileira de Normas Técnicas); Normas para Avaliações de Imóveis Urbanos publicadas pelo IBAPE/SP (Instituto Brasileiro e Avaliações e Perícias de Engenharia); Requisitos básicos do Red Book, estipulados pelo RICS (Royal Institution of Chartered Surveyors), da Grã Bretanha .Metodologias: Método Comparativo Direto de Dados de e  Método da Capitalização da Renda Valor Justo para Venda. Valor Auferido: Valor de Mercado de Locação e Valor Justo para Venda respectivamente. </CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida Paulista, 1.793 - 2° andar</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>https://www.daycoval.com.br/institucional/mercado-de-capitais</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>As solicitaçãos podem ser feitas no email: adm.fundos@bancodaycoval.com.br, erick.carvalho@bancodaycoval.com.br, middlesmc@bancodaycoval.com.br, correio eletrônico, website do administrador fiduciário (https://www.daycoval.com.br/institucional/mercado-de-capitais) e na página do FII na CVM (https://cvmweb.cvm.gov.br/swb/default.asp?sg_sistema=fundosreg)</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Artigos retirados do regulamento vigente:

20.5. Para fins do disposto neste Regulamento e na regulamentação em vigor, considera-se o correio eletrônico uma forma de correspondência válida entre a Instituição Administradora e   os Cotistas, inclusive para convocação de Assembleia Geral de Cotistas e procedimentos de consulta formal. 


13.9. As deliberações da Assembleia Geral de Cotistas poderão ser tomadas, independentemente de convocação, mediante processo de consulta, formalizada por carta, correio eletrônico, voto por escrito ou telegrama dirigido pela Instituição Administradora aos Cotistas, para resposta no prazo de 10 (dez) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto, observadas as formalidades previstas nos Artigos 19, 19-A e 41, incisos I e II, da Instrução CVM 472.


13.9.1. A resposta dos Cotistas à consulta será realizada mediante o envio, pelo Cotista à Instituição Administradora, de carta, correio eletrônico ou telegrama formalizando o seu respectivo voto.

13.9.2. Os Cotistas que não se manifestarem no prazo estabelecido acima serão considerados como ausentes para fins do quórum na Assembleia Geral de Cotistas.

13.9.3. Caso algum Cotista deseje alterar o endereço para recebimento de quaisquer avisos, deverá notificar a Instituição Administradora por carta, correio eletrônico ou telegrama, em qualquer dos casos, com comprovante de entrega. 
</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Artigos retirados do regulamento vigente:

13.9. As deliberações da Assembleia Geral de Cotistas poderão ser tomadas, independentemente de convocação, mediante processo de consulta, formalizada por carta, correio eletrônico, voto por escrito ou telegrama dirigido pela Instituição Administradora aos Cotistas, para resposta no prazo de 10 (dez) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto, observadas as formalidades previstas nos Artigos 19, 19-A e 41, incisos I e II, da Instrução CVM 472.
13.9.1. A resposta dos Cotistas à consulta será realizada mediante o envio, pelo Cotista à Instituição Administradora, de carta, correio eletrônico ou telegrama formalizando o seu respectivo voto.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Artigos retirados do regulamento vigente:

11.1. A taxa de administração e gestão do Fundo (“Taxa de Administração”) será paga da seguinte forma: (a) a Instituição Administradora do Fundo fará jus à remuneração correspondente a 0,25% (vinte e cinco centésimos por cento) ao ano sobre o valor do patrimônio líquido do Fundo, excluída a depreciação, somado o valor que a Instituição Administradora deverá pagar ao escriturador e honorários de contabilidade a título de remuneração pelos serviços realizados, observado, ainda, o piso anual de R$  60.000,00  (sessenta mil reais), equivalente a R$5.000,00 (cinco mil reais) mensais, atualizado anualmente a na data base 1º de maio de 2010 de acordo com a variação do IGP-M – Índice Geral de Preços do Mercado, apurado e divulgado pela Fundação Getúlio Vargas (IGP-M) e (b) a Gestora do Fundo fará jus à remuneração correspondente a 0,25% (vinte e cinco centésimos por cento) ao ano sobre o valor total do patrimônio líquido do Fundo, excluída a depreciação, observado, ainda, o piso anual de R$ 60.000,00 (sessenta mil reais), equivalente a R$5.000,00 (cinco mil reais) mensais, atualizado anualmente a na data base 1º de maio de 2010 de acordo com a variação do IGP-M.
Artigos retirados do regulamento vigente:

11.1. A taxa de administração e gestão do Fundo (“Taxa de Administração”) será paga da seguinte forma: (a) a Instituição Administradora do Fundo fará jus à remuneração correspondente a 0,25% (vinte e cinco centésimos por cento) ao ano sobre o valor do patrimônio líquido do Fundo, excluída a depreciação, somado o valor que a Instituição Administradora deverá pagar ao escriturador e honorários de contabilidade a título de remuneração pelos serviços realizados, observado, ainda, o piso anual de R$  60.000,00  (sessenta mil reais), equivalente a R$5.000,00 (cinco mil reais) mensais, atualizado anualmente a na data base 1º de maio de 2010 de acordo com a variação do IGP-M – Índice Geral de Preços do Mercado, apurado e divulgado pela Fundação Getúlio Vargas (IGP-M) e (b) a Gestora do Fundo fará jus à remuneração correspondente a 0,25% (vinte e cinco centésimos por cento) ao ano sobre o valor total do patrimônio líquido do Fundo, excluída a depreciação, observado, ainda, o piso anual de R$ 60.000,00 (sessenta mil reais), equivalente a R$5.000,00 (cinco mil reais) mensais, atualizado anualmente a na data base 1º de maio de 2010 de acordo com a variação do IGP-M.</PoliticaRemuneracao>
			<ValorPagoAno>151156.07</ValorPagoAno>
			<PercentPatrimonioContabil>0.00257492297994067</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.00259900365137629</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>Erick Warner de Carvalho</Nome>
				<Idade>42</Idade>
				<CPF>27764653861</CPF>
				<Email>erick.carvalho@bancodaycoval.com.br</Email>
				<Profissao>Diretor de Administração Fiduciária</Profissao>
				<FormacaoAcademica>Administração de Empresas</FormacaoAcademica>
				<DataInicioFuncao>2019-08-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="317" numCotasDetidas="12334" percDetidoRelTotal="0.0266" percDetidoPF="0.0266" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento numCotistas="4" numCotasDetidas="136045" percDetidoRelTotal="0.2937" percDetidoPF="0.2937" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="314898" percDetidoRelTotal="0.6797" percDetidoPF="0" percDetidoPJ="0.6797"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>https://ri.daycoval.com.br/pt/governanca-corporativa/visao-geral</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>https://ri.daycoval.com.br/</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://ri.daycoval.com.br/</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>O Administrador possui equipes direcionadas para asseguração do cumprimento da política de divulgação de informações do Fundo com segregação de funções para elaboração, validação e envio de informações.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Não possui informação apresentada</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"