"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>TAG ALIANZA BTS – FUNDO DE INVESTIMENTO IMOBILIÁRIO – FII</NomeFundo>
		<CNPJFundo>18579302000121</CNPJFundo>
		<DataFuncionamento>2015-03-25</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>2563.042075</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Desenvolvimento para Venda</Mandato>
			<SegmentoAtuacao>Outros</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Determinado</PrazoDuracao>
		<DataPrazoDuracao>2027-12-23</DataPrazoDuracao>
		<EncerramentoExercicio>31/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>18579302000121</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 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<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>Avenida Santo Amaro, 48, 6 andar, CEP 04506-000 - São Paulo - SP.</Endereco>
				<telefone>(11) 3474.0035 </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>GRANT THORNTON AUDITORES INDEPENDENTES</Nome>
				<CNPJ>10.830.108/0001.65</CNPJ>
				<Endereco>AV. ENGENHEIRO LUIZ CARLOS BERRINI, 105 - TORRE 4,CJS. 121 E 122CIDADE MONÇÕES</Endereco>
				<telefone>(11) 3886-5135</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BRL TRUST DTVM S.A.</Nome>
				<CNPJ>13486793000142</CNPJ>
				<Endereco>Rua Iguatemi, 151 19º and - Itaim Bibi</Endereco>
				<telefone>(11) 3133-0350</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>Imóvel registrado sob matricula 94.7401 - Rio De Janeiro-RJ</Nome>
						<Objetivos>Propriedade para Venda  / Estoque</Objetivos>
						<MontantesInvestidos>8850000</MontantesInvestidos>
						<OrigemRecursos>Utilização de recursos proprios</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O fundo continuará atuando dentro do seu mandato, procurando identificar operações que se enquadrem no modelo de Built to Suit ou Sale&amp;Leaseback de imóveis destinados a inquilinos de primeira linha, no território brasileiro. Também seguiremos buscando identificar boas oportunidades de venda de ativos, dado o fundo já ter um portfolio constituído. </ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O lucro apurado em 31 de dezembro de 2016 foi de R$ 2.109.401,56.</ResultadoFundo>
			<ConjunturaEconomica>Após um primeiro semestre muito difícil, com a economia brasileira em compasso de espera, observamos no segundo semestre interessantes sinais de retomada, com um número crescente de novas operações de BTS e SLB surgindo. Contratos de longo prazo em negócios imobiliários demandam uma previsibilidade de cenários, e no contexto geral do primeiro semestre deste ano pouco foi feito, mas bastante movimentação em torno de novos projetos se iniciou no segundo semestre. Também claramente se intensificou o interesse de investidores, tanto locais quanto estrangeiros, pelo tipo de ativos foco do nosso fundo.  </ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Acreditamos que o movimento identificado no segundo semestre de 2016, citado acima, deverá se intensificar. Tanto novos projetos, como investidores interessados pelos nosso ativos, devem surgir um grau bastante superior ao que vinha acontecendo até o meio de 2016. Com isso diversas oportunidade devem surgir. O movimento das taxas de juros brasileiras deve trazer dinâmica nova para nosso mercado, nos levando de volta a ambientes similares aos vistos até 5 anos atrás. 

O fundo continuará atuando dentro do seu mandato, procurando identificar operações que se enquadrem no modelo de Built to Suit ou Sale&amp;Leaseback de imóveis destinados a inquilinos de primeira linha, no território brasileiro. Também seguiremos buscando identificar boas oportunidades de venda de ativos, dado o fundo já ter um portfolio constituído. 
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>ATENTO  CAMPO GRANDE</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>21696310.28</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IMÓVEL DEL CASTILHO</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>9157263.53</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os imóveis suprarelacioados foram adquiridos para estoque, portanto estão contabilizados pelos seus custos de aquisições.</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>http://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>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. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela administração do Fundo, nela compreendidas as atividades de administração do Fundo e demais serviços previstos no Artigo 29 da Instrução CVM 472, o Fundo pagará ao Administrador uma remuneração fixa de 1,16% (um inteiro e dezesseis centésimos por cento) ao ano, sobre o Patrimônio Líquido, calculada diariamente, na base 1/252 (um duzentos e cinquenta e dois avos), sendo que (i) 0,16% (dezesseis centésimos por cento) será pago a partir da Data da 1ª Integralização de Cotas; e (ii) 1,00% (um por cento) será pago a partir do 7º mês contado da Data da 1ª Integralização de Cotas, observado o valor mínimo mensal, nos primeiros 3 (três) meses de operação do Fundo, de R$ 10.000,00 (dez mil reais) e nos demais meses de operação do Fundo, de R$ 15.000,00 (quinze mil reais), ambos valores serão atualizado anualmente, a partir Data da 1ª Integralização de Cotas, pela variação positiva do IGP-M (Índice Geral de Preços de Mercado) apurado e divulgado pela Fundação Getúlio Vargas – FGV. </PoliticaRemuneracao>
			<ValorPagoAno>344048.54</ValorPagoAno>
			<PercentPatrimonioContabil>0.0117</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0191</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/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento numCotistas="4" numCotasDetidas="1826.054203" percDetidoRelTotal="0.71" percDetidoPJ="1"/>
			<AcimaVinteAteTrintaPorcento numCotistas="1" numCotasDetidas="736.988547" percDetidoRelTotal="0.29" percDetidoPJ="1"/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante xsi:nil="true"/>
			<PoliticaNegociacaoCotas xsi:nil="true"/>
			<PoliticaExercicioDireitoVoto>http://www.taginvest.com.br/arquivos/manual-direito-de-voto.pdf</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"