"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FATOR VERITA MULTIESTRATEGIA FUNDO DE INVESTIMENTO IMOB</NomeFundo>
		<CNPJFundo>51870412000113</CNPJFundo>
		<DataFuncionamento>2010-08-05</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRVRTMCTF003</CodigoISIN>
		<QtdCotasEmitidas>46971245</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Multiestratégia</Classificacao>
			<Subclassificacao>Não possui subclassificação</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>BANCO FATOR S.A.</NomeAdministrador>
		<CNPJAdministrador>51870412000113</CNPJAdministrador>
		<Logradouro>R. DR. RENATO PAES DE BARROS</Logradouro>
		<Numero>1017</Numero>
		<Complemento>12º andar</Complemento>
		<Bairro>ITAIM BIBI</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04530-001</CEP>
		<Telefone1>55-(11)30499100</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.bancofator.com.br</Site>
		<Email>fundosimobiliarios@fator.com.br</Email>
		<Competencia>01/2026</Competencia>
		<DataEncerTrimestre>2026-03-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Imóveis Barra da Tijuca</Nome>
								<Endereco>Rua Helios Seelinger, 155 - Barra da Tijuca - RJ</Endereco>
								<Area>4414.44</Area>
								<NumUnidades>6</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.051245</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Setor1</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor2</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Setor3</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>SetorN</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</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>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>De 30 meses e 1 dia a 33 meses</TrintaAteTrintaTresMeses>
							<TrintaTresAteTrintaSeisMeses>De 33 meses e 1 dia a 36 meses</TrintaTresAteTrintaSeisMeses>
							<AcimaTrintaSeisMeses percentReceitaImovel="1" percentReceitasFII="0.051245">Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado>Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM/>
							<INPC/>
							<IPCA percentReceitaImovel="1" percentReceitasFII="1"/>
							<INCC/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Imóvel Barra da Tijuca: aquisição 50% do imóvel, encontra-se locado, atualização IPCA.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>N/A</NomeOuEndereco>
								<CaractContratuais>N/A</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>Imóvel Barra da Tijuca: seguro com prazo de 25/07/2025 até 25/07/2026.</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
							<Imovel>
								<Nome>Alpha Houses I</Nome>
								<Endereco>Estrada Lula Chaves, 386 - Santana do Parnaíba</Endereco>
								<Area>583.83</Area>
								<NumUnidades>3</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.033877</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Tumiaru 120</Nome>
								<Endereco>R. Tumiaru, 120 - Vila Mariana, São Paulo - SP, 04008-050</Endereco>
								<Area>555.81</Area>
								<NumUnidades>3</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.19433</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Lisboa 142</Nome>
								<Endereco>R. Lisboa, 142 - Pinheiros, São Paulo - SP, 05413-000</Endereco>
								<Area>209.4</Area>
								<NumUnidades>2</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.056271</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Residencial Vida Habitat</Nome>
								<Endereco>R. Paranaíba, 581 - St. Planalto, Jataí - GO, 75805-045</Endereco>
								<Area>520.19</Area>
								<NumUnidades>8</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.037894</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Residencial Aquarela Habitat</Nome>
								<Endereco>Rua Antônio Brochado, nº 1.005, Nova Divinéia – Unaí / MG.</Endereco>
								<Area>1086.11</Area>
								<NumUnidades>18</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.066464</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Edifício Gibran</Nome>
								<Endereco>Rua Alberto Neder 424 - Campo Grande</Endereco>
								<Area>1682.17</Area>
								<NumUnidades>10</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.101646</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Stillo Barra - AGER</Nome>
								<Endereco>Rua Via Projetada 2, 111 - Rio de Janeiro</Endereco>
								<Area>168.78</Area>
								<NumUnidades>3</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.011605</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Sky Pinheiros - AAM</Nome>
								<Endereco>Rua Cardeal Arco Verde, nº 137, CEP 05407-000, Pinheiros – São Paulo / SP.</Endereco>
								<Area>473.66</Area>
								<NumUnidades>18</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.091898</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Patriani Mirai Suzano</Nome>
								<Endereco>R. Nove de Julho, 1400 - Jardim Santa Helena, Suzano - SP, 08674-230</Endereco>
								<Area>1139.32</Area>
								<NumUnidades>25</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.102417</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Green View - Patrimônio</Nome>
								<Endereco>Rua São Sebastião, 318, Brooklin – São Paulo / SP.</Endereco>
								<Area>951.28</Area>
								<NumUnidades>14</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.131796</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Coral Gables - Vetter</Nome>
								<Endereco>Av. Antônio Joaquim Tavares, nº 824, Bairro Centro, Penha, SC, CEP 88.838-000.</Endereco>
								<Area>206.17</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.025293</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Libertá - Habitat</Nome>
								<Endereco>Rua Joaquim Caetano, 875, Lotes 05/08 - Qd 61-A - Jataí - GO</Endereco>
								<Area>610.04</Area>
								<NumUnidades>5</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.055998</PercentTotalInvestido>
							</Imovel>
							<Imovel>
								<Nome>Zoe - Habitat</Nome>
								<Endereco>R. Oito, Qd: 10, Lts. 184 a 190,CEP 75.907-274, Parque Solar do Agreste "A" – Rio Verde / GO.</Endereco>
								<Area>918</Area>
								<NumUnidades>9</NumUnidades>
								<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
								<PercentTotalInvestido>0.090505</PercentTotalInvestido>
							</Imovel>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro>N/A</PoliticaContratacaoSeguro>
					</ImoveisVendaAcabados>
					<ImoveisVendaConstrucao>
						<LstImovVendaConstrucao>
							<Imovel>
								<Nome>Vista Madalena By You, Inc</Nome>
								<Endereco>Rua Paulistânia, 80 - Vila Madalena, São Paulo - SP, 05440-000</Endereco>
								<Area>622.47</Area>
								<NumUnidades>7</NumUnidades>
								<OutrasCaractRelevantes>17 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0.5882</PercentVendido>
								<PercentConclusaoObras realizado="0.3726" previsto="0.2911"/>
								<CustoConstrucao realizado="30031560" previsto="23462660"/>
							</Imovel>
							<Imovel>
								<Nome>José Antonio Bortolotto - MGB</Nome>
								<Endereco>R. JOSÉ RUSSI ESQ.C/R.RAFAEL DE CARVALHO N° 11 -SANTO ANTONIO DE POSSE </Endereco>
								<Area>2310.12</Area>
								<NumUnidades>54</NumUnidades>
								<OutrasCaractRelevantes>76 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0.2895</PercentVendido>
								<PercentConclusaoObras realizado="0.9943" previsto="1"/>
								<CustoConstrucao realizado="5965724.66" previsto="5999924.23"/>
							</Imovel>
							<Imovel>
								<Nome>Condomínio Wish 675 - EBM</Nome>
								<Endereco>R. Prof. Aprígio Gonzaga, N° 675 - Vila da Saúde, São Paulo - SP</Endereco>
								<Area>967.96</Area>
								<NumUnidades>14</NumUnidades>
								<OutrasCaractRelevantes>14 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.9648" previsto="1"/>
								<CustoConstrucao realizado="27014330.090592" previsto="27999927.54"/>
							</Imovel>
							<Imovel>
								<Nome>Haia Boa Vista - GRM</Nome>
								<Endereco>Av. Boa Vista B, 140 - Boa Vista - Sorocaba - SP</Endereco>
								<Area>2256.91</Area>
								<NumUnidades>12</NumUnidades>
								<OutrasCaractRelevantes>14 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0.1429</PercentVendido>
								<PercentConclusaoObras realizado="0.7968" previsto="0.9186"/>
								<CustoConstrucao realizado="59836323.55968" previsto="68982990.48936"/>
							</Imovel>
							<Imovel>
								<Nome>Unlimited - Oscar Freire - Youi, Inc</Nome>
								<Endereco>R. Oscar Freire, 1597 -Cerqueira César  - São Paulo - SP</Endereco>
								<Area>1540.84</Area>
								<NumUnidades>7</NumUnidades>
								<OutrasCaractRelevantes>9 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0.2222</PercentVendido>
								<PercentConclusaoObras realizado="0.9553" previsto="0.9135"/>
								<CustoConstrucao realizado="139473800" previsto="133371000"/>
							</Imovel>
							<Imovel>
								<Nome>Gafisa - Evolve Vila Mariana</Nome>
								<Endereco>R. Manuel de Paiva, 129 - Vila Mariana, São Paulo - SP, 04106-020</Endereco>
								<Area>1335.6</Area>
								<NumUnidades>9</NumUnidades>
								<OutrasCaractRelevantes>17 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0.4706</PercentVendido>
								<PercentConclusaoObras realizado="0.6685" previsto="0.8074"/>
								<CustoConstrucao realizado="37233829.6610214" previsto="44970222.9892425"/>
							</Imovel>
							<Imovel>
								<Nome>Aldana Jardim - Maximo Aldana </Nome>
								<Endereco>R. Kara, 140 - Jardim do Mar, São Bernardo do Campo - SP, 09750-300</Endereco>
								<Area>1290.55</Area>
								<NumUnidades>21</NumUnidades>
								<OutrasCaractRelevantes>21 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.2826" previsto="0.682969118902007"/>
								<CustoConstrucao realizado="10051635.492" previsto="24292132.4681365"/>
							</Imovel>
							<Imovel>
								<Nome>Varandas Joy - Realiza</Nome>
								<Endereco>Vila Formosa, Anápolis - GO, 75115-490</Endereco>
								<Area>1643.19</Area>
								<NumUnidades>28</NumUnidades>
								<OutrasCaractRelevantes>28 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.7962" previsto="0.852513784432276"/>
								<CustoConstrucao realizado="40448986.711176" previsto="43309870.3059476"/>
							</Imovel>
							<Imovel>
								<Nome>Duo Living Complex - Catamarã</Nome>
								<Endereco>Rua Pioneiro Domingos Salgueiro, nº 264 e Avenida Joaquim Moleirinho, nº 2225 – Maringá / PR.</Endereco>
								<Area>1871.05</Area>
								<NumUnidades>10</NumUnidades>
								<OutrasCaractRelevantes>10 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.6207" previsto="0.639"/>
								<CustoConstrucao realizado="77140605.242223" previsto="79414929.51471"/>
							</Imovel>
							<Imovel>
								<Nome>Derby Central - Max Plural</Nome>
								<Endereco>Rua Carlos Porto Carreiro, n° 61, bairro de Boa Vista – Recife / PE.</Endereco>
								<Area>811.47</Area>
								<NumUnidades>27</NumUnidades>
								<OutrasCaractRelevantes>27 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.1721" previsto="0.17665"/>
								<CustoConstrucao realizado="4560650" previsto="4681225"/>
							</Imovel>
							<Imovel>
								<Nome>Seven Living - Maximo Aldana</Nome>
								<Endereco>Avenida General San Martin, nº 132, bairro de Ponta da Praia – Santos / SP.</Endereco>
								<Area>1106.4</Area>
								<NumUnidades>19</NumUnidades>
								<OutrasCaractRelevantes>19 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.4825" previsto="0.53048"/>
								<CustoConstrucao realizado="22818092.98265" previsto="25087133.6071216"/>
							</Imovel>
							<Imovel>
								<Nome>Longitude - Icon</Nome>
								<Endereco>Rua Odete Jones Gigo, 380 - Sumaré - SP</Endereco>
								<Area>2363.5</Area>
								<NumUnidades>57</NumUnidades>
								<OutrasCaractRelevantes>57 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.8914" previsto="1"/>
								<CustoConstrucao realizado="50138447.946498" previsto="56246856.57"/>
							</Imovel>
							<Imovel>
								<Nome>Daxo - Res. Rhodes</Nome>
								<Endereco>Rua Otto lehmann, SN - Balneário Piçarras - SC, 88380-000</Endereco>
								<Area>1313.79</Area>
								<NumUnidades>8</NumUnidades>
								<OutrasCaractRelevantes>8 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.9897" previsto="1"/>
								<CustoConstrucao realizado="102114549.947303" previsto="103177275.88896"/>
							</Imovel>
							<Imovel>
								<Nome>Habitat - Casa Laguna</Nome>
								<Endereco>Alameda Paulo Roberto Cunha, 113 - Rio Verde - GO</Endereco>
								<Area>1104.37</Area>
								<NumUnidades>8</NumUnidades>
								<OutrasCaractRelevantes>8 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.6823" previsto="0.8703"/>
								<CustoConstrucao realizado="50477239.957128" previsto="64385668.964808"/>
							</Imovel>
							<Imovel>
								<Nome>Longitude - Vibe Itaim</Nome>
								<Endereco>Rua Salvador Balbino de Matos, 280 - Vila Itaim - SP</Endereco>
								<Area>36812</Area>
								<NumUnidades>45</NumUnidades>
								<OutrasCaractRelevantes>45 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.690281346101881" previsto="0.587302293124073"/>
								<CustoConstrucao realizado="47010813.9738842" previsto="39997544.485892"/>
							</Imovel>
							<Imovel>
								<Nome>CK - Artefacto</Nome>
								<Endereco>Av. Osvaldo Reis, 3334 - Praia Brava - Itajaí</Endereco>
								<Area>1427.4</Area>
								<NumUnidades>8</NumUnidades>
								<OutrasCaractRelevantes>8 unidades adquiridas no início da operação</OutrasCaractRelevantes>
								<PercentVendido>0</PercentVendido>
								<PercentConclusaoObras realizado="0.8566" previsto="0.8867"/>
								<CustoConstrucao realizado="73494970.528037" previsto="76077504.5146047"/>
							</Imovel>
						</LstImovVendaConstrucao>
						<JustificativaDesempenho>
							<Imovel>
								<NomeOuEndereco>Vista Madalena By You, Inc</NomeOuEndereco>
								<JustEvolucaoInferior>O atraso é devido à dificuldade de montagem e concretagem das grandes áreas de embasamento do empreendimento. Foi realizado um novo cronograma com prazo contratual para jul/27</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>José Antonio Bortolotto - MGB</NomeOuEndereco>
								<JustEvolucaoInferior>N/A</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Condomínio Wish 675 - EBM</NomeOuEndereco>
								<JustEvolucaoInferior>Obra iniciada com atraso de 60 dias.</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Haia Boa Vista - GRM</NomeOuEndereco>
								<JustEvolucaoInferior>Em novembro, refletindo a partir de dezembro, a construtora replanejou o cronograma da obra com objetivo em manter o prazo de entrega. </JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Unlimited - Oscar Freire - Youi, Inc</NomeOuEndereco>
								<JustEvolucaoInferior>N/A</JustEvolucaoInferior>
								<JustCustoSuperior>Obra adiantada.</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Gafisa - Evolve Vila Mariana</NomeOuEndereco>
								<JustEvolucaoInferior>Obra teve dificuldade de execução na estrutura, prejudicando avanço nas demais etapas.</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Residencial Aldana Jardim - Maximo Aldana </NomeOuEndereco>
								<JustEvolucaoInferior>O atraso ocorreu devido as chuvas no período durante a etapa de movimentação de terra e fundações ve também pelo atraso da entrega do aço da fundação</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Varandas Joy - Realiza</NomeOuEndereco>
								<JustEvolucaoInferior>Pequeno atraso em relação ao cronograma, porém recuperável. </JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Duo Living Complex - Catamarã</NomeOuEndereco>
								<JustEvolucaoInferior>N/A</JustEvolucaoInferior>
								<JustCustoSuperior>Obra adiantada.</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Derby Central - Max Plural</NomeOuEndereco>
								<JustEvolucaoInferior>O atraso é reflexo de início tardio de execução das fundações, agravado pelo baixo desempenho em dezembro em função do calendário reduzido (festas de fim de ano).</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Seven Living - Maximo Aldana</NomeOuEndereco>
								<JustEvolucaoInferior>Pequeno atraso em relação ao cronograma, porém recuperável. </JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Icon Residenc Club - Longitude</NomeOuEndereco>
								<JustEvolucaoInferior>Pequeno atraso em relação ao cronograma, porém recuperável. </JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Daxo - Res. Rhodes</NomeOuEndereco>
								<JustEvolucaoInferior>N/A</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Habitat - Casa Laguna</NomeOuEndereco>
								<JustEvolucaoInferior>Carência de mão de obra</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Longitude - Vibe Itaim</NomeOuEndereco>
								<JustEvolucaoInferior>N/A</JustEvolucaoInferior>
								<JustCustoSuperior>Obra adiantada.</JustCustoSuperior>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CK - Artefacto</NomeOuEndereco>
								<JustEvolucaoInferior>N/A</JustEvolucaoInferior>
								<JustCustoSuperior>N/A</JustCustoSuperior>
							</Imovel>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro>You Vista Madalena - vigência até 30/06/2027 e 30/11/2026
