"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>SP DOWNTOWN - FII</NomeFundo>
		<CNPJFundo>15538445000105</CNPJFundo>
		<DataFuncionamento>2016-07-13</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRSPTWCTF002</CodigoISIN>
		<QtdCotasEmitidas>1798000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Títulos e Valores Mobiliários</Mandato>
			<SegmentoAtuacao>Títulos e Val. Mob.</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>GERAÇÃO FUTURO CORRETORA DE VALORES S.A</NomeAdministrador>
		<CNPJAdministrador>15538445000105</CNPJAdministrador>
		<Logradouro>AV. PAULISTA</Logradouro>
		<Numero>1106</Numero>
		<Complemento>6º ANDAR</Complemento>
		<Bairro>BELA VISTA</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>01310-100</CEP>
		<Telefone1>(11) 3524-8888</Telefone1>
		<Telefone2>(11) 2137-8888</Telefone2>
		<Telefone3>0800 605 8888</Telefone3>
		<Site>www.gerafuturo.com.br</Site>
		<Email>middleadmint@gerafuturo.com.br</Email>
		<Competencia>2016-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>BRASIL PLURAL GESTAO DE RECURSOS LTDA</Nome>
				<CNPJ>11397672000107</CNPJ>
				<Endereco>Rua Surubim, 373 - 1º andar- São Paulo - SP- CEP 04.571-050</Endereco>
				<telefone>21 - 3923-3000</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Oliveira Trust DTVM S.A</Nome>
				<CNPJ>36113876000191</CNPJ>
				<Endereco>Av Das Americas, 3434, Barra Da Tijuca, Rio De Janeiro, RJ, CEP 22640-102</Endereco>
				<telefone>21 - 3514-0000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Ernst &amp; Young Auditores Independentes S.S</Nome>
				<CNPJ>61366936000206</CNPJ>
				<Endereco>Pr Do Botafogo, 370, Andar 8, Botafogo, Rio de Janeiro, RJ, CEP 22250-040</Endereco>
				<telefone>11 - 2573-2565</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>BRASIL PLURAL S.A</Nome>
				<CNPJ>45246410000155</CNPJ>
				<Endereco>PR DE BOTAFOGO, 228 - BOTAFOGO - Rio de Janeiro CEP 22.250-040</Endereco>
				<telefone>N/A</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>LCI - CAIXA ECÔNOMICA FEDERAL</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>3744196.03</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>LTN - TESOURO NACIONAL</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2530579.88</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Fundo tem por objeto a realização de investimentos nos Ativos Alvos, ou ainda, a realização de investimentos em Ativos de Renda Fixa, observado os termos e condições da legislação e regulamentação vigentes. </ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo distribuiu a título de rendimento o equivalente a R$ 32,13 por cota, representando um Dividend Yield de 0,0975%, considerando a cota de fechamento de 2016 (30/12/2016), R$ 72,562524.</ResultadoFundo>
			<ConjunturaEconomica>O Índice de Fundos de Investimentos Imobiliários (IFIX) tem como objetivo ser o indicador do desempenho médio das cotações dos fundos imobiliários negociados nos mercados de bolsa e de balcão organizado da BM&amp;FBOVESPA. Esse índice subiu 32,33% em 2016, mostrando a boa performance dos Fundos de investimento imobiliário no ano. Essa valorização se deve, principalmente, a expectativa de redução para a taxa SELIC e fechamento das taxas dos títulos públicos indexados a inflação (NTN-B).</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A perspectiva de continuidade na redução da taxa SELIC para 2017 deve continuar contribuindo para a performance do segmento de Fundos de investimento imobiliário no mercado secundário, dada a forte correlação entre eles. Além disso, a perspectiva de melhora nas taxas de ocupação de imóveis e a melhora do ambiente macroeconomico brasileiro também devem contribuir para esse movimento e para o aumento do número de novas emissões de Fundos de investimento imobiliário em 2017 em relação a 2016.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>IMÓVEL - EDIFICIO COMERCIAL BELENZINHO</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>40154000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>IMÓVEL - EDIFICIO COMERCIAL BADARÓ</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>88022000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>#</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Surumbim, 373, térreo, Cidade Monções, São Paulo/SP ou Avenida Paulista, 1106, 6º andar, Bela Vista, São Paulo/SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>http://www.gerafuturo.com.br/; https://fnet.bmfbovespa.com.br/fnet/login</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>(i) os titulares de, no mínimo, 3% (três por cento) das cotas emitidas ou o representante dos cotistas podem solicitar, por meio de requerimento escrito encaminhado ao administrador do fundo, a inclusão de matérias na ordem do dia da assembleia geral. Os documentos e informações pertinentes às deliberações propostas podem ser enviados tanto por correio eletrônico para o endereço assembleias@gerafuturo.com.br ou por via física nos seguintes endereços: Rua Surubim, 373, Térreo, Cidade Monções, São Paulo/SP e Avenida Paulista, 1106, 6º andar, Bela Vista, São Paulo/SP;

