"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>XP LOGÍSTICO PRIME YIELD FUNDO DE INVESTIMENTO IMOBILIÁRIO</NomeFundo>
		<CNPJFundo>26502794000185</CNPJFundo>
		<DataFuncionamento>2016-10-18</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRXPLGCTF002</CodigoISIN>
		<QtdCotasEmitidas>41954498</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Renda</Subclassificacao>
			<SegmentoAtuacao>Logística</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 CCTVM S.A.</NomeAdministrador>
		<CNPJAdministrador>26502794000185</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>22.440-032</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>1/2026</Competencia>
		<DataEncerTrimestre>2026-03-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>2260_49076 (Piracicaba)</Nome>
								<Endereco>Avenida Comendador Leopoldo Dedini, nº 2.260 - Piracicaba, SP</Endereco>
								<Area>67988</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 49076</OutrasCaractRelevantes>
								<PercentVacancia>0.16</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Diversos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CACHOEIRINHA</Nome>
								<Endereco>Rua Lennie Queiroz, 333 - Cachoeirinha - RS</Endereco>
								<Area>38410</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 31483</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CAJAMAR</Nome>
								<Endereco>Rod. dos Bandeirantes, km 34 - Cajamar, SP</Endereco>
								<Area>110208.57</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 56.549, 56.551</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Material de Construção</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CD LEROY M</Nome>
								<Endereco>Rod. dos Bandeirantes, km 34 - Cajamar, SP</Endereco>
								<Area>21349.43</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 56.549, 56.551</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Automotivo</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Transportes</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CD RENNER</Nome>
								<Endereco>Avenida Osvaldo José do Amaral, SN - Areias São José - SC</Endereco>
								<Area>47912.9</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 68.019 a 68.026 e 111.421</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DIA AMERICA</Nome>
								<Endereco>Rua Joao de Padula, 245 - Americana - SP</Endereco>
								<Area>30345.13</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 58407</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio e Distrib. de Alimentos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DIA RIBEIR</Nome>
								<Endereco>Via Jose Luiz Galvão, 1905 - Ribeirão Preto - SP</Endereco>
								<Area>21135.52</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 177959</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio e Distrib. de Alimentos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>DUQUECX_RJ</Nome>
								<Endereco>Av. SN 1, 280 - Parque Duque. Rio de Janeiro - RJ</Endereco>
								<Area>23541</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 20330</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logístico</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>ESPECULATIVO</Nome>
								<Endereco>Rod. dos Bandeirantes, km 34 - Cajamar, SP</Endereco>
								<Area>125555</Area>
								<NumUnidades>16</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 56.549, 56.551</OutrasCaractRelevantes>
								<PercentVacancia>0.12</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Material de Construção</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>EXP RENNER</Nome>
								<Endereco>Avenida Osvaldo José do Amaral, SN - Areias São José - SC</Endereco>
								<Area>11843.49</Area>
								<NumUnidades>62</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 68.019 a 68.026 e 111.421</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>IMO ITAPEVA</Nome>
								<Endereco>Estrada Municipal do Mandu, 2550 - Itapeva - MG</Endereco>
								<Area>23453.67</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 13627</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Eletroeletrônicos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>REC GRAVATA</Nome>
								<Endereco>Rodovia RS118, km 11, Gravataí - RS</Endereco>
								<Area>105270.92</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 95.965</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Farmacêutico</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logístico</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SBP</Nome>
								<Endereco>Estrada Tenente Marques, 1818 - Santana de Parnaiba - SP</Endereco>
								<Area>50181</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 201542 a 201564</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logístico</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Saúde</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Suprimento e Papel</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SYSLOG RJ</Nome>
								<Endereco>Avenida OL-1 -Duque de Caxias, RJ</Endereco>
								<Area>29087</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 20330 e 22126</OutrasCaractRelevantes>
								<PercentVacancia>0.13</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Empresarial</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Energia</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Farmacêutico</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SYSLOG SP</Nome>
								<Endereco>km 26 + 175,35m e o km 25 + 759,35m da Rodovia Anhanguera</Endereco>
								<Area>66378</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 188.415. Investimento indireto por meio da SPE Rec Log SP.</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>SEROPEDICA</Nome>
								<Endereco>Estrada Miguel Pereira nº 34, Bairro São Miguel, CEP: 23.890-000</Endereco>
								<Area>82048.99</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 2737-2774</OutrasCaractRelevantes>
								<PercentVacancia>0.37</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logística</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>EXTREMA MG</Nome>
								<Endereco>Estrada Luiz Lopes Neto, 728</Endereco>
								<Area>76388</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>17.033; 23.435; 22.333</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Alimentos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Logística</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>1702_26502 (Guarulhos)</Nome>
								<Endereco>Av. Francisco Xavier, 62</Endereco>
								<Area>111197.53</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 1702</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>12769_26502 (Galpão Extrema I)</Nome>
								<Endereco>Estrada M. Vargem João Pinto</Endereco>
								<Area>37600.24</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 20694</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Comércio Varejista</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>24929_26502 (Galpão Extrema II)</Nome>
								<Endereco>Estrada M. Luiz Lopes Neto</Endereco>
								<Area>77106.29</Area>
								<NumUnidades>13</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 24917-24929</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Diversos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>88913_26502 (Galpão Hortolândia I)</Nome>
								<Endereco>Rod. Jornalista F. A. Proença, Km 09</Endereco>
								<Area>15349.29</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 88913</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Diversos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>110307_26502 (Galpão Hortolândia II)</Nome>
								<Endereco>Rod. SP 101, Km 9,5</Endereco>
								<Area>43123.34</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrícula 110307</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Diversos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>95140_26502 (Galpão WT RBR Log)</Nome>
								<Endereco>Rod. P. Tancredo Neves, Km 45</Endereco>
								<Area>33615.9</Area>
								<NumUnidades>2</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 93939 e 95141</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Diversos</SetorAtuacao><PercentReceitaImovel>0</PercentReceitaImovel><PercentReceitasFII>0</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>CD São Bernardo - CD CL Imigrantes V</Nome>
								<Endereco>Rua Maria Loprete, 120</Endereco>
								<Area>62457</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Matrículas 104.097 e nº 104.098</OutrasCaractRelevantes>
								<PercentVacancia>1</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>NA</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 percentReceitaImovel="0.23">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 percentReceitaImovel="0.04">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 percentReceitaImovel="0.12">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="0.61">Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado>Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0.07"/>
							<INPC/>
							<IPCA percentReceitaImovel="0.93"/>
							<INCC/>
							<OutrosIndicadores>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>As carácterísticas básicas estão refletidas nas tabelas acima. O fundo conta com contratos de locação tanto atípicos quanto típicos. Para mais detalhes, os relatórios gerenciais podem ser visualizados na CVM.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>CACHOEIRINHA - CD Via Varejo</NomeOuEndereco>
								<CaractContratuais>Atípico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CD RENNER - CD Renner + Expansão</NomeOuEndereco>
								<CaractContratuais>Atípico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DIA AMERICA - CD Atual Cargas</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>DIA RIBEIR - CD Atacadão</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>IMO ITAPEVA - CD Panasonic</NomeOuEndereco>
								<CaractContratuais>Atípico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>SBP - Santana Business Park</NomeOuEndereco>
								<CaractContratuais>Típico; Atípico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Condomínio DDC RJ - Syslog RJ</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CD Leroy Cajamar + Expansão Leroy</NomeOuEndereco>
								<CaractContratuais> Atípico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>B2W</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Syslog SP</NomeOuEndereco>
								<CaractContratuais>Atípico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Especulativo Cajamar</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Especulativo Extrema</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CD HGLG WL</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CD Gravataí</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Piracicaba (2260_49076 - CLP)</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>EXTREMA MG</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CD Guarulhos</NomeOuEndereco>
								<CaractContratuais>Atípico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Galpão Extrema I</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Galpão Extrema II</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Galpão Hortolândia I</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Galpão Hortolândia II</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>Galpão WT Franco da Rocha</NomeOuEndereco>
								<CaractContratuais>Típico</CaractContratuais>
							</Imovel>
							<Imovel>
								<NomeOuEndereco>CD São Bernardo</NomeOuEndereco>
								<CaractContratuais>NA</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>O time de gestão da XP Vista Asset Management conta com um programa de Manutenção Preventiva (PMP), no intuito de monitorar e tomar ações com vistas à preservação dos imóveis. Para os imóveis com contrato Atípico, e/ou de monousuário, o Fundo monitora a renovação anual dos seguros providenciados pelas locatárias. Para os imóveis com contratos típicos e multiusuários o Fundo contrata anualmente uma apólice de seguro, seja diretamente ou indiretamente via condomínio.</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>
					<Emissor>
						<Fundo>GARE11</Fundo>
						<CNPJ>37.295.919/0001-60</CNPJ>
						<Quantidade>257978</Quantidade>
						<Valor>2208291.68</Valor>
					</Emissor>
					<Emissor>
						<Fundo>RBRL11</Fundo>
						<CNPJ>35.705.463/0001-33</CNPJ>
						<Quantidade>172038</Quantidade>
						<Valor>15550514.82</Valor>
					</Emissor>
					<Emissor>
						<Fundo>VILG11</Fundo>
						<CNPJ>24.853.044/0001-22</CNPJ>
						<Quantidade>200343</Quantidade>
						<Valor>19813922.7</Valor>
					</Emissor>
					<Emissor>
						<Fundo>NE LOGISTIC FII</Fundo>
						<CNPJ>30.495.165/0001-42</CNPJ>
						<Quantidade>438700</Quantidade>
						<Valor>389126037.53</Valor>
					</Emissor>
				</FII>
				<CriCra>
				</CriCra>
				<LciLca>
				</LciLca>
				<LIG>
				</LIG>
				<CEPAC>
				</CEPAC>
				<Acoes>
				</Acoes>
				<AcoesSocFII>
					<Emissor>
						<Sociedade>SPE APLHA SF 2023</Sociedade>
						<CNPJ>26.502.794/0001-85</CNPJ>
						<Quantidade>100</Quantidade>
						<Valor>100</Valor>
					</Emissor>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
					<Emissor>
						<Fundo>XP CASH O1 FIRF SIMPLES RESP</Fundo>
						<CNPJ>57346708000116</CNPJ>
						<Quantidade>76902943.4</Quantidade>
						<Valor>92284590.27</Valor>
					</Emissor>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
					<Ativo>
						<Emissor>MERCURIO LTDA</Emissor>
						<CNPJ>33.980.924/0001-50</CNPJ>
						<NomeAtivo>AFAC</NomeAtivo>
						<Quantidade>100</Quantidade>
						<Valor>100</Valor>
					</Ativo>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>11001814.57</Disponibilidades>
				<TitulosPublicos>0</TitulosPublicos>
				<TitulosPrivados>0</TitulosPrivados>
				<FundosRendaFixa>92284590.27</FundosRendaFixa>
			</AtivosNecessidadeLiquidez>
		</InfoTipoAtivo>
		<AquisicoesAlienacoes>
			<Terrenos>
				<Aquisicoes>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Terrenos>
			<Imoveis>
				<Aquisicoes>
					<Imovel>
						<Nome>CD São Bernardo - CD CL Imigrantes V</Nome>
						<Endereco>Rua Maria Loprete, 120</Endereco>
						<Area>62457</Area>
						<NumUnidades>1</NumUnidades>
						<OutrasCaractRelevantes>N/A</OutrasCaractRelevantes>
						<PercentTotalInvestido>0</PercentTotalInvestido>
						<Categoria>Renda</Categoria>
					</Imovel>
				</Aquisicoes>
				<Alienacoes>
				</Alienacoes>
			</Imoveis>
		</AquisicoesAlienacoes>
		<OutrasInfo>
			<RentabilidadeGarantida>
				<AtivosGarantiaRent>
				</AtivosGarantiaRent>
				<RentEfetivaVigGarantia>
				</RentEfetivaVigGarantia>
			</RentabilidadeGarantida>
		</OutrasInfo>
		<DemonstracoesContabilFinanc>
			<AtivosImobiliarios>
				<Estoques>
					<ReceitasVenda contabil="0" financeiro="0"/>
					<CustoImovEstoque contabil="-3252289.87" financeiro="0"/>
					<AjusteValor contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="0"/>
					<ResultadoLiquido contabil="-3252289.87" financeiro="0"/>
				</Estoques>
				<PropriedadesInvest>
					<ReceitasAlugueis contabil="143967504.73" financeiro="124055060"/>
					<DespManutencaoConservacao contabil="-2360611.46" financeiro="-3314876"/>
					<ReceitasVenda contabil="0" financeiro="0"/>
					<CustoPropriedadesVendidas contabil="0" financeiro="0"/>
					<AjusteValor contabil="10899503.64" financeiro="0"/>
					<OutrasRecOuDesp contabil="-31868300.95" financeiro="0"/>
					<ResultadoLiquido contabil="120638095.96" financeiro="120740184"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="9403106.24" financeiro="903057.93"/>
					<AjusteValor contabil="960905.6" financeiro="0"/>
					<ResultadoVenda contabil="0" financeiro="3290282"/>
					<OutrasRecOuDesp contabil="0" financeiro="0"/>
					<ResultadoLiquido contabil="10364011.84" financeiro="4193339.93"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="127749817.93" financeiro="124933523.93"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="0" financeiro="1673167"/>
				<AjusteValorAplicacoes contabil="4759160.01" financeiro="0"/>
				<ResultadoVendaAplicacoes contabil="0" financeiro="0"/>
				<OutrasRecOuDespAplicacoes contabil="0" financeiro="-16062785"/>
				<ResultadoLiquido contabil="4759160.01" financeiro="-14389618"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos contabil="0" financeiro="0"/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-10232926.59" financeiro="-7824706"/>
				<TaxaDesempenho contabil="0" financeiro="0"/>
				<ConsultoriaEspecializada contabil="0" financeiro="0"/>
				<EmpresaEspecializada contabil="0" financeiro="0"/>
				<FormadorMercado contabil="0" financeiro="0"/>
				<CustodiaTitulosValores contabil="0" financeiro="0"/>
				<AuditoriaIndependente contabil="-23448.86" financeiro="0"/>
				<RepresentantesCotistas contabil="0" financeiro="0"/>
				<TaxasImpostosContribuicoes contabil="-147673.57" financeiro="0"/>
				<ComissoesEmolumentos contabil="-433175.47" financeiro="0"/>
				<HonorariosDespesasDefesas contabil="-946157.39" financeiro="0"/>
				<GastosContratosSeguros contabil="0" financeiro="0"/>
				<DespesasAvaliacoes contabil="0" financeiro="0"/>
				<TaxasIngressoSaidaFundos contabil="0" financeiro="0"/>
				<DespesasRegistroCartorio contabil="-160132.26" financeiro="0"/>
				<OutrasRecOuDesp contabil="2918441.41" financeiro="0"/>
				<Total contabil="-9025072.73" financeiro="-7824706"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="123483905.21" financeiro="102719199.93"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>102719199.93</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>97583239.9335</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte xsi:nil="true"/>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<ResultadoFinanceiroExcedeMinimo>0</ResultadoFinanceiroExcedeMinimo>
			<RendimentosDeclarados>97583239.9335</RendimentosDeclarados>
			<RendimentosPagosAntec>0</RendimentosPagosAntec>
			<RendimentoPagar>97583239.9335</RendimentoPagar>
			<ResultadoLiquidoDeclarado>0.95</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"