"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>BRAZIL PROPERTIES FDO DE INVESTIMENTO IMOBILIÁRIO - FII </NomeFundo>
		<CNPJFundo>22081808000183</CNPJFundo>
		<DataFuncionamento>2017-08-17</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>1635.77031</QtdCotasEmitidas>
		<FundoExclusivo>true</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Renda</Mandato>
			<SegmentoAtuacao>Outros</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>Intrader D.T.V.M. Ltda</NomeAdministrador>
		<CNPJAdministrador>22081808000183</CNPJAdministrador>
		<Logradouro>Rua Ramos Batista </Logradouro>
		<Numero>152</Numero>
		<Complemento>1º ANDAR</Complemento>
		<Bairro>VILA OLIMPIA</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04552-020</CEP>
		<Telefone1>11 31985151</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.intrader.com.br</Site>
		<Email>adm@intrader.com.br</Email>
		<Competencia>2018-12-01</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>REAG GESTORA DE RECURSOS LTDA.</Nome>
				<CNPJ>18606232000153</CNPJ>
				<Endereco>Av. Brig Faria Lima, 2277 - 17º and - Cj 1702 -  Jd Paulistano </Endereco>
				<telefone>(11) 3504-6800</telefone>
			</Gestor>
			<Custodiante>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</Custodiante>
			<AuditorIndependente>
				<Nome>YPC /ABX AUDIBANCO AUDITORIA INDEPENDENTE S/S</Nome>
				<CNPJ>64184922000189</CNPJ>
				<Endereco>RUA ISAURA COMICHOLE PIRES, 39, SALA 02,CAPOEIRAS, CEP 88090-130, FLORIANOPOLIS/SC</Endereco>
				<telefone>(11) 3742-0787</telefone>
			</AuditorIndependente>
			<FormadorMercado>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</FormadorMercado>
			<DistribuidorCotas>
				<Nome>Intrader D.T.V.M. Ltda</Nome>
				<CNPJ>15489568000195</CNPJ>
				<Endereco>RUA RAMOS  BATISTA, 152, 1º ANDAR, VILA OLIMPIA, SÃO PAULO/SP</Endereco>
				<telefone>(11) 3198-5151</telefone>
			</DistribuidorCotas>
			<ConsultorEspecializado>
				<Nome>RCI CONSULTORIA IMOBILIÁRIA LTDA</Nome>
				<CNPJ>18315353000146</CNPJ>
				<Endereco>AV COPACABANA, 71, JD PROF. BENOA,SANTANA DE PARNAIBA/SP</Endereco>
				<telefone>(11) 3816-9888</telefone>
			</ConsultorEspecializado>
			<EmpEspecializadaAdmLocacoes>
				<Nome xsi:nil="true"/>
				<CNPJ xsi:nil="true"/>
				<Endereco xsi:nil="true"/>
				<telefone xsi:nil="true"/>
			</EmpEspecializadaAdmLocacoes>
			<OutrosPrestadores>
				<Prestador>
					<Nome>ITAU CORRETORA DE VALORES S.A</Nome>
					<CNPJ>61194353000164</CNPJ>
					<Endereco>AV BRIG FARIA LIMA, 3400, 10º ANDAR, ITAIM BIBI, SÃO PAULO/SP</Endereco>
					<telefone>(11) 3003-4828</telefone>
				</Prestador>
				<Prestador>
					<Nome>COUTINHO, LACERDA, DINIZ ADVOGADOS ASSOCIADOS</Nome>
					<CNPJ>2213835000155</CNPJ>
					<Endereco>RUA DOS INCONFIDENTES,911, 13º ANDAR, BELO HORIZONTE/MG</Endereco>
					<telefone>(31) 3269-5900</telefone>
				</Prestador>
				<Prestador>
					<Nome>COSTA RANGEL SOCIEDADE DE ADVOGADOS</Nome>
					<CNPJ>22250010000118</CNPJ>
					<Endereco>AV. ATAULFO DE PAIVA, 204, SALA 02,CEP 22440-033, RIO DE JANEIRO/RJ</Endereco>
					<telefone>(21) 8151-8314</telefone>
				</Prestador>
				<Prestador>
					<Nome>YORK &amp; PARTNERS CONSULTORIA SS LTDA</Nome>
					<CNPJ>8587588000133</CNPJ>
					<Endereco>RUA DOM BERNARDO NOGUEIRA, 479, 18º ANDAR, VILA GUMERCINDO, SÃO PAULO/SP</Endereco>
					<telefone>(11) 3101-1257</telefone>
				</Prestador>
			</OutrosPrestadores>
		</PrestadoresServicos>
		<InvestimentosFII>
			<NegociosRealizadosPeriodo>
				<RelacaoAtivosAdquiridos>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>1137.38%</ResultadoFundo>
			<ConjunturaEconomica>Em linhas gerais, o ano de 2018 foi um ano de cautela, mas ao mesmo tempo de descolamento da crise política, trazendo um crescimento reativo para o mercado imobiliário.</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>A recuperação econômica deve dar forças ao mercado imobiliário, fazendo com que os preços voltem a subir em 2018, mas as incertezas econômicas e políticas potencializadas pelo ano eleitoral pode colocar obstáculos no caminho. </PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>GALPÕES</Nome>
				<ValorJusto>NÃO</ValorJusto>
				<Valor>7000000</Valor>
				<PercentValorizacaoDesvalorizacao>0</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>Os investimentos foram avaliados conforme laudo de avaliação efetuado por consultor independente contratado pelo administrador.</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>RUA RAMOS BATISTA, 152, 1º ANDAR, VILA OLIMPIA, SÃO PAULO/SP</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.intrader.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>O comunicado, envio, divulgação e/ou disponibilização, pelo Administrador, de quaisquer informações, comunicados, cartas e documentos, cuja obrigação esteja disposta neste Regulamento ou na regulamentação vigente, será realizado por meio de correio eletrônico (e-mail). </MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>O Administrador deve manter em sua página na rede mundial de computadores, pelo prazo mínimo de 5 (cinco) anos contados de sua divulgação, ou por prazo superior por determinação expressa da CVM, em caso de processo administrativo, todos os documentos e informações, periódicas ou eventuais, exigidos pela Instrução CVM 472, bem como indicação dos endereços físicos e eletrônicos em que podem ser obtidas as informações e documentos relativos ao C22fundo. </RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>A publicação das informações é feita na página do Administrador na rede mundial de computadores e mantida disponível aos cotistas em sua sede.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>Pela administração do Fundo, nela compreendida as atividades de administração do Fundo, gestão dos Outros Ativos, tesouraria, controle e processamento dos títulos e valores mobiliários integrantes de sua carteira e escrituração da emissão de suas Cotas, o Fundo pagará ao Administrador uma Taxa de Administração, equivalente a 0,18% (dezoito centésimos por cento) ao ano, calculada sobre o Patrimônio Líquido do Fundo no último dia do mês imediatamente anterior ao mês de seu pagamento, observado o valor mínimo mensal de R$ 20.000,00 (vinte mil reais) com vencimento da primeira parcela, tão somente quando da integralização de cotas do Fundo, valor este que será atualizado anualmente, a partir de 1º de janeiro de 2015, pela variação positiva do IGP-M (Índice Geral de Preços de Mercado) apurado e divulgado pela Fundação Getúlio Vargas – FGV.A remuneração prevista no caput deste Artigo deve ser provisionada diariamente (em base de 252 dias por ano) sobre o valor do patrimônio líquido do Fundo e paga mensalmente, por período vencidos, até o 2º (segundo) dia útil do mês subsequente, sendo que o primeiro pagamento deverá ocorrer no 2º (segundo) dia útil do mês subsequente à Data da 1ª Integralização de Cotas.</PoliticaRemuneracao>
			<ValorPagoAno>103913</ValorPagoAno>
			<PercentPatrimonioContabil>0.0744326170284806</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>EDSON HYDALGO JUNIOR</Nome>
				<Idade>41</Idade>
				<CPF>16735461886</CPF>
				<Email>compliance@intrader.com.br</Email>
				<Profissao>Socio Diretor</Profissao>
				<FormacaoAcademica>Administração de Empresas</FormacaoAcademica>
				<DataInicioFuncao>2016-06-14</DataInicioFuncao>
				<QtdCotasDetidasFII>0</QtdCotasDetidasFII>
				<QtdCotasFIICompradas>0</QtdCotasFIICompradas>
				<QtdCotasFIIVendidas>0</QtdCotasFIIVendidas>
				<ExperienciasProfUltimosCincoAnos>
				</ExperienciasProfUltimosCincoAnos>
				<Eventos>
					<CondenacaoCriminal/>
					<CondenacaoProcAdminCVM/>
				</Eventos>
			</DiretorResponsavel>
		</Governanca>
		<DistribuicaoCotistas>
			<AteCincoPorcento/>
			<AcimaCincoAteDezPorcento/>
			<AcimaDezAteQuinzePorcento/>
			<AcimaQuinzeAteVintePorcento/>
			<AcimaVinteAteTrintaPorcento/>
			<AcimaTrintaAteQuarentaPorcento/>
			<AcimaQuarentaAteCinquentaPorcento/>
			<AcimaCiquentaPorcento numCotistas="1" numCotasDetidas="100" percDetidoRelTotal="1" percDetidoPF="1"/>
		</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>
"