(ii) o passivo do fundo é administrado pelo escriturador. O cotista deve fazer a solicitação do pedido público de procuração para o adminsitrador, por via física ou eletrônica, que irá encaminhar o pedido para os demais cotistas do fundo.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>A identificação dos cotistas é realizada mediante a apresentação de documentos comprobatórios, nos casos de voto presencial ou a distância.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>O administrador não tem infraestrutura para a realização de assembleia por meio eletrônico.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Taxa de Administração:
Pelos serviços de administração, gestão e escrituração das Quotas, será devida a Taxa de Administração de 0,25% (vinte e cinco centésimos por cento) ao ano (considerando-se, para tanto, um ano de 252 (duzentos e cinquenta e dois) dias úteis calculado sobre o Patrimônio Líquido, observado o valor mínimo mensal de R$ 15.000,00 (quinze mil reais).

A Taxa de Administração engloba a remuneração do Administrador, do Gestor. O valor mínimo mensal estabelecido, será corrigido anualmente pela variação positiva do IGP-M.

A Taxa de Administração será provisionada diariamente, por Dia Útil, e será paga até o 5º (quinto) Dia Útil do mês subsequente ao dos serviços prestados. Observada a regulamentação em vigor, parcelas da Taxa de Administração poderão ser pagas pelo Fundo diretamente ao Administrador, ao Gestor ou a outros prestadores de serviço contratados pelo Fundo, conforme o caso. 
</PoliticaRemuneracao>
			<ValorPagoAno>196843.75</ValorPagoAno>
			<PercentPatrimonioContabil>0.0015</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0015</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>Eduardo Alvares Moreira</Nome>
				<Idade>40</Idade>
				<CPF>43055557</CPF>
				<Email/>
				<Profissao>Diretor</Profissao>
				<FormacaoAcademica>Engenheiro - Economista</FormacaoAcademica>
				<DataInicioFuncao>2014-11-04</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Grupo Brasil Plural</NomeEmpresa>
						<Periodo>10/2009 á 10/2014</Periodo>
						<CargoFuncoes>Senior Partner</CargoFuncoes>
						<AtividadePrincipalEmpresa>Responsável pela estruturação das áreas de Wealth Management</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Geração Futuro CTVM</NomeEmpresa>
						<Periodo>11/2014 até o momento</Periodo>
						<CargoFuncoes>Senior Partner</CargoFuncoes>
						<AtividadePrincipalEmpresa>Diretor responsavel</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>N/A</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>N/A</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="2163" numCotasDetidas="1584513" percDetidoRelTotal="0.8813" percDetidoPF="0.7492" percDetidoPJ="0.1321"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="213487" percDetidoRelTotal="0.1187" percDetidoPJ="0.1187"/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>A Política de Divulgação de Fato Relevante estabelece diretrizes e procedimentos a serem observados na divulgação de fato relevante. A divulgação de fatos relevantes deve ser ampla e imediata, de modo a garantir aos cotistas e demais investidores acesso às informações completas e tempestivas sobre fatos relevantes, assegurando igualdade e transparência dessa
informação a todos os interessados, sem privilegiar alguns em detrimento de outros, informações que possam, direta ou indiretamente, influir em suas decisões de adquirir ou alienar cotas do fundo, sendo vedado ao administrador valer-se da informação para obter, para si ou para outrem, vantagem mediante compra ou venda das cotas do fundo. A divulgação do fato relevante se dará por meio de publicação no web site da CVM, no web site do administrador, e, caso as cotas do referido fundo sejam negociadas em Bolsa, por meio do envio do fato relevante para a Bovespa, sem prejuízo de outro meio que o administrador entender necessário.</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>Não aplicável, as cotas do fundo são admitidas à negociação entidade administradora de mercado organizado.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>A politica está descrita no regulamento do Fundo, disponível no link abaixo: https://www.gerafuturo.com.br/fundos-imobiliarios</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>O Administrador possui equipes direcionadas para asseguração do cumprimento da política de divulgação de informações do Fundo.</FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Será de acordo com estabelecido em Assembleia Geral Extraordinária respeitando as regras do regulamento.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"