"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIÁRIO HERMES</NomeFundo>
		<CNPJFundo>00.868.235/0001-08</CNPJFundo>
		<DataFuncionamento>1995-10-03</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRHERMCTF004</CodigoISIN>
		<QtdCotasEmitidas>54316</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Híbrido</SegmentoAtuacao>
			<TipoGestao>Passiva</TipoGestao>
		</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>RIO BRAVO INVESTIMENTOS DTVM LTDA</NomeAdministrador>
		<CNPJAdministrador>00.868.235/0001-08</CNPJAdministrador>
		<Logradouro>AV. CHEDID JAFET</Logradouro>
		<Numero>222</Numero>
		<Complemento>BLOCO B - 3ª ANDAR</Complemento>
		<Bairro>VILA OLÍMPIA</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>045551-065</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>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Rio Bravo Investimentos DTVM Ltda</Nome>
				<CNPJ>72600026000181</CNPJ>
				<Endereco>Av. Chedid Jafet, 222 Bloco B 3º Andar</Endereco>
				<telefone>(11) 3509-6641</telefone>
			</Gestor>
			<Custodiante>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>ERNST &amp; YOUNG Auditores Independentes S.S.</Nome>
				<CNPJ>61.366.936/0001-25</CNPJ>
				<Endereco>Av. Pres. Juscelino Kubitschek, 1909 8º andar - São Paulo/SP</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>Auxiliadora Predial Ltda</Nome>
				<CNPJ>92.780.600/0001-38</CNPJ>
				<Endereco>A. Sete de Setembro, 1116 - Porto Alegre/RS</Endereco>
				<telefone>(51) 3216-6100</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Fundo tem por objeto captar recursos para investimento em incorporações, construções e empreendimentos imobiliários, podendo comprar, vender, revender ou locar imóveis comerciais e/ou residenciais situados no Estado do Rio Grande do Sul, por meio da aquisição dos seguintes ativos: (i) quaisquer direitos reais sobre bens imóveis, inclusive terrenos, centros comerciais e/ou residenciais, prédios destinados ao comércio varejista e atacadista, depósitos, lojas, conjuntos comerciais e/ou residenciais; e (ii) letras hipotecárias (“Ativos Imobiliários”). A politica deverá se manter inaterada para os exercícios seguintes.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O lucro líquido do Fundo no exercício foi de R$ 8,078 milhões. O resultado se deu principalmente às receitas de locação, totalizando R$ 9,034 milhões.</ResultadoFundo>
			<ConjunturaEconomica>Em termos econômicos o ano foi positivo ao país, a inflação permaneceu em valores historicamente baixos, sendo que terminou o ano em 3,74% a.a.. Isso permitiu uma queda de 0,5 ponto percentual na taxa SELIC, atingindo 6,5% a.a., valor mais baixo da história do plano real. Esse fato é importante para os Fundos Imobiliários, visto que os investimentos em Renda fixa tornaram-se bem menos atrativos influenciando os investidores a migrarem seus investimentos para ativos de risco.
