"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIÁRIO PHORBIS</NomeFundo>
		<CNPJFundo>10.456.799/0001-89</CNPJFundo>
		<DataFuncionamento>2008-10-24</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN>0</CodigoISIN>
		<QtdCotasEmitidas>31219</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Lajes Corporativas</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</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>CORRETORA GERAL DE VALORES E CÂMBIO LTDA</NomeAdministrador>
		<CNPJAdministrador>10.456.799/0001-89</CNPJAdministrador>
		<Logradouro>RUA DR. JOSÉ MONTAURY</Logradouro>
		<Numero>139</Numero>
		<Complemento>7º andar</Complemento>
		<Bairro>CENTRO HISTÓRICO</Bairro>
		<Cidade>PORTO ALEGRE</Cidade>
		<Estado>RS</Estado>
		<CEP>90.010-090</CEP>
		<Telefone1>(51) 3213-2727</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.geralinvestimentos.com.br</Site>
		<Email>edegasperin@geralinvestimentos.com.br</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Geral Asset Management  S/S Ltda.</Nome>
				<CNPJ>05.196.089/0001-27</CNPJ>
				<Endereco>Rua Dr. José Montaury, 139 - 8º andar - Porto Alegre/RS</Endereco>
				<telefone>51 - 3213-2708</telefone>
			</Gestor>
			<Custodiante>
				<Nome>0</Nome>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Confidor Auditores Associados</Nome>
				<CNPJ>89.859.466/0001-50</CNPJ>
				<Endereco>Travessa Azevedo, 178 - Porto Alegre/RS</Endereco>
				<telefone>51 - 3222-8933</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome>0</Nome>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>0</Nome>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>0</Nome>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome>PHORBIS Planejamento Serviços e Empreendimentos Imobiliários Ltda.</Nome>
				<CNPJ> 10.408.555/0001-20</CNPJ>
				<Endereco>Rua Antônio Carlos Berta, 475, cj. 1401 – Boa Vista - Cep: 91340-020 - Porto Alegre/ - RS</Endereco>
				<telefone> (51) 3073-7100</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
				<Prestador>
					<Nome>Condominio Viva Open Mall</Nome>
					<CNPJ/>
					<Endereco>Av. Dr. Nilo Peçanha, 3228 - Porto Alegre/RS</Endereco>
					<telefone>51 - 3073-7130</telefone>
				</Prestador>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
					<Ativo>
						<Nome>Loja 1 - Dr. Nilo Peçanha, 3349 Matricula 174.858</Nome>
						<Objetivos>Aquisição para venda</Objetivos>
						<MontantesInvestidos>78000</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Loja 2 - Dr. Nilo Peçanha, 3351 Matricula 174.859</Nome>
						<Objetivos>Aquisição para venda</Objetivos>
						<MontantesInvestidos>72000</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Loja 3 - Dr. Nilo Peçanha, 3353 Matricula 174.860</Nome>
						<Objetivos>Aquisição para venda</Objetivos>
						<MontantesInvestidos>61000</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Loja 4 - Dr. Nilo Peçanha, 3355 Matricula 174.861</Nome>
						<Objetivos>Aquisição para venda</Objetivos>
						<MontantesInvestidos>92000</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Loja 5 - Dr. Nilo Peçanha, 3357 Matricula 174.862</Nome>
						<Objetivos>Aquisição para venda</Objetivos>
						<MontantesInvestidos>59000</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Loja 6 - Dr. Nilo Peçanha, 3359 Matricula 174.863</Nome>
						<Objetivos>Aquisição para venda</Objetivos>
						<MontantesInvestidos>84000</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Loja 7 - Dr. Nilo Peçanha, 3363 Matricula 174.864</Nome>
						<Objetivos>Aquisição para venda</Objetivos>
						<MontantesInvestidos>87000</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Apartamento 804 e Box 09 Edifício Nilo Home Square</Nome>
						<Objetivos>Aquisição para venda</Objetivos>
						<MontantesInvestidos>35000</MontantesInvestidos>
						<OrigemRecursos>Recursos próprios</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O Fundo tem como objetivo a aquisição e/ou venda de imóveis residenciais, comerciais e industriais, livres e desembaraçados de quaisquer ônus e gravames, notadamente, terrenos, lotes, edifícios comerciais, plantas industriais e centros de distribuição e logística (“Imóveis” ou, individualmente, “Imóvel”), e a realização de investimentos na construção e urbanização de loteamentos comerciais e/ou residenciais em Imóveis de sua propriedade.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O resultado no exercício findo encontra-se adequado para o modelo de negócios, considerando a situação da conjuntura econômica.</ResultadoFundo>
			<ConjunturaEconomica>O ano de 2018 fechou no Brasil com a confiança em elevação e com fortes incertezas em relação ao desempenho da economia internacional. Nessa evolução no ano, viu-se que no início de 2018, as expectativas eram bastante positivas em relação à economia mundial e brasileira. Essas projeções acabaram não se confirmando ao longo do ano, em especial após a paralisação no setor de transportes e a consequente freada de uma economia já enfraquecida, e que tem crescido gradualmente. O crescimento do PIB foi de 1,1% em 2018, de acordo com o IBGE. No restante, viu-se que a economia brasileira terminou 2018 com: (i) a inflação abaixo da meta, o que é positivo; (ii) os indicadores do setor externo ainda positivos, algo bastante importante, dado um cenário de possível reversão do crescimento econômico mundial; (iii) os dados de emprego já melhoraram, mas aquém do que se desejaria para uma retomada mais consistente do crescimento da economia; (iv) a utilização da capacidade instalada abaixo da média histórica e dos melhores momentos de crescimento; (v) a taxa de juros no menor patamar da história, Selic igual a 6,5% ao ano; (vi) os indicadores fiscais preocupantes tanto do país quanto dos Estados; e (vii) a confiança em alta nos diversos setores. Ademais, após a confirmação da vitória, o novo presidente começou a indicar os novos integrantes do governo e as propostas para a economia, sendo essas bem recebidas pelo mercado financeiro por serem de caráter mais liberal. Isso gerou aumento da euforia internamente, sobretudo para os setor ligados a economia doméstica, relacionados com privatização, que teriam uma postura mais pró-mercado ou que teriam maior viés de baixa caso a atual oposição tivesse vencido as eleições, como é caso do setor financeiro. Ou seja, o novo governo contava com o benefício da dúvida dos agentes econômicos, dado que conta com o apoio da maioria da população em diversos temas. Em suma, viu-se que no geral as expectativas evoluíram positivamente, apesar do crescimento e do emprego abaixo do desejado em 2018. Na tabela a seguir é possível verificar que o mercado chegou a projetar crescimento de 2,89% do PIB em 2018 no mês de março, algo que após a greve dos caminhoneiros ficou ainda mais difícil. Todavia, o ano terminou com as expectativas mais positivas em relação a nova administração da economia brasileira.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A expectativa é de que com a retomada da economia, com crescimento estimado em 2,5%, com os juros baixos (Selic = 6,5% a.a.), na comparação histórica brasileira, e com o crédito e a confiança sendo retomados e a possibilidade aprovação das reformas, espera-se que haja continuidade do crescimento do setor em 2019. E nessa perspectiva já há na cidade de São Paulo, maior mercado imobiliário do Brasil, uma nova fase de expansão das incorporadoras aumentando a demanda por terrenos, sobretudo nos projetos destinado as rendas média e alta. Além dos fatores econômicos, ajustes em regras também tendem a ajudar o setor. No fim de 2018, foi publicada a nova regulamentação dos distratos, pois caso o comprador desista da aquisição, será mais penalizado no ressarcimento do que no passado. Conforme a lei sancionada pelo então presidente Michel Temer, as regras do distrato se tornaram mais claras e também mais duras, pois a desistência da compra de um imóvel por parte do consumidor quando ele está inadimplente ou porque desistiu por razões diversas, faz com que ele tenha, sob forma de multa, 50% do montante pago retido.
