"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>SP DOWNTOWN FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</NomeFundo>
		<CNPJFundo>15538445000105</CNPJFundo>
		<DataFuncionamento>2013-03-01</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRSPTWCTF002</CodigoISIN>
		<QtdCotasEmitidas>1798000</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Lajes Corporativas</SegmentoAtuacao>
			<TipoGestao>Passiva</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>Rua Candelária</Logradouro>
		<Numero>65</Numero>
		<Complemento>Salas 1701 e 1702</Complemento>
		<Bairro>Centro</Bairro>
		<Cidade>Rio de Janeiro</Cidade>
		<Estado>RJ</Estado>
		<CEP>20091-020</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>2017-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Brasil Plural Gestão de Recursos Ltda.</Nome>
				<CNPJ>11397672000107</CNPJ>
				<Endereco>Rua Surubim, 373 - 1º andar- São Paulo - SP - CEP: 04.571-050</Endereco>
				<telefone>N/A</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Itaú Unibanco S.A.</Nome>
				<CNPJ>60701190000104</CNPJ>
				<Endereco>Praça Alfredo Egydio de Souza Aranha, 100 - São Paulo - SP - CEP:04344-902</Endereco>
				<telefone>N/A</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Ernst Young Auditores Independentes S.S.</Nome>
				<CNPJ>61366936000206</CNPJ>
				<Endereco>Pr de Botafogo, 370, Andar 8, Botafogo, Rio de Janeiro, RJ, CEP 22250-040</Endereco>
				<telefone>N/A</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. Banco Múltiplo</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>ITAU CUSTODIA RF CURTO PRAZO CAIXA</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>788604.21</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>LFT</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>4498711.05</MontantesInvestidos>
						<OrigemRecursos>Capital</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Fundo tem por objeto a realização de investimentos nos Ativos Alvos, observado os termos e condições da legislação e regulamentação vigentes. A Política de investimentos seguirá inalterada para o exercício. Observando a manutenção de valor dos ativos imobiliários e continuidade das operações, poderão ser realizados ao longo do ano benfeitorias nos ativos.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo recebe, mensalmente, o resultado dos aluguéis dos dois imóveis que compõem o seu patrimônio. Durante 2017, o Fundo distribuiu, a título de rendimentos, o equivalente a R$ 6,41 por cota, o que representa um Dividend Yield de 8,67% a.a., considerando o valor de mercado da cota de fechamento de Dez/17 (R$ 74,00).</ResultadoFundo>
			<ConjunturaEconomica>A perspectiva de continuidade na redução da taxa SELIC para 2018 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 2018.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Sabendo que o mercado imobiliário tem três fundamentos relevantes em sua estrutura (i) taxa de juros (ii) oferta de crédito (iii) estabilidade de renda e observando as perspectivas do cenário econômico com continuidade redução da taxa SELIC durante ao ano de 2018, acreditamos contribuir a atratividade dos compradores. O IGPM será importante inidcador na atualização dos contratos de aluguel para a carteira do Fundo.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Imóvel - Edifício Comercial Belenzinho</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>44000000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0957812422174629</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Imóvel - Edifício Comercial Badaró</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>86900000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0127468132966758</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os valores justos dos imóveis foram atualizados através de laudo elaborado por terceiro contratado datado de 22 de dezembro de 2017 onde a metodologia aplciada na avaliação do imóvel foi através da capitalização de renda.</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/publico/abrirGerenciadorDocumentosCVM?cnpjFundo=15538445000105</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>(i) email: assembleia@genialinvestimentos.com.br; telefones: (11) 2137-8888, (21) 2169-9999 e (51) 2121-9500 para esclarecimentos julgados necessários.
(ii)A manifestação de voto e, conforme o caso, a via original ou cópia reprográfica do instrumento de
mandato, devidamente autenticada, ou pedidos de esclarecimentos deverá(ão) ser
encaminhado(s) por escrito à Administradora no seguinte endereço aos cuidados do Sr. Rodrigo
Godoy, com endereço na Rua Surubim, 373, Cidade Monções, na Cidade e Estado de São Paulo, ou
por meio do e-mail: assembleia@genialinvestimentos.com.br.</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.
A Assembleia Geral de Cotistas se instalará com a presença de qualquer número de cotistas, nos
termos do Art. 19 da Instrução CVM nº 472/08 c/c o Art. 70 da Instrução CVM nº 555, de 17 de
dezembro de 2014, sendo que as deliberações deverão ser tomadas por maioria de votos dos
cotistas presentes.
Nos termos da Instrução CVM nº 472/08 e observado o disposto no Regulamento, os cotistas
poderão votar na Assembleia Geral de Cotistas por meio de comunicação escrita ou eletrônica (email)
encaminhada à Administradora, no endereço abaixo, na forma do Anexo I à presente
convocação.
Poderão votar na Assembleia Geral de Cotistas, os cotistas adimplentes com todas as suas
obrigações até a data de convocação da Assembleia Geral, seus representantes legais ou
procuradores legalmente constituídos há menos de 1 (um) ano, observado o disposto no Art. 22 da
Instrução CVM nº 472/08.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>O administrador não tem infraestrutura para a realização de assembleia por meio eletrônico.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pelos serviços de administração, gestão e escrituração serão devidas a taxa de administração de 0,25% ao ano sobre o patrimônio líquido do Fundo, observado o valor mínimo mensal de R$15 mil. A remuneração devida à administradora é calculada e paga mensalmente, diretamente pelo Fundo, até o 5 dia útil do mês subsequente a dos serviços prestados. A remuneração da Administradora é calculada todo dia útil com base no patrimônio líquido do Fundo do dia anterior à realização do cálculo, a razão de 1/252.</PoliticaRemuneracao>
			<ValorPagoAno>372000</ValorPagoAno>
			<PercentPatrimonioContabil>0.00279606746640209</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.00279606746640209</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>41</Idade>
				<CPF>43055557.19</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="3222" numCotasDetidas="1584513" percDetidoRelTotal="0.881264182424919" percDetidoPF="0.764209677419359" percDetidoPJ="0.117054505005562"/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="213487" percDetidoRelTotal="0.118735817575083" percDetidoPF="0" percDetidoPJ="0.118735817575083"/>
			<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>
"