"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>ARENA FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>14149745000121</CNPJFundo>
		<DataFuncionamento>2011-12-20</DataFuncionamento>
		<PublicoAlvo>Investidor Qualificado</PublicoAlvo>
		<CodigoISIN xsi:nil="true"/>
		<QtdCotasEmitidas>623046661.029231</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>true</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Híbrido</Mandato>
			<SegmentoAtuacao>Outros</SegmentoAtuacao>
			<TipoGestao>Passiva</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Determinado</PrazoDuracao>
		<DataPrazoDuracao>2041-12-19</DataPrazoDuracao>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>false</Bolsa>
			<MBO>false</MBO>
			<MB>true</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>false</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>BRL TRUST DISTRIBUIDORA DE TÍTULOS E VALORES MOBILIÁRIOS S.A</NomeAdministrador>
		<CNPJAdministrador>14149745000121</CNPJAdministrador>
		<Logradouro>RUA IGUATEMI</Logradouro>
		<Numero>151</Numero>
		<Complemento>19 ANDAR</Complemento>
		<Bairro>ITAIM BIBI</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>01451011</CEP>
		<Telefone1>11 3133-0350</Telefone1>
		<Telefone2>11 4871-2221</Telefone2>
		<Telefone3>11 3133-0351</Telefone3>
		<Site>WWW.BRLTRUST.COM.BR</Site>
		<Email>INFOLEGAL@BRLTRUST.COM.BR</Email>
		<Competencia>03/2018</Competencia>
		<DataEncerTrimestre>2018-09-30</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Arena Esportiva</Nome>
								<Endereco>Avenida Miguel Inácio Curí, 111 - Vila Carmosina - São Paulo/SP;</Endereco>
								<Area>197095.14</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>O estádio de futebol foi construído em um terreno de 197.095,14 M² (cento e noventa e sete) mil, noventa e cinco metros e quatorze decímetros quadrados, concedido pela Prefeitura do Município de São Paulo, entidade jurídica de direito público interno ao Sport Club Corinthians Paulista, sociedade civil sem fins lucrativos, com sede social na Rua São Jorge, 777, São Paulo - SP, inscrito no CNPJ (MF) 61.902.722/0001-26, por um período de 90 (noventa) anos, gratuitamente, conforme Escritura Pública de Concessão de uso registrado no 17º Tabelionato da Cidade de São Paulo, em 20 de dezembro de 1988, Livro 2520, folhas 127.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Arena</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>1</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses/>
							<TresAteSeisMeses/>
							<SeisAteNoveMeses/>
							<NoveAteDozeMeses/>
							<DozeAteQuinzeMeses/>
							<QuinzeAteDezoitoMeses/>
							<DezoitoAteVinteUmMeses/>
							<VinteUmAteVinteQuatroMeses/>
							<VinteQuatroAteVinteSeteMeses/>
							<VinteSeteAteTrintaMeses/>
							<TrintaAteTrintaTresMeses/>
							<TrintaTresAteTrintaSeisMeses percentReceitaImovel="1" percentReceitasFII="1"/>
							<AcimaTrintaSeisMeses/>
							<PrazoIndeterminado/>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM/>
							<INPC/>
							<IPCA percentReceitaImovel="1" percentReceitasFII="1"/>
							<INCC/>
							<OutrosIndicadores>
								<Indicador nome="IGP-DI"/>
								<Indicador nome="MÉDIA (IGP-DI | IPCA) "/>
								<Indicador nome="MÉDIA (IGP-DI | IPCA e IPC)"/>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Em 26 de novembro de 2013 o SCCP cedeu os direitos dos Certificados de Incentivo ao Desenvolvimento “CID” ao Fundo, com base nas considerações formalizadas no parecer emitido por consultor jurídico emitido pela Mazars Cabrera - Consultoria Contábil e Tributária Sociedade Simples Ltda, pelo montante de R$ 346.973, em permuta de cotas juniores do Fundo.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>Arena</NomeOuEndereco>
								<CaractContratuais>Não se aplica</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>Os contratos de seguros são de responsabilidade do Fundo.</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
				</FII>
				<CRI>
				</CRI>
				<LCI>
				</LCI>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>BRL REFERENCIADO DI </Fundo>
						<CNPJ>15348108000147</CNPJ>
						<Quantidade>21.84885608</Quantidade>
						<Valor>40888.06</Valor>
					</Emissor>
					<Emissor>
						<Fundo>FIC GIRO EMPRESAS</Fundo>
						<CNPJ>16916063000122</CNPJ>
						<Quantidade>324775.2769</Quantidade>
						<Valor>558932.26</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
					<Ativo>
						<Emissor>Municipio de São Paulo</Emissor>
						<CNPJ>46395000000139</CNPJ>
						<NomeAtivo>CID</NomeAtivo>
						<Quantidade>6415.0999</Quantidade>
						<Valor>264984100.71</Valor>
					</Ativo>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>24875.21</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa>599820.32</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda/>
					<CustoImovEstoque/>
					<AjusteValor/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis/>
					<DespManutencaoConservacao contabil="-1165768.33" financeiro="-1165768.33"/>
					<ReceitasVenda/>
					<CustoPropriedadesVendidas/>
					<AjusteValor/>
					<OutrasRecOuDesp contabil="15338770.06" financeiro="15303130.06"/>
					<ResultadoLiquido contabil="14173001.73" financeiro="14137361.73"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros/>
					<AjusteValor/>
					<ResultadoVenda/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="14173001.73" financeiro="14137361.73"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="33712.04" financeiro="33712.04"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes contabil="3455487.29" financeiro="3455487.29"/>
				<OutrasRecOuDespAplicacoes contabil="-41391.3" financeiro="-41391.3"/>
				<ResultadoLiquido contabil="3447808.03" financeiro="3447808.03"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos contabil="0" financeiro="0"/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-309645.57" financeiro="-309645.57"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada contabil="-304571.43" financeiro="-350174.31"/>
				<EmpresaEspecializada/>
				<FormadorMercado/>
				<CustodiaTitulosValores contabil="-41286.09" financeiro="-41286.09"/>
				<AuditoriaIndependente contabil="-37574.66" financeiro="-22973.9"/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-14097.37" financeiro="-15036.94"/>
				<ComissoesEmolumentos/>
				<HonorariosDespesasDefesas contabil="-34484.73" financeiro="-34484.73"/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio contabil="-509.2" financeiro="-1390.7"/>
				<OutrasRecOuDesp contabil="1738823.96" financeiro="-1257330.07"/>
				<Total contabil="996654.91" financeiro="-2032322.31"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="18617464.67" financeiro="15552847.45"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>15552847.45</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>14775205.0775</PercentResultFinanLiqAcumulado>
			<ParcelasRendimentosRetidos>
				<Parcela data="2018-01-15"/>
				<Parcela data="2018-02-15"/>
				<Parcela data="2018-03-15"/>
			</ParcelasRendimentosRetidos>
			<LucroContabil>0</LucroContabil>
			<RendimentosDeclarados>14775205.0775</RendimentosDeclarados>
			<RendimentosPagosAntec>0</RendimentosPagosAntec>
			<RendimentoPagar>14775205.0775</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.95</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"