You Unlimited  - vigência até  30/09/2026;
GRM - vigência até 01/09/2026;
MGB - 24/08/2024; - Vigência até  31/07/2025
Condomínio Wish 675 – vigência - até 02/12/2026
Evolve Vila Mariana – vigência - em contratação
Aldana Jardim - vigência até 01/07/2027
Varandas Joy - vigência até 31/07/2027
Duo Living Complex - Catamarã - vigência - até 16/06/2028
Derby Central - Max Plural- vigência - até 05/10/2028
Seven Living - Maximo Aldana - vigência - até 30/12/2027
Icon Longitude - vigência - até12/10/2027
Daxo Rhodes - vigência - até 27/06/2026
Habita Casa Laguna - vigência - até 29/06/2027
Longitude - Vibe Itaim - vigência 25/04/2028
CK - Artefacto - vigência 01/12/2026</PoliticaContratacaoSeguro>
					</ImoveisVendaConstrucao>
				</Imoveis>
				<OutrosDireitosReais>
				</OutrosDireitosReais>
			</DireitosReaisImoveis>
			<AtivosFinanceiros>
				<FII>
					<Emissor>
						<Fundo>Alianza Crédito Imobiliário</Fundo>
						<CNPJ>40011324000140</CNPJ>
						<Quantidade>557150</Quantidade>
						<Valor>4301198</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Navi Residencial</Fundo>
						<CNPJ>42432327000182</CNPJ>
						<Quantidade>352663</Quantidade>
						<Valor>2951789.31</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Open K Ativos e Recebiveis Imobiliarios</Fundo>
						<CNPJ>32006821000121</CNPJ>
						<Quantidade>117201</Quantidade>
						<Valor>805170.87</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Brio Crédito Estruturado</Fundo>
						<CNPJ>39332032000120</CNPJ>
						<Quantidade>5586</Quantidade>
						<Valor>4960368</Valor>
					</Emissor>
					<Emissor>
						<Fundo>BTG Pactual Corporate Office Fund</Fundo>
						<CNPJ>8924783000101</CNPJ>
						<Quantidade>77233</Quantidade>
						<Valor>3611415.08</Valor>
					</Emissor>
					<Emissor>
						<Fundo>BTG Pactual Crédito Imobiliário</Fundo>
						<CNPJ>9552812000114</CNPJ>
						<Quantidade>484326</Quantidade>
						<Valor>4455799.2</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Devant Recebíveis Imobiliários</Fundo>
						<CNPJ>37087810000137</CNPJ>
						<Quantidade>35332</Quantidade>
						<Valor>844434.8</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Galapagos Recebíveis Imobiliários</Fundo>
						<CNPJ>38293897000161</CNPJ>
						<Quantidade>24781</Quantidade>
						<Valor>1672717.5</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Green Towers</Fundo>
						<CNPJ>23740527000158</CNPJ>
						<Quantidade>55859</Quantidade>
						<Valor>4796612.33</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Hedge Brasil Shopping</Fundo>
						<CNPJ>8431747000106</CNPJ>
						<Quantidade>108660</Quantidade>
						<Valor>2221010.4</Valor>
					</Emissor>
					<Emissor>
						<Fundo>CSHG Recebíveis Imobiliários</Fundo>
						<CNPJ>11160521000122</CNPJ>
						<Quantidade>30653</Quantidade>
						<Valor>3002767.88</Valor>
					</Emissor>
					<Emissor>
						<Fundo>JPP Capital Recebíveis Imobiliários</Fundo>
						<CNPJ>30982880000100</CNPJ>
						<Quantidade>21331</Quantidade>
						<Valor>1837665.65</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Kinea Índices de Preços</Fundo>
						<CNPJ>24960430000113</CNPJ>
						<Quantidade>57066</Quantidade>
						<Valor>5230098.9</Valor>
					</Emissor>
					<Emissor>
						<Fundo>VBI Logístico</Fundo>
						<CNPJ>30629603000118</CNPJ>
						<Quantidade>38103</Quantidade>
						<Valor>4171516.44</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Newport Logística Fundo De Investimento Imobiliário</Fundo>
						<CNPJ>32527626000147</CNPJ>
						<Quantidade>67289</Quantidade>
						<Valor>7197231.44</Valor>
					</Emissor>
					<Emissor>
						<Fundo>ORIZ RE Crédito Privado</Fundo>
						<CNPJ>54505439000103</CNPJ>
						<Quantidade>50000</Quantidade>
						<Valor>4884000</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Patria Crédito Imobiliário Índice De Preços FII</Fundo>
						<CNPJ>28729197000113</CNPJ>
						<Quantidade>30197</Quantidade>
						<Valor>2570368.64</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Patria Securities FII - Responsabilidade Limitada</Fundo>
						<CNPJ>35507457000171</CNPJ>
						<Quantidade>33590</Quantidade>
						<Valor>2079221</Valor>
					</Emissor>
					<Emissor>
						<Fundo>VBI Prime Properties</Fundo>
						<CNPJ>35652102000176</CNPJ>
						<Quantidade>22607</Quantidade>
						<Valor>1718132</Valor>
					</Emissor>
					<Emissor>
						<Fundo>REC Multiestratégia</Fundo>
						<CNPJ>56430935000162</CNPJ>
						<Quantidade>804869</Quantidade>
						<Valor>6471146.76</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Real Investor FII</Fundo>
						<CNPJ>44625612000145</CNPJ>
						<Quantidade>4091</Quantidade>
						<Valor>445673.54</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Valora CRI Índice de Preço</Fundo>
						<CNPJ>34197811000146</CNPJ>
						<Quantidade>37623</Quantidade>
						<Valor>3019245.75</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Valora Renda Imobiliária FII Resp. Limitada</Fundo>
						<CNPJ>53656482000107</CNPJ>
						<Quantidade>650000</Quantidade>
						<Valor>5460000</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Vinci Imóveis Urbanos</Fundo>
						<CNPJ>36445587000190</CNPJ>
						<Quantidade>300000</Quantidade>
						<Valor>1668000</Valor>
					</Emissor>
					<Emissor>
						<Fundo>V2 Renda Imobiliária</Fundo>
						<CNPJ>49184940000177</CNPJ>
						<Quantidade>98602</Quantidade>
						<Valor>8839669.3</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Ourinvest RE I</Fundo>
						<CNPJ>28693595000127</CNPJ>
						<Quantidade>160000</Quantidade>
						<Valor>10240000</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Zagros Multiestratégia</Fundo>
						<CNPJ>45188066000195</CNPJ>
						<Quantidade>477160</Quantidade>
						<Valor>4513933.6</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Sucesspar Varejo</Fundo>
						<CNPJ>27538422000171</CNPJ>
						<Quantidade>55315</Quantidade>
						<Valor>1356873.35</Valor>
					</Emissor>
					<Emissor>
						<Fundo>Vênus</Fundo>
						<CNPJ>36669535000105</CNPJ>
						<Quantidade>63652</Quantidade>
						<Valor>6030148.06</Valor>
					</Emissor>
				</FII>
				<CriCra>
					<Emissor>
						<Companhia>BARI SEC. S.A. - CRI - 22H1104501</Companhia>
						<CNPJ>10608405000160</CNPJ>
						<Emissao>8</Emissao>
						<Serie>1</Serie>
						<Quantidade>8518</Quantidade>
						<Valor>724512.19</Valor>
					</Emissor>
					<Emissor>
						<Companhia>BARI SEC. S.A. - CRI - 22H1104501</Companhia>
						<CNPJ>10608405000160</CNPJ>
						<Emissao>8</Emissao>
						<Serie>1</Serie>
						<Quantidade>2064</Quantidade>
						<Valor>175556.84</Valor>
					</Emissor>
					<Emissor>
						<Companhia>BARI SEC. S.A. - CRI - 22H1104501</Companhia>
						<CNPJ>10608405000160</CNPJ>
						<Emissao>8</Emissao>
						<Serie>1</Serie>
						<Quantidade>6154</Quantidade>
						<Valor>523438.37</Valor>
					</Emissor>
					<Emissor>
						<Companhia>CANAL CIA DE SECURITIZAÇÃO - CRI - 23E3611801</Companhia>
						<CNPJ>41811375000119</CNPJ>
						<Emissao>2</Emissao>
						<Serie>3</Serie>
						<Quantidade>8210</Quantidade>
						<Valor>8941312.1</Valor>
					</Emissor>
					<Emissor>
						<Companhia>HABITASEC SEC. S.A. - CRI - 19C0281298</Companhia>
						<CNPJ>9304427000158</CNPJ>
						<Emissao>1</Emissao>
						<Serie>135</Serie>
						<Quantidade>3500</Quantidade>
						<Valor>7815714.95</Valor>
					</Emissor>
					<Emissor>
						<Companhia>HABITASEC SEC. S.A. - CRI - 22J0268409</Companhia>
						<CNPJ>9304427000158</CNPJ>
						<Emissao>6</Emissao>
						<Serie>2</Serie>
						<Quantidade>5079</Quantidade>
						<Valor>916200.81</Valor>
					</Emissor>
					<Emissor>
						<Companhia>LEVERAGE CIA SEC. - CRI - 24B1573243</Companhia>
						<CNPJ>48415978000140</CNPJ>
						<Emissao>4</Emissao>
						<Serie>1</Serie>
						<Quantidade>10000</Quantidade>
						<Valor>7721750.37</Valor>
					</Emissor>
					<Emissor>
						<Companhia>OPEA SEC. S.A. - CRI - 23K2348010</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>223</Emissao>
						<Serie>1</Serie>
						<Quantidade>11000</Quantidade>
						<Valor>5092234.36</Valor>
					</Emissor>
					<Emissor>
						<Companhia>OPEA SEC. S.A. - CRI - 23K2348010</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>223</Emissao>
						<Serie>1</Serie>
						<Quantidade>5000</Quantidade>
						<Valor>2314651.98</Valor>
					</Emissor>
					<Emissor>
						<Companhia>OPEA SEC. S.A. - CRI - 23K2348010</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>223</Emissao>
						<Serie>1</Serie>
						<Quantidade>5000</Quantidade>
						<Valor>2314651.98</Valor>
					</Emissor>
					<Emissor>
						<Companhia>OPEA SEC. S.A. - CRI - 24H2277797</Companhia>
						<CNPJ>2773542000122</CNPJ>
						<Emissao>276</Emissao>
						<Serie>1</Serie>
						<Quantidade>3559</Quantidade>
						<Valor>3803013.74</Valor>
					</Emissor>
					<Emissor>
						<Companhia>OURINVEST SEC. S.A. - CRI - 19E0966783</Companhia>
						<CNPJ>12320349000190</CNPJ>
						<Emissao>1</Emissao>
						<Serie>17</Serie>
						<Quantidade>371</Quantidade>
						<Valor>397757</Valor>
					</Emissor>
					<Emissor>
						<Companhia>OURINVEST SEC. S.A. - CRI - 19E0966784</Companhia>
						<CNPJ>12320349000190</CNPJ>
						<Emissao>1</Emissao>
						<Serie>18</Serie>
						<Quantidade>830</Quantidade>
						<Valor>2065038.11</Valor>
					</Emissor>
					<Emissor>
						<Companhia>OURINVEST SEC. S.A. - CRI - 20F0692684</Companhia>
						<CNPJ>12320349000190</CNPJ>
						<Emissao>1</Emissao>
						<Serie>28</Serie>
						<Quantidade>4931</Quantidade>
						<Valor>1480616.64</Valor>
					</Emissor>
					<Emissor>
						<Companhia>OURINVEST SEC. S.A. - CRI - 21I0912120</Companhia>
						<CNPJ>12320349000190</CNPJ>
						<Emissao>1</Emissao>
						<Serie>46</Serie>
						<Quantidade>3000</Quantidade>
						<Valor>1564850.22</Valor>
					</Emissor>
					<Emissor>
						<Companhia>PROVINCIA - CRI - 24J3510650</Companhia>
						<CNPJ>4200649000107</CNPJ>
						<Emissao>79</Emissao>
						<Serie>1</Serie>
						<Quantidade>1216</Quantidade>
						<Valor>1209696.68</Valor>
					</Emissor>
					<Emissor>
						<Companhia>PROVINCIA - CRI - 24J3510650</Companhia>
						<CNPJ>4200649000107</CNPJ>
						<Emissao>79</Emissao>
						<Serie>1</Serie>
						<Quantidade>1500</Quantidade>
						<Valor>1492224.52</Valor>
					</Emissor>
					<Emissor>
						<Companhia>PROVINCIA - CRI - 24J3510650</Companhia>
						<CNPJ>4200649000107</CNPJ>
						<Emissao>79</Emissao>
						<Serie>1</Serie>
						<Quantidade>1016</Quantidade>
						<Valor>1010733.41</Valor>
					</Emissor>
					<Emissor>
						<Companhia>PROVINCIA - CRI - 24J3510650</Companhia>
						<CNPJ>4200649000107</CNPJ>
						<Emissao>79</Emissao>
						<Serie>1</Serie>
						<Quantidade>3672</Quantidade>
						<Valor>3652965.62</Valor>
					</Emissor>
					<Emissor>
						<Companhia>PROVINCIA - CRI - 25F2199910</Companhia>
						<CNPJ>4200649000107</CNPJ>
						<Emissao>106</Emissao>
						<Serie>1</Serie>
						<Quantidade>30000</Quantidade>
						<Valor>28492907.95</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRAVESSIA SEC. S.A. - CRI - 22H1140858</Companhia>
						<CNPJ>26609050000164</CNPJ>
						<Emissao>14</Emissao>
						<Serie>1</Serie>
						<Quantidade>1674</Quantidade>
						<Valor>169554.59</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRAVESSIA SEC. S.A. - CRI - 22H1140858</Companhia>
						<CNPJ>26609050000164</CNPJ>
						<Emissao>14</Emissao>
						<Serie>1</Serie>
						<Quantidade>596</Quantidade>
						<Valor>60367.11</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRAVESSIA SEC. S.A. - CRI - 22H1140858</Companhia>
						<CNPJ>26609050000164</CNPJ>
						<Emissao>14</Emissao>
						<Serie>1</Serie>
						<Quantidade>4904</Quantidade>
						<Valor>496711.9</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRAVESSIA SEC. S.A. - CRI - 22H2247401</Companhia>
						<CNPJ>26609050000164</CNPJ>
						<Emissao>14</Emissao>
						<Serie>2</Serie>
						<Quantidade>2000</Quantidade>
						<Valor>585978.53</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRUE SEC. S.A. - CRI - 19K1139670</Companhia>
						<CNPJ>12130744000100</CNPJ>
						<Emissao>1</Emissao>
						<Serie>244</Serie>
						<Quantidade>333</Quantidade>
						<Valor>1515670.71</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRUE SEC. S.A. - CRI - 22I1423539</Companhia>
						<CNPJ>12130744000100</CNPJ>
						<Emissao>98</Emissao>
						<Serie>1</Serie>
						<Quantidade>9297</Quantidade>
						<Valor>4489789.43</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRUE SEC. S.A. - CRI - 22L1198359</Companhia>
						<CNPJ>12130744000100</CNPJ>
						<Emissao>108</Emissao>
						<Serie>1</Serie>
						<Quantidade>3889</Quantidade>
						<Valor>1165120.01</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRUE SEC. S.A. - CRI - 22L1198359</Companhia>
						<CNPJ>12130744000100</CNPJ>
						<Emissao>108</Emissao>
						<Serie>1</Serie>
						<Quantidade>9368</Quantidade>
						<Valor>2806594.06</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRUE SEC. S.A. - CRI - 22L1198359</Companhia>
						<CNPJ>12130744000100</CNPJ>
						<Emissao>108</Emissao>
						<Serie>1</Serie>
						<Quantidade>4920</Quantidade>
						<Valor>1474001.15</Valor>
					</Emissor>
					<Emissor>
						<Companhia>TRUE SEC. S.A. - CRI - 22L1198359</Companhia>
						<CNPJ>12130744000100</CNPJ>
						<Emissao>108</Emissao>
						<Serie>1</Serie>
						<Quantidade>2162</Quantidade>
						<Valor>647721.64</Valor>
					</Emissor>
					<Emissor>
						<Companhia>VIRGO CIA DE SECURITIZACAO - CRI - 21G0785091</Companhia>
						<CNPJ>8769451000108</CNPJ>
						<Emissao>4</Emissao>
						<Serie>314</Serie>
						<Quantidade>5050</Quantidade>
						<Valor>4435182.92</Valor>
					</Emissor>
					<Emissor>
						<Companhia>VIRGO CIA DE SECURITIZACAO - CRI - 24J4921075</Companhia>
						<CNPJ>8769451000108</CNPJ>
						<Emissao>221</Emissao>
						<Serie>1</Serie>
						<Quantidade>5000</Quantidade>
						<Valor>4744122.95</Valor>
					</Emissor>
				</CriCra>
				<LciLca>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>1000</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa>24280598</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
					<Imovel>
						<Nome>Habitat - Vida</Nome>
						<Endereco>R. Paranaíba, 581 - St. Planalto, Jataí - GO, 75805-045</Endereco>
						<DataAlienacao>2026-01-19</DataAlienacao>
						<Area>189.15</Area>
						<NumUnidades>3</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.363617138585043</PercentTotalInvestido>
						<PercentPL>0.0017</PercentPL>
					</Imovel>
					<Imovel>
						<Nome>Habitat - Vida</Nome>
						<Endereco>R. Paranaíba, 581 - St. Planalto, Jataí - GO, 75805-045</Endereco>
						<DataAlienacao>2026-02-13</DataAlienacao>
						<Area>63.05</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.190460366252145</PercentTotalInvestido>
						<PercentPL>0.00057</PercentPL>
					</Imovel>
					<Imovel>
						<Nome>Habitat - Vida</Nome>
						<Endereco>R. Paranaíba, 581 - St. Planalto, Jataí - GO, 75805-045</Endereco>
						<DataAlienacao>2026-03-13</DataAlienacao>
						<Area>63.05</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.235269971119743</PercentTotalInvestido>
						<PercentPL>0.00057</PercentPL>
					</Imovel>
					<Imovel>
						<Nome>Vista Madalena By You, Inc</Nome>
						<Endereco>Rua Paulistânia, 80 - Vila Madalena, São Paulo - SP, 05440-000</Endereco>
						<DataAlienacao>2026-02-23</DataAlienacao>
						<Area>599.28</Area>
						<NumUnidades>7</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.498672768907766</PercentTotalInvestido>
						<PercentPL>0.0129388393551417</PercentPL>
					</Imovel>
					<Imovel>
						<Nome>Tumiaru 120</Nome>
						<Endereco>R. Tumiaru, 120 - Vila Mariana, São Paulo - SP, 04008-050</Endereco>
						<DataAlienacao>2026-02-05</DataAlienacao>
						<Area>185.27</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.3333</PercentTotalInvestido>
						<PercentPL>0.00774855444282923</PercentPL>
					</Imovel>
					<Imovel>
						<Nome>Edifício Gibran</Nome>
						<Endereco>Rua Alberto Neder 424 - Campo Grande</Endereco>
						<DataAlienacao>2026-02-27</DataAlienacao>
						<Area>168.67</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.111111111111111</PercentTotalInvestido>
						<PercentPL>0.00143347011438551</PercentPL>
					</Imovel>
					<Imovel>
						<Nome>Residencial Aquarela Habitat</Nome>
						<Endereco>Rua Antônio Brochado, nº 1.005, Nova Divinéia – Unaí / MG.</Endereco>
						<DataAlienacao>2026-02-23</DataAlienacao>
						<Area>70.39</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.0648092734621723</PercentTotalInvestido>
						<PercentPL>0.000548053807936496</PercentPL>
					</Imovel>
					<Imovel>
						<Nome>José Antonio Bortolotto - MGB</Nome>
						<Endereco>R. JOSÉ RUSSI ESQ.C/R.RAFAEL DE CARVALHO N° 11 -SANTO ANTONIO DE POSSE </Endereco>
						<DataAlienacao>2026-01-29</DataAlienacao>
						<Area>42.78</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.0178571428571428</PercentTotalInvestido>
						<PercentPL>0.000167546923966417</PercentPL>
					</Imovel>
					<Imovel>
						<Nome>José Antonio Bortolotto - MGB</Nome>
						<Endereco>R. JOSÉ RUSSI ESQ.C/R.RAFAEL DE CARVALHO N° 11 -SANTO ANTONIO DE POSSE </Endereco>
						<DataAlienacao>2026-03-31</DataAlienacao>
						<Area>42.78</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0.0181818181818182</PercentTotalInvestido>
						<PercentPL>0.000167546923966417</PercentPL>
					</Imovel>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda/>
					<CustoImovEstoque/>
					<AjusteValor/>
					<OutrasRecOuDesp contabil="11444329.51" financeiro="7260044.65"/>
					<ResultadoLiquido contabil="11444329.51" financeiro="7260044.65"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis/>
					<DespManutencaoConservacao/>
					<ReceitasVenda/>
					<CustoPropriedadesVendidas/>
					<AjusteValor/>
					<OutrasRecOuDesp/>
					<ResultadoLiquido contabil="0" financeiro="0"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="12013963.12" financeiro="3507006.93"/>
					<AjusteValor contabil="-4383239.1"/>
					<ResultadoVenda contabil="141286.79" financeiro="32682.8"/>
					<OutrasRecOuDesp financeiro="3191279.52"/>
					<ResultadoLiquido contabil="7772010.81" financeiro="6730969.25"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="19216340.32" financeiro="13991013.9"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="610927.74" financeiro="473469.46"/>
				<AjusteValorAplicacoes/>
				<ResultadoVendaAplicacoes/>
				<OutrasRecOuDespAplicacoes/>
				<ResultadoLiquido contabil="610927.74" financeiro="473469.46"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-1183644.06" financeiro="-1175371.26"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada financeiro="-120830.4"/>
				<EmpresaEspecializada/>
				<FormadorMercado/>
				<CustodiaTitulosValores contabil="-64539.43" financeiro="-64081.54"/>
				<AuditoriaIndependente financeiro="-95000"/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-48606.46" financeiro="-38015.61"/>
				<ComissoesEmolumentos financeiro="0"/>
				<HonorariosDespesasDefesas contabil="0" financeiro="-3625"/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio contabil="-16939.56"/>
				<OutrasRecOuDesp contabil="-251186.07" financeiro="-57985.62"/>
				<Total contabil="-1564915.58" financeiro="-1554909.43"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="18262352.48" financeiro="12909573.93"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>12909573.93</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>12264095.2335</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte xsi:nil="true"/>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<ResultadoFinanceiroExcedeMinimo>418140.92</ResultadoFinanceiroExcedeMinimo>
			<RendimentosDeclarados>12682236.1535</RendimentosDeclarados>
			<RendimentosPagosAntec>-8454824.1</RendimentosPagosAntec>
			<RendimentoPagar>4227412.0535</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.98239</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"