"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>SUCCESS FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>15348117000138</CNPJFundo>
		<DataFuncionamento>2012-08-29</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>1000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>true</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Shoppings</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>30/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>false</MBO>
			<MB>true</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BRL TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>15348117000138</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>01451011</CEP>
		<Telefone1>11 3133-0350</Telefone1>
		<Telefone2>11 4871-2221</Telefone2>
		<Telefone3>11 3133-0351</Telefone3>
		<Site>WWW.BRLTRUST.COM.BR</Site>
		<Email>CONTROLADORIA@BRLTRUST.COM.BR</Email>
		<Competencia>2016-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>TAG INVESTIMENTOS LTDA</Nome>
				<CNPJ>1591499000111</CNPJ>
				<Endereco>Av Santo Amaro, 48 -  6º and - Itaim Bibi</Endereco>
				<telefone>(11) 3474-0000</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BRL TRUST DTVM S.A.</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 19º and - Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>YORK PARTNERS AUDITORIA INDEPENDENTE S/S</Nome>
				<CNPJ>24.882.658/0001.32</CNPJ>
				<Endereco>AV BRIGADEIRO FARIA LIMA, 1572,CONJ 509 PARTE JARDIM PAULISTANO</Endereco>
				<telefone>(11) 6588-0943</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>BRL TRUST DTVM S.A.</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 19º and - Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</telefone>
			</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>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>O resultado apurado no exercício do fundo foi lucro no valor de  R$ 4.160.087,72.</ResultadoFundo>
			<ConjunturaEconomica>A crise política e a recessão impactaram negativamente o setor imobiliário e de gestão patrimonial no Brasil em 2016.  As incertezas do cenário político destruíram a confiança do investidor, enquanto o desemprego e o crédito mais caro e restrito dificultaram as negociações.   O mercado imobiliário residencial, encerrou 2016 com expansão dos lançamentos de novos projetos (+9% em relação a 2015) e redução nas vendas (-8% ante 2015), o que ainda configura um quadro de adversidades para incorporadoras e construtoras.  Em relação aos alugueis o mercado também se retraiu e os valores reduziram, poucas capitais apresentaram aumento. O cenário foi positivo para os consumidores que já possuíam a reserva de dinheiro para a compra do imóvel. </ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A desaceleração da inflação deverá deixar o índice mais próximo da meta central para o ano, que é de 4.5%.  A flexibilização da política monetária deverá se intensificar em 2017 e puxar para baixo a taxa de juros no setor.  O crescimento do PIB representa um fator que contribui para a recuperação do mercado imobiliário.  Um ano de melhora no cenário político-econômico, com aumento da confiança dos investidores e dos consumidores da indústria imobiliária.
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Ativo 1 - Localizado à Rodovia PA 160, lote 10-B da Quadra 04 s/n°, km 16 Gleba Taboca, Parauapebas/PA; Área Total 14,52 h.a</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2200000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ativo 2 -  Localizado à Rodovia BR 135 s/n°, km 15, Bairro Vila Maranhão, São Luis/MA; Área Total 97.166,858 m2</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>4600000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ativo 3 - Localizado à Estrada Luciano Rocha Peçanha, 1.500, bairro da Ressaca, Atibaia/SP; Área Total 7.338 m2</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>800000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ativo 4 - Localizado à Avenida Rui Barbosa 88, bairro do Jardim Gramacho, Duque de Caxias/RJ</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1099575</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ativo 5 -  Localizado à Rua Almirante Grenfeel, 405, com acesso pela Rodovia Washington Luís, 2.910, Conjuntos 513 e 514 do Bloco 03 – Condomínio Centro Empresarial Washington Luiz, bairro Parque Duque de Caxias, Duque de Caxias/RJ</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>530425</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ativo 6 - Localizado à Rua Princesa Isabel, 760, bairro Cidade Nova, Pindamonhangaba/SP; Área Total 600 m2.</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>200000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ativo 7 - Localizado à Rua Rodolfo Moreira Costalonga, 10, Bairro Nova Valverde, Cariacica/ES; Área Total 6.048,30 m2</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>700000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Ativo 8 - Localizado à Via Expressa de Contagem, 15.999, bairro de Vila Cristina, Betim/MG; Área Total 68.448,04 m2</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>42000000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os investimentos foram avaliados conforme laudo de avaliação efetuado por consultor independente contratado pelo administrador.</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 será realizada por qualquer meio de comunicação cuja comprovação de recebimento pelos membros do Comitê de Investimentos seja possível, e desde que o fim pretendido
seja atingido, tais como envio de correspondência com aviso de recebimento, fac-símile e correio eletrônico (e-mail), sendo a convocação dispensada quando estiverem presentes à reunião todos os membros do Comitê de Investimentos. Ainda, admite-se que a segunda convocação da reunião do Comitê de Investimentos seja providenciada juntamente com a correspondência de primeira convocação. </MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>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 (e-mail), e será disponibilizada nas páginas do Administrador e do Distribuidor na rede mundial de computadores, contendo, obrigatoriamente, o dia, hora e local em que será realizada tal Assembleia e ainda, de forma sucinta, os assuntos a serem tratados.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>As deliberações da Assembleia Geral de Cotistas do Fundo poderão ser tomadas mediante processo de consulta formalizada por correio eletrônico (e-mail), com confirmação de recebimento, a ser dirigido pelo Administrador a cada Cotista para resposta no prazo máximo de 30 (trinta) dias. 
</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Taxa de Administração. Observado o disposto no item 10.6 abaixo, o Administrador receberá, pelos serviços de administração ao Fundo, os quais incluem a custódia qualificada e controladoria ao Fundo, bem como a escrituração de Cotas, uma “Taxa de Administração” equivalente a 0,80% (oitenta centésimos por cento) ao ano, incidente sobre o Patrimônio Líquido do Fundo, calculada diariamente, na base 1/252 (um duzentos e cinquenta e dois avos) da percentagem referida neste item, e será provisionada por dia útil e paga até o 2º (segundo) Dia Útil do mês subsequente ao vencido, a partir do mês em que ocorrer a primeira integralização de Cotas, sendo devida uma remuneração mínima mensal de R$ 19.500,00 (dezenove mil e quinhentos reais). </PoliticaRemuneracao>
			<ValorPagoAno>145487.75</ValorPagoAno>
			<PercentPatrimonioContabil>0.0026</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.003</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>RODRIGO MARTINS CAVALCANTE</Nome>
				<Idade>42</Idade>
				<CPF>16913257830</CPF>
				<Email>rcavalcante@brltrust.com.br</Email>
				<Profissao>Contador</Profissao>
				<FormacaoAcademica>Ciências contábeis e Direito</FormacaoAcademica>
				<DataInicioFuncao>2011-10-07</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento numCotistas="3" numCotasDetidas="333.3333" percDetidoRelTotal="1" percDetidoPF="0" percDetidoPJ="0.3333"/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante xsi:nil="true"/>
			<PoliticaNegociacaoCotas xsi:nil="true"/>
			<PoliticaExercicioDireitoVoto xsi:nil="true"/>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"