"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>CASTELLO BRANCO OFFICE PARK FUNDO DE INVEST IMOBILIÁRIO FII</NomeFundo>
		<CNPJFundo>17144039000185</CNPJFundo>
		<DataFuncionamento>2012-12-17</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRCBOPCTF001</CodigoISIN>
		<QtdCotasEmitidas>141500</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>CREDIT SUISSE HEDGING - GRIFFO CORRETORA DE VALORES S.A.</NomeAdministrador>
		<CNPJAdministrador>17144039000185</CNPJAdministrador>
		<Logradouro>RUA LEOPOLDO COUTO MAGALHAES JR</Logradouro>
		<Numero>700</Numero>
		<Complemento>11º andar</Complemento>
		<Bairro>ITAIM BIBI</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04542-000</CEP>
		<Telefone1>(11) 3701-8600</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.cshg.com.br</Site>
		<Email>list.imobiliario@cshg.com.br</Email>
		<Competencia>2017-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>-</Nome>
				<CNPJ>-</CNPJ>
				<Endereco>-</Endereco>
				<telefone>-</telefone>
			</Gestor>
			<Custodiante>
				<Nome>ITAÚ UNIBANCO S.A.</Nome>
				<CNPJ>60701190000104</CNPJ>
				<Endereco>PC ALFREDO EGYDIO DE SOUZA ARANHA 100 - TORRE OLAVO SETUBAL</Endereco>
				<telefone>(11) 3701-8753</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>PRICEWATERHOUSECOOPERS AUDITORES INDEPENDENTES</Nome>
				<CNPJ>61562112000201</CNPJ>
				<Endereco>AV. FRANSCISCO MATARAZZO, 1400 - TORRE TORINO</Endereco>
				<telefone>(11) 3674-2000</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>TS Consultoria Imobiliária Ltda</Nome>
				<CNPJ>10.262.910/0001-04</CNPJ>
				<Endereco>Avenida das Nações Unidas, 12.901 – 34º andar – sala 27 – CEP 04578-000</Endereco>
				<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>O Fundo seguirá sua política de investimentos, conforme regulamento do mesmo,  e poderá buscar possibilidades de ampliação de seu patrimônio.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O fundo recebe, mensalmente, o resultado gerado pelo empreendimento que compõe o seu patrimônio imobiliário e a rentabilidade auferida pelos investimentos em ativos financeiros. Durante o exercício de 2017, o Fundo auferiu rendimentos que somaram R$ 8.235.300,00, equivalente a R$ 58,20 por cota. De acordo com a Lei 11.196, o Fundo enquadra-se na relação dos Fundos com isenção de IR. O cotista (pessoa física) que detém participação inferior a 10% tem direito a isenção do imposto de renda sobre os rendimentos distribuídos pelo Fundo mensalmente.</ResultadoFundo>
			<ConjunturaEconomica>O ano de 2017 foi marcado por um movimento importante de retomada da economia em comparação a 2016 e com uma sinalização de evolução significativa para 2018.
