"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>Banestes Recebiveis Imobiliarios FII</NomeFundo>
		<CNPJFundo>22219335000138</CNPJFundo>
		<DataFuncionamento>2015-05-14</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRBCRICTF009</CodigoISIN>
		<QtdCotasEmitidas>1210001</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>BANCO FATOR S.A</NomeAdministrador>
		<CNPJAdministrador>22219335000138</CNPJAdministrador>
		<Logradouro>RUA DR RENATO PAES DE BARROS</Logradouro>
		<Numero>1017</Numero>
		<Complemento>12ª ANDAR</Complemento>
		<Bairro>ITAIM BIBI</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04530001</CEP>
		<Telefone1>30499165</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>fator.com.br</Site>
		<Email>recursosdeterceiros@fator.com.br</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>BANESTES DISTRIBUIDORA DE TÍTULOS E VALORES MOBILIÁRIOS S.A</Nome>
				<CNPJ>28156057000101</CNPJ>
				<Endereco>Av.: Nossa Senhora dos Navegantes, N.º 755, Salas 7 e 8. Enseada do Suá, Vitória ES, CEP: 29.050-335.</Endereco>
				<telefone>(27) 3383-3110</telefone>
			</Gestor>
			<Custodiante>
				<Nome>ITAÚ UNIBANCO S.A</Nome>
				<CNPJ>60701190000104</CNPJ>
				<Endereco>PRAÇA ALFREDO EDYDIO DE SOUZA ARANHA, 100 - TORRE ITAÚSA - SÃO PAULO - SP</Endereco>
				<telefone>(11) 30496215</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>BDO RCS AUDITORES INDEPENDENTES - SOCIEDADE SIMPLES</Nome>
				<CNPJ>54276936000179</CNPJ>
				<Endereco>RUA MAJOR QUEDINHO, 90 - 3º ANDAR - CONSOLAÇÃO - SÃO PAULO - SP</Endereco>
				<telefone>(11) 30496215</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BANESTES DISTRIBUIDORA DE TÍTULOS E VALORES MOBILIÁRIOS S.A</Nome>
				<CNPJ>28156057000101</CNPJ>
				<Endereco>RUA DR. RENATO PAES DE BARROS, 1017 - 12 ANDAR - SÃO PAULO</Endereco>
				<telefone>(11) 30496215</telefone>
			</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>MRV Engenharia 11ª Emissão 2ª Série</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>4112537.26</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>RB Capital 1ª Emissão 107ª Série</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>3403689.83</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Ourinvest 1ª Emissão 11ª Série</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2141471.52</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Gaia 4ª Emissão 106ª Série</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>4065155.93</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Ápice 1ª Emissão 149ª Série</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>5222345.52</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Apice  1ª Emissão 143ª Série</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>5064001.11</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>RB Capital 1ª Emissão 187ª Série</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>3850092.9</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Ourinvest 1ª Emissão 14ª Série</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2192120.94</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo distribuiu a título de rendimentos o equivalente a R$ 9,90 por cota, o que representa um Dividend Yield de 9,90% considerando a cota de Fechamento de 2018 (R$100,82).</ResultadoFundo>
			<ConjunturaEconomica>No último semestre do ano de 2018 teve dois meses em que os índices de inflação (IGP-M e IPCA) foram negativos, impactando os resultados do fundo, visto que parcela significativa dos ativos do fundo estão lastreados em índices de inflação. </ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A perspectiva para o ano de 2019 é que os índices de inflação se mantém próximo ao patamar de 2018 de forma a impactar positivamente nos resultados dos ativos do fundo, e consequentemente no resultado da carteira, mantendo a relação risco e retorno.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Apice  1ª Emissão 143ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5064001.11</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ápice 1ª Emissão 149ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5222345.52</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ápice 1ª Emissão 22ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5023441.05</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ápice 1ª Emissão 63ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4279053.65</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ápice 1ª Emissão 74ª  Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3508807.8</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ápice 1ª Emissão 82ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1604298.09</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ápice 1ª Emissão 83ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5618410.56</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Barigui 1ª Emissão 1ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6714116.77</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Barigui 1ª Emissão 52ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5277476.43</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Brazilian 1ª Emissão 261ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>91521.47</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Cibrasec 2ª Emissão 290ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4166517.13</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Gaia 4ª Emissão 100ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5960815.43</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Gaia 4ª Emissão 106ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4065155.93</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Gaia 4ª Emissão 53ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1241084.42</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Gaia 4ª Emissão 7ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3915332.11</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Gaia 4ª Emissão 97ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2044114.28</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Habitasec 1ª Emissão 1ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1212025.15</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Habitasec 1ª Emissão 58ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1090310.65</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Habitasec 1ª Emissão 64ª  Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>830347.05</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>MRV Eng 11ª Emissão 2ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4112537.26</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ourinvest 1ª Emissão 11ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2141471.52</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ourinvest 1ª Emissão 14ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2192120.94</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª  Emissão  108ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2751453.77</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 107ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3403689.83</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 109ª  Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1891133.46</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 122ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3002002.19</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 130ª  Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>521966.59</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 141ª  Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1046468.25</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 153ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5045467.06</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 165ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5185101.42</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 187ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3850092.9</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 77ª  Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>232028.67</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 94ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1490234.24</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>RB Capital 1ª Emissão 95ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3513669.98</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>SCCI 1ª Emissão 19ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>531360.79</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>SCCI 1ª Emissão 1ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3241986.82</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>SCCI 1ª Emissão 31ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4185048.76</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>SCCI 1ª Emissão 32ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4477237.35</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>TRX 1ª Emissão 14ª Série</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3516766.67</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os Ativos e os Ativos de Liquidez serão precificados de acordo com procedimentos para registro e avaliação de títulos e valores mobiliários, conforme estabelecido na regulamentação em vigor (tais como o critério de marcação a mercado) e de acordo com o manual de precificação adotado pelo Custodiante. O manual está disponível para consulta no website www.itaucustodia.com.br/Manual_Precificacao.pdf . A precificação dos Ativos e dos Ativos de Liquidez será feita pelo valor de mercado com base no manual de precificação do CUSTODIANTE. No entanto, caso o ADMINISTRADOR e/ou o GESTOR não concordem com a precificação baseada no manual de precificação do CUSTODIANTE, o ADMINISTRADOR e o GESTOR, em conjunto com o CUSTODIANTE, deverão decidir de comum acordo o critério a ser seguido.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Dr. Renato Paes de Barros, 1017 - 11 e 12 andares - Itai Bibi - São Paulo - SP - CEP: 04530-001</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>fator.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Todas as informações e documentos relativos ao Fundo que, por força deste Regulamento e/ou normas aplicáveis, devem ficas disponíveis aos quotists poderão ser obtidos e/ou consultados na sede do Administrador ou em sua página na rede mundial de computadores no seguinte endereço www.fator.com.br e na CVM, pelo site www.cvm.gov.br;</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Todas as informações e documentos relativos ao Fundo que, por força deste Regulamento e/ou normas aplicáveis, devem ficas disponíveis aos quotists poderão ser obtidos e/ou consultados na sede do Administrador ou em sua página na rede mundial de computadores no seguinte endereço www.fator.com.br e na CVM, pelo site www.cvm.gov.br;</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>0</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos serviços do Administrador, nos termos deste Regulamento e em conformidade com a regulação vigente, o Fundo pagará ao Administrador uma remuneração equivalente a 1,00% (um por cento) ao ano calculado sobre o valor de mercado do Fundo, calculado com base na média diária da cotação de fechamento das Quotas de emissão do Fundo no mês anterior ao do pagamento da Taxa de Administração pelo Fundo, sendo que este valor deverá corresponder a, no mínimo, R$ 30.000,00 (trinta mil reais) por mês, atualizado anualmente pela variação acumulada do IGPM a partir de 1º de março de 2015. No pagamento da Taxa de Administração observar-se-á as seguintes regras:
o valor equivalente à R$ 10.000,00 (dez mil reais), no mínimo, serão pagos diretamente ao Administrador que utilizará prioritariamente para o pagamento da remuneração dos prestadores de serviços de controladoria, tesouraria e de escrituração; e
o restante será dividido entre o Administrador, ao Gestor e a Co-Gestora de Investimentos da seguinte forma: (a) ao Administrador 25% (vinte e cinco por cento) do restante da Taxa de Administração; (b) ao Gestor 50% (cinquenta por cento) do restante da Taxa de Administração; e (c) ao Consultor de Investimentos 25% (vinte e cinco por cento) do restante da Taxa de Administração. 
A Taxa de Administração será calculada e provisionada diariamente, por Dia Útil, considerado o ano de 252 (duzentos e cinquenta e dois) Dias Úteis, como despesa do Fundo, e será paga mensalmente até o 5º (quinto) Dia Útil do mês subsequente.</PoliticaRemuneracao>
			<ValorPagoAno>1154345.56</ValorPagoAno>
			<PercentPatrimonioContabil>0.01</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.01</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 VELLANI DE LIMA</Nome>
				<Idade>47</Idade>
				<CPF>14733190808</CPF>
				<Email>plima@fator.com.br</Email>
				<Profissao>ECONOMISTA</Profissao>
				<FormacaoAcademica>GRADUAÇÃO EM ECONOMIA, PUC SP</FormacaoAcademica>
				<DataInicioFuncao>2015-12-07</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>BANCO FATOR S.A</NomeEmpresa>
						<Periodo>12/2015 - Atual</Periodo>
						<CargoFuncoes>Diretor de Recursos de Terceiros</CargoFuncoes>
						<AtividadePrincipalEmpresa>Administração Fiduciária</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>FAOR S.A CORRETORA DE VALORES</NomeEmpresa>
						<Periodo>12/2015 - Atual</Periodo>
						<CargoFuncoes>Diretor de Recursos de Terceiros</CargoFuncoes>
						<AtividadePrincipalEmpresa>Administração Fiduciária</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>FAR FATOR ADMINISTRAÇÃO DE RECURSOS LTDA</NomeEmpresa>
						<Periodo>01/2008 - 12/2015</Periodo>
						<CargoFuncoes>Gerente Processo de Operações</CargoFuncoes>
						<AtividadePrincipalEmpresa>Administração Fiduciária</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="5862" numCotasDetidas="1210001" percDetidoRelTotal="1" percDetidoPF="0.9907" percDetidoPJ="0.0093"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>Todas as informações e documentos relativos ao Fundo que, por força deste Regulamento e/ou normas aplicáveis, devem ficar disponíveis aos quotistas poderão ser obtidos e/ou consultados na sede do Administrador ou em sua página na rede mundial de computadores no seguinte endereço www.fator.com.br e na CVM, pelo site www.cvm.gov.br;</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas xsi:nil="true"/>
			<PoliticaExercicioDireitoVoto>Todas as informações e documentos relativos ao Fundo que, por força deste Regulamento e/ou normas aplicáveis, devem ficar disponíveis aos quotistas poderão ser obtidos e/ou consultados na sede do Administrador ou em sua página na rede mundial de computadores no seguinte endereço www.fator.com.br e na CVM, pelo site www.cvm.gov.br;</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"