"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FII BRASIL VAREJO</NomeFundo>
		<CNPJFundo>21126204000143</CNPJFundo>
		<DataFuncionamento>2014-10-30</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRBVARCTF006</CodigoISIN>
		<QtdCotasEmitidas>625540</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<TipoGestao>Definida</TipoGestao>
			<SegmentoAtuacao>Varejo</SegmentoAtuacao>
		</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>RIO BRAVO INVESTIMENTOS - DTVM LTDA</NomeAdministrador>
		<CNPJAdministrador>72600026000181</CNPJAdministrador>
		<Logradouro>AV. CHEDID JAFET</Logradouro>
		<Numero>222</Numero>
		<Complemento>CONJ 32 - BLOCO B</Complemento>
		<Bairro>VILA OLÍMPIA</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04551065</CEP>
		<Telefone1>(11) 3509-6600</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.riobravo.com.br</Site>
		<Email>fundosimobiliarios@riobravo.com.br</Email>
		<Competencia>2025-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>RIO BRAVO DTVM</Nome>
				<CNPJ>72600026000181</CNPJ>
				<Endereco>AV. CHEDID JAFET, 222, CONJUNTO 32, BLOCO B- VILA OLÍMPIA</Endereco>
				<telefone>(11)3509-6500</telefone>
			</Gestor>
			<Custodiante>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Grant Thornton Auditores Independentes Ltda.</Nome>
				<CNPJ>10830108000165</CNPJ>
				<Endereco>Av. Eng Luís Carlos Berrini, 105 - 12° andar</Endereco>
				<telefone>11 3886-5100</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>MAREASA PARTICIPAÇÕES LTDA.</Nome>
				<CNPJ>43423177000103</CNPJ>
				<Endereco>Rua dos Pinheiros, 870 - 20º</Endereco>
				<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>Não existe, até o momento, a estimativa de investimentos para os exercicios seguintes.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O lucro do Fundo no exercício ficou em torno de R$ 23 milhões. O resultado é representado principalmente pelo resultado líquido das atividades imobiliárias do empreendimento.</ResultadoFundo>
			<ConjunturaEconomica>Seguimos otimistas com o processo de suavização da política monetária, com uma sequência de cortes de juros cuja largada deve ocorrer na reunião do Copom de março (18/03). Embora desdobramentos geopolíticos recentes tragam pressões inflacionárias, avaliamos que seus efeitos serão de natureza transitória, sem alteração estrutural do cenário base.