A nova regulamentação dos distratos, a melhora nos níveis de confiança, os patamares baixos de juros, impulsionarão os lançamentos em 2019. Acreditamos que nesse momento a demanda seguirá aquecida para imóveis como padrão mais elevado.
Em conclusão, passado o período complicado da crise econômica brasileira e de retomada fraca de 2018, a expectativa é de continuidade da retomada em 2019, talvez não seja o ano mais forte observando um período de 5 anos a frente, mas que já tem perspectivas melhores do que o início dos últimos anos, especialmente de 2015 em diante.
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Terrenos e conjuntos comerciais diversos</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>300409600</Valor>
				<PercentValorizacaoDesvalorizacao>0.428</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Para a avaliação da área de terras foi utilizado o consagrado método comparativo direto de dados de mercado, que segundo a NBR 14.653, em sua parte 1, item 8.2.1:
“Identifica o valor de mercado do bem por meio de tratamento técnico dos atributos dos elementos comparáveis, constituintes da amostra.”
Quanto ao tratamento técnico implementado neste trabalho, utilizamos o processo científico, o qual permite com maior isenção de subjetividade atingir o valor mais provável de mercado do imóvel. Segundo a NBR 14.653-2, item 8.2.1.4.1:
“Tratamento científico: tratamento de evidências empíricas pelo uso de metodologia científica que leve à indução de modelo validado para o comportamento do mercado.”
“Deve-se levar em conta que qualquer modelo é uma representação simplificada do mercado, uma vez que não considera todas as suas informações. Por isso, precisam ser tomados cuidados científicos na sua elaboração, desde a preparação da pesquisa e o trabalho de campo, até o exame final dos resultados.”
A inferência estatística, através de modelos de regressão de pontos observados a equações de ajuste, constitui-se em instrumento de fundamental valia e aplicabilidade na Engenharia Econômica
e Avaliações, pois permite interpretar, objetivamente, efeitos e influências que guardem regularidade estatística.
Exemplificando, se os valores de terrenos mostram-se decrescentes, à medida que sua localização distancia-se de um pólo valorizante, a correta interpretação da variação dos valores dos terrenos ao longo deste eixo, é expressa através de modelo matemático-estatístico, justificado inferencialmente, cuja variável independente é a distância ao pólo e a variável dependente (resposta) é o respectivo valor. As correlações podem ser entre duas ou mais variáveis.
Pela ilustração anterior, podemos exemplificar:
• valor em função da distância: 2 variáveis
• valor em função da distância e da área do terreno: 3 variáveis
• valor em função da distância, da área e da testada do terreno: 4 variáveis
O parâmetro de qualidade do ajuste do modelo entre variáveis de observação é o coeficiente de correlação de Pearson, que quanto mais próximo de ± 1, informará o nível de aderência entre os pontos pesquisados e o modelo inferido. Além disso, torna-se imperioso para a definição do modelo estimativo, a análise da variância amostral, através do teste da hipótese de existência de regressão. Para tanto, lança-se mão da distribuição "F" de Fischer-Snedecor, bem como da distribuição "t" de Student, para a análise da importância das variáveis do processo, concluindo-se os níveis de incerteza da modelagem. A NBR 14.653, estabelece parâmetros críticos para a modelagem, os quais permitirão nivelar o grau de fundamentação do trabalho (I, II e III). Uma vez definido o modelo, a amplitude do intervalo de confiança parametrizará os graus I, II e III de precisão da estimativa.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Rua Dr. José Montaury, 139 - 7º andar - Centro Histórico - Porto Alegre/RS CEP 90.010-090.</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.geralinvestimentos.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>- Correspondência para o endereço físico da administradora; e-mail e telefone.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>(i) A participação dos cotistas em assembleias gerais será autorizada desde que comprovada sua qualidade de cotista ou documento que comprove a sua representação legal; (ii) Não utilizamos consultas formais; (iii) Não utilizamos procedimentos de participação à distância e envio de comunicação escrita ou eletrônica de voto.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico> Não utilizamos procedimentos de participação à distância de assembleia e envio de comunicação escrita ou eletrônica de voto.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>A taxa de administração do Fundo (“Taxa de Administração”), vigente desde 01 de agosto de 2009, é composta de uma parcela fixa no valor de R$ 2.700,00 (dois mil e setecentos reais), acrescida de uma parcela variável, atualizadas monetariamente em 01 de agosto de cada ano, tendo sua periodicidade alterada a partir de 01 de janeiro de 2014 para o dia 01 de janeiro de cada ano, de acordo com a variação do IGP-M - Índice Geral de Preços do Mercado (“IGP-M”), apurado e divulgado pela Fundação Getúlio Vargas (“FGV”), calculadas da seguinte forma:
i) 0,24% (zero vírgula vinte e quatro por cento) ao ano calculado sobre a parcela do Patrimônio Líquido de até R$ 90.000.000,00 (noventa milhões de reais);
ii) 0,22% (zero vírgula vinte e dois por cento) ao ano calculado sobre a parcela do Patrimônio Líquido que exceder R$ 90.000.000,00 (noventa milhões de reais) e até R$ 180.000.000,00 (cento e oitenta milhões de reais); e
iii) 0,20% (zero vírgula vinte por cento) ao ano calculado sobre a parcela do Patrimônio Líquido que exceder R$ 180.000.000,00 (cento e oitenta milhões de reais). 
Parágrafo Primeiro – A parcela variável é o valor resultante da aplicação dos percentuais acima discriminados, sobre o que convencionamos chamar de Patrimônio Líquido Ajustado, que corresponderá ao valor do Patrimônio Líquido Anual, apurado no Balanço de Encerramento do exercício social do ano anterior, deduzido do saldo da conta “Resultado do Valor Justo”, não realizado.
Parágrafo Segundo – Não obstante o acima disposto, a Taxa de Administração prevista no caput deste artigo deverá ser equivalente a, no mínimo, R$ 19.950,00 (dezenove mil, novecentos e cinquenta reais) mensais.
Parágrafo Terceiro – A Taxa de Administração será calculada e paga mensalmente, por período vencido, até o quinto dia útil do mês subsequente ao dos serviços prestados.
Parágrafo Quarto – O ADMINISTRADOR poderá estabelecer as parcelas da Taxa de Administração que deverão ser pagas diretamente pelo Fundo aos prestadores de serviços contratados.
Parágrafo Quinto – A partir de 01 de janeiro de 2018, o valor da parcela fixa, as faixas da parcela variável e a remuneração mínima, passam a ser atualizados anualmente, de acordo com a variação do IGP-M, apurado e divulgado pela FGV.
Parágrafo Sexto – A partir de 01 de julho de 2017, a parcela fixa terá o seu valor acrescido de 10% (dez por cento).
Parágrafo Sétimo – Além dos honorários previstos no caput deste artigo, também será devida ao ADMINISTRADOR, a título de Taxa de Administração, o valor referente aos serviços de escrituração de cotas.
</PoliticaRemuneracao>
			<ValorPagoAno>399813.96</ValorPagoAno>
			<PercentPatrimonioContabil>0.0011</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>EDE ANTONIO GASPERIN</Nome>
				<Idade>64</Idade>
				<CPF>213.560.170-53</CPF>
				<Email>edegasperin@geralinvestimentos.com.br</Email>
				<Profissao>ADMINISTRADOR DE EMPRESAS</Profissao>
				<FormacaoAcademica>ADMINISTRAÇÃO DE EMPRESAS - DIRETO</FormacaoAcademica>
				<DataInicioFuncao>2009-04-30</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>CORRETORA GERAL DE VALORES E CÂMBIO LTDA.</NomeEmpresa>
						<Periodo>                              Desde 01/06/1982 </Periodo>
						<CargoFuncoes>Diretor</CargoFuncoes>
						<AtividadePrincipalEmpresa>Corretora de Valores e Câmbio</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento numCotistas="1" numCotasDetidas="15609" percDetidoRelTotal="0.4999" percDetidoPF="0" percDetidoPJ="0.4999"/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="15610" percDetidoRelTotal="0.5" percDetidoPF="0" percDetidoPJ="0.5"/>
		</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>
"