"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>HUSI FUNDO DE INVESTIMENTO IMOBILIÁRIO </NomeFundo>
		<CNPJFundo>30017492000199</CNPJFundo>
		<DataFuncionamento>2018-03-12</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>0</CodigoISIN>
		<QtdCotasEmitidas>7850</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Desenvolvimento para Renda</Mandato>
			<SegmentoAtuacao>Hospital</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>Planner Corretora de Valores SA </NomeAdministrador>
		<CNPJAdministrador>30017492000199</CNPJAdministrador>
		<Logradouro>Avenida Brigadeiro Faria Lima</Logradouro>
		<Numero>3900</Numero>
		<Complemento>10º andar</Complemento>
		<Bairro>Itaim Bibi</Bairro>
		<Cidade>São Paulo</Cidade>
		<Estado>SP</Estado>
		<CEP>04538-132</CEP>
		<Telefone1>(11) 2172-2600</Telefone1>
		<Telefone2>0800 179 444</Telefone2>
		<Telefone3>(11) 2172-2667</Telefone3>
		<Site>www.planner.com.br</Site>
		<Email>investfundos@planner.com.br</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>Planner Corretora de Valores S.A.</Nome>
				<CNPJ>00.806.535/0001-54</CNPJ>
				<Endereco>Av. Brigadeiro Faria Lima, 3.900 - 10º andar - Itaim Bibi - CEP 04538-132 - São Paulo - SP</Endereco>
				<telefone>(11) 2172 - 2667</telefone>
			</Gestor>
			<Custodiante>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>BDO RCS Auditores Independentes</Nome>
				<CNPJ>54.276.936/0001-79</CNPJ>
				<Endereco>Rua Major Quedinho, 90 - Consolação - CEP 01050-030 - São Paulo, SP</Endereco>
				<telefone>(11) 3848 5880 </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 xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
					<Ativo>
						<Nome>LFT01092020</Nome>
						<Objetivos>Gestão de Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>9880.1</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>LFT01032024</Nome>
						<Objetivos>Gestão de Liquidez do Fundo</Objetivos>
						<MontantesInvestidos>59227.82</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>15TABELIÃO - UNIMED ITU/SALTO</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>30162.26</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>AC&amp;F CONSULTORIA</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>70137.76</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>ACSENG - VI</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>29400</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>ARQMATE CONSULTORIA E ASSESSORIA</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>3800</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>CRIAP IDEIAS PAISAGEM</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>2800</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>EMAC PROJETOS S/C LTDA</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>18600</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>ENGEKONS GESTÃO E CONSULTORIA</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>19890</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>ENGESOLOS ENG</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>48802.19</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>EQUIPAMENT CARE SERV CONSULT</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>32250</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>FREITAS LEITE ADVOGADOS</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>25298.41</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>ITBI - UNIMED ITU/SALTO</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>141000</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>POLITECNICA ENGENHARIA DE ESTUD</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>66600</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>QUALCOMTEC GEOTECNIA</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>45927.84</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>SOROFIRE PROJETOS E INSTALAÇÕES</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>9600</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>UNIMED ITU/SALTO COOPERATIVA MEDICA</Nome>
						<Objetivos>Renda</Objetivos>
						<MontantesInvestidos>7050000</MontantesInvestidos>
						<OrigemRecursos>FLUXO DE CAIXA</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>No exercicio encerrado em 31 de dezembro de 2018, o Fundo apresentou um Resultado Operacional de -R$ 183mil, e um Lucro Líquido de -R$ 237mil. No exercício não houve distribuíção aos cotistas.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>Passada a grande euforia vivida nos anos 2010 a 2013, o ano de 2016 nos parece o fechamento do primeiro ciclo da indústria, na medida em que novas ofertas se tornam cada vez menos frequentes e algumas dúvidas anda não foram plenamente esclarecidas. As respostas estão sendo buscadas constantemente e o amadurecimento deste mercado acontece de forma lenta (mas acontece). Dito isso, é hora de reflexão dos agentes participantes da indústria, sejam eles investidores, gestores, administradores, reguladores e fiscalizadores.
O ano de 2017 foi marcado pela retomada das emissões de fundos, na medida em que a taxa de juros voltaram para patamares razoáveis. Somado a isto, os índices tiveram forte valorização, levando o valor de mercado dos fundos para acima de R$ 40 bilhões. Não menos importante, o número de investidores na bolsa passou de aproximadamente 90 mil para mais de 140 mil em pouco menos de 6 meses. Porém, este aumento praticamente manteve constante a proporção de pessoas físicas detentoras do estoque de FIIs em 80%.
</ResultadoFundo>
			<ConjunturaEconomica>O modesto crescimento de 0,1% na passagem do 2°T para o 3ºT de 2017, encobre o desempenho bastante positivo que a economia brasileira apresentou nesse período. A razão é que a volatilidade do PIB agropecuário, que apresentou crescimento muito expressivo no 1ºT deste ano, vem dificultando a leitura dos dados subsequentes de atividade econômica. Excluindo a agropecuária, o desempenho do PIB no terceiro trimestre foi bastante robusto.
Os indicadores de confiança voltaram a subir no final de 2017, refletindo a consolidação da retomada da economia. A confiança empresarial retornou aos níveis médios de 2014, influenciada pelo bom momento da indústria, ao passo que a confiança dos consumidores também continuou avançando no último trimestre. 
Sobre o mercado de trabalho, as últimas pesquisas divulgadas apontam continuidade na trajetória de recuperação do emprego. Esperamos que esse quadro de retomada do emprego se reverta em 2018, quando devemos observar um crescimento mais intenso da atividade, capaz inclusive de permitir uma recuperação mais forte da ocupação formal. 
Quanto à inflação, os dados coletados durante a primeira quinzena de dezembro indicam que a inflação do ano ficará abaixo dos 3%, terreno em que se encontra desde julho. Mais de dois terços da desaceleração inflacionária ocorrida em 2017 se explicam pela redução de quase 15 pontos de percentagem da taxa de variação dos preços dos alimentos. 
Terminamos o ano de 2017 com os juros básicos em 7,0%, o mais baixo patamar atingido durante toda a vigência do regime de metas de inflação. Os sinais emitidos pelo Banco Central, sobre a política monetária, deixam clara a possibilidade de nova redução de 25 pontos da taxa Selic para o mês de março.
</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte/>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
		</ValorContabilAtivos>
		<CriteriosAvaliacao/>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias/>
			<EnderecoEletronicoDocsAssembleias/>
			<MeiosComunicacao/>
			<RegrasProcParticipacaoCotistas/>
			<PraticasAssembleiaMeioEletronico/>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao/>
			<ValorPagoAno xsi:nil="true"/>
			<PercentPatrimonioContabil xsi:nil="true"/>
			<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/>
				<Idade/>
				<CPF/>
				<Email/>
				<Profissao/>
				<FormacaoAcademica/>
				<DataInicioFuncao/>
				<QtdCotasDetidasFII/>
				<QtdCotasFIICompradas/>
				<QtdCotasFIIVendidas/>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="7850" percDetidoRelTotal="1" percDetidoPF="0" percDetidoPJ="0"/>
		</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>
"