"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FARIA LIMA CAPITAL RECEBÍVEIS IMOBILIÁRIOS I - FII</NomeFundo>
		<CNPJFundo>33884145000151</CNPJFundo>
		<DataFuncionamento>2019-05-24</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>BRFLCRR01M19</CodigoISIN>
		<QtdCotasEmitidas>500000</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>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BRL TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>33884145000151</CNPJAdministrador>
		<Logradouro>Rua Iguatemi</Logradouro>
		<Numero>151</Numero>
		<Complemento>19º andar</Complemento>
		<Bairro>Itaim Bibi</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>01451-011</CEP>
		<Telefone1>(11)31330350</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.brltrust.com.br</Site>
		<Email>juridico.fii@brltrust.com.br </Email>
		<Competencia>2021-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>FARIA LIMA CAPITAL LTDA</Nome>
				<CNPJ>23398913000103</CNPJ>
				<Endereco>Avenida Brigadeiro Faria Lima, 2894, 9º andar,
Conjunto 91, São Paulo/SP</Endereco>
				<telefone>(11) 3074-4919</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BRL TRUST DTVM S.A.</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151, 19° Andar - CEP 01451-011 São Paulo/SP</Endereco>
				<telefone>(11) 3133-0350</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KPMG AUDITORES INDEPENDENTES</Nome>
				<CNPJ>57755217001281</CNPJ>
				<Endereco>Rua Dr. Renato Paes de Barros, 33 - São Paulo</Endereco>
				<telefone>(11) 3940-3162</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>FII BARIGUI - BARI11</Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>51925</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FII VBI CRI - CVBI11</Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>10225</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FII DEVANT - DEVA11	</Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>21901.8</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FII MORE CRI - MORC11</Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>601140</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FII RBR PCRI - RBRY11	</Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>18095.8</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FII UBS (BR) - RECR11</Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>4762547.3</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FII VALORAIP - VGIP11	</Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>73775.6</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI_19J0713613 - HABITASEC </Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>2902579.2</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI_19L0906182 - HABITASEC </Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>4877016.02</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI_20L0870667 - HABITASEC </Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>5002132.67</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI_21C0731381 - HABITASEC </Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>5000136</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI_21F1076965 - HABITASEC </Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>5000000</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI_21G0881444 - HABITASEC </Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>4972105.31</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI_21H0720107 - HABITASEC </Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>5000000</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRI_21L0866334 - TRUE SEC</Nome>
						<Objetivos>Benefícios futuros</Objetivos>
						<MontantesInvestidos>4678687.48</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O objetivo do Fundo é a obtenção de renda e ganho de capital por meio da aquisição e negociação de Ativos Alvo, observada a Política de Investimentos estabelecida em regulamento. Descatam-se as aquisições de Ativos Alvo que sejam CRI devem respeitar regras específicas definidas em regulamento.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>No exercício social findo em 31/12/2021, o Fundo, foi apurado um lucro no montante de R$ 6.385.517,99, sendo as principais rubricas: Resultado com operações imobiliárias  no valor de R$ 7.132.096,40; Outras Receitas Operacionais no valor de  R$ 4.841.119,72 e as demais despesas no valor de R$ 5.587.698,13.</ResultadoFundo>
			<ConjunturaEconomica>O IFIX, indicador do desempenho médio das cotações dos fundos imobiliários negociados nos mercados de bolsa e de balcão organizado da B3, fechou o mês de dezembro com uma alta de 2,19%. Apesar do desfecho ainda indefinido da pandemia do coronavírus ocasionar alguns pontos de interrogação diante do investidor de fundos imobiliários (FII), o mercado imobiliário vem apresentando sinais de recuperação.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Fundos imobiliários " tendem a diversificar a carteira, contribuindo para a maximização da fronteira eficiente, ou seja, ajudam na relação entre risco e retorno. Fundos que possuem como característica o investimento em recebíveis possuem perspectiva positiva de retorno para o ano de 2021, principalmente pelo fato dos Fundos de CRIs continuarem aproveitando o cenário de taxa de juros baixa.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>FII BARIGUI - BARI11</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>51925</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>FII VBI CRI - CVBI11</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>10225</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>FII DEVANT - DEVA11	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>21901.8</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>FII MORE CRI - MORC11</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>601140</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>FII RBR PCRI - RBRY11	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>18095.8</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>FII UBS (BR) - RECR11</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4762547.3</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>FII VALORAIP - VGIP11	</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>73775.6</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_19J0713613 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2913925.34</Valor>
				<PercentValorizacaoDesvalorizacao>0.0039</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_19K1145467 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1391532.61</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_19L0906182 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5002031.93</Valor>
				<PercentValorizacaoDesvalorizacao>0.0256</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_20A1026890 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4927563.07</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_20L0870667 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4594505.48</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0814</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_21C0731381 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5090378.8</Valor>
				<PercentValorizacaoDesvalorizacao>0.018</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_21F1076965 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4937769.3</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0124</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_21G0881444 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4995376.31</Valor>
				<PercentValorizacaoDesvalorizacao>0.0046</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_21H0720107 - HABITASEC </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5116920.63</Valor>
				<PercentValorizacaoDesvalorizacao>0.0233</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>CRI_21L0866334 - TRUE SEC</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4701614.19</Valor>
				<PercentValorizacaoDesvalorizacao>0.0049</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Entende-se por valor justo o valor pelo qual um ativo pode ser trocado ou um passivo liquidado entre partes independentes, conhecedoras do negócio e dispostas a realizar a transação, sem que represente uma operação forçada, conforme instrução CVM 516, Art. 7º §1º.
