"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>BB FUNDO DE INVESTIMENTO IMOBILIARIO PROGRESSIVO</NomeFundo>
		<CNPJFundo>07000400000146</CNPJFundo>
		<DataFuncionamento>2004-07-26</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRBBFICTF006</CodigoISIN>
		<QtdCotasEmitidas>130000</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>false</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>CAIXA ECONOMICA FEDERAL</NomeAdministrador>
		<CNPJAdministrador>07000400000146</CNPJAdministrador>
		<Logradouro>Avenida Paulista</Logradouro>
		<Numero>2300</Numero>
		<Complemento>11º Andar</Complemento>
		<Bairro>Cerqueira Cesar</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>01310300</CEP>
		<Telefone1>(11) 3572-4219</Telefone1>
		<Telefone2>(11) 3572-4388</Telefone2>
		<Telefone3 xsi:nil="true"/>
		<Site>www.caixa.gov.br</Site>
		<Email>supot02@caixa.gov.br</Email>
		<Competencia>2016-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Caixa Economica Federal</Nome>
				<CNPJ>360305000104</CNPJ>
				<Endereco>Av. Paulista, nº 2.300, 11º andar - Cerqueira Cesar - São Paulo/SP - CEP nº 01310-300</Endereco>
				<telefone>(11) 3572-4218</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Banco do Brasil S.A.</Nome>
				<CNPJ>191</CNPJ>
				<Endereco>Rua Lélio Gama, 105, 38º andar - Centro -
Rio de Janeiro/RJ - CEP nº 20031-080</Endereco>
				<telefone>(21) 3808-3561</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>Pricewaterhousecoopers Auditores Independentes</Nome>
				<CNPJ>61562112001526</CNPJ>
				<Endereco>Av. Francisco Matarazzo, nº 1400, Torre Torino , 9º andar -  Água Branca - São Paulo - SP - CEP nº 05001-100</Endereco>
				<telefone>(11) 3674-2686</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>J. Fleury Assessoria e Consultoria Imobiliária LTDA</Nome>
				<CNPJ>37097813000151</CNPJ>
				<Endereco>SRTV SUL Quadra nº 701, Bloco B, Centro Empresarial Brasília, salas nº 606/608 - Brasília/DF - CEP nº 70340-907</Endereco>
				<telefone>(61) 3224-9884</telefone>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>Submeter propostas de retrofit e de administração condominial do Edifício Sede I à assembleia de cotistas. Com relação ao edifício CARJ, avaliar e discutir com o locatário, o prazo e condições de uma eventual saída do imóvel.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Durante o exercício de 2016 foram auferidos R$ 35.803.623,79 como receita de aluguel, sendo R$ 26.537.938,46 provenientes do contrato de locação total do imóvel CARJ e R$ 9.265.685,33 provenientes do contrato de locação parcial do imóvel Sede I. A receita com operações financeiras em 2016 totalizou R$ 2.107.117,31. 
Do resultado financeiro líquido obtido, mensalmente, 95% foi distribuído como rendimento aos cotistas e 5% retido para compor reserva estatutária. </ResultadoFundo>
			<ConjunturaEconomica>O período foi marcado por instabilidade econômica, além de um ambiente político incerto. Os indicadores de emprego e renda, que influenciam diretamente a demanda do mercado imobiliário seguem pressionados.
Sendo o segundo ano consecutivo de retração do PIB (-3,6%), só não foi pior que 2015 (-3,8%) numa janela partindo desde a década de 90.
O segmento imobiliário também foi impactado negativamente, muito em função da economia, bem como, da fase do ciclo imobiliário atual. A situação econômica vem fazendo com que as empresas cortem os investimentos programados, bem como adotem grandes de políticas de austeridade, com amplo corte de gastos. 
Em relação ao mercado imobiliário de Brasília, cidade onde se situa o Edifício Sede I, conforme diagnóstico da Colliers International: "passa por um momento de expansão do estoque de áreas de escritório e residencial. O movimento segue um padrão fortemente estabelecido pelo aumento da demanda de espaços oriunda do desenvolvimento econômico e participativo de novas empresas na capital, além do aumento significativo de funcionários públicos e a criação de novos postos de trabalho nas instituições ligadas ao governo. O mercado está enfrentando dificuldades para suprir esta demanda aquecida devido, principalmente, à falta de terrenos para incorporações na região do Plano Piloto."
Já em relação ao mercado imobiliário do Rio de Janeiro, cidade onde se situa o Edifício CARJ, o diagnóstico da Colliers International foi de que: "o inventário do Rio de Janeiro fechou o segundo trimestre do ano com 1,375 milhões m² nos imóveis de classe A+ A e com 866 mil m² na classe B. As taxas de vacância atuais são de 26% e 27%, respectivamente. Quanto aos preços médios pedidos de locação, observou-se que a diferença entre as classes de imóveis A+ A e B é de 12%, o que indica que o mercado deve passar, em breve, por um movimento de migração de ocupantes da classe B para edifícios classe A+ A.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A perspectiva em relação ao Edifício Sede I é de fortalecer o trabalho com o assessor imobiliário para locação das áreas vagas. Quanto ao CARJ, a perspectiva é de alinhar com o atual locatário as condições de uma eventual saída do imóvel, porém o contrato está vigente até outubro de 2020.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Imóvel DF - SEDE1</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>217000000</Valor>
				<PercentValorizacaoDesvalorizacao>0.0187</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Imóvel RJ - CARJ</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>247300000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0941</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>As avaliações foram realizadas pela mesma metodologia, qual seja, a comparação direta com imóveis semelhantes e inseridos na mesma região socioeconômica.
