"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>EZTB FUNDO DE INVESTIMENTO IMOBILIÁRIO - FII</NomeFundo>
		<CNPJFundo>18.312.285/0001-61</CNPJFundo>
		<DataFuncionamento>2017-09-11</DataFuncionamento>
		<PublicoAlvo>Investidor Profissional</PublicoAlvo>
		<CodigoISIN/>
		<QtdCotasEmitidas>204671135.66</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Mandato>Híbrido</Mandato>
			<SegmentoAtuacao>Híbrido</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>BRKB DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS S.A.</NomeAdministrador>
		<CNPJAdministrador>18.312.285/0001-61</CNPJAdministrador>
		<Logradouro>RUA LAURO MULLER</Logradouro>
		<Numero>116</Numero>
		<Complemento>SL 2101 A 2108</Complemento>
		<Bairro>BOTAFOGO</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22290-160</CEP>
		<Telefone1>(21) 37257708</Telefone1>
		<Telefone2 xsi:nil="true"/>
		<Telefone3 xsi:nil="true"/>
		<Site>WWW.BRKBDTVM.COM.BR</Site>
		<Email>JOLIVEIRA@BROOKFIELDBR.COM</Email>
		<Competencia>2018-12-31</Competencia>
	</DadosGerais>
	<InformeAnual>
		<PrestadoresServicos>
			<Gestor>
				<Nome>BRKB DISTRIBUIDORA DE TITULOS E VALORES MOBILIARIOS S.A.</Nome>
				<CNPJ>33923111000129</CNPJ>
				<Endereco>RUA LAURO MULLER, 116 - SL 2101 A 2108 - BOTAFOGO - RIO DE JANEIRO - RJ</Endereco>
				<telefone>(21) 37257708</telefone>
			</Gestor>
			<Custodiante>
				<Nome>BRASIL PLURAL S.A. BANCO MÚLTIPLO</Nome>
				<CNPJ>45246410000155</CNPJ>
				<Endereco>PRAIA DE BOTAFOGO,228 - 9º ANDAR - PARTE, SALA 907</Endereco>
				<telefone>(11) 32068397 </telefone>
			</Custodiante>
			<AuditorIndependente>
				<Nome>DELOITTE TOUCHE TOHMATSU AUDITORES INDEPENDENTES</Nome>
				<CNPJ>49928567000200</CNPJ>
				<Endereco>AVENIDA PRESIDENTE WILSON, 231 - SL 2201 A 2204, 2502, 2503 E 2603 - CENTRO - RIO DE JANEIRO - RJ</Endereco>
				<telefone>(11) 51866665</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>
				</RelacaoAtivosAdquiridos>
			</NegociosRealizadosPeriodo>
		</InvestimentosFII>
		<ProgramaInvestimentos xsi:nil="true"/>
		<AnaliseAdministrador>
			<ResultadoFundo>No exercício findo em 31/12/2018, o Fundo obteve um lucro de R$ 40.307.000,00.</ResultadoFundo>
			<ConjunturaEconomica>
São Paulo: Os alugueis estão começando a se recuperar nos mercados de ativos AAA  (principais localidades), com queda de 24,7% para 14,3% e retido em níveis menores desde 2017. As perspectivas são positivas, já que novas entregas foram reduzidas significativamente

Rio de Janeiro: Mercado de escritórios está mostrando uma ligeira recuperação, 2018 apresentou uma absorção líquida positiva, o quê não ocorria desde 2013</ConjunturaEconomica>
			<PerspectivaPeriodoSeguinte>Em São Paulo e Rio de Janeiro é esperado que a absorção de AAA e vacância deve seguir os números médios últimos trimestres, além disso, a demanda do mercado deve ser reforçada pelas empresas de médio mercado como tem sido nos últimos trimestres.</PerspectivaPeriodoSeguinte>
		</AnaliseAdministrador>
		<ValorContabilAtivos>
			<Ativo>
				<Nome>EZ TOWER B</Nome>
				<ValorJusto>SIM</ValorJusto>
				<Valor>770433119.68</Valor>
				<PercentValorizacaoDesvalorizacao>0.0906</PercentValorizacaoDesvalorizacao>
			</Ativo>
		</ValorContabilAtivos>
		<CriteriosAvaliacao>“Abordagem de capitalização de renda" pelo fluxo de caixa descontado.
 
