"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>GRUPO RCFA FUNDO DE INVESTIMENTO IMOBILIARIO</NomeFundo>
		<CNPJFundo>27771586000144</CNPJFundo>
		<DataFuncionamento>2018-07-26</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>BRRCFACTF007</CodigoISIN>
		<QtdCotasEmitidas>583926.07550609</QtdCotasEmitidas>
		<FundoExclusivo>true</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Desenvolvimento</Subclassificacao>
			<TipoGestao>Ativa</TipoGestao>
			<SegmentoAtuacao>Multicategoria</SegmentoAtuacao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>false</MBO>
			<MB>true</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>MONETAR DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS LTDA</NomeAdministrador>
		<CNPJAdministrador>12063256000127</CNPJAdministrador>
		<Logradouro>Rua Joaquim Floriano, nº 100, 5º andar, conj 51/52, Itaim Bibi, SP, CEP 4534000</Logradouro>
		<Numero>100</Numero>
		<Complemento>5º andar</Complemento>
		<Bairro>Itaim Bibi</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>04534000</CEP>
		<Telefone1>11 3165.6000</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.terrainvestimentos.com.br</Site>
		<Email>admfundos@terrainvestimentos.com.br</Email>
		<Competencia>2025-12-31</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>FRAM CAPITAL GESTÃO DE ATIVOS</Nome>
				<CNPJ>14.283.986/0001-69</CNPJ>
				<Endereco>Rua Dr. Eduardo de Souza Aranha, 153 - SP</Endereco>
				<telefone>(11) 35133100</telefone>
			</Gestor>
			<Custodiante>
				<Nome>TERRA INVESTIMENTOS DTVM LTDA</Nome>
				<CNPJ>03.751.794/0001-13</CNPJ>
				<Endereco>Rua Joaquim Floriano, 100, 5º andar - SP</Endereco>
				<telefone>(11) 20502864</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>UHY BENDORAYTES &amp; Cia</Nome>
				<CNPJ>42.170.852/0001-77</CNPJ>
				<Endereco>AV JOAO CABRAL DE MELLO NETO, 850 - RJ</Endereco>
				<telefone>(21) 3030-4662</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>TERRA INVESTIMENTOS DTVM LTDA</Nome>
				<CNPJ>03.751.794/0001-13</CNPJ>
				<Endereco>Rua Joaquim Floriano, 100, 5º andar - SP</Endereco>
				<telefone>(11) 20502864</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>DOMINUS ADMINISTRACAO E SERVICOS LTDA</Nome>
				<CNPJ>01.667.752/0002-54</CNPJ>
				<Endereco>AVENIDA DAS AMERICAS, 700
BLOCO 02 SALA 234 A 242 - RJ</Endereco>
				<telefone>(21) 21329035 </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>Não possui informação apresentada.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Não possui informação apresentada.</ResultadoFundo>
			<ConjunturaEconomica>Não possui informação apresentada.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Não possui informação apresentada.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Green 2000 Empreendimentos Imobiliarios Ltda</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1225214.41</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Green 3000 Empreendimentos Imobiliarios Ltda</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3550153.57</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Hesa 107 Investimento Imobiliario Ltda</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>86529.17</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Hesa 98 Investimento Imobiliario Ltda</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3688374.4</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>PDG BH Incorporacoes S.A.</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3703766.58</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>PDG Nova Lima Incorporacoes S.A.</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>233929.4</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rio II Park Empreendimentos Imobiliarios Ltda</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>-10724.97</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Não possui informação apresentada.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos>Não possui informação apresentada.</AnaliseImpactos>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Custodiante - RUA JOAQUIM FLORIANO, 100 - 5ºANDAR</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.terrainvestimentos.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>admfundos@terrainvestimentos.com.br</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>9.4. Consulta formal. 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 ou telegrama dirigido pelo Administrador aos Cotistas, para resposta no prazo de 15 (quinze) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício
de voto.
9.4.1. A resposta dos Cotistas à consulta será realizada mediante o envio, pelo Cotista ao Administrador, de carta, correio eletrônico ou telegrama formalizando o seu respectivo voto.
9.4.2. Caso algum Cotista deseje alterar o endereço para recebimento de quaisquer avisos, deverá notificar o Administrador.
9.5. Voto. Somente poderão votar na Assembleia Geral de Cotistas os Cotistas inscritos no registro de Cotistas na data da convocação da Assembleia Geral de Cotistas ou seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano.
9.5.1. Os Cotistas também poderão votar por meio de comunicação escrita ou eletrônica, observado neste Regulamento e a legislação e normativos vigentes.
9.5.2. O pedido de procuração, encaminhado pelo Administrador mediante correspondência ou anúncio publicado, deverá satisfazer aos seguintes requisitos: 

I. Conter todos os elementos informativos necessários ao exercício do voto pedido;
II. Facultar que o Cotista exerça o voto contrário à proposta, por meio da mesma
procuração; e
III. Ser dirigido a todos os Cotistas. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não há a realização de assembleia por meio eletrônico para fundos imobiliários.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O ADMINISTRADOR receberá, pelos serviços de administração do FUNDO, a remuneração anual equivalente a 0,2% a.a. (dois décimos por cento ao ano) sobre o valor do Patrimônio Líquido do FUNDO, com um mínimo mensal de R$ 10.000,00 (dez mil reais), a ser atualizado anualmente pelo IGP-M/FGV.</PoliticaRemuneracao>
			<ValorPagoAno>0</ValorPagoAno>
			<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0</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>LUIZ ALVARO DE PAIVA FERREIRA</Nome>
				<Idade>62</Idade>
				<CPF>049.035.538-25</CPF>
				<Email>lferreira@terrainvestimentos.com.br</Email>
				<Profissao>ECONOMISTA</Profissao>
				<FormacaoAcademica>ECONOMIA</FormacaoAcademica>
				<DataInicioFuncao>2020-03-14</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="55" numCotasDetidas="83802.7221934" percDetidoRelTotal="0.1435" percDetidoPF="0.1435" percDetidoPJ="0"/>
			<AcimaQuinzeAteVintePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaVinteAteTrintaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuarentaAteCinquentaPorcento numCotistas="1" numCotasDetidas="583926.07550609" percDetidoRelTotal="0.8565" percDetidoPF="0" percDetidoPJ="0.8565"/>
			<AcimaCiquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>A divulgação de informações deve ser feita na página do Administrador na rede mundial de computadores, em lugar de destaque e disponível para acesso gratuito, e mantida disponível aos Cotistas em sua sede. OAdministrador deverá, ainda, simultaneamente à divulgação referida acima, enviar as informações referidas ao mercado organizado em que as cotas do FII sejam admitidas à negociação, bem como à CVM, através do Sistema de Envio de Documentos disponível na página da CVM na rede mundial de computadores. As informações ou documentos referidos podem ser remetidos aos Cotistas por meio eletrônico ou disponibilizados por meio de canais eletrônicos. A comunicação deverá ser encaminhada para o e-mail: admfundos@terrainvestimentos.com.br.</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>www.terrainvestimentos.com.br</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>www.terrainvestimentos.com.br</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>www.terrainvestimentos.com.br</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>As regras e prazos para a chamada de capital será de acordo com o deliberado em Assembleia, seguindo o estabelecido em regulamento.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"