"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>BLUECAP LOG FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>49592781000140</CNPJFundo>
		<DataFuncionamento>2023-02-14</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRBLOGCTF001</CodigoISIN>
		<QtdCotasEmitidas>14257443</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<SegmentoAtuacao>Outros</SegmentoAtuacao>
			<TipoGestao>Ativa</TipoGestao>
		</Autorregulacao>
		<PrazoDuracao>Indeterminado</PrazoDuracao>
		<DataPrazoDuracao xsi:nil="true"/>
		<EncerramentoExercicio>31/12</EncerramentoExercicio>
		<MercadoNegociacao>
			<Bolsa>true</Bolsa>
			<MBO>false</MBO>
			<MB>false</MB>
		</MercadoNegociacao>
		<EntidadeAdministradora>
			<BVMF>true</BVMF>
			<CETIP>false</CETIP>
		</EntidadeAdministradora>
		<NomeAdministrador>XP INVESTIMENTOS CORRETORA DE CÂMBIO, TÍTULOS E VAL MOB S/A</NomeAdministrador>
		<CNPJAdministrador>49592781000140</CNPJAdministrador>
		<Logradouro>AVENIDA ATAULFO DE PAIVA</Logradouro>
		<Numero>153</Numero>
		<Complemento>5º e 8º andares</Complemento>
		<Bairro>LEBLON</Bairro>
		<Cidade>RIO DE JANEIRO</Cidade>
		<Estado>RJ</Estado>
		<CEP>22440-033</CEP>
		<Telefone1>(11) 3027-2237</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.xpi.com.br</Site>
		<Email>adm.fundos.estruturados@xpi.com.br</Email>
		<Competencia>4/2025</Competencia>
		<DataEncerTrimestre>2025-12-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>BlueCap Camaçari I</Nome>
								<Endereco>Via de Ligação, 858-1.176</Endereco>
								<Area>30455.44</Area>
								<NumUnidades>0</NumUnidades>
								<OutrasCaractRelevantes>Galpão de uso logístico industrial de 30.455,44 m² de área, com área de mezanino, 100% locada, no polo petroquímico de Camaçari, possui pátio de manobras em pavimentação asfáltica, estacionamento externo para carretas e veículos leves, 32 docas com plataformas niveladoras, 6 docas nível zero, pé direito de livre de 11,6 m, piso industrial com capacidade para 5 t/m², cobertura com iluminação zenital, isolamento termoacústico, sistema de exaustão e ventilação forçada. O galpão está equipado com luminárias de alta eficiência e sistema de combate a incêndio classe J4 dotado de sprinklers. Serviço de portaria 4 vigilâncias 24h.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.189134204590803</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Varejista</SetorAtuacao><PercentReceitaImovel>0.832871</PercentReceitaImovel><PercentReceitasFII>0.157524</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Siderurgia</SetorAtuacao><PercentReceitaImovel>0.167129</PercentReceitaImovel><PercentReceitasFII>0.03161</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>BlueCap Camaçari III</Nome>
								<Endereco>Via de Ligação Camaçari, s/n - polo industrial de Camaçari</Endereco>
								<Area>28066.89</Area>
								<NumUnidades>0</NumUnidades>
								<OutrasCaractRelevantes>Galpão de uso logístico industrial de 28.066,89 m² de área, totalmente locada, no polo petroquímico de Camaçari, possui pátio de manobras em pavimentação asfáltica, 36 docas com plataformas niveladoras, 16 docas nível zero, pé direito livre de 11,3 m, piso industrial com capacidade para 5 t/m², cobertura com iluminação zenital e isolamento termoacústico. O galpão está equipado com luminárias de alta eficiência e sistema de combate a incêndio classe J4.</OutrasCaractRelevantes>
								<PercentVacancia>0.222999056895866</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.126359414707846</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Energia Renovável</SetorAtuacao><PercentReceitaImovel>0.390592</PercentReceitaImovel><PercentReceitasFII>0.049355</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logística</SetorAtuacao><PercentReceitaImovel>0.12465</PercentReceitaImovel><PercentReceitasFII>0.015751</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logística</SetorAtuacao><PercentReceitaImovel>0.076601</PercentReceitaImovel><PercentReceitasFII>0.009679</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>E-Commerce</SetorAtuacao><PercentReceitaImovel>0.186539</PercentReceitaImovel><PercentReceitasFII>0.023571</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Indústria de Vidros</SetorAtuacao><PercentReceitaImovel>0.158977</PercentReceitaImovel><PercentReceitasFII>0.020088</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Varejista</SetorAtuacao><PercentReceitaImovel>0.062642</PercentReceitaImovel><PercentReceitasFII>0.007915</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>BlueCap Pacatuba</Nome>
								<Endereco>Avenida Doutor Mendel Steinbruch, 11. 308</Endereco>
								<Area>22968</Area>
								<NumUnidades>0</NumUnidades>
								<OutrasCaractRelevantes>Galpão com 22.968 m² de ABL, destinado ao uso logístico industrial tais como acondicionamento e expedição de produtos acabados. Construído em alvenaria e divisórias metálicas, com cobertura em telha ondulada zipada de alumínio, revestimento interno térmico e claraboias para captação de iluminação natural. Piso industrial de fácil limpeza e alta mobilidade/facilidade de movimentação de cargas, pé direto com 9,5m de altura no menor ponto (paredes laterais) e 11 metros de altura no ponto mais elevado (central) e sistema Roberts de ventilação/exaustão. Todo contorno do prédio tem meia parede com tijolos vazados tipo cobogó que facilitam a ventilação e troca de calor, conferindo ótimo conforto térmico ao prédio. O galpão conta com a instalação de 10 docas com plataformas articuladas para carregamento com fácil manobra e acesso de caminhões. O galpão conta ainda com a instalação de banheiros masculinos, femininos e PNE. Subestação independente com transformador de 225KVA com tensão de saída monofásica de 220v e trifásica de 380v.</OutrasCaractRelevantes>
								<PercentVacancia>1</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII/>
								<Inquilinos/></Imovel>
							<Imovel>
								<Nome>BlueCap Paulista/PE</Nome>
								<Endereco>Rodovia BR - 101 Norte, 5.800 - Jaguaribe</Endereco>
								<Area>65179.77</Area>
								<NumUnidades>0</NumUnidades>
								<OutrasCaractRelevantes>Galpão de uso logístico industrial de 65.179,77 m² de área, com área de mezanino, 100% locada, na região metropolitana da grande Recife, possui pátio de manobras em pavimentação intertravado de alta resistência, 50 docas com plataformas niveladoras, pé direito de livre de 11,6 m, piso industrial com capacidade para 5 t/m² , cobertura com iluminação zenital, isolamento termoacústico e sistema de geração de energia fotovoltaica. O galpão está equipado com luminárias de alta eficiência e sistema de combate a incêndio classe J4.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.292636734705903</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Varejista</SetorAtuacao><PercentReceitaImovel>0.419004</PercentReceitaImovel><PercentReceitasFII>0.122616</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Indústria Alimentícia</SetorAtuacao><PercentReceitaImovel>0.29498</PercentReceitaImovel><PercentReceitasFII>0.086322</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Varejista</SetorAtuacao><PercentReceitaImovel>0.286016</PercentReceitaImovel><PercentReceitasFII>0.083699</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Centro Logístico Igarassu</Nome>
								<Endereco>Av. Alfredo Bandeira de Melo, s/n - Quadra Area - Lote C - Vila Rural, Igarassu-PE</Endereco>
								<Area>58822.61</Area>
								<NumUnidades>0</NumUnidades>
								<OutrasCaractRelevantes>Galpão de uso logístico industrial com 58.822,61 m² de área construída, localizado em Igarassu, Pernambuco, dentro de um terreno de 99.897 m². O ativo, configurado como condomínio logístico, possui 100% de sua área locável ocupada, consolidando-se como uma oportunidade estratégica para operações de alta performance. Conta com pátio de manobras em piso intertravado e vias de acesso em ótimas condições gerais. Além disso, o imóvel dispõe de 55 docas equipadas com plataformas niveladoras em estado novo de conservação, pavimentação externa funcional e sistema de nivelamento para carga e descarga eficiente. O piso industrial tem capacidade para 6 t/m², com pé-direito livre de 12 metros, ideal para operações logísticas e de armazenamento vertical. Também apresenta cobertura metálica com iluminação zenital, isolamento termoacústico e sistema de ventilação forçada.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.257789105889529</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Varejista</SetorAtuacao><PercentReceitaImovel>0.601458</PercentReceitaImovel><PercentReceitasFII>0.155049</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logística</SetorAtuacao><PercentReceitaImovel>0.398542</PercentReceitaImovel><PercentReceitasFII>0.10274</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>BLOG Garuva</Nome>
								<Endereco>Rodovia SC - 417, 11915, Bairro Mina Velha, Garuva/SC</Endereco>
								<Area>22789.59</Area>
								<NumUnidades>0</NumUnidades>
								<OutrasCaractRelevantes>Galpão de uso logístico industrial com 22.789,59 m² de área bruta locável entregue, localizado em Garuva, Santa Catarina, dentro de um terreno com área total de 61.737 m². O ativo, configurado como condomínio logístico classe AAA, possui 100% de sua área entregue atualmente ocupada, consolidando-se como uma oportunidade estratégica para operações de alta performance na Região Sul do Brasil.
