"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>CIX CAPITAL OPORTUNIDADES FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>27538335000114</CNPJFundo>
		<DataFuncionamento>2017-12-28</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>1000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato xsi:nil="true"/>
			<SegmentoAtuacao xsi:nil="true"/>
			<TipoGestao xsi:nil="true"/>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>false</MBO>
			<MB>true</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>FRAM CAPITAL DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>27538335000114</CNPJAdministrador>
		<Logradouro>Avenida Presidente Jucelino Kubitschek</Logradouro>
		<Numero>1700</Numero>
		<Complemento>2º ANDAR</Complemento>
		<Bairro>VILA NOVA CONCEIÇÃO</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04543-000</CEP>
		<Telefone1>(11) 3513-3144</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.framcapitaldtvm.com</Site>
		<Email>fiduciario@framcapitaldtvm.com</Email>
		<Competencia>2017-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>CIX CAPITAL GESTÃO DE ATIVOS LTDA;</Nome>
				<CNPJ>24503059000160</CNPJ>
				<Endereco>Av. Brig. Faria Lima, 2601, 5º. andar, Jardim Paulistano  São Paulo / SP</Endereco>
				<telefone>(11) 3113-0021</telefone>
			</Gestor>
			<Custodiante>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>YORK PARTNERS AUDITORIA INDEPENDENTE S/S</Nome>
				<CNPJ>2488265800132</CNPJ>
				<Endereco>Av Brigadeiro Faria Lima, 1572, Conj 509 Parte, Jardim Paulistano, Sao Paulo/SP</Endereco>
				<telefone>(11)6588-0943</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 Cix Capital Oportunidades FII teve início em 28/12/2017, portanto não apresentou resultado dentro do exercício.</ResultadoFundo>
			<ConjunturaEconomica>O ano de 2017 foi marcado pelo início da retomada. Na economia, o PIB (Produto Interno Bruto) apresentou sinais de recuperação, encerrando uma série de oito quedas trimestrais consecutivas, iniciada no primeiro trimestre de 2015 e que perdurou até o quarto trimestre de 2016.
Outros indicadores melhoraram em relação a 2016. A variação acumulada do IPCA (Índice de Preços ao Consumidor Amplo), de 2,95%, ficou abaixo da meta mínima; a taxa Selic caiu de 13,75% a.a. (dez/2016) para 7,0% a.a. (dez/2017), alcançando o menor patamar histórico; e a taxa de desocupação passou de 13,7% para 11,8%, segundo levantamento
do último trimestre de 2017 realizado pelo IBGE (Instituto Brasileiro de Geografia e Estatística).
Com a economia mostrando sinais positivos, os índices de confiança dos consumidores e dos empresários voltaram a crescer. 
O mercado imobiliário da cidade de São Paulo acompanhou este momento de retomada e, depois de registrar os pontos mais baixos de seus indicadores no ano de 2016, apresentou resultadossurpreendentes em 2017.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A retomada dos lançamentos e da comercialização de imóveis novos na cidade de São Paulo contribui para ampliar as perspectivas de retorno do emprego na construção civil a partir do segundo semestre de 2018. Vale lembrar que o ciclo de desenvolvimento dos empreendimentos imobiliários é longo e existe um intervalo entre os lançamentos e o efetivo
início das obras.
A perspectiva para o próximo período é de garantir as oportunidades imobiliária para aquisição de imóveis, sobretudo imóveis com necessidade de reforma e unidades em estoques do mercado atingido pela crise dos últimso anos, aproveitando-se da expectativa de valorização dos ativos, sobretudo em São Paulo.
Segundo SECOVI, tomando como base as expectativas dos empresários do setor imobiliário, aliadas aos dados do Boletim Focus do Bacen (Banco Central do Brasil), é possível estimar crescimento nas vendas para 2018 de 5% a 10%.
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Não Há</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>0</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Não há</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Dr. Eduardo de Souza Aranha, 153 - 4º andar</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>http://www.framcapital.com/administracao-de-fundos/</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>O comunicado, envio, divulgação e/ou disponibilização, pelo Administrador, de quaisquer informações, comunicados, cartas e documentos, cuja obrigação </MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>O Administrador deve manter em sua página na rede mundial de computadores, pelo prazo mínimo de 5 (cinco) anos contados de sua divulgação, ou por prazo superior por determinação expressa da CVM, em caso de processo administrativo, todos os documentos e informações, periódicas ou eventuais, exigidos pela Instrução CVM 472, bem como indicação dos endereços físicos e eletrônicos em que podem ser obtidas as informações e documentos relativos ao C22fundo. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>A publicação das informações é feita na página do Administrador na rede mundial de computadores e mantida disponível aos cotistas em sua sede.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>I O ADMINISTRADOR receberá, pelos serviços de administração, a remuneração anual fixa equivalente a 0,30% a.a. (trinta centésimos por cento ao ano) sobre o valor do Patrimônio Líquido do FUNDO, com um mínimo mensal de (i) R$ 10.000,00 (dez mil reais) durante os 6 (seis) primeiros meses após o início das atividades do FUNDO e (ii) R$ 20.000,00 (vinte mil reais) após o período mencionado no item “i” acima, a ser atualizado anualmente pelo IPCA. O ADMINISTRADOR, de maneira discricionária e sem consentimento da Assembleia Geral de Cotistas, poderá reduzir temporariamente a parcela da Taxa de Administração que lhe é devida; e
II O GESTOR receberá, pelos serviços de gestão, a remuneração anual fixa equivalente a 1,70% a.a. (um inteiro e setenta centésimos por cento ao ano) sobre o valor do Patrimônio Líquido do FUNDO, com um mínimo mensal de R$ 20.000,00 (vinte mil reais), a ser atualizado anualmente pelo IPCA. O GESTOR, de maneira discricionária e sem consentimento da Assembleia Geral de Cotistas, poderá reduzir temporariamente a parcela da Taxa de Administração que lhe é devida.
III  As Partes acordaram que o Fundo pagará ao Administrador a diferença da remuneração, mencionado no item I deste parágrafo, no período dos 6 primeiros meses (isto é, R$ 60.000,00) nas seguintes hipóteses: (i) destituição e/ou substituição do Administrador; ou (ii) encerramento do Fundo, no prazo de 12 meses após o termino do desconto.
</PoliticaRemuneracao>
			<ValorPagoAno>3.4285</ValorPagoAno>
			<PercentPatrimonioContabil>0.0343</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>ALBERTO GARCIA ROCHE</Nome>
				<Idade>61</Idade>
				<CPF>154.184.438-60</CPF>
				<Email>financas@framcapital.com</Email>
				<Profissao>ADM de Empresas</Profissao>
				<FormacaoAcademica>Economista</FormacaoAcademica>
				<DataInicioFuncao>2017-05-16</DataInicioFuncao>
				<QtdCotasDetidasFII>3541.67543</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="13" numCotasDetidas="1365.94799" percDetidoRelTotal="0.385678478165911" percDetidoPF="1" percDetidoPJ="0"/>
			<AcimaCincoAteDezPorcento numCotistas="4" numCotasDetidas="930.02778" percDetidoRelTotal="0.262595429305051" percDetidoPF="0.681725249110301" percDetidoPJ="0.318274750889699"/>
			<AcimaDezAteQuinzePorcento numCotistas="2" numCotasDetidas="1245.69966" percDetidoRelTotal="0.351726092529038" percDetidoPF="0" percDetidoPJ="1"/>
			<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>
"