Este método é utilizado para determinar o valor da propriedade como um investimento, com base no seu estado operacional atual.
</CriteriosAvaliacao>
		<ProcessosJudiciais>
		</ProcessosJudiciais>
		<ProcessosJudiciaisSemelhantes>
		</ProcessosJudiciaisSemelhantes>
		<AnaliseImpactos xsi:nil="true"/>
		<AssembleiaGeral>
			<EnderecoFisicoDocsAssembleias>RUA LAURO MULLER, 116 - SL 2101 A 2108 - BOTAFOGO - RIO DE JANEIRO - RJ</EnderecoFisicoDocsAssembleias>
			<EnderecoEletronicoDocsAssembleias>www.brkbdtvm.com.br</EnderecoEletronicoDocsAssembleias>
			<MeiosComunicacao>O Administrador disponibilizará todas as informações e documentos necessários ao exercício do direito de voto pelos Cotistas, na página por ele mantida na rede mundial de computadores, na data da realização da convocação até a data da efetiva realização da Assembleia Geral de Cotistas.

Da convocação devem constar, obrigatoriamente, dia, hora e local em que será realizada a Assembleia Geral de Cotistas e, na ordem do dia, todas as matérias a serem deliberadas, não se admitindo que, sob a rubrica de assuntos gerais haja matérias que dependem de deliberação da Assembleia Geral de Cotistas.

As deliberações da Assembleia Geral de Cotistas 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 15 (quinze) dias, devendo constar da consulta todos os elementos informativos necessários ao exercício de voto.

A resposta dos Cotistas à consulta será realizada mediante o envio, pelo Cotista ao Administrador, de carta, correio eletrônico ou telegrama formalizando o seu respectivo voto.

Caso algum Cotista deseje alterar o endereço para recebimento de quaisquer avisos, deverá notificar o Administrador por meio eletrônico na forma prevista acima.
</MeiosComunicacao>
			<RegrasProcParticipacaoCotistas>(i) Somente poderão votar na Assembleia Geral de Cotistas os Cotistas adimplentes inscritos no registro de Cotistas na data da convocação da Assembleia Geral de Cotistas, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano.
(ii) As consultas formais são admitidas em Regulamento sendo formalizada por carta, correio eletrônico ou telegrama, dirigido pelo Administrador aos Cotistas, para resposta no prazo de 15 (quinze) dias, devendo constar da consulta formal todos os elementos informativos necessários ao exercício do direito de voto. 
A convocação da Assembleia Geral de Cotistas deve ser feita por meio de correspondência encaminhada a cada Cotista do Fundo, com antecedência de, no mínimo, 10 (dez) dias de sua realização. Independentemente das formalidades previstas anteriormente, será considerada regular a Assembleia Geral de Cotistas a que comparecerem a totalidade dos Cotistas.
</RegrasProcParticipacaoCotistas>
			<PraticasAssembleiaMeioEletronico>(i) Os Cotistas poderão votar por meio de comunicação escrita ou eletrônica, desde que estejam adimplentes e inscritos no registro de Cotistas na data da convocação da Assembleia Geral de Cotistas, seus representantes legais ou procuradores legalmente constituídos há menos de 1 (um) ano.</PraticasAssembleiaMeioEletronico>
		</AssembleiaGeral>
		<RemuneracaoAdministrador>
			<PoliticaRemuneracao>A Taxa de Administração devida ao Administrador equivale a 0,15% (quinze centésimos por cento) ao ano sobre o Patrimônio Líquido do Fundo, observado o valor mínimo mensal de R$ 15.000,00 (quinze mil reais), sendo que referido valor será atualizado anualmente pela variação positiva acumulada do IGPM ou qualquer outro índice que venha a substitui-lo. A Taxa de Administração será: (a) devida a partir da data da primeira integralização de Cotas e deixará de ser devida na data em que a liquidação do Fundo estiver concluída. A Taxa de Administração referente a qualquer período inferior a um mês em que o Administrador preste serviços ao Fundo, na qualidade de administrador, deverá ser calculada pro rata com base no número total de dias de tal período comparado ao número de dias em que o Administrador tenha prestado serviços ao Fundo no mesmo período.Todos os valores previstos neste Capítulo IX, serão acrescidos dos tributos incidentes sobre os valores efetivamente devidos, quando aplicáveis, tais como: Imposto Sobre Serviços (ISS), Contribuição para o Programa de Integração Social (PIS), Contribuição para o financiamento da Seguridade Social (COFINS), Contribuição Social sobre o Lucro (CSLL), Imposto de Renda Retido na Fonte (IRRF) e outros que porventura venham a incidir.</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>Isacson Casiuch</Nome>
				<Idade>62</Idade>
				<CPF>59529326734</CPF>
				<Email>icasiuch@brookfieldbr.com</Email>
				<Profissao>Diretor Executivo</Profissao>
				<FormacaoAcademica>Direito</FormacaoAcademica>
				<DataInicioFuncao>2014-02-04</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="204671135.66" percDetidoRelTotal="1" percDetidoPF="0" percDetidoPJ="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>
"