O câmbio, sustentado em patamares mais apreciados, tem funcionado como âncora fundamental do processo desinflacionário brasileiro, evidenciado de forma nítida na retração dos preços de comercializáveis — em especial, alimentos. Condições de oferta mais benignas devem igualmente contribuir para manter essa categoria, que representa mais de um quinto da cesta do IPCA, em níveis menos pressionados ao consumidor.
As expectativas de inflação seguem convergindo de forma sustentada em direção ao centro da meta — atualmente em 3,91% —, ao passo que os dados de atividade econômica apontam arrefecimento considerável na margem, particularmente no consumo. Esperamos a manutenção dessa dinâmica ao longo de 2026.
O principal ponto de dissonância entre os analistas reside no mercado de trabalho. A inflação de serviços — essencialmente uma inflação salarial — permanece em níveis superiores ao teto da meta, demonstrando elevada resiliência. A combinação de reajustes salariais acima do INPC, avanço da formalização da força de trabalho e desemprego em mínimas históricas (5,4% na última PNAD Contínua) tende a sustentar esse desafio à autoridade monetária. O maior grau de indexação dessa categoria reduz a sensibilidade dos preços ao aperto monetário no curto prazo, limitando a velocidade da convergência.
Assim, para 2026 projetamos crescimento econômico modesto, próximo a 1,7%, com desaceleração continuada do consumo e acomodação gradual dos preços livres — a despeito da persistência no componente de serviços. O principal risco mapeável ao cenário é o papel do câmbio no processo desinflacionário: a volatilidade do dólar e a escalada de tensões geopolíticas permanecem como vetores com potencial de trazer consequências deletérias à inflação doméstica.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Em 2026 o fundo continuará em busca da locação das áreas vagas do empreendimento e, até o momento, não há previsão para novos investimentos.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Av. Portugal, 221 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4735000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0691</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Conselheiro João Alfredo, 68 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>20706000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0468</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. Portugal, 213 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>10747000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0001</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. 13 de Maio, 53 - Altos - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1736000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.2546</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Maciel Pinheiro, 185 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>8616000</Valor>
				<PercentValorizacaoDesvalorizacao>0.047</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Antonio João, 59 - Lj 12 e 13 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>523000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0336</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Antonio João, 59 - Lj 14 e 15 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>676000</Valor>
				<PercentValorizacaoDesvalorizacao>0.1064</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua 13 de Junho, 265 - Lj 01 a 11 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>9496000</Valor>
				<PercentValorizacaoDesvalorizacao>0.003</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua 13 de Junho, 265</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>15133000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0527</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>R. Manoel Correa,76/80/86/90 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>11908000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0797</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Major Facundo, 532 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>10565000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.1917</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. Anhanguera, 5.520 - Bairro Setor Central</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3130000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0364</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Candido Mendes, 1.280 - Bairro Central</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>12757000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0467</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua do Comércio, 352/356/364 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6371000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0468</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Avenida Eduardo Ribeiro, 390/406 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>13501000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0437</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. Rio Branco, 637 - Cidade Alta</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>10276000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.1288</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Voluntários da Pátria, 167/183 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>12707000</Valor>
				<PercentValorizacaoDesvalorizacao>0.047</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua da Azenha, 795, 807 e 811 - Bairro Azenha</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5268000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0467</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua dos Andradas, 1.307 / 1.315 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>13227000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.1613</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua dos Andradas, 1.441 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6942000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0105</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. Sete de Setembro, 941-A - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>18320000</Valor>
				<PercentValorizacaoDesvalorizacao>0.047</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Sete de Setembro, 12/34 - Boa Vista</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5158000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0196</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Imperatriz Terreza Cristina, 35 - Boa Vista</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2170000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0046</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Duque de Caxias, 222 - Santo Antonio</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2207000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0147</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Imperatriz Tereza Cristina, 57 - Boa Vista</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7099000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0522</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua João de Barros, 1.812 - Encruzilhada</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2652000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0335</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Nova, 163/171 - Bairro Santo Antonio</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2267000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0152</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Visconde de Pirajá, 138 -A - Ipanema</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>14780000</Valor>
				<PercentValorizacaoDesvalorizacao>0.3666</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Grande, 517/523 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>7022000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0468</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua James Holland, 422 - Barra Funda</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>27593000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0397</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Pça Ramos de Azevedo, 229</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2886000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.097</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Serra Dourada, 102/110 - S. Miguel Paulista</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>9572000</Valor>
				<PercentValorizacaoDesvalorizacao>0.047</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Teodoro Sampaio, 2.382 e 2.394 - Pinheiros</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5363000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0258</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Rua Senador Teodoro Pacheco, 1.074 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>11004000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0468</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. Geronimo Monteiro, 299 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3362000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0386</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Av. Sete de Setembro, 740 - Centro</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>16196000</Valor>
				<PercentValorizacaoDesvalorizacao>0.2335</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>A Cushman Wakefield Brasil, empresa de avaliação externa e independente, tendo apropriada qualificação profissional reconhecida e experiência recente na região e no tipo de propriedade que está sendo avaliada, avaliou pela marcação a valor de mercado os imóveis de propriedade do Fundo em 31 de dezembro de 2025. A avaliação dos imóveis foi realizada pelo Método da Capitalização da Renda através do Fluxo de Caixa Descontado (FCD) num horizonte de 10 anos analisando-se os prazos dos contratos vigentes. A taxa de desconto real aplicada variou entre 8,00% a 9,50% a.a. e na avaliação do perito terceirizado e da instituição administradora refletem as avaliações atuais do mercado quanto às incertezas no valor e prazo dos fluxos de caixa. As despesas de conservação e manutenção dos imóveis locados são de responsabilidade dos locatários e, portanto, não foram considerados no laudo de avaliação. Foram considerados no fluxo de caixa as despesas de conservação e manutenção dos imóveis durante o período de vacância, assim como os valores a serem gastos com a recolocação dos imóveis.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. Chedid Jafet, 222 Bloco B CJ 32 - Vila Olímpia - São Paulo/SP </EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.riobravo.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>As solicitaçãos podem ser feitas nos emails: ri@riobravo.com.br, Administracaofii@riobravo.com.br e FIIBrasilVarejo@riobravo.com.br</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Os cotistas do Fundo poderão participar de Assembleia Geral de Cotistas, por si, seus representantes legais ou procuradores, consoante o disposto no artigo 77 da Resolução CVM nº 175, portando os seguintes documentos: (a) se Pessoas Físicas: documento de identificação com foto; (b) se Pessoas Jurídicas: cópia autenticada do último estatuto ou contrato social consolidado e da documentação societária outorgando poderes de representação, bem como documento de identificação com foto do(s) representante(s) legal(is); (c) se Fundos de Investimento: cópia autenticada do último regulamento consolidado do fundo e do estatuto ou contrato social do seu administrador, além da documentação societária outorgando poderes de representação, bem como documento de identificação com foto do(s) representante(s) legal(is). Caso o cotista seja representado por procurador este deverá apresentar o instrumento particular de mandato, sendo certo que o procurador deve estar legalmente constituído há menos de 1 (um) ano.
