"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>IZAR - FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII </NomeFundo>
		<CNPJFundo>22646161000190</CNPJFundo>
		<DataFuncionamento>2016-04-08</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>260811</QtdCotasEmitidas>
		<FundoExclusivo>true</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Híbrido</Mandato>
			<SegmentoAtuacao>Residencial</SegmentoAtuacao>
			<TipoGestao>Passiva</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>30/06</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>true</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>true</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>OLIVEIRA TRUST DTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>22646161000190</CNPJAdministrador>
		<Logradouro>Avenida das Américas</Logradouro>
		<Numero>3434</Numero>
		<Complemento>Bloco 07, sala 201</Complemento>
		<Bairro>Barra da Tijuca</Bairro>
		<Cidade>Rio de Janeiro</Cidade>
		<Estado>RJ</Estado>
		<CEP>22640-102</CEP>
		<Telefone1>(21) 3514-0000</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.oliveiratrust.com.br</Site>
		<Email>ger2.fundos@oliveiratrust.com.br</Email>
		<Competencia>2018-06-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>POLO CAPITAL GESTÃO DE RECURSOS</Nome>
				<CNPJ>05.451.668/0001-79</CNPJ>
				<Endereco>Av. Ataulfo de Paiva, 204, 10º andar, Leblon, CEP 22.440-033</Endereco>
				<telefone>(21) 3205-9800</telefone>
			</Gestor>
			<Custodiante>
				<Nome>Oliveira Trust DTVM S.A.</Nome>
				<CNPJ>36.113.876/0001-91</CNPJ>
				<Endereco>Avenida das Américas, n.º 3.434, Bloco 07, Sala 201</Endereco>
				<telefone>(21) 3514-0000</telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>KPMG  Auditores Independentes</Nome>
				<CNPJ>57.755.217/0003-90</CNPJ>
				<Endereco>Rua do Passeio, n° 38 - Setor 2 - 17° andar, Centro</Endereco>
				<telefone>(21) 2207-9400</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>Frade Spot Participações Ltda.</Nome>
						<Objetivos>Garantir liquidez financeira aos empreendimentos imobiliários em construção</Objetivos>
						<MontantesInvestidos>12800000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 202 - BL-2 - Village Maris</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>2879690</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 201 - BL-2 - Village Maris</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>2879690</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 201 - BL-5 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1556741.5</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 101 - BL-3 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1565148</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 102 - BL-3 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1565148</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 301 - BL-4 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>2674338.5</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 201 - BL-4 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1575165</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 203 - BL-5 - Village Natura</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1056777.5</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 302 - BL-5 - Village Natura</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1995541</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 204 - BL-5 - Village Natura</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1062590</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 102 - BL-5 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1583828</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 101 - BL-5 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1583828</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 202 - BL-4 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1583828</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Birsa - Unid. 604 - Tijuca Royalle</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1000000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 202 - BL-5 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1585095.24</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 203 - BL-3 - Village Natura</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1063439.7</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 101 - BL-8 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 202 - BL-8 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 301 - BL-8 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>3507000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 101 - BL-10 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 101 - BL-3 - Village Natura</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1080000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 101 - BL-9 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 102 - BL-9 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 201 - BL-9 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 102 - BL-11 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 101 - BL-11 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 301 - BL-05 - Village Natura</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>2100000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 101 - BL-01 - Village Acqua</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1750000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 301 - BL-4 - Village Natura</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>2166750</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Unid. 301 - BL-6 - Village Maris</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>6237000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Maris - BL-2 - Unid. 301</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>6237000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Natura - BL-4 - Unid. 102</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1852500</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Maris - BL-2 - Unid. 101</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>5332635</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Concept Botafogo - Unid. 301</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1220000</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Maris - BL-2 - Unid. 102</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>5332635</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Maris - BL-3 - Unid. 102</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>5332635</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Natura - BL-3 - Unid. 301</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>3705142.5</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Maris - BL-4 - Unid. 202</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>5332635</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Acqua - BL-9 - Unid. 202</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>3040297.07</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Natura - BL-6 - Unid. 203</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1876297.61</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
					<Ativo>
						<Nome>Frad.E - Village Natura - BL-4 - Unid. 103</Nome>
						<Objetivos>Aquisição e posterior gestão patrimonial dos Ativos imobiliários, de forma a gerar remuneração buscando alcance de uma rentabilidade superior ao CDI</Objetivos>
						<MontantesInvestidos>1883243.4</MontantesInvestidos>
						<OrigemRecursos>Aplicação de recursos de um grupo de investidores via Emissão de quotas do fundo</OrigemRecursos>
					</Ativo>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos>O programa de investimentos do Fundo para o próximo exercício possui poucos investimentos previstos para realização. Os investimentos feitos no período sob análise são quase a totalidade prevista no Programa inicial de Investimentos. Também poderão entrar em análise imóveis em áreas fora da concentração, os quais possam auferir ganhos de modo a auxiliar o Fundo à render ganhos acima do esperado.</ProgramaInvestimentos>
		<AnaliseAdministrador>
			<ResultadoFundo>O Fundo no período em análise gerou resultados dentro do esperado, considerando sua fase inicial de investimentos, onde ao fim do ano de referência foram feitos os investimentos previstos até então.</ResultadoFundo>
			<ConjunturaEconomica>O Fundo possui investimentos concentrados em uma área de alta renda, a qual sofreu com a crise econômica do país, dado ainda por sua localização ser uma área de procura de lazer e turismo. Mas dada a fase inicial de investimentos do Fundo, ainda é cedo para que seja tomada qualquer decisão que altere o rumo previsto inicialmente sobre as aquisições.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Para o período seguinte, o Fundo objetiva manter sua posição nos imóveis adquiridos até então, aguardando até que as obras dos classificados como Propriedades de imóveis sejam finalizadas, de modo a auferir ganhos na futura alienação dos imóveis, conforme previsto em sua Política de Investimento. Para os imóveis que já se encontrem destinados à venda, o Fundo explorará os direitos a eles relacionados com o mesmo intuito inicial de auferir ganhos com sua alienação.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>Frad.E - Unid. 202 - BL-2 - Village Maris</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2879690</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 201 - BL-2 - Village Maris</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2879690</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 201 - BL-5 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1556741.5</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 101 - BL-3 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1565148</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 102 - BL-3 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1565148</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 301 - BL-4 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2674338.5</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 201 - BL-4 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1575165</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 203 - BL-5 - Village Natura</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1056777.5</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 302 - BL-5 - Village Natura</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1995541</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 204 - BL-5 - Village Natura</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1062590</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 102 - BL-5 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1583828</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 101 - BL-5 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1583828</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 202 - BL-4 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1583828</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Birsa - Unid. 604 - Tijuca Royalle</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1000000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 202 - BL-5 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1585095.24</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 203 - BL-3 - Village Natura</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1063439.7</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 101 - BL-8 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 202 - BL-8 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 301 - BL-8 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3507000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 101 - BL-10 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 101 - BL-3 - Village Natura</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1080000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 101 - BL-9 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 102 - BL-9 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 201 - BL-9 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 102 - BL-11 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 101 - BL-11 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 301 - BL-05 - Village Natura</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2100000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 101 - BL-01 - Village Acqua</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1750000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 301 - BL-4 - Village Natura</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>2166750</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Unid. 301 - BL-6 - Village Maris</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6237000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Maris - BL-2 - Unid. 301</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>6237000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Natura - BL-4 - Unid. 102</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1852500</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Maris - BL-2 - Unid. 101</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5332635</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Concept Botafogo - Unid. 301</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1220000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Maris - BL-2 - Unid. 102</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5332635</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Maris - BL-3 - Unid. 102</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5332635</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Natura - BL-3 - Unid. 301</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3705142.5</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Maris - BL-4 - Unid. 202</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>5332635</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Acqua - BL-9 - Unid. 202</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>3040297.07</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Natura - BL-6 - Unid. 203</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1876297.61</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
			<Ativo>
				<Nome>Frad.E - Village Natura - BL-4 - Unid. 103</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>1883243.4</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os imóveis propriedades para investimento, categoria que engloba imóveis em cosntrução, imóveis adquiridos para auferir renda e imóveis com apreciação de capital de longo prazo, inicialmente são contabilizados pelo custo de aquisição. Este custo inclui todos os gastos das transação diretamente atribuíveis à operação de compra, tais como, taxas cartorárias, tributos incidentes sobre a transferência de propriedade do imóvel, corretagens e honorários advocatícios. Os imóveis destinados à venda são contabilizados na maneira acima, sendo que o custo engloba também os gastos incorridos para colocar o imóvel em condições normais de venda, tais como, reformas, gastos com engenharia e projetos de arquitetura. 