Em relação ao Mercado Imobiliário, o ano de 2018 marcou o início da recuperação do setor, principalmente, nas regiões mais centrais do país. Por exemplo, nas regiões centrais do mercado de escritórios corporativos de São Paulo – ou seja, Faria Lima, Vila Olímpia e Paulista –, a taxa de vacância já é de um digito, conforme dados da consultoria Buildings. Aliado à falta de terrenos disponíveis para construção nessas regiões, a relação oferta e demanda do setor é positiva para os proprietários. Já quanto ao segmento de imóveis industriais e de logística em São Paulo, a taxa de vacância diminuiu em 2018, mas ainda se mantém em patamares superiores a 20%. Entretanto, ao olhar somente os imóveis até 30 km da capital, a taxa cai, ficando abaixo de 20%. A provável recuperação do poder de consumo da cidade e as mudanças que estamos observando no setor varejista, no qual novos players estão entrando no mercado brasileiro e o prazo para entrega dos produtos é cada vez menor, estimulam a instalação dessas empresas próximas à capital.
Para os Fundos Imobiliários (FIIs), o ano foi de consolidação, de forma que tivemos o recorde histórico nos termos de liquidez, tamanho do mercado e número de investidores. Em termos de rentabilidade, uma melhor análise é feita quando separamos o ano em três períodos. O primeiro quadrimestre relevante para o segmento, comprovado pelo montante significativo de registros de novas ofertas, novos fundos no mercado e alta rentabilidade acumulada do IFIX, de 5,0% no período, equivalente a 15,6% ao ano. Em maio de 2018, a greve dos caminhoneiros acabou expondo um país ainda muito fragilizado politicamente. Devido a essas incertezas políticas, em apenas um mês, os Fundos caíram 5,3%, devolvendo toda rentabilidade acumulada no ano. Porém, os fundamentos do mercado imobiliário não pareciam corroborar com essa queda tão abrupta. Não à toa, logo após as eleições, com uma perspectiva positiva para a economia, os FIIs se recuperaram, atingindo rentabilidade de 5,6% em 2018.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>xxxxx
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Hotel</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>20100000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0428</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Lojas e Conjuntos</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>59900000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0583</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Terreno</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>10250000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Estacionamento</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>10000000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0909</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>A Colliers International 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 esta sendo avaliada, avaliou para marcação a valor de mercado os imóveis de propriedade do Fundo na data base Novembro de 2018. (No exercício findo em 2018, avaliou os imóveis na data base de Novembro de 2018).
Para o Empreendimento América Business Square, a avaliação foi realizada pelo Método da Capitalização da Renda, analisando-se os contratos atuais e ao final deles, considerou-se que os imóveis seriam levados a mercado. Por este método determina-se o valor de venda dos imóveis através da capitalização da renda líquida possível de ser auferida por ele, através da análise de um fluxo de caixa descontado, no qual são consideradas todas as receitas e despesas para a operação do imóvel, descontado a uma taxa compatível com o mercado de 10,50%. 
Para o Empreendimento Hotel, a avaliação foi realizada pelo Método da Capitalização da Renda, analisando-se o contrato atual e ao final dele, considerou-se que os imóveis seriam levados a mercado. Por este método determina-se o valor de venda dos imóveis através da capitalização da renda líquida possível de ser auferida por ele, através da análise de um fluxo de caixa descontado, no qual são consideradas todas as receitas e despesas para a operação do imóvel, descontado a uma taxa compatível com o mercado de 10,75%.
Para o Terreno, foi aplicado o Método Comparativo Direto de Dados de Mercado, mediante o qual o valor do terreno é obtido pela comparação direta com outros terrenos semelhantes situados na mesma região geoeconômica.
Para o empreendimento denominado Novotel a avaliação foi realizada pelo Método da Capitalização da Renda, analisando-se os contratos e ao final deles, considerou-se que os imóveis seriam levados a mercado. Por este método determina-se o valor de venda dos imóveis através da capitalização da renda líquida possível de ser auferida por ele, através da análise de um fluxo de caixa descontado, no qual são consideradas todas as receitas e despesas para a operação do imóvel, descontado a uma taxa compatível com o mercado, considerando os bens de uso necessários ao funcionamento do hotel.</CriteriosAvaliacao>
		<ProcessosJudiciais>
			<Processo>
				<Numero>3408851-74.2005.8.21.0001</Numero>
				<Juizo>06ª Vara da Fazenda Pública</Juizo>
				<Instancia>Nos tribunais superiores</Instancia>
				<DataInstauracao>2000-06-09</DataInstauracao>
				<ValorCausa>56560.33</ValorCausa>
				<PartesProcesso>MUNICÍPIO DE PORTO ALEGRE</PartesProcesso>
				<PrincipaisFatos>Nulidade do IPTU com pedido de antecipação de tutela, a fim de discutir a alíquota de 6% referente aos exercícios de 1998, 1999 e 2000, referente ao imóvel situado na Rua Primeiro de Janeiro, 100, em vista da inconstitucionalidade do regime da progressividade de alíquotas fixado pela Lei 7/73, com a redação dada pela Lei 212/89.09/11/2017 Decisão desfavorável em segunda instância. Recurso especial sobrestado para julgamento pelo rito dos recursos repetitivos. Em 11/08/2017 Processo Reativado. Em 11/08/2017 Concluso os autos para juízo de admissibilidade. Em 14/08/2017 Processo desarquivado por paradigma julgado. Em 24/10/2017 Expedida nota de expediente. Em 09/11/2017 Proferida Decisão: "deve ser reativado o recurso extraordinário, oportunamente retornem os autos conclusos a esta Vice-Presidência, sob o registro do pertinente recurso extraordinário".</PrincipaisFatos>
				<ChancePerda>provável</ChancePerda>
				<AnaliseImpactoPerda>O valor envolvido atualizado é de R$ 58.639,15</AnaliseImpactoPerda>
			</Processo>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>AV CHEDID JAFET, 222 Bloco B 3º andar - São Paulo SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.riobravo.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>As solicitaçãos podem ser feitas no email ri@riobravo.com.br</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>A Assembleia Geral de Cotistas também pode ser convocada diretamente por Cotistas que detenham, no mínimo 5% (cinco por cento) das Cotas emitidas ou pelo Representante dos Cotistas, observado o disposto no presente Regulamento.A convocação da Assembleia Geral de Cotistas deve ser feita por carta, correio eletrônico ou telegrama encaminhada a cada Cotista. Por ocasião da Assembleia Geral Ordinária, os titulares de, no mínimo, 3% (três por cento) das cotas emitidas ou os Representantes dos Cotistas podem solicitar, por meio de requerimento escrito encaminhado à Instituição Administradora, a inclusão de matérias na ordem do dia da Assembleia Geral, que passará a ser Ordinária e Extraordinária. O pedido acima deve vir acompanhado de eventuais documentos necessários ao exercício do direito de voto e deve ser encaminhado em até 10 (dez) dias contados da data de convocação da Assembleia Geral Ordinária.Somente poderão votar na Assembleia Geral os Cotistas inscritos no registro de Cotistas na data da convocação da Assembleia Geral de Cotistas, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano.Os Cotistas também poderão votar por meio de comunicação escrita ou eletrônica, desde que recebida pela Instituição Administradora antes do início da Assembleia Geral de Cotistas e observado o disposto no Regulamento.</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 nos Artigos 19, 19-A e 41, incisos I e II, da Instrução CVM 472.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos serviços de administração, será devida pelo Fundo uma remuneração correspondente a 0,20% (zero virgula vinte por cento) ao ano sobre o valor do patrimônio líquido do Fundo, provisionada mensalmente na proporção de 1/12 (um doze avos), paga até o 5º (quinto) Dia Útil do mês subsequente, observada, ainda, a remuneração mínima de R$ 32.615,00 (trinta e dois mil, seiscentos e quinze reais) mensais, reajustada anualmente pela variação positiva do IGP-M, publicado pela Fundação Getúlio Vargas – FGV, a partir de 1º de janeiro de 2017. (“Taxa de Administração”).  </PoliticaRemuneracao>
			<ValorPagoAno>391380</ValorPagoAno>
			<PercentPatrimonioContabil>0.0038</PercentPatrimonioContabil>
			<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>PAULO ANDRE PORTO BILYK</Nome>
				<Idade>53</Idade>
				<CPF>8930378854</CPF>
				<Email>CORRESPONDECIA@RIOBRAVO.COM.BR</Email>
				<Profissao>Adminstrador de Empresas</Profissao>
				<FormacaoAcademica>Adminstrador 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>Últimos 5 anos</Periodo>
						<CargoFuncoes>Chief Investment Officer</CargoFuncoes>
						<AtividadePrincipalEmpresa>Investimentos Imobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="3" numCotasDetidas="2100" percDetidoRelTotal="0.0387" percDetidoPF="1" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento numCotistas="2" numCotasDetidas="6056" percDetidoRelTotal="0.1115" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento numCotistas="1" numCotasDetidas="9084" percDetidoRelTotal="0.167243537815745" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="37076" percDetidoRelTotal="0.6826" percDetidoPF="0" percDetidoPJ="1"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>O Fundo Hermes não é listado e portanto não se aplica dentro da politica de fatos relevantes</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>www.riobravo.com.br</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>www.riobravo.com.br</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"