"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>TRANSINC FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</NomeFundo>
		<CNPJFundo>17007443000107</CNPJFundo>
		<DataFuncionamento>2013-08-15</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRTSNCCTF009</CodigoISIN>
		<QtdCotasEmitidas>18113</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>true</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Desenvolvimento para Renda</Mandato>
			<SegmentoAtuacao>Lajes Corporativas</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Determinado</PrazoDuracao>
		<DataPrazoDuracao>2033-08-15</DataPrazoDuracao>
		<EncerramentoExercicio>30/06</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BANCO FINAXIS S.A.</NomeAdministrador>
		<CNPJAdministrador>17007443000107</CNPJAdministrador>
		<Logradouro>Rua Pasteur</Logradouro>
		<Numero>463</Numero>
		<Complemento>11° andar</Complemento>
		<Bairro>Água Verde</Bairro>
		<Cidade>Curitiba</Cidade>
		<Estado>PR</Estado>
		<CEP>80250 -080</CEP>
		<Telefone1>(41) 3074-0909</Telefone1>
		<Telefone2>(41) 3074-5817</Telefone2>
		<Telefone3>(41) 3074-0928</Telefone3>
		<Site>http://finaxis.com.br/</Site>
		<Email>informacoesfundos@finaxis.com.br</Email>
		<Competencia>2017-06-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>FRAM Capital Gestão de Ativos Ltda. </Nome>
				<CNPJ>8157028000149</CNPJ>
				<Endereco>Avenida Presidente Juscelino Kubitschek, 1700, 2º andar, cj 22, Vila Nova Conceição - São Paulo - SP</Endereco>
				<telefone>(11) 3513-3144</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Banco Finaxis S.A. </Nome>
				<CNPJ>11758741000152</CNPJ>
				<Endereco>Rua Pasteur, 463, 11º andar, Curitiba-PR</Endereco>
				<telefone>(41) 3074-0909</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Grant Thornton Auditores Independentes </Nome>
				<CNPJ>10830108000165</CNPJ>
				<Endereco>Avenida Engenheiro Luiz Carlos Berrini, 105</Endereco>
				<telefone>(11) 3886-8977</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>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>O fundo auferiu receita bruta de R$ 31.017.970,12 e as despesas do período totalizaram R$ 936.358,53. Portanto o resultado foi de R$ 30.081.611,59.</ResultadoFundo>
			<ConjunturaEconomica>Diante do excesso de oferta e deterioração dos indicadores macroeconômicos, a solução encontrada pelo mercado de escritórios para se manter competitivo foi a diminuição do preço pedido de locação criando um cenário favorável ao inquilino. A cidade de São Paulo obedece a uma tendência bastante comum entre as capitais brasileiras , com aumento da taxa de vacância devido à entrega de um número excessivo de empreendimentos.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>O Jabaquara possui a menor vacância dentre as regiões NCBD. A queda de 1.7 pp na taxa nos últimos 12 meses é justificada, principalmente, pelo saldo positivo nas absorções na região junto com nenhuma entrega de novo estoque realizada na região.
Como não há previsão de novas entregas no Jabaquara para os próximos anos, a vacância ficará sujeita unicamente a eventuais movimentações de inquilinos, que não são tão significativos nem frenquentes.
Com relação à região de Pinheiros, essa região possui a sétima vacância mais alta (23,6%), considerando as regiões CBD. A elevação de 5,2 pp na taxa nos últimos 12 meses de vacância é justificado, principalmente, pelo elevado número de novas entregas nos últimos meses e pela baixa absorção líquida positiva.
Devido a saturação da região, não há previsão de novo estoque em 2017 e em 2018. Com isso, a vacância será guiada de acordo com as entradas e saídas nos próximos períodos e consequentemente o preço pedido.

</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Imóvel Jabaquara </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>81718000</Valor>
				<PercentValorizacaoDesvalorizacao>0.31</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Imóvel Pinheiros </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>12826000</Valor>
				<PercentValorizacaoDesvalorizacao>0.31</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Metódo de capitalização de renda com base no fluxo de caixa descontado para determinação do valor de mercado para venda e pelo metódo comparativo direto para determinação do valor de mercado para locação. As avaliações foram realizadas por avaliador independente (Cushman&amp;Wakefield) e foram entregues em laudo de avaliação oficial dessa empresa.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida Paulista, nº 1842, 1º andar, conjunto 17, Bela Vista, CEP 01310-923</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>https://fnet.bmfbovespa.com.br; http://finaxis.com.br/</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Os documentos ou informações estarão disponíveis nos endereços físicos e eletrônicos
do ADMINISTRADOR: na Cidade e Estado de São Paulo na Avenida Paulista nº 1842, Torre Norte, 1º andar, conjunto 17,
Bela Vista, CEP 01310-923 e http://finaxis.com.br/</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Somente poderão votar na assembleia geral os quotistas inscritos no registro de quotistas na data daconvocação da assembleia, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano; As deliberações da Assembleia Geral poderão ser tomadas, independentemente de convocação, mediante processo de consulta, formalizada por carta, correio eletrônico ou telegrama dirigido pelo ADMINISTRADOR aos quotistas, e/ou participantes (no caso de consulta formal ou voto por escrito/eletrônico. As deliberações das Assembleias Gerais regularmente convocadas e instaladas ou através de consulta, serão tomadas por maioria de votos dos quotistas presentes e/ou participantes (no caso de consulta formal ou voto por escrito/eletrônico, ressalvadas as hipóteses de "quorum" qualificado. As deliberações das Assembleias Gerais regularmente convocadas e instaladas ou através de consulta, serão tomadas por maioria de votos dos quotistas presentes. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não se aplica para esse Fundo. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>A Instituição Administradora terá direito a receber pela prestação dos serviços de administração custódia e controladoria, a título de taxa de administração, o maior valor entre 0,50% (cinquenta centésimos por cento) ao ano calculados sobre o Patrimônio Líquido do Fundo e R$ 29.500,00 (vinte nove mil e quinhentos reais), corrigidos, anualmente, pelo IPCA.</PoliticaRemuneracao>
			<ValorPagoAno xsi:nil="true"/>
			<PercentPatrimonioContabil xsi:nil="true"/>
			<PercentPatrimonioValorMercado xsi:nil="true"/>
		</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>Ricardo Augusto Meira Pedro</Nome>
				<Idade>52</Idade>
				<CPF>4995131850</CPF>
				<Email>ricardo.pedro@finaxis.com.br</Email>
				<Profissao>Bancário </Profissao>
				<FormacaoAcademica>Administrador </FormacaoAcademica>
				<DataInicioFuncao>2013-08-05</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="60" numCotasDetidas="11615.46479" percDetidoRelTotal="0.6413" percDetidoPF="0.6413"/>
			<AcimaCincoAteDezPorcento numCotistas="6" numCotasDetidas="6497.53521" percDetidoRelTotal="0.3587" percDetidoPF="0.3587"/>
			<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>
"