"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FII BARIGUI RENDIMENTOS IMOBILIÁRIOS I FII</NomeFundo>
		<CNPJFundo>29267567000100</CNPJFundo>
		<DataFuncionamento>2016-04-04</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN>BRBARICTF003</CodigoISIN>
		<QtdCotasEmitidas>305000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Títulos e Valores Mobiliários</Mandato>
			<SegmentoAtuacao>Títulos e Val. Mob.</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>30/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>OLIVEIRA TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>29267567000100</CNPJAdministrador>
		<Logradouro>Avenida das Américas</Logradouro>
		<Numero>3434</Numero>
		<Complemento>Bloco 07, sala 201</Complemento>
		<Bairro>Barra da Tijuca</Bairro>
		<Cidade>Rio de Janeiro</Cidade>
		<Estado>RJ</Estado>
		<CEP>22640-102</CEP>
		<Telefone1>(21) 3514-0000</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.oliveiratrust.com.br</Site>
		<Email>ger2.fundos@oliveiratrust.com.br</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>BARIGUI GESTÃO DE RECURSOS LTDA</Nome>
				<CNPJ>17.054.901/0001-69</CNPJ>
				<Endereco>Cidade de São Paulo, Estado de São Paulo, na Rua Álvaro Anes, nº 46, 11º andar, cj. 114 – Pinheiros</Endereco>
				<telefone>55 (11) 2144 - 4036</telefone>
			</Gestor>
			<Custodiante>
				<Nome>OLIVEIRA TRUST DTVM S.A.</Nome>
				<CNPJ>36.113.876/0001-91</CNPJ>
				<Endereco>Cidade do Rio de Janeiro, Estado do Rio de Janeiro, na Avenida das Américas, nº 3.434, Bloco 07, Sala 201, Barra da Tijuca</Endereco>
				<telefone>55 (21) 3514 - 0000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KPMG Auditores Independentes</Nome>
				<CNPJ>57.755.217/0001-29</CNPJ>
				<Endereco>Rua Arquiteto Olvao Redig Campos, 105, 11º andar, Edifício EZ Tower – Torre A, São Paulo – SP - Cep: 04.711-904</Endereco>
				<telefone>55 (11) 3940-2118</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>
					<Ativo>
						<Nome>CRI 18L1111524</Nome>
						<Objetivos>Alocação de portifolio para renda mensal</Objetivos>
						<MontantesInvestidos>29874217.71</MontantesInvestidos>
						<OrigemRecursos>Cedulas de crédito imobiliário </OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>A oferta do Fundo de Investimento Imobiliário Barigui Rendimentos Imobiliários I FII encontra-se ainda em fase de captação com encerramento da oferta previsto para o primeiro semestre de 2019, onde os recursos oriundos das novas subscrições de cotas serão alocados em CRI's com lastro em créditos Imobiliários pulverizados que atendam os critérios de elegibilidade definidos no regulamento do Fundo.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>A cota do fundo em 31 de dezembro de 2018 fechou em 100,691731, valorização de 0,69% frente ao valor de emissão neste mesmo mês de R$ 100,00. a Julgar pelo fato do Fundo ter sua primeira subscrição de cotas em 12 de dezembro de 2018 e a primeira alocação em CRI foi feita em 19 de dezembro de 2018 acreditamos ser um resultado satisfatório, lembrando  que o período de amostragem para apuração deste resultado foi de apenas 12 dias uteis a contar da primeira subscrição de cotas do Fundo. </ResultadoFundo>
			<ConjunturaEconomica>A julgar exclusivamente pelo IFIX (Índice de Fundos de Investimento Imobiliário) que vinha sofrendo uma constante depreciação dentro do 1S2018, e seguiu sem grandes alterações até meados do segundo semestre. Que e por fim mostrou uma grande reação na segunda metade o 2S2018, período este que se iniciou as atividades do Fundo, e fechou o ano com taxa de crescimento de 5,6% com relação ao ano de 2017. Entrando no que diz respeito a créditos imobiliários pulverizados (estratégia de atuação do Fundo) notamos uma redução do volume de estoques das incorporadoras no período, que consequentemente gera um aumento de originação de créditos imobiliários. </ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Com o  reaquecimento da economia brasileira somados a constante baixa nos estoques das incorporadoras, vislumbramos um cenário positivo no que se diz respeito a retomada dos lançamentos tanto para o setor residencial como comercial em créditos imobiliarios pulverizados, e consequentemente um aumento pela demanda de financiamentos com garantia imobiliária beneficiando a estratégia do Fundo e seus novos investimentos e alocações.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>CRI 18L1111524</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>30039717.4</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Metodologia de precificação seguindo curva de variação do índice.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida das Américas, 3434, bloco 07, sala 201, Barra da Tijuca, Rio de Janeiro - RJ</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>ger2.fundos@oliveiratrust.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>As solciitações dos itens (i) e (ii) podem ser direcionadas diretamente para  e-mail da equipe de Administração, qual seja, ger2.fundos@oliveiratrust.com.br ou ainda pelo "Fale Conosco" disponível no portal do administrador pelo link a seguir: http://www.oliveiratrust.com.br/portal/?item1=Atendimento&amp;item2=Fale_Conosco</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Somente poderão votar na assembléia geral os cotistas inscritos no registro de cotistas na data da convocação da assembléia, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano. As deliberações da Assembleia Geral de Cotistas do Fundo poderão ser tomadas mediante processo de consulta formalizada em carta, telex, telegrama, correio eletrônico (e-mail) ou fac-símile, ambos com confirmação de recebimento, a ser dirigido pelo Administrador a cada Cotista para resposta no prazo máximo de 30 (trinta) dias corridos, observadas as formalidades previstas na legislação vigente. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>O Regulamento do Fundo não prevê a possibilidade de realização de assembleia por meio eletrônico.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos serviços de administração do Fundo, neles compreendidas as atividades descritas no Artigo 2º deste Regulamento, bem como as atividades de gestão, custódia, escrituração e controladoria de ativos, o Fundo pagará ao Administrador e aos demais prestadores de serviços do Fundo, nos termos deste Regulamento e em conformidade com a regulamentação vigente, uma remuneração máxima, a título de Taxa de Administração, equivalente a 1,305% (um inteiro e trezentos e cinco milésimos por cento) ao ano, à razão de 1/252 (um duzentos e cinquenta e dois avos), aplicado sobre o valor do Patrimônio Líquido diário do Fundo, a ser paga aos respectivos prestadores de serviços no último Dia Útil de cada mês. </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>José Alexandre Costa de Freitas</Nome>
				<Idade>47</Idade>
				<CPF>008.991.207-17</CPF>
				<Email>ger2.fundos@oliveiratrust.com.br</Email>
				<Profissao>Diretor Presidente</Profissao>
				<FormacaoAcademica>Direito</FormacaoAcademica>
				<DataInicioFuncao>2015-06-11</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Oliveira Trust</NomeEmpresa>
						<Periodo>Março/1992 - Data Atual</Periodo>
						<CargoFuncoes>Diretor Presidente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Distribuidora de Títulos e Valores Mobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="1" numCotasDetidas="5000" percDetidoRelTotal="0.01639" percDetidoPF="1" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento numCotistas="1" numCotasDetidas="80000" percDetidoRelTotal="0.2623" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="2" numCotasDetidas="220000" percDetidoRelTotal="0.72131" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>São considerados relevantes pelo Administrador qualquer deliberação da assembleia geral de cotistas ou do Administrador ou qualquer outro ato ou fato que possa influir de modo ponderável (I) na cotação das cotas ou de valores mobiliários a elas referenciados, (II) na decisão dos investidores de comprar, vender ou manter as cotas, e (III) na decisão dos investidores de exercer quaisquer direitos inerentes à condição de titular cotas ou de valores mobiliários a elas referenciados, tais como, exemplificativamente, mas não limitados a: I – atraso para o recebimento de quaisquer rendimentos que representem percentual significativo dentre as receitas do fundo; II – venda ou locação dos imóveis de propriedade do fundo destinados a arrendamento ou locação, e que possam gerar impacto significativo em sua rentabilidade; III – fusão, incorporação, cisão, transformação do fundo ou qualquer outra operação que altere substancialmente a sua composição patrimonial; IV – emissão de cotas nos termos do inciso VIII do artigo 15 da Instrução CVM 472. Tais informações são divulgadas à CVM, à BM&amp;FBovespa, e também através do site do Administrador, no endereço https://www.oliveratrust.com.br/. Adicionalmente, o Administrador adota segregação física da sua área de administração de fundos imobiliários em relação às áreas responsáveis por outras atividades e linhas de negócio. Neste sentido, o acesso a sistemas e arquivos, inclusive em relação à guarda de documentos de caráter confidencial, é restrito à equipe dedicada pela administração de tais fundos, sendo possível o compartilhamento de informações às equipes jurídicas e de compliance que atendam tal área de negócio. Adicionalmente, o Administrador tem como política interna a exigência de termos de confidencialidade com todos os seus funcionários, no momento de sua contratação.</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>Fundo listado em bolsa de valores (BM&amp;FBovespa), onde suas cotas são admitidas à negociação no mercado secundário. As informações e documentos públicos do fundo estão disponíveis no website do Administrador: https://www.oliveratrust.com.br</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.oliveiratrust.com.br/downloads/OLIVEIRA_TRUST_Politica_de_Voto.pdf</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>A integralização de Cotas pelos Cotistas, até o valor comprometido, deverá ocorrer em até 5 (cinco) dias úteis contados do recebimento da chamada de capital a ser enviada pelo Administrador mediante o envio de correspondência com aviso de recebimento, telegrama com comunicação de entrega, fax ou correio eletrônico dirigido para os Cotistas, conforme as informações constantes no Boletim de Subscrição e no Compromisso de Investimento, observado o descrito no Compromisso de Investimento.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"