No mercado imobiliário corporativo de São Paulo o cenário não foi diferente, apresentando uma redução de vacância no mercado como um todo , com variações importantes por microrregião.
O mercado de escritórios de São Paulo tem atualmente 15,6 milhões de metros quadrados, sendo 5,0 milhões em salas comerciais (office) e 10,6 milhões em escritórios corporativos (corporate) das diversas classes, AAA até C. Como os imóveis classe C são tecnicamente inferiores (não tem ar condicionado central, por exemplo) e nossa carteira não tem alocação em escritórios Classe C, sempre analisamos o mercado de escritórios sem considerá-los, apenas com as classes AAA, AA, A, BB e B, que somam 7,5 milhões de m².
A previsão para o ano de 2017 era bastante cautelosa, já que estávamos saindo de 2016 muito difícil, num ano que a absorção líquida (soma das novas locações e expansões com as devoluções e reduções) do mercado havia ficado em zero e a vacância havia atingido 19%, com 1,5 milhões de m² vagos. O fato é que concluído o ano e com todos os dados disponíveis, fica claro que 2017 representa uma inversão do cenário anterior, com dados significativos de melhora, por exemplo, alcançando absorção bruta (total de espaço locados) de 840 mil m² - um recorde em volume de transações – e uma absorção líquida de 240 mil m², melhor patamar desde 2010. 
Em função deste cenário positivo de absorção líquida (prevíamos 77 mil m² e foram absorvidos 240 mil m²), somado às postergações de entrega num total de 231 mil m² (prevíamos 413 mil m² e foram entregues 182 mil m²), a vacância do final de 2017, que era estimada em 23%, ficou estável em 19%. 
Como a projeção do mercado (boletim Focus de 02/fevereiro) aponta para um crescimento do PIB de 2,7% para 2018 e 3,0% para 2019, nossa expectativa para a absorção líquida para 2018-2020, que anteriormente estava em média de 153 mil m² ao ano, subiu para 221 mil m², com uma explicação simples. Em geral, acreditamos que cada variação positiva de 1% no PIB representará uma absorção líquida positiva de 76 mil m², assim, como as diversas projeções econômicas já apontam uma melhoria na economia, é natural que nosso cenário também se beneficie disso.
Ainda que, em 2017, a performance do mercado tenha sido melhor do que imaginado, ela ocorreu diferentemente entre as diversas classes e regiões. O movimento “flight to quality”, em que os locatários migram de imóveis de escritórios de classe inferior para superior, continuou presente, fazendo com que a vacância dos prédios AAA caísse vertiginosamente, de 22,9% em dezembro/2016 para 14,2% em dezembro/2017. 
Este processo de redução de vacância, iniciado de forma mais relevante nos prédios AAA, continuará acontecendo em todas as classes.
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Em conformidade com o  Regulamento do Fundo, a política de investimentos seguirá inalterada para o exercício seguinte, e o Fundo poderá buscar novas possibilidades de ampliação de seu patrimônio.
No mercado de locações, esperamos que a vacância continue o processo de redução, tanto no mercado, como na carteira do Fundo. Dentro da carteira do fundo, os esforços comerciais surtiram efeito, fazendo com que a vacância permanecesse estável em 7,0%, quando comparado o início e fim de 2017.
É esperado que a demanda continue aquecida, no entanto, como ainda existe uma oferta de imóveis novos, a taxa de vacância ainda poderá subir, porém, num mercado com melhor dinâmica comercial e, quando comparado com 2016-2017, esperamos termos mais favoráveis aos proprietários de imóveis.
O objetivo central da equipe de gestão será a gestão do nível de vacância no menor patamar possível, atuando fortemente na manutenção dos locatários atuais, prospecção ativa de novos locatários, além da constante busca de otimização de custos dos imóveis e do fundo.
</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Edifício Castello Branco Office Park – Torre Jatobá</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>100513000</Valor>
				<PercentValorizacaoDesvalorizacao>-0.0243</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>As propriedades para investimento estão demonstradas pelos seus respectivos valores justos, os quais foram obtidos através de laudos de avaliação elaborados por entidades profissionais com qualificação reconhecida e formalmente aprovados pela Administradora do Fundo. A variação no valor justo das propriedades para investimento é reconhecida na demonstração do resultado do período em que referida valorização ou desvalorização tenha ocorrido.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>RUA LEOPOLDO COUTO MAGALHÃES JUNIOR, 700 - ITAIM BIBI - SÃO PAULO - SP - 11º ANDAR</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>https://www.cshg.com.br/site/publico/imob/imob.seam</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Endereço Físico: RUA LEOPOLDO COUTO MAGALHÃES JUNIOR, 700 - ITAIM BIBI - SÃO PAULO - SP - 11º ANDAR
Endereço Eletrônico: list.imobiliario@cshg.com.br
</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>Poderão participar da Assembleia os cotistas inscritos no registro de cotistas do Fundo na data da convocação da respectiva Assembleia, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano. Sendo assim, é necessário apresentar documento de identificação válido, no caso de cotista pessoa física, ou em caso de pessoa jurídica ou fundo de investimento, documento de identificação válido do(s) representante(s) acompanhado de cópia autenticada do estatuto/contrato social ou cópia simples do regulamento e procuração específica para comprovar poderes. Em caso de cotista representado por procurador, a procuração deve trazer poderes específicos para prática do voto e estar com firma reconhecida. No caso de consultas formais, deverão ser observados os prazos e condições específicas a cada consulta conforme detalhado em seu edital, observado sempre o prazo mínimo previsto em regulamento e na regulamentação. O procedimento para verificação da qualidade de cotista e sua representação acima descrita também é aplicável neste caso. Não há possibilidade de voto à distância</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>A administradora não tem como prática, neste momento, a realização de assembleias por meio eletrônico. </PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela prestação dos serviços de administração, o Fundo pagará à Administradora a quantia equivalente a 0,3% (três décimos por cento) ao ano sobre o valor de mercado das cotas do Fundo, calculado com base na média diária da cotação de fechamento das cotas de emissão do Fundo no mês anterior ao do pagamento da remuneração, observado o valor mínimo mensal de R$ 30.000,00 (trinta mil reais), atualizado anualmente pela variação do IGP-M (Índice Geral de Preços de Mercado), apurado e divulgado pela Fundação Getúlio Vargas – FGV.
Tais honorários serão calculados diariamente e pagos mensalmente, até o 5º (quinto) dia útil de cada mês subsequente ao da prestação dos serviços, vencendo-se a primeira mensalidade no 5º (quinto) dia útil do mês seguinte ao da concessão da autorização da CVM para o funcionamento do Fundo. 
A Administradora pode estabelecer que parcelas da taxa de administração sejam pagas diretamente pelo Fundo aos prestadores de serviços contratados.
</PoliticaRemuneracao>
			<ValorPagoAno>464744.68</ValorPagoAno>
			<PercentPatrimonioContabil>0.0046</PercentPatrimonioContabil>
			<PercentPatrimonioValorMercado>0.0044</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>Bruno Laskowsky</Nome>
				<Idade>56 anos</Idade>
				<CPF>761.157.717-49</CPF>
				<Email>bruno.laskowsky@cshg.com.br</Email>
				<Profissao>administrador de empresas</Profissao>
				<FormacaoAcademica>Mestrado em Administração de Empresas </FormacaoAcademica>
				<DataInicioFuncao>2017-05-22</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Credit Suisse Hedging-Griffo Corretora de Valores S.A.</NomeEmpresa>
						<Periodo>Janeiro/2017 até a presente data