Os imóveis propriedades para investimento, após seu reconhecimento inicial, são continuamente mensurados ao seu valor justo, resultando em impactos nos resultados de exercício do fundo. Os imóveis destinados à venda são mensurados entre o valor de custo ou valor realizável líquido, dos dois o menor. O valor realizável líquido corresponde ao valor estimado de venda no curso ordinário do negócio menos as despesas estimadas necessárias para realizar a venda. No caso de imóveis em construção, também são deduzidos os custos estimados para completar a cosntrução para a determinação do valor realizável líquido.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>Avenida das Américas, 3.434, bloco 7, sala 201, Barra da Tijuca, Rio de Janeiro - RJ</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>ger2.fundos@oliveiratrust.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>Os cotistas também poderão votar por meio de comunicação escrita ou eletrônica, observado o disposto neste Regulamento e a legislação e normativos vigentes.</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>(ii) As deliberações da Assembleia Geral poderão ser tomadas, independentemente de convocação, mediante processo de consulta, formalizada por carta, correio eletrônico ou telegrama dirigido pelo ADMINISTRADOR aos cotistas, para resposta no prazo de 30 (trinta) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto. (iii) Somente poderão votar na Assembleia Geral os cotistas inscritos no registro de cotistas na data da convocação da assembleia, seus representantes legais ou procuradores legalmente constituídos há menos de 01 (um) ano. Os cotistas também poderão votar por meio de comunicação escrita ou eletrônica, observado o disposto neste Regulamento e a legislação e normativos vigentes.</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>N/A</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Parcela da Taxa de Administração, devida ao ADMINISTRADOR, CUSTODIANTE e Gestor, a primeira no último dia útil de cada mês calendário e as demais sempre no último dia útil de cada mês calendário,  remuneração mensal equivalente ao maior valor entre: (i) 0,20% (vinte centésimos por cento) ao ano, à razão de 1/12 (um doze avos), apurada diariamente, com base nos últimos 252 (duzentos e cinquenta e dois) dias úteis e calculado sobre o patrimônio líquido do FUNDO do ultimo dia útil do mês anterior ao pagamento, ou (ii) R$ 15.000,00 (quinze mil reais); Parcela da Taxa de Administração, devida ao ADMINISTRADOR em uma única parcela e ocasião equivalente a R$ 15.000,00 (quinze mil reais) devidos na data da primeira integralização de cotas do FUNDO, a ser paga em até 2 dias úteis após a data da primeira integralização.</PoliticaRemuneracao>
			<ValorPagoAno>0.16</ValorPagoAno>
			<PercentPatrimonioContabil>0.0016</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>José Alexandre Costa de Freitas</Nome>
				<Idade>46</Idade>
				<CPF>008.991.207-17</CPF>
				<Email>ger2.fundos@oliveiratrust.com.br</Email>
				<Profissao>Diretor Presidente</Profissao>
				<FormacaoAcademica>Direito</FormacaoAcademica>
				<DataInicioFuncao>2014-03-05</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
					<Experiencia>
						<NomeEmpresa>Oliveira Trust</NomeEmpresa>
						<Periodo>Março/1992 - Data Atual</Periodo>
						<CargoFuncoes>Diretor Presidente</CargoFuncoes>
						<AtividadePrincipalEmpresa>Distribuidora de Títulos e Valores Mobiliários</AtividadePrincipalEmpresa>
					</Experiencia>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal>Não</CondenacaoCriminal>
					<CondenacaoProcAdminCVM>Não</CondenacaoProcAdminCVM>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento numCotistas="1" numCotasDetidas="28885" percDetidoRelTotal="0.1161" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaQuinzeAteVintePorcento numCotistas="1" numCotasDetidas="48978.08" percDetidoRelTotal="0.1969" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaVinteAteTrintaPorcento numCotistas="1" numCotasDetidas="73727.08" percDetidoRelTotal="0.2963" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaTrintaAteQuarentaPorcento numCotistas="1" numCotasDetidas="97208.47" percDetidoRelTotal="0.3907" percDetidoPF="0" percDetidoPJ="1"/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento/>
		</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.oliveratrust.com.br/. 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 website do Administrador: https://www.oliveratrust.com.br</PoliticaNegociacaoCotas>
			<PoliticaExercicioDireitoVoto>O ADMINISTRADOR deve disponibilizar, na mesma data da convocação, todas as informações e documentos necessários ao exercício informado do direito de voto em assembleias gerais:
I – em sua página na rede mundial de computadores;
II – no Sistema de Envio de Documentos, disponível na página da CVM na rede mundial de computadores; e
III – na página da entidade administradora do mercado organizado em que as cotas do FUNDO sejam admitidas à negociação.</PoliticaExercicioDireitoVoto>
			<FuncResponsaveisPoliticaDivulgacao xsi:nil="true"/>
		</PoliticaDivulgacao>
		<RegrasPrazosChamadaCapital>Ao receberem a chamada de capital, os cotistas serão obrigados a integralizar parte ou a totalidade de suas cotas, no prazo máximo de 15 (quinze) dias úteis contados do recebimento da chamada de capital, conforme solicitado pelo ADMINISTRADOR e de acordo com o disposto nos respectivos compromissos de investimento.</RegrasPrazosChamadaCapital>
	</InformeAnual>
</DadosEconomicoFinanceiros>
"