"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<DadosEconomicoFinanceiros xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<DadosGerais>
		<NomeFundo>FUNDO DE INVESTIMENTO IMOBILIÁRIO SC 401 RESP Ltda</NomeFundo>
		<CNPJFundo>12804013000100</CNPJFundo>
		<DataFuncionamento>2010-10-25</DataFuncionamento>
		<PublicoAlvo>Investidores em Geral</PublicoAlvo>
		<CodigoISIN>BRFISCCTF008</CodigoISIN>
		<QtdCotasEmitidas>1699996</QtdCotasEmitidas>
		<FundoExclusivo>false</FundoExclusivo>
		<EnquadraNotaSeis>false</EnquadraNotaSeis>
		<VinculoFamiliarCotistas>false</VinculoFamiliarCotistas>
		<Autorregulacao>
			<Classificacao>Tijolo</Classificacao>
			<Subclassificacao>Híbrido</Subclassificacao>
			<SegmentoAtuacao>Escritórios</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>BR-CAPITAL DIST. DE TÍTULOS E VALORES MOBILIÁRIOS S/A</NomeAdministrador>
		<CNPJAdministrador>12804013000100</CNPJAdministrador>
		<Logradouro>RUA SURUBIM</Logradouro>
		<Numero>577</Numero>
		<Complemento>CONJ. 101</Complemento>
		<Bairro>CIDADE MONÇÕES</Bairro>
		<Cidade>SÃO PAULO</Cidade>
		<Estado>SP</Estado>
		<CEP>04571-050</CEP>
		<Telefone1>(11) 5508-3500</Telefone1>
		<Telefone2/>
		<Telefone3 xsi:nil="true"/>
		<Site>www.brcapital.com.br</Site>
		<Email>fundos@brcapital.com.br</Email>
		<Competencia>01/2026</Competencia>
		<DataEncerTrimestre>2026-03-31</DataEncerTrimestre>
	</DadosGerais>
	<InformeTrimestral>
		<InfoTipoAtivo>
			<DireitosReaisImoveis>
				<Terrenos>
				</Terrenos>
				<Imoveis>
					<ImoveisRendaAcabados>
						<LstImovRendaAcabados>
							<Imovel>
								<Nome>Emp. Com. SC 401 Square Corporate T. Lagoa, Campeche, Jurerê</Nome>
								<Endereco>Rodovia SC 401, KM 5</Endereco>
								<Area>16015.43</Area>
								<NumUnidades>20</NumUnidades>
								<OutrasCaractRelevantes>Empreendimento Comercial - Lojas</OutrasCaractRelevantes>
								<PercentVacancia>0.028667</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.611263</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Móveis e decoração</SetorAtuacao><PercentReceitaImovel>0.34306</PercentReceitaImovel><PercentReceitasFII>0.209702</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Educação Cursos</SetorAtuacao><PercentReceitaImovel>0.282707</PercentReceitaImovel><PercentReceitasFII>0.172809</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Pet Shop</SetorAtuacao><PercentReceitaImovel>0.154017</PercentReceitaImovel><PercentReceitasFII>0.094145</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Emp. Com. SC 401 Square Corporate T. Lagoa, Campeche, Jurerê</Nome>
								<Endereco>Rodovia SC 401, KM 5</Endereco>
								<Area>2769.8</Area>
								<NumUnidades>45</NumUnidades>
								<OutrasCaractRelevantes>Empreendimento Comercial - Conjuntos Comerciais com direito de uso de 55 vagas no estacionamento</OutrasCaractRelevantes>
								<PercentVacancia>0.245036</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.100797</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>escritórios</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.100797</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Emp. Com. SC 401 Square Corporate T. Lagoa, Campeche, Jurerê</Nome>
								<Endereco>Rodovia SC 401, KM 5</Endereco>
								<Area>8297.01</Area>
								<NumUnidades>326</NumUnidades>
								<OutrasCaractRelevantes>Empreendimento Comercial - Estacionamento (rotativo) (82,37% das vagas do estacionamento rotativo constrantes da matrícula 156.994 do 2º Ofício do Registro de Imóveis do Estado de Santa Catarina)</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.157787</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Estacionamento</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.157787</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>Terreno destinado à locação</Nome>
								<Endereco>Rodovia SC 401, ao lado direito da rodovia no sentido Centro/Praia e ao lado direito do empreendimento SC-401 Square Corporate</Endereco>
								<Area>789.24</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Fração ideal de 50% da área de 1.578,48m² do terreno objeto da matrícula nº 160.554 do 2º Ofício do Registro de imóveis de Florianópolis S/C. A referida matrícula foi aberta em decorrência do encerramento da matrícula 44.607 do 2º Ofício de Registro de Imóveis de Florianópolis/SC. A área locada é de 500m².</OutrasCaractRelevantes>
								<PercentVacancia>0</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.006927</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Pet Shop</SetorAtuacao><PercentReceitaImovel>1</PercentReceitaImovel><PercentReceitasFII>0.006927</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
							<Imovel>
								<Nome>W Tower</Nome>
								<Endereco>Rua Alfredo Chaves, 1208 - Caxias do Sul/RS</Endereco>
								<Area>3224.97</Area>
								<NumUnidades>20</NumUnidades>
								<OutrasCaractRelevantes>Imóveis para locação</OutrasCaractRelevantes>
								<PercentVacancia>0.107288</PercentVacancia>
								<PercentInadimplencia>0</PercentInadimplencia>
								<PercentReceitasFII>0.112645</PercentReceitasFII>
								<Inquilinos><Inquilino><SetorAtuacao>Academia</SetorAtuacao><PercentReceitaImovel>0.232825</PercentReceitaImovel><PercentReceitasFII>0.024464</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Alimentação</SetorAtuacao><PercentReceitaImovel>0.220734</PercentReceitaImovel><PercentReceitasFII>0.023193</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Conveniência</SetorAtuacao><PercentReceitaImovel>0.198007</PercentReceitaImovel><PercentReceitasFII>0.020805</PercentReceitasFII></Inquilino><Inquilino><SetorAtuacao>Saúde</SetorAtuacao><PercentReceitaImovel>0.19183</PercentReceitaImovel><PercentReceitasFII>0.020156</PercentReceitasFII></Inquilino></Inquilinos></Imovel>
						</LstImovRendaAcabados>
						<DistrContratosPrazo>
							<AteTresMeses percentReceitaImovel="0.058827" percentReceitasFII="0.057494">Até 3 meses</AteTresMeses>
							<TresAteSeisMeses percentReceitaImovel="0.048432" percentReceitasFII="0.047335">De 3 meses e 1 dia a 6 meses</TresAteSeisMeses>
							<SeisAteNoveMeses percentReceitaImovel="0.031329" percentReceitasFII="0.030619">De 6 meses e 1 dia a 9 meses</SeisAteNoveMeses>
							<NoveAteDozeMeses percentReceitaImovel="0.023573" percentReceitasFII="0.023039">De 9 meses e 1 dia a 12 meses</NoveAteDozeMeses>
							<DozeAteQuinzeMeses percentReceitaImovel="0.021794" percentReceitasFII="0.0213">De 12 meses e 1 dia a 15 meses</DozeAteQuinzeMeses>
							<QuinzeAteDezoitoMeses percentReceitaImovel="0.012271" percentReceitasFII="0.011993">De 15 meses e 1 dia a 18 meses</QuinzeAteDezoitoMeses>
							<DezoitoAteVinteUmMeses percentReceitaImovel="0.019519" percentReceitasFII="0.019077">De 18 meses e 1 dia a 21 meses</DezoitoAteVinteUmMeses>
							<VinteUmAteVinteQuatroMeses percentReceitaImovel="0.051329" percentReceitasFII="0.050166">De 21 meses e 1 dia a 24 meses</VinteUmAteVinteQuatroMeses>
							<VinteQuatroAteVinteSeteMeses percentReceitaImovel="0.153204" percentReceitasFII="0.149732">De 24 meses e 1 dia a 27 meses</VinteQuatroAteVinteSeteMeses>
							<VinteSeteAteTrintaMeses percentReceitaImovel="0.127292" percentReceitasFII="0.124408">De 27 meses e 1 dia a 30 meses</VinteSeteAteTrintaMeses>
							<TrintaAteTrintaTresMeses percentReceitaImovel="0.009365" percentReceitasFII="0.009153">De 30 meses e 1 dia a 33 meses</TrintaAteTrintaTresMeses>
							<TrintaTresAteTrintaSeisMeses percentReceitaImovel="0.064634" percentReceitasFII="0.063169">De 33 meses e 1 dia a 36 meses</TrintaTresAteTrintaSeisMeses>
							<AcimaTrintaSeisMeses percentReceitaImovel="0.181354" percentReceitasFII="0.177246">Acima de 36 meses</AcimaTrintaSeisMeses>
							<PrazoIndeterminado percentReceitaImovel="0.042321" percentReceitasFII="0.041362">Prazo indeterminado</PrazoIndeterminado>
						</DistrContratosPrazo>
						<DistrContratosIndexador>
							<IGPM percentReceitaImovel="0.268563" percentReceitasFII="0.262478"/>
							<INPC/>
							<IPCA percentReceitaImovel="0.163797" percentReceitasFII="0.160086"/>
							<INCC/>
							<OutrosIndicadores>
								<Indicador nome="IGP-DI" percentReceitaImovel="0.412884" percentReceitasFII="0.403529"/>
							</OutrosIndicadores>
						</DistrContratosIndexador>
						<CaractContratuaisComuns>Cláusula de reajuste - IGPM, ou Ipca ou IGP-DI; garantia por fiador, seguro fiança ou depósito caução, cláusula de rescisão determinando o valor da multa, cláusula de exigência para contratação de seguro patrimonial. Alguns contratos contém descontos nos primeiros meses de locação, com prazo determinado. Alguns contratos pagam aluguel variável com base no percentual do faturamento.</CaractContratuaisComuns>
						<CaractContratuaisIndividual>
							<Imovel>
								<NomeOuEndereco>nda</NomeOuEndereco>
								<CaractContratuais>nda</CaractContratuais>
							</Imovel>
						</CaractContratuaisIndividual>
						<PoliticaContratacaoSeguro>Cláusula de exigência para a Contratação de seguros das seguintes coberturas para os imóveis locados: Incêndio  Raio  explosão e Responsabilidade Civil.</PoliticaContratacaoSeguro>
					</ImoveisRendaAcabados>
					<ImoveisRendaConstrucao>
						<LstImovRendaConstrucao>
						</LstImovRendaConstrucao>
						<JustificativaDesempenho>
						</JustificativaDesempenho>
						<PoliticaContratacaoSeguro xsi:nil="true"/>
					</ImoveisRendaConstrucao>
					<ImoveisVendaAcabados>
						<LstImovVendaAcabados>
							<Imovel>
								<Nome>Conjunto 217B Lagoa Torre B</Nome>
								<Endereco>Rodovia SC 401</Endereco>
								<Area>61.78</Area>
								<NumUnidades>1</NumUnidades>
								<OutrasCaractRelevantes>Conjunto Comercial. Objeto da matrícula 157.278 do 2º ofício do registro de imóveis do estado de Santa Catarina</OutrasCaractRelevantes>
								<PercentTotalInvestido>1</PercentTotalInvestido>
							</Imovel>
						</LstImovVendaAcabados>
						<PoliticaContratacaoSeguro>não há política específica. Como o imóvel é parte integrante de um condomínío, há seguro contra incêndio para os conjuntos do condomínio.</PoliticaContratacaoSeguro>
					</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>
				</AcoesSocFII>
				<CotasSocFII>
				</CotasSocFII>
				<FIA>
				</FIA>
				<FIP>
				</FIP>
				<FIDC>
				</FIDC>
				<OutrasCotasFI>
				</OutrasCotasFI>
				<OutrosAtivosFinanceiros>
					<Ativo>
						<Emissor>Aplicação Banco Itaú Trust DI</Emissor>
						<CNPJ>60701190000104</CNPJ>
						<NomeAtivo>CDB</NomeAtivo>
						<Quantidade>3372.56658</Quantidade>
						<Valor>1563354.6</Valor>
					</Ativo>
					<Ativo>
						<Emissor>Aplicação Banco Itaú Highgrade</Emissor>
						<CNPJ>60701190000104</CNPJ>
						<NomeAtivo>CDB</NomeAtivo>
						<Quantidade>3554.26</Quantidade>
						<Valor>189812.12</Valor>
					</Ativo>
				</OutrosAtivosFinanceiros>
			</AtivosFinanceiros>
			<AtivosNecessidadeLiquidez>
				<Disponibilidades>805.41</Disponibilidades>
				<TitulosPublicos xsi:nil="true"/>
				<TitulosPrivados xsi:nil="true"/>
				<FundosRendaFixa>1753166.72</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="4019475.58" financeiro="3490577.74"/>
					<DespManutencaoConservacao contabil="-9999.99" financeiro="-9999.99"/>
					<ReceitasVenda contabil="0" financeiro="0"/>
					<CustoPropriedadesVendidas contabil="0" financeiro="0"/>
					<AjusteValor contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="-316102" financeiro="-316102"/>
					<ResultadoLiquido contabil="3693373.59" financeiro="3164475.75"/>
				</PropriedadesInvest>
				<TVM>
					<ReceitasJuros contabil="1632.22" financeiro="0"/>
					<AjusteValor contabil="0" financeiro="0"/>
					<ResultadoVenda contabil="0" financeiro="0"/>
					<OutrasRecOuDesp contabil="0" financeiro="0"/>
					<ResultadoLiquido contabil="1632.22" financeiro="0"/>
				</TVM>
				<ResultadoLiquidoTotal contabil="3695005.81" financeiro="3164475.75"/>
			</AtivosImobiliarios>
			<RecursosLiquidez>
				<ReceitasJurosAplicacoes contabil="55948.95" financeiro="55948.95"/>
				<AjusteValorAplicacoes contabil="0" financeiro="0"/>
				<ResultadoVendaAplicacoes contabil="0" financeiro="0"/>
				<OutrasRecOuDespAplicacoes contabil="0" financeiro="0"/>
				<ResultadoLiquido contabil="55948.95" financeiro="55948.95"/>
			</RecursosLiquidez>
			<ResultadoLiquidoDerivativos/>
			<OutrasReceitasDespesas>
				<TaxaAdministracao contabil="-151281.94" financeiro="-142825.07"/>
				<TaxaDesempenho/>
				<ConsultoriaEspecializada/>
				<EmpresaEspecializada/>
				<FormadorMercado/>
				<CustodiaTitulosValores/>
				<AuditoriaIndependente contabil="-6125" financeiro="-6125"/>
				<RepresentantesCotistas/>
				<TaxasImpostosContribuicoes contabil="-19125.01" financeiro="-19125.01"/>
				<ComissoesEmolumentos/>
				<HonorariosDespesasDefesas contabil="-16050" financeiro="-16050"/>
				<GastosContratosSeguros/>
				<DespesasAvaliacoes contabil="-10500" financeiro="-10500"/>
				<TaxasIngressoSaidaFundos/>
				<DespesasRegistroCartorio contabil="0" financeiro="0"/>
				<OutrasRecOuDesp contabil="-74860.71" financeiro="-82456.59"/>
				<Total contabil="-277942.66" financeiro="-277081.67"/>
			</OutrasReceitasDespesas>
			<ResultadoTrimestralLiquido contabil="3473012.1" financeiro="2943343.03"/>
		</DemonstracoesContabilFinanc>
		<DistrResultadoAcumulado>
			<ResultadoFinanLiqAcumulado>2942343.23</ResultadoFinanLiqAcumulado>
			<PercentResultFinanLiqAcumulado>2795226.0685</PercentResultFinanLiqAcumulado>
			<ParcelaDistribuidaTriSeguinte xsi:nil="true"/>
			<ParcelasRendimentosRetidos>
			</ParcelasRendimentosRetidos>
			<LucroContabil xsi:nil="true"/>
			<ResultadoFinanceiroExcedeMinimo>162766.97</ResultadoFinanceiroExcedeMinimo>
			<RendimentosDeclarados>2957993.0385</RendimentosDeclarados>
			<RendimentosPagosAntec>-1898197.33</RendimentosPagosAntec>
			<RendimentoPagar>1059795.7085</RendimentoPagar>
			<ResultadoLiquidoDeclarado>1.005319</ResultadoLiquidoDeclarado>
		</DistrResultadoAcumulado>
	</InformeTrimestral>
</DadosEconomicoFinanceiros>
"