</Periodo>
						<CargoFuncoes>Managing Director - Real Estate

</CargoFuncoes>
						<AtividadePrincipalEmpresa>Instituição Financeira</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Boston Consulting Group</NomeEmpresa>
						<Periodo>Julho/2016 a Dezembro/2016</Periodo>
						<CargoFuncoes>Senior Advisor</CargoFuncoes>
						<AtividadePrincipalEmpresa>Consultoria</AtividadePrincipalEmpresa>
					</Experiencia>
					<Experiencia>
						<NomeEmpresa>Viver/Inpar Incorporadora e Construtora S.A</NomeEmpresa>
						<Periodo>Outubro/2012 a Junho/2016</Periodo>
						<CargoFuncoes>CEO</CargoFuncoes>
						<AtividadePrincipalEmpresa>Incorporadora e Construtora</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento numCotistas="2246" numCotasDetidas="61357" percDetidoRelTotal="0.4337" percDetidoPF="0.996" percDetidoPJ="0.004"/>
			<AcimaCincoAteDezPorcento numCotistas="1" numCotasDetidas="9110" percDetidoRelTotal="0.0643" percDetidoPF="0" percDetidoPJ="1"/>
			<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="1" numCotasDetidas="71033" percDetidoRelTotal="0.502" percDetidoPF="0" percDetidoPJ="1"/>
		</DistribuicaoCotistas>
		<TransacoesInstrucaoCVM>
		</TransacoesInstrucaoCVM>
		<PoliticaDivulgacao>
			<PoliticaDivulgacaoAtoFatoRelevante>São considerados relevantes pelo Administrador qualquer deliberação da assembleia geral de cotistas ou do Administrador ou qualquer outro ato ou fato que possa influir de modo ponderável (I) na cotação das cotas ou de valores mobiliários a elas referenciados, (II) na decisão dos investidores de comprar, vender ou manter as cotas, e (III) na decisão dos investidores de exercer quaisquer direitos inerentes à condição de titular cotas ou de valores mobiliários a elas referenciados, tais como, exemplificativamente, mas não limitados a: I – atraso para o recebimento de quaisquer rendimentos que representem percentual significativo dentre as receitas do fundo; II – venda ou locação dos imóveis de propriedade do fundo destinados a arrendamento ou locação, e que possam gerar impacto significativo em sua rentabilidade; III – fusão, incorporação, cisão, transformação do fundo ou qualquer outra operação que altere substancialmente a sua composição patrimonial; IV – emissão de cotas nos termos do inciso VIII do artigo 15 da Instrução CVM 472.
Tais informações são divulgadas à CVM, à BM&amp;FBovespa, e também através do site do Administrador, no endereço https://www.cshg.com.br/site/publico/imob/imob.seam
Adicionalmente, o Administrador adota segregação física da sua área de administração de fundos imobiliários em relação às áreas responsáveis por outras atividades e linhas de negócio. Neste sentido, o acesso a sistemas e arquivos, inclusive em relação à guarda de documentos de caráter confidencial, é restrito à equipe dedicada pela administração de tais fundos, sendo possível o compartilhamento de informações às equipes jurídicas e de compliance que atendam tal área de negócio. Adicionalmente, o Administrador tem como política interna a exigência de termos de confidencialidade com todos os seus funcionários, no momento de sua contratação.   
</PoliticaDivulgacaoAtoFatoRelevante>
			<PoliticaNegociacaoCotas>Fundo listado em bolsa de valores (BM&amp;FBovespa), onde suas cotas são admitidas à negociação no mercado secundário. As informações e documentos públicos do fundo estão disponíveis no endereço:  https://www.cshg.com.br/site/publico/imob/imob.seam</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>https://www.cshg.com.br/site/publico/download/arquivos/Politica_Exercicio_Voto_Assembleias_Fundos_CSHG.pdf </PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Fundo não possui chamada de capital. Novas emissões de cotas podem ser realizadas mediante aprovação da assembleia geral de cotistas.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"