"<?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>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>2018-06-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>CIX CAPITAL GESTÃO DE ATIVOS LTDA</Nome>
				<CNPJ>24503059000160</CNPJ>
				<Endereco>Avenida Brigadeiro Faria Lima, 2.601, 5º andar</Endereco>
				<telefone>(11) 3811-3232</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>MGI Assurance Auditores Independentes</Nome>
				<CNPJ>15454120000136</CNPJ>
				<Endereco>Av. Paraná, 202 - Conjunto 903 - Cabral, Curitiba - PR</Endereco>
				<telefone>(41) 3044-6127</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>Lucro de R$ 11.673.022,47.</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>Jabaquara apresenta a menor vacância entre as regiões NCBD (5,0%). A diminuição de 0,3 p.p. na taxa de vacância se comparada ao trimestre passado é resultado da absorção líquida de 540 m², visto que sem nenhuma entrega de novos empreendimentos, a taxa de vacância fica sujeita as movimentações dos inquilinos.
Para 2018 não deve ser entregue nenhum edifício novo em Jabaquara, o que deve reduzir ainda mais a taxa de vacância na região, possibilitando assim um aumento no preço pedido.
A região da Marginal Pinheiros apresenta a terceira vacância mais elevada entre as regiões CBD (38,6%). O aumento de 0,3 p.p na taxa de vacância se comparada ao trimestre passado é resultado do aumento da área disponível, visto que a região apresentou uma absorção líquida negativa de 13 mil m².
Para 2018, devem ser entregue 24 mil m², o que deve forçar um aumento na taxa de vacância da Região da Marginal Pinheiros até que os mesmo sejam absorvidos pelo mercado, além de aumentar o volume de ofertas na região, as quais devem ter preços reduzidos por seus proprietários para adaptar ao momento econômico que o país atravessa.

</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Imóvel Jabaquara </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>84678000</Valor>
				<PercentValorizacaoDesvalorizacao>0.04</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Imóvel Pinheiros </Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>13393000</Valor>
				<PercentValorizacaoDesvalorizacao>0.04</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 da convocaçã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>204251</ValorPagoAno>
			<PercentPatrimonioContabil>0.00204</PercentPatrimonioContabil>
			<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> http://finaxis.com.br/</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas> http://finaxis.com.br/</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto> http://finaxis.com.br/</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital xsi:nil="true"/>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"