Foram consideradas na avaliação as práticas e padrões profissionais aplicáveis de acordo com a Norma Brasileira de Avaliações NBR 14.653 da ABNT – Associação Brasileira e Normas Técnicas, em todas as suas partes, além dos padrões de conduta e ética profissionais estabelecidos no Red Book em sua edição 2015 editada pelo Royal Institute of Chartered Surveyors (“RICS”) e nas normas do International Valuation Standards Council (“IVSC”), nos seus pronunciamentos 101 – Scope of Work, 102 – Implementation e 103 – Reporting. A base de valor adotada foi a definida pelo Red Book.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Av. Paulista, nº 2.300, 11º andar - Cerqueira Cesar - São Paulo/SP - CEP nº 01310-300</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>http://www.caixa.gov.br/site/paginas/downloads.aspx</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>e-mail supot02@caixa.gov e telefones (11) 3572-4219 e 3572-4388.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Os cotistas devem comparecer ao local designado para a Assembleia Geral presencial portando documento de identidade original com validade em todo o território nacional e, no caso daqueles que se fizerem representar por procuradores, estes devem ter sido constituídos há menos de 1 (um) ano e devem comparecer ao local designado portando procuração original com firma reconhecida e com poderes específicos. Nas consultas formais, são recebidos os votos pelo correio com firma reconhecida em cartório do cotista e contabilizados em controle específico. Não é admitido pelo Regulamento do Fundo a realização de Assembleia Geral para a participação à distancia e envio de comunicação escrita ou eletrônica de voto, com exceção das consultas formais.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>Não é admitido pelo Regulamento do Fundo a realização de Assembleia Geral por meio eletrônico. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>A ADMINISTRADORA receberá, pelos serviços de gestão do FUNDO, com exclusão de qualquer outra, a seguinte remuneração, cobrada mensalmente: o equivalente à 5,10% (cinco inteiros e dez centésimos) ao mês sobre o total de receitas do FUNDO, deduzidas todas as despesas e provisões do FUNDO, antes da incidência da referida taxa, tendo como piso mensal o valor de R$ 36.000,00 (trinta e seis mil reais), corrigido anualmente pelo IGP-M da FGV.</PoliticaRemuneracao>
			<ValorPagoAno>1148587.95</ValorPagoAno>
			<PercentPatrimonioContabil>0.0024</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0037</PercentPatrimonioValorMercado>
		</RemuneracaoAdministrador>
		<Governanca>
			<RepresentantesCotistas>
				<Representante1>
					<Nome>Gabriel Jose Lindenbaum</Nome>
					<Idade>44 anos</Idade>
					<CPF>1111095744</CPF>
					<Email>lisboalindenbaum@gmail.com</Email>
					<Profissao>Advogado</Profissao>
					<FormacaoAcademica>Direito</FormacaoAcademica>
					<FormaRemuneracao>Sem remuneração no exercício 2016</FormaRemuneracao>
					<ValorPagoAno>0</ValorPagoAno>
					<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
					<PercentPatrimonioValorMercado>0</PercentPatrimonioValorMercado>
					<QtdCotasDetidasFII>106</QtdCotasDetidasFII>
					<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
					<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
					<DataEleicaoAssembleia>2016-06-14</DataEleicaoAssembleia>
					<TerminoMandato>2018-06-14</TerminoMandato>
					<ExperienciasProfUltimosCincoAnos>
						<Experiencia>
							<NomeEmpresa>Lisboa Lindenbaum Imovéis LTDA</NomeEmpresa>
							<Periodo>1992 até os dias atuais</Periodo>
							<CargoFuncoes>Sócio Gerente</CargoFuncoes>
							<AtividadePrincipalEmpresa>Administração, locação, compra e venda de imóveis</AtividadePrincipalEmpresa>
						</Experiencia>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
						<Fundo>
							<Nome>Fundo de Investimento Imobiliário Edifício Almirante Barroso</Nome>
							<DataEleicaoAssembGeral>2016-05-31</DataEleicaoAssembGeral>
							<TerminoMandato>2017-05-31</TerminoMandato>
						</Fundo>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal>Não há</CondenacaoCriminal>
						<CondenacaoProcAdminCVM>Não há</CondenacaoProcAdminCVM>
					</Eventos>
				</Representante1>
				<Representante2>
					<Nome>Luiz Gustavo Aurnheimer Vieira</Nome>
					<Idade>37 anos</Idade>
					<CPF>8436389743</CPF>
					<Email>lgvieira2013@gmail.com </Email>
					<Profissao>Administrador</Profissao>
					<FormacaoAcademica>Sem formação</FormacaoAcademica>
					<FormaRemuneracao>Sem remuneração no exercício 2016</FormaRemuneracao>
					<ValorPagoAno>0</ValorPagoAno>
					<PercentPatrimonioContabil>0</PercentPatrimonioContabil>
					<PercentPatrimonioValorMercado>0</PercentPatrimonioValorMercado>
					<QtdCotasDetidasFII>88</QtdCotasDetidasFII>
					<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
					<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
					<DataEleicaoAssembleia xsi:nil="true"/>
					<TerminoMandato xsi:nil="true"/>
					<ExperienciasProfUltimosCincoAnos>
						<Experiencia>
							<NomeEmpresa>Consenso Locação e Construção de Imóveis LTDA</NomeEmpresa>
							<Periodo>2004 até os dias atuais</Periodo>
							<CargoFuncoes>Sócio</CargoFuncoes>
							<AtividadePrincipalEmpresa>Locação e construção de imóveis</AtividadePrincipalEmpresa>
						</Experiencia>
					</ExperienciasProfUltimosCincoAnos>
					<FundosExercaFuncaoRepresentante>
						<Fundo>
							<Nome>Fundo de Investimento Imobiliário Edifício Almirante Barroso</Nome>
							<DataEleicaoAssembGeral>2016-05-31</DataEleicaoAssembGeral>
							<TerminoMandato>2017-05-31</TerminoMandato>
						</Fundo>
					</FundosExercaFuncaoRepresentante>
					<Eventos>
						<CondenacaoCriminal>Não há</CondenacaoCriminal>
						<CondenacaoProcAdminCVM>Não há</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>FLAVIO EDUARDO ARAKAKI</Nome>
				<Idade>37 anos</Idade>
				<CPF>28384495831</CPF>
				<Email>viter@caixa.gov.br</Email>
				<Profissao>Economiário</Profissao>
				<FormacaoAcademica>Mestrado</FormacaoAcademica>
				<DataInicioFuncao>2016-07-26</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Caixa Econômica Federal</NomeEmpresa>
						<Periodo>26/07/2016 até o momento</Periodo>
						<CargoFuncoes>Vice-Presidente Interino</CargoFuncoes>
						<AtividadePrincipalEmpresa>Vice-Presidência de Gestão de Ativos de Terceiros</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Caixa Econômica Federal</NomeEmpresa>
						<Periodo>22/05/2013 a 25/07/2016</Periodo>
						<CargoFuncoes>Diretor Executivo</CargoFuncoes>
						<AtividadePrincipalEmpresa>Diretoria Executiva de Ativos de Terceiros</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Caixa Econômica Federal</NomeEmpresa>
						<Periodo>10/06/2011 a 21/05/2013</Periodo>
						<CargoFuncoes>Superintendente Nacional</CargoFuncoes>
						<AtividadePrincipalEmpresa>Superintendência Nacional de Fundos de Investimento Especiais</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não há</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não há</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="3494" numCotasDetidas="123340" percDetidoRelTotal="0.948769" percDetidoPF="0.911685" percDetidoPJ="0.037085"/>
			<AcimaCincoAteDezPorcento numCotistas="1" numCotasDetidas="6660" percDetidoRelTotal="0.051231" percDetidoPF="0.051231" percDetidoPJ="0"/>
			<AcimaDezAteQuinzePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuinzeAteVintePorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaVinteAteTrintaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaQuarentaAteCinquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
			<AcimaCiquentaPorcento numCotistas="0" numCotasDetidas="0" percDetidoRelTotal="0" percDetidoPF="0" percDetidoPJ="0"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>Fatos relevantes são divulgados no site do Administrador (www.caixa.gov.br → opção “Downloads” → item “Aplicação Financeira – Fundo de Investimento Imobiliário Progressivo”), no site da Comissão de Valores Mobiliarios (www.cvm.gov.br → opção “Informações de Regulados” → opção “Fundos de Investimento” → opção “Consulta a Informações de Fundos” → opção “Fundos de Investimento Registrados” em seguida digitar o nome do Fundo), e da BM&amp;FBOVESPA (www.bmfbovespa.com.br → selecionar “Produtos” → “opção “Renda Variável” → item “Fundos de Investimentos” → selecionar “FIIs listados” → localizar “BB FDO INV IMOB PROGRESSIVO”).</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>As cotas do Fundo são negociadas no mercado de balcão organizado da BM&amp;Fbovespa.</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>Fundo não possui participações societárias.</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao>Gerente Executivo:  ALEXANDRE PEREIRA DO NASCIMENTO               
Operadores de Mesa:  ALBERTO DANIEL ARAUJO DA SILVA, CLEBER ALVES FABIO, DAZIA VANESSA EGUCHI KEMPER, ELIANA MARQUES LISBOA, FERNANDA BUENO FREDERICO MARTINIS, HEBERT GONCALEZ GALLY, LEONARDO CESAR FERREIRA SILVA, LUCI CLEIDE SILVA, PAULA CUNHA DE OLIVEIRA, VINICIUS BARBIERI DOMINGUES      </FuncResponsaveisPoliticaDivulgacao>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Capital foi totalmente subscrito e integralizado.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"