Os fundos de investimentos imobiliários são trazidos ao valor justo através da marcação a mercado e a marcação de preço dos títulos de crédito privado (CRI) é feita na curva do papel.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Iguatemi nº 151 19º andar Bairro Itaim Bibi Cidade de São Paulo Estado de São Paulo</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>WWW.BRLTRUST.COM.BR</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>A convocação da Assembleia Geral de Cotistas pelo Administrador far-se-á mediante correspondência encaminhada a cada Cotista, por meio de correio eletrônico (email), contendo, obrigatoriamente, o dia, hora e local em que será realizada tal Assembleia e ainda, de forma sucinta, os assuntos a serem tratados.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>A convocação da Assembleia Geral de Cotistas deve ser feita com pelo menos 30 (trinta) dias de antecedência no caso de Assembleias Gerais Ordinárias e com pelo menos 15 (quinze) dias de antecedência no caso de Assembleias Gerais  30 Extraordinárias, contado o prazo da data de comprovação de recebimento da convocação pelos Cotistas. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>A convocação da Assembleia Geral de Cotistas pelo Administrador far-se-á mediante correspondência encaminhada a cada Cotista, por meio de correio eletrônico (email), contendo, obrigatoriamente, o dia, hora e local em que será realizada tal Assembleia e ainda, de forma sucinta, os assuntos a serem tratados. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>O Fundo terá uma Taxa de Administração fixa e anual equivalente a 1,00% ao ano, sujeito aos valores mínimos estipulados abaixo e calculada à razão de 1/12 : (A) sobre o Patrimônio
Líquido do Fundo; ou (B) sobre o valor de mercado do Fundo, caso suas cotas tenham integrado ou passado a integrar, no período, índices de mercado, cuja metodologia preveja critérios de inclusão que considerem a liquidez das cotas e critérios de ponderação que considerem o volume financeiro das cotas emitidas pelo Fundo, como por exemplo, o Índice de Fundos de Investimentos Imobiliários (IFIX), calculado com base na média diária da cotação de fechamento das cotas de emissão do Fundo no mês anterior ao do pagamento da remuneração.. Deverá ser pago ao Administrador, pelos serviços de administração, controladoria, custódia e escrituração, o valor mínimo mensal de: (a) R$ 15.000,00 (quinze mil reais) até o encerramento da primeira Oferta Pública que seja destinada ao público geral, desde que distribuído o montante mínimo previsto nos documentos da respectiva Oferta Pública; e (b) R$ 20.000,00 (vinte mil reais) após o final do período acima mencionado. Os valores acima serão atualizados anualmente segundo a variação do IPCA, ou índice que vier a substituí-lo, a partir do mês de início de funcionamento do Fundo.
</PoliticaRemuneracao>
			<ValorPagoAno>511585.57</ValorPagoAno>
			<PercentPatrimonioContabil>0.0102</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0102</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>Danilo Christófaro Barbieri</Nome>
				<Idade>42</Idade>
				<CPF>28729710847</CPF>
				<Email>dbarbieri@brltrust.com.br</Email>
				<Profissao>Administrador de empresas</Profissao>
				<FormacaoAcademica>Administrador de empresas</FormacaoAcademica>
				<DataInicioFuncao>2018-04-01</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>BRL TRUST DTVM S.A</NomeEmpresa>
						<Periodo>Desde 01/04/2016</Periodo>
						<CargoFuncoes>Sócio-Diretor</CargoFuncoes>
						<AtividadePrincipalEmpresa>Administrador fiduciário</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="837" numCotasDetidas="160058" percDetidoRelTotal="0.3201" percDetidoPF="0.2189" percDetidoPJ="0.1012"/>
			<AcimaCincoAteDezPorcento numCotistas="2" numCotasDetidas="79033" percDetidoRelTotal="0.158" percDetidoPF="0.083" percDetidoPJ="0.075"/>
			<AcimaDezAteQuinzePorcento numCotistas="2" numCotasDetidas="132106" percDetidoRelTotal="0.2642" percDetidoPF="0" percDetidoPJ="0.2642"/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento numCotistas="1" numCotasDetidas="128803" percDetidoRelTotal="0.2576" percDetidoPF="0" percDetidoPJ="0.2576"/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>A divulgação de ato ou fato relevante pela Administradora é realizada nos termos da regulamentação aplicável e seu conteúdo é disponibilizado no sistema Fundos.Net, vinculado à CVM e à B3, bem como no site da Administradora http://www.brltrust.com.br</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>A negociação das cotas do Fundo é realizada exclusivamente por meio dos sistemas operacionalizados pela B3 - Brasil, Bolsa, Balcão S.A.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>www.brltrust.com.br</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Daniela Assarito Bonifacio Borovicz  – CPF: 320.334.648-65 - Diretora responsável pelo Departamento Jurídico.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>As regras e prazos para chamada de capital do Fundo, se houver, estarão previstas nos documentos relativos às ofertas de distribuição de cada emissão de cotas.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"