O empreendimento conta com pátio de manobras, vagas de espera para caminhões e estacionamento para motos, além de vias internas em ótimas condições operacionais. Inaugurado em 2020, com habite-se emitido e pronto para ocupação, o imóvel é certificado como green building e oferece infraestrutura moderna para operadores logísticos. Todos os módulos possuem sistema de sprinklers, niveladores de doca e pé-direito de 12 metros, com piso industrial de alta resistência, com capacidade para 5 t/m². A distância entre pilares é de 22,50 x 22,50 metros, favorecendo layout flexível de armazenagem.
O Módulo 1 dispõe de 17 docas, enquanto os módulos 1-A, 2 e 3 contam com 4, 4 e 5 docas, respectivamente. O imóvel conta ainda com cobertura metálica, iluminação zenital, isolamento termoacústico e ventilação forçada, garantindo eficiência energética e conforto operacional. O controle de acesso para veículos leves, pesados e pedestres reforça os padrões de segurança, posicionando o Braspark Garuva como um polo logístico de referência na região.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.134080540105919</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Logística</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.134081</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses>Até 3 meses</AteTresMeses>
							<TresAteSeisMeses>De 3 meses e 1 dia a 6 meses</TresAteSeisMeses>
							<SeisAteNoveMeses>De 6 meses e 1 dia a 9 meses</SeisAteNoveMeses>
							<NoveAteDozeMeses>De 9 meses e 1 dia a 12 meses</NoveAteDozeMeses>
							<DozeAteQuinzeMeses>De 12 meses e 1 dia a 15 meses</DozeAteQuinzeMeses>
							<QuinzeAteDezoitoMeses>De 15 meses e 1 dia a 18 meses</QuinzeAteDezoitoMeses>
							<DezoitoAteVinteUmMeses percentReceitaImovel="0.03161" percentReceitasFII="0.03161">De 18 meses e 1 dia a 21 meses</DezoitoAteVinteUmMeses>
							<VinteUmAteVinteQuatroMeses>De 21 meses e 1 dia a 24 meses</VinteUmAteVinteQuatroMeses>
							<VinteQuatroAteVinteSeteMeses>De 24 meses e 1 dia a 27 meses</VinteQuatroAteVinteSeteMeses>
							<VinteSeteAteTrintaMeses>De 27 meses e 1 dia a 30 meses</VinteSeteAteTrintaMeses>
							<TrintaAteTrintaTresMeses percentReceitaImovel="0.007915" percentReceitasFII="0.007915">De 30 meses e 1 dia a 33 meses</TrintaAteTrintaTresMeses>
							<TrintaTresAteTrintaSeisMeses>De 33 meses e 1 dia a 36 meses</TrintaTresAteTrintaSeisMeses>
							<AcimaTrintaSeisMeses percentReceitaImovel="0.960475" percentReceitasFII="0.960475">Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado>Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0.478165" percentReceitasFII="0.478165"/>
							<INPC/>
							<IPCA percentReceitaImovel="0.521835" percentReceitasFII="0.521835"/>
							<INCC/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>N/A</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>N/A</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>
				<CriCra>
				</CriCra>
				<LciLca>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
					<Emissor>
						<Sociedade>BLUECAP LOG SPE LTDA</Sociedade>
						<CNPJ>53259785000188</CNPJ>
						<Quantidade>100</Quantidade>
						<Valor>342043.08</Valor>
					</Emissor>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>OT SOBERANO FIRF REF DI LP</Fundo>
						<CNPJ>17455369000191</CNPJ>
						<Quantidade>71.61</Quantidade>
						<Valor>205157.81</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>0</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa>205157.81</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 contabil="0" financeiro="0"/>
					<CustoImovEstoque contabil="0" financeiro="0"/>
					<AjusteValor contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="0"/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="11775000.02" financeiro="8316026.26"/>
					<DespManutencaoConservacao contabil="-122759.62" financeiro="0"/>
					<ReceitasVenda contabil="0" financeiro="0"/>
					<CustoPropriedadesVendidas contabil="0" financeiro="0"/>
					<AjusteValor contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="-7093892.84" financeiro="-2333.45"/>
					<ResultadoLiquido contabil="4558347.56" financeiro="8313692.81"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="0" financeiro="0"/>
					<AjusteValor contabil="-37048.61" financeiro="0"/>
					<ResultadoVenda contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="-4819639.24"/>
					<ResultadoLiquido contabil="-37048.61" financeiro="-4819639.24"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="4521298.95" financeiro="3494053.57"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="0" financeiro="13109.08"/>
				<AjusteValorAplicacoes contabil="12386.92" financeiro="0"/>
				<ResultadoVendaAplicacoes contabil="0" financeiro="0"/>
				<OutrasRecOuDespAplicacoes contabil="0" financeiro="0"/>
				<ResultadoLiquido contabil="12386.92" financeiro="13109.08"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos contabil="0" financeiro="0"/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-788779.1" financeiro="-671624.2"/>
				<TaxaDesempenho contabil="0" financeiro="0"/>
				<ConsultoriaEspecializada contabil="-102164.95" financeiro="-102164.95"/>
				<EmpresaEspecializada contabil="0" financeiro="0"/>
				<FormadorMercado contabil="0" financeiro="0"/>
				<CustodiaTitulosValores contabil="0" financeiro="0"/>
				<AuditoriaIndependente contabil="-14593.03" financeiro="-60286"/>
				<RepresentantesCotistas contabil="0" financeiro="0"/>
				<TaxasImpostosContribuicoes contabil="-14095.49" financeiro="-27514.49"/>
				<ComissoesEmolumentos contabil="0" financeiro="0"/>
				<HonorariosDespesasDefesas contabil="-20.12" financeiro="0"/>
				<GastosContratosSeguros contabil="0" financeiro="0"/>
				<DespesasAvaliacoes contabil="0" financeiro="0"/>
				<TaxasIngressoSaidaFundos contabil="0" financeiro="0"/>
				<DespesasRegistroCartorio contabil="0" financeiro="0"/>
				<OutrasRecOuDesp contabil="-155.99" financeiro="-4378.84"/>
				<Total contabil="-919808.68" financeiro="-865968.48"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="3613877.19" financeiro="2641194.17"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>2641194.17</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>2509134.4615</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte>-513092.44</ParcelaDistribuidaTriSeguinte>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<ResultadoFinanceiroExcedeMinimo xsi:nil="true"/>
			<RendimentosDeclarados>1996042.0215</RendimentosDeclarados>
			<RendimentosPagosAntec>-1425744.3</RendimentosPagosAntec>
			<RendimentoPagar>570297.7215</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.755735</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"