Ressaltamos que os Srs. Cotistas e/ou seus representantes deverão apresentar seus documentos de identificação (documentos pessoais, societários ou procuração) quando da realização da assembleia. Os votos poderão ser encaminhados para a Rio Bravo, mediante modelo de voto por escrito disponibilizado quando da realização da assembleia.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>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 mínimo de 10 (dez) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto, observadas as formalidades previstas no artigo 13 do Anexo Normativo III da Resolução CVM n° 175.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos serviços de administração, será devida pelo Fundo uma remuneração correspondente a 0,10% (dez centésimos por cento) ao ano sobre o valor do patrimônio líquido do Fundo, provisionada mensalmente na proporção de um doze avos (1/12), paga até o dia 5º (quinto) Dia Útil do mês subsequente ao vencido, observada, ainda, a remuneração mínima de R$ 38.000,00 (trinta e oito mil reais) mensais, corrigida anualmente pela variação do Índice Geral de Preços do Mercado – IGP-M, apurado e divulgado pela Fundação Getúlio Vargas, com base em 02 de outubro de 2014 (“Taxa de Administração”).</PoliticaRemuneracao>
			<ValorPagoAno>1043548.95</ValorPagoAno>
			<PercentPatrimonioContabil>0.0021</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0166</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>PAULO ANDRE PORTO BILYK</Nome>
				<Idade>60</Idade>
				<CPF>8930378854</CPF>
				<Email>CORRESPONDECIA@RIOBRAVO.COM.BR</Email>
				<Profissao>Administrador de Empresas</Profissao>
				<FormacaoAcademica>Administrador de Empresas</FormacaoAcademica>
				<DataInicioFuncao>1994-07-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Rio Bravo Investimentos</NomeEmpresa>
						<Periodo>Desde 2015</Periodo>
						<CargoFuncoes>CIO Chief Investment Officer</CargoFuncoes>
						<AtividadePrincipalEmpresa>Investimentos Imobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Rio Bravo Investimentos</NomeEmpresa>
						<Periodo>Desde 2019</Periodo>
						<CargoFuncoes>CEO Chief Executive Officer</CargoFuncoes>
						<AtividadePrincipalEmpresa>Investimentos Imobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="120" numCotasDetidas="97611" percDetidoRelTotal="0.156" percDetidoPF="0.1226" percDetidoPJ="0.0334"/>
			<AcimaCincoAteDezPorcento numCotistas="9" numCotasDetidas="527929" percDetidoRelTotal="0.844" percDetidoPF="0.844"/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>https://riobravo.com.br/governanca-corporativa</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>https://riobravo.com.br/governanca-corporativa</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://riobravo.com.br/governanca-corporativa</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"