Auto merge of #155283 - jieyouxu:revert-gnullvm-link-shared-stable, r=Mark-Simulacrum

[stable] Revert "Build shared LLVM lib for windows-gnullvm" This reverts commit 1d1280a. Looks like this causes problems (rust-lang/rust#155268) with certain LLVM bin tools not finding `libLLVM` on `*-windows-gnullvm`. This PR is a _minimal_ revert to return us to known state to alleviate time pressure to investigate.
Revert "Build shared LLVM lib for windows-gnullvm"
2026-04-14 19:55:32 +00:00 · 2026-04-14 19:48:39 +08:00 · 2026-04-13 00:01:55 +00:00 · 2026-04-12 15:51:55 -04:00 · 2026-04-12 15:51:49 -04:00 · 2026-04-12 15:50:14 -04:00
204 changed files with 2465 additions and 1733 deletions
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1267,9 +1267,9 @@ dependencies = [

 [[package]]
 name = "ena"
-version = "0.14.4"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabffdaee24bd1bf95c5ef7cec31260444317e72ea56c4c91750e8b7ee58d5f1"
+checksum = "3d248bdd43ce613d87415282f69b9bb99d947d290b10962dd6c56233312c2ad5"
 dependencies = [
 "log",
 ]
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -1,3 +1,263 @@
+Version 1.95 (2026-04-16)
+==========================
+
+<a id="1.95-Language"></a>
+
+Language
+--------
+- [Stabilize `if let` guards on match arms](https://github.com/rust-lang/rust/pull/141295)
+- [`irrefutable_let_patterns` lint no longer lints on let chains](https://github.com/rust-lang/rust/pull/146832)
+- [Support importing path-segment keywords with renaming](https://github.com/rust-lang/rust/pull/146972)
+- [Stabilize inline assembly for PowerPC and PowerPC64](https://github.com/rust-lang/rust/pull/147996)
+- [const-eval: be more consistent in the behavior of padding during typed copies](https://github.com/rust-lang/rust/pull/148967)
+- [Const blocks are no longer evaluated to determine if expressions involving fallible operations can implicitly be constant-promoted.](https://github.com/rust-lang/rust/pull/150557). Expressions whose ability to implicitly be promoted would depend on the result of a const block are no longer implicitly promoted.
+- [Make operational semantics of pattern matching independent of crate and module](https://github.com/rust-lang/rust/pull/150681)
+
+
+<a id="1.95-Compiler"></a>
+
+Compiler
+--------
+- [Stabilize `--remap-path-scope` for controlling the scoping of how paths get remapped in the resulting binary](https://github.com/rust-lang/rust/pull/147611)
+
+
+<a id="1.95-Platform-Support"></a>
+
+Platform Support
+----------------
+- [Promote `powerpc64-unknown-linux-musl` to Tier 2 with host tools](https://github.com/rust-lang/rust/pull/149962)
+- [Promote `aarch64-apple-tvos` to Tier 2](https://github.com/rust-lang/rust/pull/152021)
+- [Promote `aarch64-apple-tvos-sim` to Tier 2](https://github.com/rust-lang/rust/pull/152021)
+- [Promote `aarch64-apple-watchos` to Tier 2](https://github.com/rust-lang/rust/pull/152021)
+- [Promote `aarch64-apple-watchos-sim` to Tier 2](https://github.com/rust-lang/rust/pull/152021)
+- [Promote `aarch64-apple-visionos` to Tier 2](https://github.com/rust-lang/rust/pull/152021)
+- [Promote `aarch64-apple-visionos-sim` to Tier 2](https://github.com/rust-lang/rust/pull/152021)
+
+
+Refer to Rust's [platform support page][platform-support-doc]
+for more information on Rust's tiered platform support.
+
+[platform-support-doc]: https://doc.rust-lang.org/rustc/platform-support.html
+
+<a id="1.95-Libraries"></a>
+
+Libraries
+---------
+- [`thread::scope`: document how join interacts with TLS destructors](https://github.com/rust-lang/rust/pull/149482)
+- [Speed up `str::contains` on aarch64 targets with `neon` target feature enabled by default](https://github.com/rust-lang/rust/pull/152176)
+
+
+<a id="1.95-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`MaybeUninit<[T; N]>: From<[MaybeUninit<T>; N]>`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#impl-From%3CMaybeUninit%3C%5BT;+N%5D%3E%3E-for-%5BMaybeUninit%3CT%3E;+N%5D)
+- [`MaybeUninit<[T; N]>: AsRef<[MaybeUninit<T>; N]>`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#impl-AsRef%3C%5BMaybeUninit%3CT%3E;+N%5D%3E-for-MaybeUninit%3C%5BT;+N%5D%3E)
+- [`MaybeUninit<[T; N]>: AsRef<[MaybeUninit<T>]>`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#impl-AsRef%3C%5BMaybeUninit%3CT%3E%5D%3E-for-MaybeUninit%3C%5BT;+N%5D%3E)
+- [`MaybeUninit<[T; N]>: AsMut<[MaybeUninit<T>; N]>`](https://doc.rust-lang.org/beta/std/mem/union.MaybeUninit.html#impl-AsMut%3C%5BMaybeUninit%3CT%3E;+N%5D%3E-for-MaybeUninit%3C%5BT;+N%5D%3E)
+- [`MaybeUninit<[T; N]>: AsMut<[MaybeUninit<T>]>`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#impl-AsMut%3C%5BMaybeUninit%3CT%3E%5D%3E-for-MaybeUninit%3C%5BT;+N%5D%3E)
+- [`[MaybeUninit<T>; N]: From<MaybeUninit<[T; N]>>`](https://doc.rust-lang.org/stable/std/mem/union.MaybeUninit.html#impl-From%3C%5BMaybeUninit%3CT%3E;+N%5D%3E-for-MaybeUninit%3C%5BT;+N%5D%3E)
+- [`Cell<[T; N]>: AsRef<[Cell<T>; N]>`](https://doc.rust-lang.org/stable/std/cell/struct.Cell.html#impl-AsRef%3C%5BCell%3CT%3E;+N%5D%3E-for-Cell%3C%5BT;+N%5D%3E)
+- [`Cell<[T; N]>: AsRef<[Cell<T>]>`](https://doc.rust-lang.org/stable/std/cell/struct.Cell.html#impl-AsRef%3C%5BCell%3CT%3E%5D%3E-for-Cell%3C%5BT;+N%5D%3E)
+- [`Cell<[T]>: AsRef<[Cell<T>]>`](https://doc.rust-lang.org/stable/std/cell/struct.Cell.html#impl-AsRef%3C%5BCell%3CT%3E%5D%3E-for-Cell%3C%5BT%5D%3E)
+- [`bool: TryFrom<{integer}>`](https://doc.rust-lang.org/stable/std/primitive.bool.html#impl-TryFrom%3Cu128%3E-for-bool)
+- [`AtomicPtr::update`](https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicPtr.html#method.update)
+- [`AtomicPtr::try_update`](https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicPtr.html#method.try_update)
+- [`AtomicBool::update`](https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicBool.html#method.update)
+- [`AtomicBool::try_update`](https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicBool.html#method.try_update)
+- [`AtomicIn::update`](https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicIsize.html#method.update)
+- [`AtomicIn::try_update`](https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicIsize.html#method.try_update)
+- [`AtomicUn::update`](https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicUsize.html#method.update)
+- [`AtomicUn::try_update`](https://doc.rust-lang.org/stable/std/sync/atomic/struct.AtomicUsize.html#method.try_update)
+- [`cfg_select!`](https://doc.rust-lang.org/stable/std/macro.cfg_select.html)
+- [`mod core::range`](https://doc.rust-lang.org/stable/core/range/index.html)
+- [`core::range::RangeInclusive`](https://doc.rust-lang.org/stable/core/range/struct.RangeInclusive.html)
+- [`core::range::RangeInclusiveIter`](https://doc.rust-lang.org/stable/core/range/struct.RangeInclusiveIter.html)
+- [`core::hint::cold_path`](https://doc.rust-lang.org/stable/core/hint/fn.cold_path.html)
+- [`<*const T>::as_ref_unchecked`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.as_ref_unchecked)
+- [`<*mut T>::as_ref_unchecked`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.as_ref_unchecked-1)
+- [`<*mut T>::as_mut_unchecked`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.as_mut_unchecked)
+
+
+These previously stable APIs are now stable in const contexts:
+
+- [`fmt::from_fn`](https://doc.rust-lang.org/stable/std/fmt/fn.from_fn.html)
+- [`ControlFlow::is_break`](https://doc.rust-lang.org/stable/core/ops/enum.ControlFlow.html#method.is_break)
+- [`ControlFlow::is_continue`](https://doc.rust-lang.org/stable/core/ops/enum.ControlFlow.html#method.is_continue)
+
+
+<a id="1.95-Cargo"></a>
+
+Cargo
+-----
+- [docs(report): enhance man pages for `cargo report *`](https://github.com/rust-lang/cargo/pull/16430/)<a id="1.95-Rustdoc"></a>
+
+Rustdoc
+-----
+- [In search results, rank unstable items lower](https://github.com/rust-lang/rust/pull/149460)
+- [Add new "hide deprecated items" setting in rustdoc](https://github.com/rust-lang/rust/pull/151091)
+<a id="1.95-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [Array coercions may now result in less inference constraints than before](https://github.com/rust-lang/rust/pull/140283)
+- Importing `$crate` without renaming, i.e. `use $crate::{self};`, is now no longer permitted due to stricter error checking for `self` imports.
+- [const-eval: be more consistent in the behavior of padding during typed copies.](https://github.com/rust-lang/rust/pull/148967)
+  In very rare cases, this may cause compilation errors due to bytes from parts of a pointer ending up in the padding bytes of a `const` or `static`.
+- [A future-incompatibility warning lint `ambiguous_glob_imported_traits` is now reported when using an ambiguously glob imported trait](https://github.com/rust-lang/rust/pull/149058)
+- [Check lifetime bounds of types mentioning only type parameters](https://github.com/rust-lang/rust/pull/149389)
+- [Report more visibility-related ambiguous import errors](https://github.com/rust-lang/rust/pull/149596)
+- [Deprecate `Eq::assert_receiver_is_total_eq` and emit future compatibility warnings on manual impls](https://github.com/rust-lang/rust/pull/149978)
+- [powerpc64: Use the ELF ABI version set in target spec instead of guessing](https://github.com/rust-lang/rust/pull/150468) (fixes the ELF ABI used by the OpenBSD target)
+- Matching on a `#[non_exhaustive]` enum [now reads the discriminant, even if the enum has only one variant](https://github.com/rust-lang/rust/pull/150681). This can cause closures to capture values that they previously wouldn't.
+- `mut ref` and `mut ref mut` patterns, part of the unstable [Match Ergonomics 2024 RFC](https://github.com/rust-lang/rust/issues/123076), were accidentally allowed on stable within struct pattern field shorthand. These patterns are now correctly feature-gated as unstable in this position.
+- [Add future-compatibility warning for derive helper attributes which conflict with built-in attributes](https://github.com/rust-lang/rust/pull/151152)
+- [JSON target specs](https://doc.rust-lang.org/rustc/targets/custom.html) have been destabilized and now require `-Z unstable-options` to use. Previously, they could not be used without the standard library, which has no stable build mechanism. In preparation for the `build-std` project adding that support, JSON target specs are being proactively gated to ensure they remain unstable even if `build-std` is stabilized. Cargo now includes the `-Z json-target-spec` CLI flag to automatically pass `-Z unstable-options` to the compiler when needed. See [#150151](https://github.com/rust-lang/rust/pull/150151), [#151534](https://github.com/rust-lang/rust/pull/150151), and [rust-lang/cargo#16557](https://github.com/rust-lang/cargo/pull/16557).
+- [The arguments of `#[feature]` attributes on invalid targets are now checked](https://github.com/rust-lang/rust/issues/153764)
+
+
+<a id="1.95-Internal-Changes"></a>
+
+Internal Changes
+----------------
+
+These changes do not affect any public interfaces of Rust, but they represent
+significant improvements to the performance or internals of rustc and related
+tools.
+
+- [Update to LLVM 22](https://github.com/rust-lang/rust/pull/150722)
+
+
+Version 1.94.1 (2026-03-26)
+===========================
+
+<a id="1.94.1"></a>
+
+* [Fix `std::thread::spawn` on wasm32-wasip1-threads](https://github.com/rust-lang/rust/pull/153634)
+* [Remove new methods added to `std::os::windows::fs::OpenOptionsExt`](https://github.com/rust-lang/rust/pull/153491)
+  The new methods were unstable, but the trait itself is not sealed and so
+  cannot be extended with non-default methods.
+* [Clippy: fix ICE in `match_same_arms`](https://github.com/rust-lang/rust-clippy/pull/16685)
+* [Cargo: update tar to 0.4.45](https://github.com/rust-lang/cargo/pull/16769)
+  This resolves CVE-2026-33055 and CVE-2026-33056. Users of crates.io are not affected.
+  See [blog](https://blog.rust-lang.org/2026/03/21/cve-2026-33056/) for more details.
+
+Version 1.94.0 (2026-03-05)
+==========================
+
+<a id="1.94.0-Language"></a>
+
+Language
+--------
+- [Impls and impl items inherit `dead_code` lint level of the corresponding traits and trait items](https://github.com/rust-lang/rust/pull/144113)
+- [Stabilize additional 29 RISC-V target features including large portions of the RVA22U64 / RVA23U64 profiles](https://github.com/rust-lang/rust/pull/145948)
+- [Add warn-by-default `unused_visibilities` lint for visibility on `const _` declarations](https://github.com/rust-lang/rust/pull/147136)
+- [Update to Unicode 17](https://github.com/rust-lang/rust/pull/148321)
+- [Avoid incorrect lifetime errors for closures](https://github.com/rust-lang/rust/pull/148329)
+
+<a id="1.94.0-Platform-Support"></a>
+
+Platform Support
+----------------
+
+- [Add `riscv64im-unknown-none-elf` as a tier 3 target](https://github.com/rust-lang/rust/pull/148790)
+
+Refer to Rust's [platform support page][platform-support-doc]
+for more information on Rust's tiered platform support.
+
+[platform-support-doc]: https://doc.rust-lang.org/rustc/platform-support.html
+
+<a id="1.94.0-Libraries"></a>
+
+Libraries
+---------
+
+- [Relax `T: Ord` bound for some `BinaryHeap<T>` methods.](https://github.com/rust-lang/rust/pull/149408)
+
+<a id="1.94.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`<[T]>::array_windows`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.array_windows)
+- [`<[T]>::element_offset`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.element_offset)
+- [`LazyCell::get`](https://doc.rust-lang.org/stable/std/cell/struct.LazyCell.html#method.get)
+- [`LazyCell::get_mut`](https://doc.rust-lang.org/stable/std/cell/struct.LazyCell.html#method.get_mut)
+- [`LazyCell::force_mut`](https://doc.rust-lang.org/stable/std/cell/struct.LazyCell.html#method.force_mut)
+- [`LazyLock::get`](https://doc.rust-lang.org/stable/std/sync/struct.LazyLock.html#method.get)
+- [`LazyLock::get_mut`](https://doc.rust-lang.org/stable/std/sync/struct.LazyLock.html#method.get_mut)
+- [`LazyLock::force_mut`](https://doc.rust-lang.org/stable/std/sync/struct.LazyLock.html#method.force_mut)
+- [`impl TryFrom<char> for usize`](https://doc.rust-lang.org/stable/std/convert/trait.TryFrom.html#impl-TryFrom%3Cchar%3E-for-usize)
+- [`std::iter::Peekable::next_if_map`](https://doc.rust-lang.org/stable/std/iter/struct.Peekable.html#method.next_if_map)
+- [`std::iter::Peekable::next_if_map_mut`](https://doc.rust-lang.org/stable/std/iter/struct.Peekable.html#method.next_if_map_mut)
+- [x86 `avx512fp16` intrinsics](https://github.com/rust-lang/rust/issues/127213)
+  (excluding those that depend directly on the unstable `f16` type)
+- [AArch64 NEON fp16 intrinsics](https://github.com/rust-lang/rust/issues/136306)
+  (excluding those that depend directly on the unstable `f16` type)
+- [`f32::consts::EULER_GAMMA`](https://doc.rust-lang.org/stable/std/f32/consts/constant.EULER_GAMMA.html)
+- [`f64::consts::EULER_GAMMA`](https://doc.rust-lang.org/stable/std/f64/consts/constant.EULER_GAMMA.html)
+- [`f32::consts::GOLDEN_RATIO`](https://doc.rust-lang.org/stable/std/f32/consts/constant.GOLDEN_RATIO.html)
+- [`f64::consts::GOLDEN_RATIO`](https://doc.rust-lang.org/stable/std/f64/consts/constant.GOLDEN_RATIO.html)
+
+
+These previously stable APIs are now stable in const contexts:
+
+- [`f32::mul_add`](https://doc.rust-lang.org/stable/std/primitive.f32.html#method.mul_add)
+- [`f64::mul_add`](https://doc.rust-lang.org/stable/std/primitive.f64.html#method.mul_add)
+
+
+<a id="1.94.0-Cargo"></a>
+
+Cargo
+-----
+
+- Stabilize the config include key. The top-level include config key allows loading additional config files, enabling better organization, sharing, and management of Cargo configurations across projects and environments. [docs](https://doc.rust-lang.org/nightly/cargo/reference/config.html#including-extra-configuration-files) [#16284](https://github.com/rust-lang/cargo/pull/16284)
+- Stabilize the pubtime field in registry index. This records when a crate version was published and enables time-based dependency resolution in the future. Note that crates.io will gradually backfill existing packages when a new version is published. Not all crates have pubtime yet. [#16369](https://github.com/rust-lang/cargo/pull/16369) [#16372](https://github.com/rust-lang/cargo/pull/16372)
+- Cargo now parses [TOML v1.1](https://toml.io/en/v1.1.0) for manifests and configuration files. Note that using these features in Cargo.toml will raise your development MSRV, but the published manifest remains compatible with older parsers. [#16415](https://github.com/rust-lang/cargo/pull/16415)
+- [Make `CARGO_BIN_EXE_<crate>` available at runtime ](https://github.com/rust-lang/cargo/pull/16421/)
+
+<a id="1.94.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [Forbid freely casting lifetime bounds of `dyn`-types](https://github.com/rust-lang/rust/pull/136776)
+- [Make closure capturing have consistent and correct behaviour around patterns](https://github.com/rust-lang/rust/pull/138961)
+  Some finer details of how precise closure captures get affected by pattern matching have been changed. In some cases, this can cause a non-move closure that was previously capturing an entire variable by move, to now capture only part of that variable by move, and other parts by borrow. This can cause the borrow checker to complain where it previously didn't, or cause `Drop` to run at a different point in time.
+- [Standard library macros are now imported via prelude, not via injected `#[macro_use]`](https://github.com/rust-lang/rust/pull/139493)
+  This will raise an error if macros of the same name are glob imported.
+  For example if a crate defines their own `matches` macro and then glob imports that,
+  it's now ambiguous whether the custom or standard library `matches` is meant and
+  an explicit import of the name is required to resolve the ambiguity.
+  One exception is `core::panic` and `std::panic`, if their import is ambiguous
+  a new warning ([`ambiguous_panic_imports`](https://github.com/rust-lang/rust/issues/147319)) is raised.
+  This may raise a new warning ([`ambiguous_panic_imports`](https://github.com/rust-lang/rust/issues/147319)) on `#![no_std]` code glob importing the std crate.
+  Both `core::panic!` and `std::panic!` are then in scope and which is used is ambiguous.
+- [Don't strip shebang in expression-context `include!(…)`s](https://github.com/rust-lang/rust/pull/146377)
+  This can cause previously working includes to no longer compile if they included files which started with a shebang.
+- [Ambiguous glob reexports are now also visible cross-crate](https://github.com/rust-lang/rust/pull/147984)
+  This unifies behavior between local and cross-crate errors on these exports, which may introduce new ambiguity errors.
+- [Don't normalize where-clauses before checking well-formedness](https://github.com/rust-lang/rust/pull/148477)
+- [Introduce a future compatibility warning on codegen attributes on body-free trait methods](https://github.com/rust-lang/rust/pull/148756)
+  These attributes currently have no effect in this position.
+- [On Windows `std::time::SystemTime::checked_sub_duration` will return `None` for times before the Windows epoch (1/1/1601)](https://github.com/rust-lang/rust/pull/148825)
+- [Lifetime identifiers such as `'a` are now NFC normalized](https://github.com/rust-lang/rust/pull/149192).
+- [Overhaul filename handling for cross-compiler consistency](https://github.com/rust-lang/rust/pull/149709)
+  Any paths emitted by compiler now always respect the relative-ness of the paths and `--remap-path-prefix` given originally.
+  One side-effect of this change is that paths emitted for local crates in Cargo (path dependencies and workspace members) are no longer absolute but relative when emitted as part of a diagnostic in a downstream crate.
+
+<a id="1.94.0-Internal-Changes"></a>
+
+Internal Changes
+----------------
+
+These changes do not affect any public interfaces of Rust, but they represent
+significant improvements to the performance or internals of rustc and related
+tools.
+
+- [Switch to `annotate-snippets` for error emission](https://github.com/rust-lang/rust/pull/150032)
+  This should preserve mostly the same outputs in rustc error messages.
+
 Version 1.93.1 (2026-02-12)
 ===========================

--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1,5 +1,5 @@
 // tidy-alphabetical-start
-#![cfg_attr(all(feature = "nightly", bootstrap, test), feature(assert_matches))]
+#![cfg_attr(all(feature = "nightly", test), feature(assert_matches))]
 #![cfg_attr(feature = "nightly", allow(internal_features))]
 #![cfg_attr(feature = "nightly", feature(rustc_attrs))]
 #![cfg_attr(feature = "nightly", feature(step_trait))]
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -2,8 +2,8 @@

 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(default_field_values)]
 #![feature(file_buffered)]
--- a/compiler/rustc_builtin_macros/src/lib.rs
+++ b/compiler/rustc_builtin_macros/src/lib.rs
@@ -3,8 +3,8 @@

 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(decl_macro)]
 #![feature(iter_order_by)]
--- a/compiler/rustc_codegen_gcc/src/builder.rs
+++ b/compiler/rustc_codegen_gcc/src/builder.rs
@@ -1655,10 +1655,6 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
        unimplemented!();
    }

-    fn get_funclet_cleanuppad(&self, _funclet: &Funclet) -> RValue<'gcc> {
-        unimplemented!();
-    }
-
    // Atomic Operations
    fn atomic_cmpxchg(
        &mut self,
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -1296,10 +1296,6 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
        ret
    }

-    fn get_funclet_cleanuppad(&self, funclet: &Funclet<'ll>) -> &'ll Value {
-        funclet.cleanuppad()
-    }
-
    // Atomic Operations
    fn atomic_cmpxchg(
        &mut self,
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -5,8 +5,8 @@
 //! This API is completely unstable and subject to change.

 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(extern_types)]
 #![feature(file_buffered)]
 #![feature(impl_trait_in_assoc_type)]
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -702,7 +702,9 @@ pub(crate) fn global_llvm_features(sess: &Session, only_base_features: bool) ->

                features_string
            };
-            features.extend(features_string.split(',').map(String::from));
+            if !features_string.is_empty() {
+                features.extend(features_string.split(',').map(String::from));
+            }
        }
        Some(_) | None => {}
    };
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -1,6 +1,6 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(file_buffered)]
 #![feature(negative_impls)]
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -215,18 +215,19 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
            mir::UnwindAction::Continue => None,
            mir::UnwindAction::Unreachable => None,
            mir::UnwindAction::Terminate(reason) => {
-                if fx.mir[self.bb].is_cleanup && base::wants_wasm_eh(fx.cx.tcx().sess) {
-                    // For wasm, we need to generate a nested `cleanuppad within %outer_pad`
-                    // to catch exceptions during cleanup and call `panic_in_cleanup`.
-                    Some(fx.terminate_block(reason, Some(self.bb)))
-                } else if fx.mir[self.bb].is_cleanup
-                    && base::wants_new_eh_instructions(fx.cx.tcx().sess)
-                {
+                if fx.mir[self.bb].is_cleanup && base::wants_new_eh_instructions(fx.cx.tcx().sess) {
                    // MSVC SEH will abort automatically if an exception tries to
                    // propagate out from cleanup.
+
+                    // FIXME(@mirkootter): For wasm, we currently do not support terminate during
+                    // cleanup, because this requires a few more changes: The current code
+                    // caches the `terminate_block` for each function; funclet based code - however -
+                    // requires a different terminate_block for each funclet
+                    // Until this is implemented, we just do not unwind inside cleanup blocks
+
                    None
                } else {
-                    Some(fx.terminate_block(reason, None))
+                    Some(fx.terminate_block(reason))
                }
            }
        };
@@ -238,7 +239,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {

        if let Some(unwind_block) = unwind_block {
            let ret_llbb = if let Some((_, target)) = destination {
-                self.llbb_with_cleanup(fx, target)
+                fx.llbb(target)
            } else {
                fx.unreachable_block()
            };
@@ -309,7 +310,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
    ) -> MergingSucc {
        let unwind_target = match unwind {
            mir::UnwindAction::Cleanup(cleanup) => Some(self.llbb_with_cleanup(fx, cleanup)),
-            mir::UnwindAction::Terminate(reason) => Some(fx.terminate_block(reason, None)),
+            mir::UnwindAction::Terminate(reason) => Some(fx.terminate_block(reason)),
            mir::UnwindAction::Continue => None,
            mir::UnwindAction::Unreachable => None,
        };
@@ -317,7 +318,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
        if operands.iter().any(|x| matches!(x, InlineAsmOperandRef::Label { .. })) {
            assert!(unwind_target.is_none());
            let ret_llbb = if let Some(target) = destination {
-                self.llbb_with_cleanup(fx, target)
+                fx.llbb(target)
            } else {
                fx.unreachable_block()
            };
@@ -334,7 +335,7 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
            MergingSucc::False
        } else if let Some(cleanup) = unwind_target {
            let ret_llbb = if let Some(target) = destination {
-                self.llbb_with_cleanup(fx, target)
+                fx.llbb(target)
            } else {
                fx.unreachable_block()
            };
@@ -1915,39 +1916,8 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
        })
    }

-    fn terminate_block(
-        &mut self,
-        reason: UnwindTerminateReason,
-        outer_catchpad_bb: Option<mir::BasicBlock>,
-    ) -> Bx::BasicBlock {
-        // mb_funclet_bb should be present if and only if the target is wasm and
-        // we're terminating because of an unwind in a cleanup block. In that
-        // case we have nested funclets and the inner catch_switch needs to know
-        // what outer catch_pad it is contained in.
-        debug_assert!(
-            outer_catchpad_bb.is_some()
-                == (base::wants_wasm_eh(self.cx.tcx().sess)
-                    && reason == UnwindTerminateReason::InCleanup)
-        );
-
-        // When we aren't in a wasm InCleanup block, there's only one terminate
-        // block needed so we cache at START_BLOCK index.
-        let mut cache_bb = mir::START_BLOCK;
-        // In wasm eh InCleanup, use the outer funclet's cleanup BB as the cache
-        // key.
-        if let Some(outer_bb) = outer_catchpad_bb {
-            let cleanup_kinds =
-                self.cleanup_kinds.as_ref().expect("cleanup_kinds required for funclets");
-            cache_bb = cleanup_kinds[outer_bb]
-                .funclet_bb(outer_bb)
-                .expect("funclet_bb should be in a funclet");
-
-            // Ensure the outer funclet is created first
-            if self.funclets[cache_bb].is_none() {
-                self.landing_pad_for(cache_bb);
-            }
-        }
-        if let Some((cached_bb, cached_reason)) = self.terminate_blocks[cache_bb]
+    fn terminate_block(&mut self, reason: UnwindTerminateReason) -> Bx::BasicBlock {
+        if let Some((cached_bb, cached_reason)) = self.terminate_block
            && reason == cached_reason
        {
            return cached_bb;
@@ -1985,35 +1955,12 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
            //      cp_terminate:
            //         %cp = catchpad within %cs [null, i32 64, null]
            //         ...
-            //
-            // By contrast, on WebAssembly targets, we specifically _do_ want to
-            // catch foreign exceptions. The situation with MSVC is a
-            // regrettable hack which we don't want to extend to other targets
-            // unless necessary. For WebAssembly, to generate catch(...) and
-            // catch only C++ exception instead of generating a catch_all, we
-            // need to call the intrinsics @llvm.wasm.get.exception and
-            // @llvm.wasm.get.ehselector in the catch pad. Since we don't do
-            // this, we generate a catch_all. We originally got this behavior
-            // by accident but it luckily matches our intention.

            llbb = Bx::append_block(self.cx, self.llfn, "cs_terminate");
+            let cp_llbb = Bx::append_block(self.cx, self.llfn, "cp_terminate");

            let mut cs_bx = Bx::build(self.cx, llbb);
-
-            // For wasm InCleanup blocks, our catch_switch is nested within the
-            // outer catchpad, so we need to provide it as the parent value to
-            // catch_switch.
-            let mut outer_cleanuppad = None;
-            if outer_catchpad_bb.is_some() {
-                // Get the outer funclet's catchpad
-                let outer_funclet = self.funclets[cache_bb]
-                    .as_ref()
-                    .expect("landing_pad_for didn't create funclet");
-                outer_cleanuppad = Some(cs_bx.get_funclet_cleanuppad(outer_funclet));
-            }
-            let cp_llbb = Bx::append_block(self.cx, self.llfn, "cp_terminate");
-            let cs = cs_bx.catch_switch(outer_cleanuppad, None, &[cp_llbb]);
-            drop(cs_bx);
+            let cs = cs_bx.catch_switch(None, None, &[cp_llbb]);

            bx = Bx::build(self.cx, cp_llbb);
            let null =
@@ -2034,18 +1981,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
            } else {
                // Specifying more arguments than necessary usually doesn't
                // hurt, but the `WasmEHPrepare` LLVM pass does not recognize
-                // anything other than a single `null` as a `catch_all` block,
+                // anything other than a single `null` as a `catch (...)` block,
                // leading to problems down the line during instruction
                // selection.
                &[null] as &[_]
            };

            funclet = Some(bx.catch_pad(cs, args));
-            // On wasm, if we wanted to generate a catch(...) and only catch C++
-            // exceptions, we'd call @llvm.wasm.get.exception and
-            // @llvm.wasm.get.ehselector selectors here. We want a catch_all so
-            // we leave them out. This is intentionally diverging from the MSVC
-            // behavior.
        } else {
            llbb = Bx::append_block(self.cx, self.llfn, "terminate");
            bx = Bx::build(self.cx, llbb);
@@ -2071,7 +2013,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {

        bx.unreachable();

-        self.terminate_blocks[cache_bb] = Some((llbb, reason));
+        self.terminate_block = Some((llbb, reason));
        llbb
    }

--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -90,11 +90,8 @@ pub struct FunctionCx<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {
    /// Cached unreachable block
    unreachable_block: Option<Bx::BasicBlock>,

-    /// Cached terminate upon unwinding block and its reason. For non-wasm
-    /// targets, there is at most one such block per function, stored at index
-    /// `START_BLOCK`. For wasm targets, each funclet needs its own terminate
-    /// block, indexed by the cleanup block that is the funclet's head.
-    terminate_blocks: IndexVec<mir::BasicBlock, Option<(Bx::BasicBlock, UnwindTerminateReason)>>,
+    /// Cached terminate upon unwinding block and its reason
+    terminate_block: Option<(Bx::BasicBlock, UnwindTerminateReason)>,

    /// A bool flag for each basic block indicating whether it is a cold block.
    /// A cold block is a block that is unlikely to be executed at runtime.
@@ -230,7 +227,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
        personality_slot: None,
        cached_llbbs,
        unreachable_block: None,
-        terminate_blocks: IndexVec::from_elem(None, &mir.basic_blocks),
+        terminate_block: None,
        cleanup_kinds,
        landing_pads: IndexVec::from_elem(None, &mir.basic_blocks),
        funclets: IndexVec::from_fn_n(|_| None, mir.basic_blocks.len()),
--- a/compiler/rustc_codegen_ssa/src/traits/builder.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/builder.rs
@@ -552,12 +552,12 @@ pub trait BuilderMethods<'a, 'tcx>:

    fn set_personality_fn(&mut self, personality: Self::Function);

-    // These are used by everyone except msvc and wasm EH
+    // These are used by everyone except msvc
    fn cleanup_landing_pad(&mut self, pers_fn: Self::Function) -> (Self::Value, Self::Value);
    fn filter_landing_pad(&mut self, pers_fn: Self::Function);
    fn resume(&mut self, exn0: Self::Value, exn1: Self::Value);

-    // These are used by msvc and wasm EH
+    // These are used only by msvc
    fn cleanup_pad(&mut self, parent: Option<Self::Value>, args: &[Self::Value]) -> Self::Funclet;
    fn cleanup_ret(&mut self, funclet: &Self::Funclet, unwind: Option<Self::BasicBlock>);
    fn catch_pad(&mut self, parent: Self::Value, args: &[Self::Value]) -> Self::Funclet;
@@ -567,7 +567,6 @@ pub trait BuilderMethods<'a, 'tcx>:
        unwind: Option<Self::BasicBlock>,
        handlers: &[Self::BasicBlock],
    ) -> Self::Value;
-    fn get_funclet_cleanuppad(&self, funclet: &Self::Funclet) -> Self::Value;

    fn atomic_cmpxchg(
        &mut self,
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -1,7 +1,7 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
 #![feature(array_try_map)]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(decl_macro)]
 #![feature(never_type)]
--- a/compiler/rustc_data_structures/Cargo.toml
+++ b/compiler/rustc_data_structures/Cargo.toml
@@ -9,7 +9,7 @@ arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 either = "1.0"
 elsa = "1.11.0"
-ena = "0.14.4"
+ena = "0.14.3"
 indexmap = "2.12.1"
 jobserver_crate = { version = "0.1.28", package = "jobserver" }
 measureme = "12.0.1"
--- a/compiler/rustc_data_structures/src/lib.rs
+++ b/compiler/rustc_data_structures/src/lib.rs
@@ -10,7 +10,6 @@
 #![allow(internal_features)]
 #![allow(rustc::default_hash_types)]
 #![allow(rustc::potential_query_instability)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(cfg_select))]
 #![cfg_attr(bootstrap, feature(cold_path))]
 #![cfg_attr(test, feature(test))]
@@ -18,6 +17,7 @@
 #![feature(allocator_api)]
 #![feature(ascii_char)]
 #![feature(ascii_char_variants)]
+#![feature(assert_matches)]
 #![feature(auto_traits)]
 #![feature(const_default)]
 #![feature(const_trait_impl)]
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -5,7 +5,7 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::direct_use_of_rustc_type_ir)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
+#![feature(assert_matches)]
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]
 #![feature(default_field_values)]
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -103,7 +103,7 @@ declare_features! (
    /// Enables `#[cfg(panic = "...")]` config key.
    (accepted, cfg_panic, "1.60.0", Some(77443)),
    /// Provides a native way to easily manage multiple conditional flags without having to rewrite each clause multiple times.
-    (accepted, cfg_select, "CURRENT_RUSTC_VERSION", Some(115585)),
+    (accepted, cfg_select, "1.95.0", Some(115585)),
    /// Allows `cfg(target_abi = "...")`.
    (accepted, cfg_target_abi, "1.78.0", Some(80970)),
    /// Allows `cfg(target_feature = "...")`.
@@ -243,7 +243,7 @@ declare_features! (
    /// Allows the use of `if let` expressions.
    (accepted, if_let, "1.0.0", None),
    /// Allows `if let` guard in match arms.
-    (accepted, if_let_guard, "CURRENT_RUSTC_VERSION", Some(51114)),
+    (accepted, if_let_guard, "1.95.0", Some(51114)),
    /// Rescoping temporaries in `if let` to align with Rust 2024.
    (accepted, if_let_rescope, "1.84.0", Some(124085)),
    /// Allows top level or-patterns (`p | q`) in `if let` and `while let`.
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -103,7 +103,7 @@ declare_features! (
    (removed, default_type_parameter_fallback, "1.82.0", Some(27336),
     Some("never properly implemented; requires significant design work"), 127655),
    /// Allows using `#[deprecated_safe]` to deprecate the safeness of a function or trait
-    (removed, deprecated_safe, "CURRENT_RUSTC_VERSION", Some(94978), Some("never properly implemented, in the way of attribute refactor"), 152554),
+    (removed, deprecated_safe, "1.95.0", Some(94978), Some("never properly implemented, in the way of attribute refactor"), 152554),
    /// Allows deriving traits as per `SmartPointer` specification
    (removed, derive_smart_pointer, "1.84.0", Some(123430), Some("replaced by `CoercePointee`"), 131284),
    /// Tells rustdoc to automatically generate `#[doc(cfg(...))]`.
@@ -174,7 +174,7 @@ declare_features! (
     Some("removed due to implementation concerns as it requires significant refactorings"), 138492),
    /// A temporary feature gate used to enable parser extensions needed
    /// to bootstrap fix for #5723.
-    (removed, issue_5723_bootstrap, "CURRENT_RUSTC_VERSION", None, None),
+    (removed, issue_5723_bootstrap, "1.95.0", None, None),
    /// Lazily evaluate constants. This allows constants to depend on type parameters.
    (removed, lazy_normalization_consts, "1.56.0", Some(72219), Some("superseded by `generic_const_exprs`"), 88369),
    /// Changes `impl Trait` to capture all lifetimes in scope.
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -368,7 +368,7 @@ declare_features! (
    /// Allows `async` trait bound modifier.
    (unstable, async_trait_bounds, "1.85.0", Some(62290)),
    /// Target features on avr.
-    (unstable, avr_target_feature, "CURRENT_RUSTC_VERSION", Some(146889)),
+    (unstable, avr_target_feature, "1.95.0", Some(146889)),
    /// Allows using Intel AVX10 target features and intrinsics
    (unstable, avx10_target_feature, "1.88.0", Some(138843)),
    /// Target features on bpf.
@@ -411,9 +411,9 @@ declare_features! (
    /// Allows `async {}` expressions in const contexts.
    (unstable, const_async_blocks, "1.53.0", Some(85368)),
    /// Allows `const { ... }` as a shorthand for `const _: () = const { ... };` for module items.
-    (unstable, const_block_items, "CURRENT_RUSTC_VERSION", Some(149226)),
+    (unstable, const_block_items, "1.95.0", Some(149226)),
    /// Allows defining and calling c-variadic functions in const contexts.
-    (unstable, const_c_variadic, "CURRENT_RUSTC_VERSION", Some(151787)),
+    (unstable, const_c_variadic, "1.95.0", Some(151787)),
    /// Allows `const || {}` closures in const contexts.
    (incomplete, const_closures, "1.68.0", Some(106003)),
    /// Allows using `[const] Destruct` bounds and calling drop impls in const contexts.
@@ -487,7 +487,7 @@ declare_features! (
    /// Allows the use of `#[ffi_pure]` on foreign functions.
    (unstable, ffi_pure, "1.45.0", Some(58329)),
    /// Allows marking trait functions as `final` to prevent overriding impls
-    (unstable, final_associated_functions, "CURRENT_RUSTC_VERSION", Some(131179)),
+    (unstable, final_associated_functions, "1.95.0", Some(131179)),
    /// Controlling the behavior of fmt::Debug
    (unstable, fmt_debug, "1.82.0", Some(129709)),
    /// Allows using `#[align(...)]` on function items
@@ -554,7 +554,7 @@ declare_features! (
    /// Allows `#[marker]` on certain traits allowing overlapping implementations.
    (unstable, marker_trait_attr, "1.30.0", Some(29864)),
    /// Enable mgca `type const` syntax before expansion.
-    (incomplete, mgca_type_const_syntax, "CURRENT_RUSTC_VERSION", Some(132980)),
+    (incomplete, mgca_type_const_syntax, "1.95.0", Some(132980)),
    /// Enables the generic const args MVP (only bare paths, not arbitrary computation).
    (incomplete, min_generic_const_args, "1.84.0", Some(132980)),
    /// A minimal, sound subset of specialization intended to be used by the
@@ -600,7 +600,7 @@ declare_features! (
    /// Allows using fields with slice type in offset_of!
    (unstable, offset_of_slice, "1.81.0", Some(126151)),
    /// Allows using generics in more complex const expressions, based on definitional equality.
-    (unstable, opaque_generic_const_args, "CURRENT_RUSTC_VERSION", Some(151972)),
+    (unstable, opaque_generic_const_args, "1.95.0", Some(151972)),
    /// Allows using `#[optimize(X)]`.
    (unstable, optimize_attribute, "1.34.0", Some(54882)),
    /// Allows specifying nop padding on functions for dynamic patching.
@@ -635,7 +635,7 @@ declare_features! (
    /// Allows `extern "rust-cold"`.
    (unstable, rust_cold_cc, "1.63.0", Some(97544)),
    /// Allows `extern "rust-preserve-none"`.
-    (unstable, rust_preserve_none_cc, "CURRENT_RUSTC_VERSION", Some(151401)),
+    (unstable, rust_preserve_none_cc, "1.95.0", Some(151401)),
    /// Target features on s390x.
    (unstable, s390x_target_feature, "1.82.0", Some(150259)),
    /// Allows the use of the `sanitize` attribute.
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_trait.rs
@@ -230,8 +230,9 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                        ordered_associated_items.extend(
                            tcx.associated_items(pred.trait_ref.def_id)
                                .in_definition_order()
-                                // Only associated types & consts can possibly be constrained via a binding.
-                                .filter(|item| item.is_type() || item.is_const())
+                                // Only associated types & type consts can possibly be
+                                // constrained in a trait object type via a binding.
+                                .filter(|item| item.is_type() || item.is_type_const(tcx))
                                // Traits with RPITITs are simply not dyn compatible (for now).
                                .filter(|item| !item.is_impl_trait_in_trait())
                                .map(|item| (item.def_id, trait_ref)),
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -56,8 +56,8 @@ This API is completely unstable and subject to change.
 */

 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(default_field_values)]
 #![feature(gen_blocks)]
 #![feature(iter_intersperse)]
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -921,6 +921,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
        callee_did: DefId,
        callee_args: GenericArgsRef<'tcx>,
    ) {
+        // FIXME(const_trait_impl): We should be enforcing these effects unconditionally.
+        // This can be done as soon as we convert the standard library back to
+        // using const traits, since if we were to enforce these conditions now,
+        // we'd fail on basically every builtin trait call (i.e. `1 + 2`).
+        if !self.tcx.features().const_trait_impl() {
+            return;
+        }
+
        // If we have `rustc_do_not_const_check`, do not check `[const]` bounds.
        if self.has_rustc_attrs && find_attr!(self.tcx, self.body_id, RustcDoNotConstCheck) {
            return;
--- a/compiler/rustc_hir_typeck/src/fallback.rs
+++ b/compiler/rustc_hir_typeck/src/fallback.rs
@@ -357,6 +357,11 @@ impl<'tcx> FnCtxt<'_, 'tcx> {
        VecGraph::new(num_ty_vars, coercion_edges)
    }

+    /// If `ty` is an unresolved type variable, returns its root vid.
+    fn root_vid(&self, ty: Ty<'tcx>) -> Option<ty::TyVid> {
+        Some(self.root_var(self.shallow_resolve(ty).ty_vid()?))
+    }
+
    /// Given a set of diverging vids and coercions, walk the HIR to gather a
    /// set of suggestions which can be applied to preserve fallback to unit.
    fn try_to_suggest_annotations(
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -1,6 +1,6 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(iter_intersperse)]
 #![feature(iter_order_by)]
--- a/compiler/rustc_infer/src/infer/mod.rs
+++ b/compiler/rustc_infer/src/infer/mod.rs
@@ -1099,45 +1099,22 @@ impl<'tcx> InferCtxt<'tcx> {
                    //
                    // Note: if these two lines are combined into one we get
                    // dynamic borrow errors on `self.inner`.
-                    let (root_vid, value) =
-                        self.inner.borrow_mut().type_variables().probe_with_root_vid(v);
-                    value.known().map_or_else(
-                        || if root_vid == v { ty } else { Ty::new_var(self.tcx, root_vid) },
-                        |t| self.shallow_resolve(t),
-                    )
+                    let known = self.inner.borrow_mut().type_variables().probe(v).known();
+                    known.map_or(ty, |t| self.shallow_resolve(t))
                }

                ty::IntVar(v) => {
-                    let (root, value) =
-                        self.inner.borrow_mut().int_unification_table().inlined_probe_key_value(v);
-                    match value {
+                    match self.inner.borrow_mut().int_unification_table().probe_value(v) {
                        ty::IntVarValue::IntType(ty) => Ty::new_int(self.tcx, ty),
                        ty::IntVarValue::UintType(ty) => Ty::new_uint(self.tcx, ty),
-                        ty::IntVarValue::Unknown => {
-                            if root == v {
-                                ty
-                            } else {
-                                Ty::new_int_var(self.tcx, root)
-                            }
-                        }
+                        ty::IntVarValue::Unknown => ty,
                    }
                }

                ty::FloatVar(v) => {
-                    let (root, value) = self
-                        .inner
-                        .borrow_mut()
-                        .float_unification_table()
-                        .inlined_probe_key_value(v);
-                    match value {
+                    match self.inner.borrow_mut().float_unification_table().probe_value(v) {
                        ty::FloatVarValue::Known(ty) => Ty::new_float(self.tcx, ty),
-                        ty::FloatVarValue::Unknown => {
-                            if root == v {
-                                ty
-                            } else {
-                                Ty::new_float_var(self.tcx, root)
-                            }
-                        }
+                        ty::FloatVarValue::Unknown => ty,
                    }
                }

@@ -1151,16 +1128,13 @@ impl<'tcx> InferCtxt<'tcx> {
    pub fn shallow_resolve_const(&self, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
        match ct.kind() {
            ty::ConstKind::Infer(infer_ct) => match infer_ct {
-                InferConst::Var(vid) => {
-                    let (root, value) = self
-                        .inner
-                        .borrow_mut()
-                        .const_unification_table()
-                        .inlined_probe_key_value(vid);
-                    value.known().unwrap_or_else(|| {
-                        if root.vid == vid { ct } else { ty::Const::new_var(self.tcx, root.vid) }
-                    })
-                }
+                InferConst::Var(vid) => self
+                    .inner
+                    .borrow_mut()
+                    .const_unification_table()
+                    .probe_value(vid)
+                    .known()
+                    .unwrap_or(ct),
                InferConst::Fresh(_) => ct,
            },
            ty::ConstKind::Param(_)
@@ -1184,13 +1158,6 @@ impl<'tcx> InferCtxt<'tcx> {
        self.inner.borrow_mut().type_variables().root_var(var)
    }

-    /// If `ty` is an unresolved type variable, returns its root vid.
-    pub fn root_vid(&self, ty: Ty<'tcx>) -> Option<ty::TyVid> {
-        let (root, value) =
-            self.inner.borrow_mut().type_variables().inlined_probe_with_vid(ty.ty_vid()?);
-        value.is_unknown().then_some(root)
-    }
-
    pub fn sub_unify_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid) {
        self.inner.borrow_mut().type_variables().sub_unify(a, b);
    }
--- a/compiler/rustc_infer/src/infer/type_variable.rs
+++ b/compiler/rustc_infer/src/infer/type_variable.rs
@@ -258,25 +258,6 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
        self.eq_relations().inlined_probe_value(vid)
    }

-    /// Retrieves the type to which `vid` has been instantiated, if
-    /// any, along with the root `vid`.
-    pub(crate) fn probe_with_root_vid(
-        &mut self,
-        vid: ty::TyVid,
-    ) -> (ty::TyVid, TypeVariableValue<'tcx>) {
-        self.inlined_probe_with_vid(vid)
-    }
-
-    /// An always-inlined variant of `probe_with_root_vid`, for very hot call sites.
-    #[inline(always)]
-    pub(crate) fn inlined_probe_with_vid(
-        &mut self,
-        vid: ty::TyVid,
-    ) -> (ty::TyVid, TypeVariableValue<'tcx>) {
-        let (id, value) = self.eq_relations().inlined_probe_key_value(vid);
-        (id.vid, value)
-    }
-
    #[inline]
    fn eq_relations(&mut self) -> super::UnificationTable<'_, 'tcx, TyVidEqKey<'tcx>> {
        self.storage.eq_relations.with_log(self.undo_log)
--- a/compiler/rustc_infer/src/lib.rs
+++ b/compiler/rustc_infer/src/lib.rs
@@ -14,7 +14,7 @@

 // tidy-alphabetical-start
 #![allow(rustc::direct_use_of_rustc_type_ir)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
+#![feature(assert_matches)]
 #![feature(extend_one)]
 #![recursion_limit = "512"] // For rustdoc
 // tidy-alphabetical-end
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -21,8 +21,8 @@

 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(iter_order_by)]
 #![feature(rustc_attrs)]
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -27,10 +27,10 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::direct_use_of_rustc_type_ir)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
 #![cfg_attr(doc, feature(intra_doc_pointers))]
 #![feature(allocator_api)]
+#![feature(assert_matches)]
 #![feature(associated_type_defaults)]
 #![feature(box_as_ptr)]
 #![feature(box_patterns)]
--- a/compiler/rustc_middle/src/ty/assoc.rs
+++ b/compiler/rustc_middle/src/ty/assoc.rs
@@ -137,8 +137,8 @@ impl AssocItem {
        self.kind.as_def_kind()
    }

-    pub fn is_const(&self) -> bool {
-        matches!(self.kind, ty::AssocKind::Const { .. })
+    pub fn is_type_const(&self, tcx: TyCtxt<'_>) -> bool {
+        matches!(self.kind, ty::AssocKind::Const { .. }) && tcx.is_rhs_type_const(self.def_id)
    }

    pub fn is_fn(&self) -> bool {
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -724,7 +724,7 @@ impl<'tcx> Ty<'tcx> {
                    .map(|principal| {
                        tcx.associated_items(principal.def_id())
                            .in_definition_order()
-                            .filter(|item| item.is_type() || item.is_const())
+                            .filter(|item| item.is_type() || item.is_type_const(tcx))
                            .filter(|item| !item.is_impl_trait_in_trait())
                            .filter(|item| !tcx.generics_require_sized_self(item.def_id))
                            .count()
--- a/compiler/rustc_mir_build/src/lib.rs
+++ b/compiler/rustc_mir_build/src/lib.rs
@@ -1,8 +1,8 @@
 //! Construction of MIR from HIR.

 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(try_blocks)]
 // tidy-alphabetical-end
--- a/compiler/rustc_mir_dataflow/src/lib.rs
+++ b/compiler/rustc_mir_dataflow/src/lib.rs
@@ -1,5 +1,5 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
+#![feature(assert_matches)]
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]
 #![feature(exact_size_is_empty)]
--- a/compiler/rustc_mir_transform/src/lib.rs
+++ b/compiler/rustc_mir_transform/src/lib.rs
@@ -1,6 +1,6 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(const_type_name)]
 #![feature(cow_is_borrowed)]
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -1,9 +1,9 @@
 //! The main parser interface.

 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
 #![cfg_attr(test, feature(iter_order_by))]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(debug_closure_helpers)]
 #![feature(default_field_values)]
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -8,10 +8,10 @@

 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
 #![cfg_attr(bootstrap, feature(ptr_as_ref_unchecked))]
 #![feature(arbitrary_self_types)]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(const_default)]
 #![feature(const_trait_impl)]
@@ -544,6 +544,13 @@ impl ModuleKind {
            ModuleKind::Def(.., name) => name,
        }
    }
+
+    fn opt_def_id(&self) -> Option<DefId> {
+        match self {
+            ModuleKind::Def(_, def_id, _) => Some(*def_id),
+            _ => None,
+        }
+    }
 }

 /// Combination of a symbol and its macros 2.0 normalized hygiene context.
@@ -781,10 +788,7 @@ impl<'ra> Module<'ra> {
    }

    fn opt_def_id(self) -> Option<DefId> {
-        match self.kind {
-            ModuleKind::Def(_, def_id, _) => Some(def_id),
-            _ => None,
-        }
+        self.kind.opt_def_id()
    }

    // `self` resolves to the first module ancestor that `is_normal`.
@@ -1421,14 +1425,19 @@ impl<'ra> ResolverArenas<'ra> {
        &'ra self,
        parent: Option<Module<'ra>>,
        kind: ModuleKind,
+        vis: Visibility<DefId>,
        expn_id: ExpnId,
        span: Span,
        no_implicit_prelude: bool,
    ) -> Module<'ra> {
        let self_decl = match kind {
-            ModuleKind::Def(def_kind, def_id, _) => {
-                Some(self.new_pub_def_decl(Res::Def(def_kind, def_id), span, LocalExpnId::ROOT))
-            }
+            ModuleKind::Def(def_kind, def_id, _) => Some(self.new_def_decl(
+                Res::Def(def_kind, def_id),
+                vis,
+                span,
+                LocalExpnId::ROOT,
+                None,
+            )),
            ModuleKind::Block => None,
        };
        Module(Interned::new_unchecked(self.modules.alloc(ModuleData::new(
@@ -1610,6 +1619,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
        let graph_root = arenas.new_module(
            None,
            ModuleKind::Def(DefKind::Mod, root_def_id, None),
+            Visibility::Public,
            ExpnId::root(),
            crate_span,
            attr::contains_name(attrs, sym::no_implicit_prelude),
@@ -1619,6 +1629,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
        let empty_module = arenas.new_module(
            None,
            ModuleKind::Def(DefKind::Mod, root_def_id, None),
+            Visibility::Public,
            ExpnId::root(),
            DUMMY_SP,
            true,
@@ -1748,7 +1759,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
        span: Span,
        no_implicit_prelude: bool,
    ) -> Module<'ra> {
-        let module = self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude);
+        let vis =
+            kind.opt_def_id().map_or(Visibility::Public, |def_id| self.tcx.visibility(def_id));
+        let module = self.arenas.new_module(parent, kind, vis, expn_id, span, no_implicit_prelude);
        self.local_modules.push(module);
        if let Some(def_id) = module.opt_def_id() {
            self.local_module_map.insert(def_id.expect_local(), module);
@@ -1764,7 +1777,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
        span: Span,
        no_implicit_prelude: bool,
    ) -> Module<'ra> {
-        let module = self.arenas.new_module(parent, kind, expn_id, span, no_implicit_prelude);
+        let vis =
+            kind.opt_def_id().map_or(Visibility::Public, |def_id| self.tcx.visibility(def_id));
+        let module = self.arenas.new_module(parent, kind, vis, expn_id, span, no_implicit_prelude);
        self.extern_module_map.borrow_mut().insert(module.def_id(), module);
        module
    }
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
@@ -239,7 +239,7 @@ fn trait_object_ty<'tcx>(tcx: TyCtxt<'tcx>, poly_trait_ref: ty::PolyTraitRef<'tc
        .flat_map(|super_poly_trait_ref| {
            tcx.associated_items(super_poly_trait_ref.def_id())
                .in_definition_order()
-                .filter(|item| item.is_type() || item.is_const())
+                .filter(|item| item.is_type() || item.is_type_const(tcx))
                .filter(|item| !tcx.generics_require_sized_self(item.def_id))
                .map(move |assoc_item| {
                    super_poly_trait_ref.map_bound(|super_trait_ref| {
--- a/compiler/rustc_symbol_mangling/src/lib.rs
+++ b/compiler/rustc_symbol_mangling/src/lib.rs
@@ -88,7 +88,7 @@
 //! DefPaths which are much more robust in the face of changes to the code base.

 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
+#![feature(assert_matches)]
 // tidy-alphabetical-end

 use rustc_hir::def::DefKind;
--- a/compiler/rustc_trait_selection/src/lib.rs
+++ b/compiler/rustc_trait_selection/src/lib.rs
@@ -11,8 +11,8 @@
 //! This API is completely unstable and subject to change.

 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]
 #![feature(default_field_values)]
--- a/compiler/rustc_ty_utils/src/lib.rs
+++ b/compiler/rustc_ty_utils/src/lib.rs
@@ -5,8 +5,8 @@
 //! This API is completely unstable and subject to change.

 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
+#![feature(assert_matches)]
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]
 #![feature(iterator_try_collect)]
--- a/compiler/rustc_type_ir/Cargo.toml
+++ b/compiler/rustc_type_ir/Cargo.toml
@@ -8,7 +8,7 @@ edition = "2024"
 arrayvec = { version = "0.7", default-features = false }
 bitflags = "2.4.1"
 derive-where = "1.2.7"
-ena = "0.14.4"
+ena = "0.14.3"
 indexmap = "2.0.0"
 rustc-hash = "2.0.0"
 rustc_ast_ir = { path = "../rustc_ast_ir", default-features = false }
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -916,9 +916,10 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
 /// heads from the stack. This may not necessarily mean that we've actually
 /// reached a fixpoint for that cycle head, which impacts the way we rebase
 /// provisional cache entries.
-#[derive(Debug)]
-enum RebaseReason {
+#[derive_where(Debug; X: Cx)]
+enum RebaseReason<X: Cx> {
    NoCycleUsages,
+    Ambiguity(X::AmbiguityInfo),
    Overflow,
    /// We've actually reached a fixpoint.
    ///
@@ -955,7 +956,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
        &mut self,
        cx: X,
        stack_entry: &StackEntry<X>,
-        rebase_reason: RebaseReason,
+        rebase_reason: RebaseReason<X>,
    ) {
        let popped_head_index = self.stack.next_index();
        #[allow(rustc::potential_query_instability)]
@@ -1034,6 +1035,9 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
                        // is not actually equal to the final provisional result. We
                        // need to discard the provisional cache entry in this case.
                        RebaseReason::NoCycleUsages => return false,
+                        RebaseReason::Ambiguity(info) => {
+                            *result = D::propagate_ambiguity(cx, input, info);
+                        }
                        RebaseReason::Overflow => *result = D::fixpoint_overflow_result(cx, input),
                        RebaseReason::ReachedFixpoint(None) => {}
                        RebaseReason::ReachedFixpoint(Some(path_kind)) => {
@@ -1348,6 +1352,27 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D, X> {
                return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
            }

+            // If computing this goal results in ambiguity with no constraints,
+            // we do not rerun it. It's incredibly difficult to get a different
+            // response in the next iteration in this case. These changes would
+            // likely either be caused by incompleteness or can change the maybe
+            // cause from ambiguity to overflow. Returning ambiguity always
+            // preserves soundness and completeness even if the goal is be known
+            // to succeed or fail.
+            //
+            // This prevents exponential blowup affecting multiple major crates.
+            // As we only get to this branch if we haven't yet reached a fixpoint,
+            // we also taint all provisional cache entries which depend on the
+            // current goal.
+            if let Some(info) = D::is_ambiguous_result(result) {
+                self.rebase_provisional_cache_entries(
+                    cx,
+                    &stack_entry,
+                    RebaseReason::Ambiguity(info),
+                );
+                return EvaluationResult::finalize(stack_entry, encountered_overflow, result);
+            };
+
            // If we've reached the fixpoint step limit, we bail with overflow and taint all
            // provisional cache entries which depend on the current goal.
            i += 1;
--- a/library/alloc/src/collections/linked_list.rs
+++ b/library/alloc/src/collections/linked_list.rs
@@ -862,7 +862,7 @@ impl<T, A: Allocator> LinkedList<T, A> {
    /// *ptr += 4;
    /// assert_eq!(dl.front().unwrap(), &6);
    /// ```
-    #[stable(feature = "push_mut", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "push_mut", since = "1.95.0")]
    #[must_use = "if you don't need a reference to the value, use `LinkedList::push_front` instead"]
    pub fn push_front_mut(&mut self, elt: T) -> &mut T {
        let mut node =
@@ -933,7 +933,7 @@ impl<T, A: Allocator> LinkedList<T, A> {
    /// *ptr += 4;
    /// assert_eq!(dl.back().unwrap(), &6);
    /// ```
-    #[stable(feature = "push_mut", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "push_mut", since = "1.95.0")]
    #[must_use = "if you don't need a reference to the value, use `LinkedList::push_back` instead"]
    pub fn push_back_mut(&mut self, elt: T) -> &mut T {
        let mut node =
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/library/alloc/src/collections/vec_deque/mod.rs
@@ -2175,7 +2175,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
    /// *x -= 1;
    /// assert_eq!(d.front(), Some(&7));
    /// ```
-    #[stable(feature = "push_mut", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "push_mut", since = "1.95.0")]
    #[must_use = "if you don't need a reference to the value, use `VecDeque::push_front` instead"]
    pub fn push_front_mut(&mut self, value: T) -> &mut T {
        if self.is_full() {
@@ -2218,7 +2218,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
    /// *x += 1;
    /// assert_eq!(d.back(), Some(&10));
    /// ```
-    #[stable(feature = "push_mut", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "push_mut", since = "1.95.0")]
    #[must_use = "if you don't need a reference to the value, use `VecDeque::push_back` instead"]
    pub fn push_back_mut(&mut self, value: T) -> &mut T {
        if self.is_full() {
@@ -2425,7 +2425,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
    /// *x += 7;
    /// assert_eq!(vec_deque, &[1, 12, 2, 3]);
    /// ```
-    #[stable(feature = "push_mut", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "push_mut", since = "1.95.0")]
    #[must_use = "if you don't need a reference to the value, use `VecDeque::insert` instead"]
    pub fn insert_mut(&mut self, index: usize, value: T) -> &mut T {
        assert!(index <= self.len(), "index out of bounds");
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@@ -89,6 +89,7 @@
 #![feature(allocator_api)]
 #![feature(array_into_iter_constructors)]
 #![feature(ascii_char)]
+#![feature(assert_matches)]
 #![feature(async_fn_traits)]
 #![feature(async_iterator)]
 #![feature(bstr)]
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -1018,7 +1018,7 @@ const impl<T, A: [const] Allocator + [const] Destruct> Vec<T, A> {
    /// vector's elements to a larger allocation. This expensive operation is
    /// offset by the *capacity* *O*(1) insertions it allows.
    #[inline]
-    #[stable(feature = "push_mut", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "push_mut", since = "1.95.0")]
    #[must_use = "if you don't need a reference to the value, use `Vec::push` instead"]
    pub fn push_mut(&mut self, value: T) -> &mut T {
        // Inform codegen that the length does not change across grow_one().
@@ -2271,7 +2271,7 @@ impl<T, A: Allocator> Vec<T, A> {
    /// the insertion index is 0.
    #[cfg(not(no_global_oom_handling))]
    #[inline]
-    #[stable(feature = "push_mut", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "push_mut", since = "1.95.0")]
    #[track_caller]
    #[must_use = "if you don't need a reference to the value, use `Vec::insert` instead"]
    pub fn insert_mut(&mut self, index: usize, element: T) -> &mut T {
--- a/library/alloctests/lib.rs
+++ b/library/alloctests/lib.rs
@@ -16,6 +16,7 @@
 // tidy-alphabetical-start
 #![feature(allocator_api)]
 #![feature(array_into_iter_constructors)]
+#![feature(assert_matches)]
 #![feature(char_internals)]
 #![feature(const_alloc_error)]
 #![feature(const_cmp)]
--- a/library/alloctests/tests/lib.rs
+++ b/library/alloctests/tests/lib.rs
@@ -4,6 +4,7 @@
 #![feature(const_heap)]
 #![feature(deque_extend_front)]
 #![feature(iter_array_chunks)]
+#![feature(assert_matches)]
 #![feature(cow_is_borrowed)]
 #![feature(core_intrinsics)]
 #![feature(downcast_unchecked)]
--- a/library/core/src/alloc/layout.rs
+++ b/library/core/src/alloc/layout.rs
@@ -263,8 +263,8 @@ impl Layout {
    /// be that of a valid pointer, which means this must not be used
    /// as a "not yet initialized" sentinel value.
    /// Types that lazily allocate must track initialization by some other means.
-    #[stable(feature = "alloc_layout_extra", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "alloc_layout_extra", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "alloc_layout_extra", since = "1.95.0")]
+    #[rustc_const_stable(feature = "alloc_layout_extra", since = "1.95.0")]
    #[must_use]
    #[inline]
    pub const fn dangling_ptr(&self) -> NonNull<u8> {
@@ -423,8 +423,8 @@ impl Layout {
    /// let repeated = padding_needed.repeat(0).unwrap();
    /// assert_eq!(repeated, (Layout::from_size_align(0, 4).unwrap(), 8));
    /// ```
-    #[stable(feature = "alloc_layout_extra", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "alloc_layout_extra", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "alloc_layout_extra", since = "1.95.0")]
+    #[rustc_const_stable(feature = "alloc_layout_extra", since = "1.95.0")]
    #[inline]
    pub const fn repeat(&self, n: usize) -> Result<(Self, usize), LayoutError> {
        // FIXME(const-hack): the following could be way shorter with `?`
@@ -520,8 +520,8 @@ impl Layout {
    /// aligned.
    ///
    /// On arithmetic overflow, returns `LayoutError`.
-    #[stable(feature = "alloc_layout_extra", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "alloc_layout_extra", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "alloc_layout_extra", since = "1.95.0")]
+    #[rustc_const_stable(feature = "alloc_layout_extra", since = "1.95.0")]
    #[inline]
    pub const fn repeat_packed(&self, n: usize) -> Result<Self, LayoutError> {
        if let Some(size) = self.size.checked_mul(n) {
@@ -538,8 +538,8 @@ impl Layout {
    /// and is not incorporated *at all* into the resulting layout.
    ///
    /// On arithmetic overflow, returns `LayoutError`.
-    #[stable(feature = "alloc_layout_extra", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "alloc_layout_extra", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "alloc_layout_extra", since = "1.95.0")]
+    #[rustc_const_stable(feature = "alloc_layout_extra", since = "1.95.0")]
    #[inline]
    pub const fn extend_packed(&self, next: Self) -> Result<Self, LayoutError> {
        // SAFETY: each `size` is at most `isize::MAX == usize::MAX/2`, so the
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -689,7 +689,7 @@ impl<T: CoerceUnsized<U>, U> CoerceUnsized<Cell<U>> for Cell<T> {}
 #[unstable(feature = "dispatch_from_dyn", issue = "none")]
 impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<Cell<U>> for Cell<T> {}

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T, const N: usize> AsRef<[Cell<T>; N]> for Cell<[T; N]> {
    #[inline]
    fn as_ref(&self) -> &[Cell<T>; N] {
@@ -697,7 +697,7 @@ impl<T, const N: usize> AsRef<[Cell<T>; N]> for Cell<[T; N]> {
    }
 }

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T, const N: usize> AsRef<[Cell<T>]> for Cell<[T; N]> {
    #[inline]
    fn as_ref(&self) -> &[Cell<T>] {
@@ -705,7 +705,7 @@ impl<T, const N: usize> AsRef<[Cell<T>]> for Cell<[T; N]> {
    }
 }

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T> AsRef<[Cell<T>]> for Cell<[T]> {
    #[inline]
    fn as_ref(&self) -> &[Cell<T>] {
--- a/library/core/src/convert/num.rs
+++ b/library/core/src/convert/num.rs
@@ -332,7 +332,7 @@ macro_rules! impl_try_from_both_bounded {
 /// Implement `TryFrom<integer>` for `bool`
 macro_rules! impl_try_from_integer_for_bool {
    ($($int:ty)+) => {$(
-        #[stable(feature = "try_from", since = "1.34.0")]
+        #[stable(feature = "bool_try_from_int", since = "1.95.0")]
        #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
        impl const TryFrom<$int> for bool {
            type Error = TryFromIntError;
--- a/library/core/src/fmt/builders.rs
+++ b/library/core/src/fmt/builders.rs
@@ -1227,7 +1227,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
 /// assert_eq!(format!("{:?}", wrapped), "'a'");
 /// ```
 #[stable(feature = "fmt_from_fn", since = "1.93.0")]
-#[rustc_const_stable(feature = "const_fmt_from_fn", since = "CURRENT_RUSTC_VERSION")]
+#[rustc_const_stable(feature = "const_fmt_from_fn", since = "1.95.0")]
 #[must_use = "returns a type implementing Debug and Display, which do not have any effects unless they are used"]
 pub const fn from_fn<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result>(f: F) -> FromFn<F> {
    FromFn(f)
--- a/library/core/src/hint.rs
+++ b/library/core/src/hint.rs
@@ -775,8 +775,8 @@ pub const fn unlikely(b: bool) -> bool {
 ///     }
 /// }
 /// ```
-#[stable(feature = "cold_path", since = "CURRENT_RUSTC_VERSION")]
-#[rustc_const_stable(feature = "cold_path", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "cold_path", since = "1.95.0")]
+#[rustc_const_stable(feature = "cold_path", since = "1.95.0")]
 #[inline(always)]
 pub const fn cold_path() {
    crate::intrinsics::cold_path()
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -205,7 +205,7 @@ use prelude::rust_2024::*;
 #[macro_use]
 mod macros;

-#[stable(feature = "assert_matches", since = "CURRENT_RUSTC_VERSION")]
+#[unstable(feature = "assert_matches", issue = "82775")]
 pub use crate::macros::{assert_matches, debug_assert_matches};

 #[unstable(feature = "derive_from", issue = "144889")]
@@ -226,7 +226,7 @@ pub mod autodiff {
 #[unstable(feature = "contracts", issue = "128044")]
 pub mod contracts;

-#[stable(feature = "cfg_select", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "cfg_select", since = "1.95.0")]
 pub use crate::macros::cfg_select;

 #[macro_use]
@@ -304,7 +304,7 @@ pub mod pat;
 pub mod pin;
 #[unstable(feature = "random", issue = "130703")]
 pub mod random;
-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 pub mod range;
 pub mod result;
 pub mod sync;
--- a/library/core/src/macros/mod.rs
+++ b/library/core/src/macros/mod.rs
@@ -147,6 +147,8 @@ macro_rules! assert_ne {
 /// # Examples
 ///
 /// ```
+/// #![feature(assert_matches)]
+///
 /// use std::assert_matches;
 ///
 /// let a = Some(345);
@@ -164,7 +166,7 @@ macro_rules! assert_ne {
 /// assert_matches!(a, Some(x) if x > 100);
 /// // assert_matches!(a, Some(x) if x < 100); // panics
 /// ```
-#[stable(feature = "assert_matches", since = "CURRENT_RUSTC_VERSION")]
+#[unstable(feature = "assert_matches", issue = "82775")]
 #[allow_internal_unstable(panic_internals)]
 #[rustc_macro_transparency = "semiopaque"]
 pub macro assert_matches {
@@ -228,7 +230,7 @@ pub macro assert_matches {
 ///     _ => { "Behind every successful diet is an unwatched pizza" }
 /// };
 /// ```
-#[stable(feature = "cfg_select", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "cfg_select", since = "1.95.0")]
 #[rustc_diagnostic_item = "cfg_select"]
 #[rustc_builtin_macro]
 pub macro cfg_select($($tt:tt)*) {
@@ -374,6 +376,8 @@ macro_rules! debug_assert_ne {
 /// # Examples
 ///
 /// ```
+/// #![feature(assert_matches)]
+///
 /// use std::debug_assert_matches;
 ///
 /// let a = Some(345);
@@ -391,7 +395,7 @@ macro_rules! debug_assert_ne {
 /// debug_assert_matches!(a, Some(x) if x > 100);
 /// // debug_assert_matches!(a, Some(x) if x < 100); // panics
 /// ```
-#[stable(feature = "assert_matches", since = "CURRENT_RUSTC_VERSION")]
+#[unstable(feature = "assert_matches", issue = "82775")]
 #[allow_internal_unstable(assert_matches)]
 #[rustc_macro_transparency = "semiopaque"]
 pub macro debug_assert_matches($($arg:tt)*) {
--- a/library/core/src/mem/maybe_uninit.rs
+++ b/library/core/src/mem/maybe_uninit.rs
@@ -1532,7 +1532,7 @@ impl<T, const N: usize> MaybeUninit<[T; N]> {
    }
 }

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T, const N: usize> From<[MaybeUninit<T>; N]> for MaybeUninit<[T; N]> {
    #[inline]
    fn from(arr: [MaybeUninit<T>; N]) -> Self {
@@ -1540,7 +1540,7 @@ impl<T, const N: usize> From<[MaybeUninit<T>; N]> for MaybeUninit<[T; N]> {
    }
 }

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T, const N: usize> AsRef<[MaybeUninit<T>; N]> for MaybeUninit<[T; N]> {
    #[inline]
    fn as_ref(&self) -> &[MaybeUninit<T>; N] {
@@ -1549,7 +1549,7 @@ impl<T, const N: usize> AsRef<[MaybeUninit<T>; N]> for MaybeUninit<[T; N]> {
    }
 }

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T, const N: usize> AsRef<[MaybeUninit<T>]> for MaybeUninit<[T; N]> {
    #[inline]
    fn as_ref(&self) -> &[MaybeUninit<T>] {
@@ -1557,7 +1557,7 @@ impl<T, const N: usize> AsRef<[MaybeUninit<T>]> for MaybeUninit<[T; N]> {
    }
 }

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T, const N: usize> AsMut<[MaybeUninit<T>; N]> for MaybeUninit<[T; N]> {
    #[inline]
    fn as_mut(&mut self) -> &mut [MaybeUninit<T>; N] {
@@ -1566,7 +1566,7 @@ impl<T, const N: usize> AsMut<[MaybeUninit<T>; N]> for MaybeUninit<[T; N]> {
    }
 }

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T, const N: usize> AsMut<[MaybeUninit<T>]> for MaybeUninit<[T; N]> {
    #[inline]
    fn as_mut(&mut self) -> &mut [MaybeUninit<T>] {
@@ -1574,7 +1574,7 @@ impl<T, const N: usize> AsMut<[MaybeUninit<T>]> for MaybeUninit<[T; N]> {
    }
 }

-#[stable(feature = "more_conversion_trait_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "more_conversion_trait_impls", since = "1.95.0")]
 impl<T, const N: usize> From<MaybeUninit<[T; N]>> for [MaybeUninit<T>; N] {
    #[inline]
    fn from(arr: MaybeUninit<[T; N]>) -> Self {
--- a/library/core/src/ops/control_flow.rs
+++ b/library/core/src/ops/control_flow.rs
@@ -151,7 +151,7 @@ impl<B, C> ControlFlow<B, C> {
    /// ```
    #[inline]
    #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-    #[rustc_const_stable(feature = "min_const_control_flow", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "min_const_control_flow", since = "1.95.0")]
    pub const fn is_break(&self) -> bool {
        matches!(*self, ControlFlow::Break(_))
    }
@@ -168,7 +168,7 @@ impl<B, C> ControlFlow<B, C> {
    /// ```
    #[inline]
    #[stable(feature = "control_flow_enum_is", since = "1.59.0")]
-    #[rustc_const_stable(feature = "min_const_control_flow", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "min_const_control_flow", since = "1.95.0")]
    pub const fn is_continue(&self) -> bool {
        matches!(*self, ControlFlow::Continue(_))
    }
--- a/library/core/src/prelude/v1.rs
+++ b/library/core/src/prelude/v1.rs
@@ -80,7 +80,7 @@ mod ambiguous_macros_only {
 #[doc(no_inline)]
 pub use self::ambiguous_macros_only::{env, panic};

-#[stable(feature = "cfg_select", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "cfg_select", since = "1.95.0")]
 #[doc(no_inline)]
 pub use crate::cfg_select;

--- a/library/core/src/ptr/const_ptr.rs
+++ b/library/core/src/ptr/const_ptr.rs
@@ -290,8 +290,8 @@ impl<T: PointeeSized> *const T {
    ///     assert_eq!(ptr.as_ref_unchecked(), &10);
    /// }
    /// ```
-    #[stable(feature = "ptr_as_ref_unchecked", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "ptr_as_ref_unchecked", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "ptr_as_ref_unchecked", since = "1.95.0")]
+    #[rustc_const_stable(feature = "ptr_as_ref_unchecked", since = "1.95.0")]
    #[inline]
    #[must_use]
    pub const unsafe fn as_ref_unchecked<'a>(self) -> &'a T {
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -288,8 +288,8 @@ impl<T: PointeeSized> *mut T {
    ///     println!("We got back the value: {}!", ptr.as_ref_unchecked());
    /// }
    /// ```
-    #[stable(feature = "ptr_as_ref_unchecked", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "ptr_as_ref_unchecked", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "ptr_as_ref_unchecked", since = "1.95.0")]
+    #[rustc_const_stable(feature = "ptr_as_ref_unchecked", since = "1.95.0")]
    #[inline]
    #[must_use]
    pub const unsafe fn as_ref_unchecked<'a>(self) -> &'a T {
@@ -611,8 +611,8 @@ impl<T: PointeeSized> *mut T {
    /// # assert_eq!(s, [4, 2, 3]);
    /// println!("{s:?}"); // It'll print: "[4, 2, 3]".
    /// ```
-    #[stable(feature = "ptr_as_ref_unchecked", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "ptr_as_ref_unchecked", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "ptr_as_ref_unchecked", since = "1.95.0")]
+    #[rustc_const_stable(feature = "ptr_as_ref_unchecked", since = "1.95.0")]
    #[inline]
    #[must_use]
    pub const unsafe fn as_mut_unchecked<'a>(self) -> &'a mut T {
--- a/library/core/src/range.rs
+++ b/library/core/src/range.rs
@@ -25,7 +25,7 @@ mod iter;
 pub mod legacy;

 #[doc(inline)]
-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 pub use iter::RangeInclusiveIter;
 #[doc(inline)]
 #[unstable(feature = "new_range_api", issue = "125687")]
@@ -45,10 +45,9 @@ use crate::iter::Step;
 use crate::ops::Bound::{self, Excluded, Included, Unbounded};
 use crate::ops::{IntoBounds, RangeBounds};

-/// A (half-open) range bounded inclusively below and exclusively above
-/// (`start..end` in a future edition).
+/// A (half-open) range bounded inclusively below and exclusively above.
 ///
-/// The range `start..end` contains all values with `start <= x < end`.
+/// The `Range` contains all values with `start <= x < end`.
 /// It is empty if `start >= end`.
 ///
 /// # Examples
@@ -60,6 +59,11 @@ use crate::ops::{IntoBounds, RangeBounds};
 /// assert_eq!(Range::from(3..5), Range { start: 3, end: 5 });
 /// assert_eq!(3 + 4 + 5, Range::from(3..6).into_iter().sum());
 /// ```
+///
+/// # Edition notes
+///
+/// It is planned that the syntax `start..end` will construct this
+/// type in a future edition, but it does not do so today.
 #[lang = "RangeCopy"]
 #[derive(Copy, Hash)]
 #[derive_const(Clone, Default, PartialEq, Eq)]
@@ -228,34 +232,37 @@ impl<T> const From<legacy::Range<T>> for Range<T> {
    }
 }

-/// A range bounded inclusively below and above (`start..=last`).
+/// A range bounded inclusively below and above.
 ///
-/// The `RangeInclusive` `start..=last` contains all values with `x >= start`
+/// The `RangeInclusive` contains all values with `x >= start`
 /// and `x <= last`. It is empty unless `start <= last`.
 ///
 /// # Examples
 ///
-/// The `start..=last` syntax is a `RangeInclusive`:
-///
 /// ```
 /// use core::range::RangeInclusive;
 ///
 /// assert_eq!(RangeInclusive::from(3..=5), RangeInclusive { start: 3, last: 5 });
 /// assert_eq!(3 + 4 + 5, RangeInclusive::from(3..=5).into_iter().sum());
 /// ```
+///
+/// # Edition notes
+///
+/// It is planned that the syntax  `start..=last` will construct this
+/// type in a future edition, but it does not do so today.
 #[lang = "RangeInclusiveCopy"]
 #[derive(Clone, Copy, PartialEq, Eq, Hash)]
-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 pub struct RangeInclusive<Idx> {
    /// The lower bound of the range (inclusive).
-    #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
    pub start: Idx,
    /// The upper bound of the range (inclusive).
-    #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
    pub last: Idx,
 }

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 impl<Idx: fmt::Debug> fmt::Debug for RangeInclusive<Idx> {
    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.start.fmt(fmt)?;
@@ -288,7 +295,7 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
    /// assert!(!RangeInclusive::from(f32::NAN..=1.0).contains(&1.0));
    /// ```
    #[inline]
-    #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
    #[rustc_const_unstable(feature = "const_range", issue = "none")]
    pub const fn contains<U>(&self, item: &U) -> bool
    where
@@ -319,7 +326,7 @@ impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx> {
    /// assert!( RangeInclusive::from(3.0..=f32::NAN).is_empty());
    /// assert!( RangeInclusive::from(f32::NAN..=5.0).is_empty());
    /// ```
-    #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
    #[inline]
    #[rustc_const_unstable(feature = "const_range", issue = "none")]
    pub const fn is_empty(&self) -> bool
@@ -345,14 +352,14 @@ impl<Idx: Step> RangeInclusive<Idx> {
    /// assert_eq!(i.next(), Some(16));
    /// assert_eq!(i.next(), Some(25));
    /// ```
-    #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
    #[inline]
    pub fn iter(&self) -> RangeInclusiveIter<Idx> {
        self.clone().into_iter()
    }
 }

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for RangeInclusive<T> {
    fn start_bound(&self) -> Bound<&T> {
@@ -369,7 +376,7 @@ impl<T> const RangeBounds<T> for RangeInclusive<T> {
 /// If you need to use this implementation where `T` is unsized,
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..=end` with `(Bound::Included(start), Bound::Included(end))`.
-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for RangeInclusive<&T> {
    fn start_bound(&self) -> Bound<&T> {
@@ -380,7 +387,7 @@ impl<T> const RangeBounds<T> for RangeInclusive<&T> {
    }
 }

-// #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+// #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 #[unstable(feature = "range_into_bounds", issue = "136903")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const IntoBounds<T> for RangeInclusive<T> {
@@ -389,7 +396,7 @@ impl<T> const IntoBounds<T> for RangeInclusive<T> {
    }
 }

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<RangeInclusive<T>> for legacy::RangeInclusive<T> {
    #[inline]
@@ -397,7 +404,7 @@ impl<T> const From<RangeInclusive<T>> for legacy::RangeInclusive<T> {
        Self::new(value.start, value.last)
    }
 }
-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
    #[inline]
@@ -412,9 +419,9 @@ impl<T> const From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
    }
 }

-/// A range only bounded inclusively below (`start..`).
+/// A range only bounded inclusively below.
 ///
-/// The `RangeFrom` `start..` contains all values with `x >= start`.
+/// The `RangeFrom` contains all values with `x >= start`.
 ///
 /// *Note*: Overflow in the [`Iterator`] implementation (when the contained
 /// data type reaches its numerical limit) is allowed to panic, wrap, or
@@ -429,8 +436,6 @@ impl<T> const From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
 ///
 /// # Examples
 ///
-/// The `start..` syntax is a `RangeFrom`:
-///
 /// ```
 /// #![feature(new_range_api)]
 /// use core::range::RangeFrom;
@@ -438,6 +443,11 @@ impl<T> const From<legacy::RangeInclusive<T>> for RangeInclusive<T> {
 /// assert_eq!(RangeFrom::from(2..), core::range::RangeFrom { start: 2 });
 /// assert_eq!(2 + 3 + 4, RangeFrom::from(2..).into_iter().take(3).sum());
 /// ```
+///
+/// # Edition notes
+///
+/// It is planned that the syntax  `start..` will construct this
+/// type in a future edition, but it does not do so today.
 #[lang = "RangeFromCopy"]
 #[derive(Copy, Hash)]
 #[derive_const(Clone, PartialEq, Eq)]
@@ -563,15 +573,13 @@ impl<T> const From<legacy::RangeFrom<T>> for RangeFrom<T> {
    }
 }

-/// A range only bounded inclusively above (`..=last`).
+/// A range only bounded inclusively above.
 ///
-/// The `RangeToInclusive` `..=last` contains all values with `x <= last`.
+/// The `RangeToInclusive` contains all values with `x <= last`.
 /// It cannot serve as an [`Iterator`] because it doesn't have a starting point.
 ///
 /// # Examples
 ///
-/// The `..=last` syntax is a `RangeToInclusive`:
-///
 /// ```
 /// #![feature(new_range_api)]
 /// #![feature(new_range)]
@@ -603,6 +611,11 @@ impl<T> const From<legacy::RangeFrom<T>> for RangeFrom<T> {
 /// ```
 ///
 /// [slicing index]: crate::slice::SliceIndex
+///
+/// # Edition notes
+///
+/// It is planned that the syntax  `..=last` will construct this
+/// type in a future edition, but it does not do so today.
 #[lang = "RangeToInclusiveCopy"]
 #[doc(alias = "..=")]
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
--- a/library/core/src/range/iter.rs
+++ b/library/core/src/range/iter.rs
@@ -11,7 +11,7 @@ use crate::{intrinsics, mem};
 pub struct RangeIter<A>(legacy::Range<A>);

 impl<A> RangeIter<A> {
-    #[unstable(feature = "new_range_api", issue = "125687")]
+    #[unstable(feature = "new_range_remainder", issue = "154458")]
    /// Returns the remainder of the range being iterated over.
    pub fn remainder(self) -> Range<A> {
        Range { start: self.0.start, end: self.0.end }
@@ -153,7 +153,7 @@ impl<A: Step> IntoIterator for Range<A> {
 }

 /// By-value [`RangeInclusive`] iterator.
-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 #[derive(Debug, Clone)]
 pub struct RangeInclusiveIter<A>(legacy::RangeInclusive<A>);

@@ -161,7 +161,7 @@ impl<A: Step> RangeInclusiveIter<A> {
    /// Returns the remainder of the range being iterated over.
    ///
    /// If the iterator is exhausted or empty, returns `None`.
-    #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[unstable(feature = "new_range_remainder", issue = "154458")]
    pub fn remainder(self) -> Option<RangeInclusive<A>> {
        if self.0.is_empty() {
            return None;
@@ -171,7 +171,7 @@ impl<A: Step> RangeInclusiveIter<A> {
    }
 }

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 impl<A: Step> Iterator for RangeInclusiveIter<A> {
    type Item = A;

@@ -227,7 +227,7 @@ impl<A: Step> Iterator for RangeInclusiveIter<A> {
    }
 }

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 impl<A: Step> DoubleEndedIterator for RangeInclusiveIter<A> {
    #[inline]
    fn next_back(&mut self) -> Option<A> {
@@ -248,10 +248,10 @@ impl<A: Step> DoubleEndedIterator for RangeInclusiveIter<A> {
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<A: TrustedStep> TrustedLen for RangeInclusiveIter<A> {}

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 impl<A: Step> FusedIterator for RangeInclusiveIter<A> {}

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 impl<A: Step> IntoIterator for RangeInclusive<A> {
    type Item = A;
    type IntoIter = RangeInclusiveIter<A>;
@@ -278,7 +278,7 @@ macro_rules! range_exact_iter_impl {

 macro_rules! range_incl_exact_iter_impl {
    ($($t:ty)*) => ($(
-        #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
        impl ExactSizeIterator for RangeInclusiveIter<$t> { }
    )*)
 }
@@ -307,7 +307,7 @@ impl<A: Step> RangeFromIter<A> {
    /// Returns the remainder of the range being iterated over.
    #[inline]
    #[rustc_inherit_overflow_checks]
-    #[unstable(feature = "new_range_api", issue = "125687")]
+    #[unstable(feature = "new_range_remainder", issue = "154458")]
    pub fn remainder(self) -> RangeFrom<A> {
        if intrinsics::overflow_checks() {
            if !self.first {
--- a/library/core/src/slice/index.rs
+++ b/library/core/src/slice/index.rs
@@ -127,7 +127,7 @@ mod private_slice_index {

    #[unstable(feature = "new_range_api", issue = "125687")]
    impl Sealed for range::Range<usize> {}
-    #[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
    impl Sealed for range::RangeInclusive<usize> {}
    #[unstable(feature = "new_range_api", issue = "125687")]
    impl Sealed for range::RangeToInclusive<usize> {}
@@ -723,7 +723,7 @@ unsafe impl<T> const SliceIndex<[T]> for ops::RangeInclusive<usize> {
    }
 }

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl<T> const SliceIndex<[T]> for range::RangeInclusive<usize> {
    type Output = [T];
--- a/library/core/src/str/traits.rs
+++ b/library/core/src/str/traits.rs
@@ -685,7 +685,7 @@ unsafe impl const SliceIndex<str> for ops::RangeInclusive<usize> {
    }
 }

-#[stable(feature = "new_range_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl const SliceIndex<str> for range::RangeInclusive<usize> {
    type Output = str;
--- a/library/core/src/sync/atomic.rs
+++ b/library/core/src/sync/atomic.rs
@@ -1358,7 +1358,7 @@ impl AtomicBool {
    /// assert_eq!(x.load(Ordering::SeqCst), false);
    /// ```
    #[inline]
-    #[stable(feature = "atomic_try_update", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "atomic_try_update", since = "1.95.0")]
    #[cfg(target_has_atomic = "8")]
    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
    #[rustc_should_not_be_called_on_const_items]
@@ -1421,7 +1421,7 @@ impl AtomicBool {
    /// assert_eq!(x.load(Ordering::SeqCst), false);
    /// ```
    #[inline]
-    #[stable(feature = "atomic_try_update", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "atomic_try_update", since = "1.95.0")]
    #[cfg(target_has_atomic = "8")]
    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
    #[rustc_should_not_be_called_on_const_items]
@@ -2037,7 +2037,7 @@ impl<T> AtomicPtr<T> {
    /// assert_eq!(some_ptr.load(Ordering::SeqCst), new);
    /// ```
    #[inline]
-    #[stable(feature = "atomic_try_update", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "atomic_try_update", since = "1.95.0")]
    #[cfg(target_has_atomic = "ptr")]
    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
    #[rustc_should_not_be_called_on_const_items]
@@ -2105,7 +2105,7 @@ impl<T> AtomicPtr<T> {
    /// assert_eq!(some_ptr.load(Ordering::SeqCst), new);
    /// ```
    #[inline]
-    #[stable(feature = "atomic_try_update", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "atomic_try_update", since = "1.95.0")]
    #[cfg(target_has_atomic = "8")]
    #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
    #[rustc_should_not_be_called_on_const_items]
@@ -3372,7 +3372,7 @@ macro_rules! atomic_int {
            /// assert_eq!(x.load(Ordering::SeqCst), 9);
            /// ```
            #[inline]
-            #[stable(feature = "atomic_try_update", since = "CURRENT_RUSTC_VERSION")]
+            #[stable(feature = "atomic_try_update", since = "1.95.0")]
            #[$cfg_cas]
            #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
            #[rustc_should_not_be_called_on_const_items]
@@ -3438,7 +3438,7 @@ macro_rules! atomic_int {
            /// assert_eq!(x.load(Ordering::SeqCst), 9);
            /// ```
            #[inline]
-            #[stable(feature = "atomic_try_update", since = "CURRENT_RUSTC_VERSION")]
+            #[stable(feature = "atomic_try_update", since = "1.95.0")]
            #[$cfg_cas]
            #[cfg_attr(miri, track_caller)] // even without panics, this helps for Miri backtraces
            #[rustc_should_not_be_called_on_const_items]
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -393,6 +393,7 @@
 //
 // Only for re-exporting:
 // tidy-alphabetical-start
+#![feature(assert_matches)]
 #![feature(async_iterator)]
 #![feature(c_variadic)]
 #![feature(cfg_accessible)]
@@ -468,9 +469,7 @@ extern crate std as realstd;

 // The standard macros that are not built-in to the compiler.
 #[macro_use]
-#[doc(hidden)]
-#[unstable(feature = "std_internals", issue = "none")]
-pub mod macros;
+mod macros;

 // The runtime entry point and a few unstable public functions used by the
 // compiler
@@ -694,7 +693,7 @@ mod panicking;
 #[allow(dead_code, unused_attributes, fuzzy_provenance_casts, unsafe_op_in_unsafe_fn)]
 mod backtrace_rs;

-#[stable(feature = "cfg_select", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "cfg_select", since = "1.95.0")]
 pub use core::cfg_select;
 #[unstable(
    feature = "concat_bytes",
@@ -724,7 +723,7 @@ pub use core::{
    assert_eq, assert_ne, debug_assert, debug_assert_eq, debug_assert_ne, r#try, unimplemented,
    unreachable, write, writeln,
 };
-#[stable(feature = "assert_matches", since = "CURRENT_RUSTC_VERSION")]
+#[unstable(feature = "assert_matches", issue = "82775")]
 pub use core::{assert_matches, debug_assert_matches};

 // Re-export unstable derive macro defined through core.
--- a/library/std/src/macros.rs
+++ b/library/std/src/macros.rs
@@ -347,70 +347,35 @@ macro_rules! eprintln {
 /// [`debug!`]: https://docs.rs/log/*/log/macro.debug.html
 /// [`log`]: https://crates.io/crates/log
 #[macro_export]
-#[allow_internal_unstable(std_internals)]
 #[cfg_attr(not(test), rustc_diagnostic_item = "dbg_macro")]
 #[stable(feature = "dbg_macro", since = "1.32.0")]
 macro_rules! dbg {
+    // NOTE: We cannot use `concat!` to make a static string as a format argument
+    // of `eprintln!` because `file!` could contain a `{` or
+    // `$val` expression could be a block (`{ .. }`), in which case the `eprintln!`
+    // will be malformed.
    () => {
        $crate::eprintln!("[{}:{}:{}]", $crate::file!(), $crate::line!(), $crate::column!())
    };
-    ($($val:expr),+ $(,)?) => {
-        $crate::macros::dbg_internal!(() () ($($val),+))
-    };
-}
-
-/// Internal macro that processes a list of expressions and produces a chain of
-/// nested `match`es, one for each expression, before finally calling `eprint!`
-/// with the collected information and returning all the evaluated expressions
-/// in a tuple.
-///
-/// E.g. `dbg_internal!(() () (1, 2))` expands into
-/// ```rust, ignore
-/// match 1 {
-///     tmp_1 => match 2 {
-///         tmp_2 => {
-///             eprint!("...", &tmp_1, &tmp_2, /* some other arguments */);
-///             (tmp_1, tmp_2)
-///         }
-///     }
-/// }
-/// ```
-///
-/// This is necessary so that `dbg!` outputs don't get torn, see #136703.
-#[doc(hidden)]
-#[rustc_macro_transparency = "semiopaque"]
-pub macro dbg_internal {
-    (($($piece:literal),+) ($($processed:expr => $bound:expr),+) ()) => {{
-        $crate::eprint!(
-            $crate::concat!($($piece),+),
-            $(
-                $crate::stringify!($processed),
-                // The `&T: Debug` check happens here (not in the format literal desugaring)
-                // to avoid format literal related messages and suggestions.
-                &&$bound as &dyn $crate::fmt::Debug
-            ),+,
-            // The location returned here is that of the macro invocation, so
-            // it will be the same for all expressions. Thus, label these
-            // arguments so that they can be reused in every piece of the
-            // formatting template.
-            file=$crate::file!(),
-            line=$crate::line!(),
-            column=$crate::column!()
-        );
-        // Comma separate the variables only when necessary so that this will
-        // not yield a tuple for a single expression, but rather just parenthesize
-        // the expression.
-        ($($bound),+)
-    }},
-    (($($piece:literal),*) ($($processed:expr => $bound:expr),*) ($val:expr $(,$rest:expr)*)) => {
+    ($val:expr $(,)?) => {
        // Use of `match` here is intentional because it affects the lifetimes
        // of temporaries - https://stackoverflow.com/a/48732525/1063961
        match $val {
-            tmp => $crate::macros::dbg_internal!(
-                ($($piece,)* "[{file}:{line}:{column}] {} = {:#?}\n")
-                ($($processed => $bound,)* $val => tmp)
-                ($($rest),*)
-            ),
+            tmp => {
+                $crate::eprintln!("[{}:{}:{}] {} = {:#?}",
+                    $crate::file!(),
+                    $crate::line!(),
+                    $crate::column!(),
+                    $crate::stringify!($val),
+                    // The `&T: Debug` check happens here (not in the format literal desugaring)
+                    // to avoid format literal related messages and suggestions.
+                    &&tmp as &dyn $crate::fmt::Debug,
+                );
+                tmp
+            }
        }
-    },
+    };
+    ($($val:expr),+ $(,)?) => {
+        ($($crate::dbg!($val)),+,)
+    };
 }
--- a/library/std/src/os/windows/fs.rs
+++ b/library/std/src/os/windows/fs.rs
@@ -138,6 +138,8 @@ impl FileExt for fs::File {
 }

 /// Windows-specific extensions to [`fs::OpenOptions`].
+// WARNING: This trait is not sealed. DON'T add any new methods!
+// Add them to OpenOptionsExt2 instead.
 #[stable(feature = "open_options_ext", since = "1.10.0")]
 pub trait OpenOptionsExt {
    /// Overrides the `dwDesiredAccess` argument to the call to [`CreateFile`]
@@ -305,18 +307,6 @@ pub trait OpenOptionsExt {
    ///     https://docs.microsoft.com/en-us/windows/win32/api/winnt/ne-winnt-security_impersonation_level
    #[stable(feature = "open_options_ext", since = "1.10.0")]
    fn security_qos_flags(&mut self, flags: u32) -> &mut Self;
-
-    /// If set to `true`, prevent the "last access time" of the file from being changed.
-    ///
-    /// Default to `false`.
-    #[unstable(feature = "windows_freeze_file_times", issue = "149715")]
-    fn freeze_last_access_time(&mut self, freeze: bool) -> &mut Self;
-
-    /// If set to `true`, prevent the "last write time" of the file from being changed.
-    ///
-    /// Default to `false`.
-    #[unstable(feature = "windows_freeze_file_times", issue = "149715")]
-    fn freeze_last_write_time(&mut self, freeze: bool) -> &mut Self;
 }

 #[stable(feature = "open_options_ext", since = "1.10.0")]
@@ -345,7 +335,28 @@ impl OpenOptionsExt for OpenOptions {
        self.as_inner_mut().security_qos_flags(flags);
        self
    }
+}

+#[unstable(feature = "windows_freeze_file_times", issue = "149715")]
+pub trait OpenOptionsExt2: Sealed {
+    /// If set to `true`, prevent the "last access time" of the file from being changed.
+    ///
+    /// Default to `false`.
+    #[unstable(feature = "windows_freeze_file_times", issue = "149715")]
+    fn freeze_last_access_time(&mut self, freeze: bool) -> &mut Self;
+
+    /// If set to `true`, prevent the "last write time" of the file from being changed.
+    ///
+    /// Default to `false`.
+    #[unstable(feature = "windows_freeze_file_times", issue = "149715")]
+    fn freeze_last_write_time(&mut self, freeze: bool) -> &mut Self;
+}
+
+#[unstable(feature = "sealed", issue = "none")]
+impl Sealed for OpenOptions {}
+
+#[unstable(feature = "windows_freeze_file_times", issue = "149715")]
+impl OpenOptionsExt2 for OpenOptions {
    fn freeze_last_access_time(&mut self, freeze: bool) -> &mut Self {
        self.as_inner_mut().freeze_last_access_time(freeze);
        self
--- a/library/std/src/prelude/v1.rs
+++ b/library/std/src/prelude/v1.rs
@@ -79,7 +79,7 @@ mod ambiguous_macros_only {
 #[doc(no_inline)]
 pub use self::ambiguous_macros_only::{vec, panic};

-#[stable(feature = "cfg_select", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "cfg_select", since = "1.95.0")]
 #[doc(no_inline)]
 pub use core::prelude::v1::cfg_select;

--- a/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
+++ b/library/stdarch/crates/core_arch/src/aarch64/neon/generated.rs
@@ -49,7 +49,7 @@ pub fn __crc32d(crc: u32, data: u64) -> u32 {
 #[inline(always)]
 #[target_feature(enable = "jsconv")]
 #[cfg_attr(test, assert_instr(fjcvtzs))]
-#[stable(feature = "stdarch_aarch64_jscvt", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "stdarch_aarch64_jscvt", since = "1.95.0")]
 pub fn __jcvt(a: f64) -> i32 {
    unsafe extern "unadjusted" {
        #[cfg_attr(
--- a/library/stdarch/crates/core_arch/src/macros.rs
+++ b/library/stdarch/crates/core_arch/src/macros.rs
@@ -226,12 +226,12 @@ macro_rules! deinterleaving_load {
    ($elem:ty, $lanes:literal, 2, $ptr:expr) => {{
        use $crate::core_arch::macros::deinterleave_mask;
        use $crate::core_arch::simd::Simd;
-        use $crate::{mem::transmute, ptr};
+        use $crate::mem::transmute;

        type V = Simd<$elem, $lanes>;
        type W = Simd<$elem, { $lanes * 2 }>;

-        let w: W = ptr::read_unaligned($ptr as *const W);
+        let w: W = $crate::ptr::read_unaligned($ptr as *const W);

        let v0: V = simd_shuffle!(w, w, deinterleave_mask::<$lanes, 2, 0>());
        let v1: V = simd_shuffle!(w, w, deinterleave_mask::<$lanes, 2, 1>());
@@ -242,12 +242,20 @@ macro_rules! deinterleaving_load {
    ($elem:ty, $lanes:literal, 3, $ptr:expr) => {{
        use $crate::core_arch::macros::deinterleave_mask;
        use $crate::core_arch::simd::Simd;
-        use $crate::{mem::transmute, ptr};
+        use $crate::mem::{MaybeUninit, transmute};

        type V = Simd<$elem, $lanes>;
        type W = Simd<$elem, { $lanes * 3 }>;

-        let w: W = ptr::read_unaligned($ptr as *const W);
+        // NOTE: repr(simd) adds padding to make the total size a power of two.
+        // Hence reading W from ptr might read out of bounds.
+        let mut mem = MaybeUninit::<W>::uninit();
+        $crate::ptr::copy_nonoverlapping(
+            $ptr.cast::<$elem>(),
+            mem.as_mut_ptr().cast::<$elem>(),
+            $lanes * 3,
+        );
+        let w = mem.assume_init();

        let v0: V = simd_shuffle!(w, w, deinterleave_mask::<$lanes, 3, 0>());
        let v1: V = simd_shuffle!(w, w, deinterleave_mask::<$lanes, 3, 1>());
@@ -259,12 +267,12 @@ macro_rules! deinterleaving_load {
    ($elem:ty, $lanes:literal, 4, $ptr:expr) => {{
        use $crate::core_arch::macros::deinterleave_mask;
        use $crate::core_arch::simd::Simd;
-        use $crate::{mem::transmute, ptr};
+        use $crate::mem::transmute;

        type V = Simd<$elem, $lanes>;
        type W = Simd<$elem, { $lanes * 4 }>;

-        let w: W = ptr::read_unaligned($ptr as *const W);
+        let w: W = $crate::ptr::read_unaligned($ptr as *const W);

        let v0: V = simd_shuffle!(w, w, deinterleave_mask::<$lanes, 4, 0>());
        let v1: V = simd_shuffle!(w, w, deinterleave_mask::<$lanes, 4, 1>());
--- a/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
+++ b/library/stdarch/crates/stdarch-gen-arm/spec/neon/aarch64.spec.yml
@@ -64,7 +64,7 @@ neon-unstable-feat-lut: &neon-unstable-feat-lut
  FnCall: [unstable, ['feature = "stdarch_neon_feat_lut"', 'issue = "138050"']]

 aarch64-stable-jscvt: &aarch64-stable-jscvt
-  FnCall: [stable, ['feature = "stdarch_aarch64_jscvt"', 'since = "CURRENT_RUSTC_VERSION"']]
+  FnCall: [stable, ['feature = "stdarch_aarch64_jscvt"', 'since = "1.95.0"']]

 # #[unstable(feature = "stdarch_neon_feat_lrcpc3", issue = "none")]
 neon-unstable-feat-lrcpc3: &neon-unstable-feat-lrcpc3
--- a/library/test/build.rs
+++ b/library/test/build.rs
@@ -2,11 +2,16 @@ fn main() {
    println!("cargo:rerun-if-changed=build.rs");
    println!("cargo:rustc-check-cfg=cfg(enable_unstable_features)");

-    let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
-    let version = std::process::Command::new(rustc).arg("-vV").output().unwrap();
-    let stdout = String::from_utf8(version.stdout).unwrap();
+    // Miri testing uses unstable features, so always enable that for its sysroot.
+    // Otherwise, only enable unstable if rustc looks like a nightly or dev build.
+    let enable_unstable_features = std::env::var("MIRI_CALLED_FROM_SETUP").is_ok() || {
+        let rustc = std::env::var("RUSTC").unwrap_or_else(|_| "rustc".into());
+        let version = std::process::Command::new(rustc).arg("-vV").output().unwrap();
+        let stdout = String::from_utf8(version.stdout).unwrap();
+        stdout.contains("nightly") || stdout.contains("dev")
+    };

-    if stdout.contains("nightly") || stdout.contains("dev") {
+    if enable_unstable_features {
        println!("cargo:rustc-cfg=enable_unstable_features");
    }
 }
--- a/src/ci/channel
+++ b/src/ci/channel
@@ -1 +1 @@
-nightly
+stable
--- a/src/ci/docker/host-x86_64/dist-arm-linux-musl/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-arm-linux-musl/Dockerfile
@@ -6,6 +6,8 @@ RUN sh /scripts/cross-apt-packages.sh
 WORKDIR /build

 COPY scripts/musl-toolchain.sh /build/
+COPY scripts/musl-cve-2026-6042.diff /build/
+COPY scripts/musl-cve-2026-40200.diff /build/
 # We need to mitigate rust-lang/rust#34978 when compiling musl itself as well
 RUN CFLAGS="-Wa,--compress-debug-sections=none -Wl,--compress-debug-sections=none" \
    CXXFLAGS="-Wa,--compress-debug-sections=none -Wl,--compress-debug-sections=none" \
--- a/src/ci/docker/host-x86_64/dist-i586-gnu-i586-i686-musl/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-i586-gnu-i586-i686-musl/Dockerfile
@@ -39,6 +39,8 @@ ENV \

 WORKDIR /build/
 COPY scripts/musl.sh /build/
+COPY scripts/musl-cve-2026-6042.diff /build/
+COPY scripts/musl-cve-2026-40200.diff /build/
 RUN CC=gcc CFLAGS="-m32 -Wa,-mrelax-relocations=no" \
    CXX=g++ CXXFLAGS="-m32 -Wa,-mrelax-relocations=no" \
    bash musl.sh i686 --target=i686 && \
--- a/src/ci/docker/host-x86_64/dist-various-1/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-various-1/Dockerfile
@@ -65,6 +65,8 @@ ENV PATH="/build/emsdk:/build/emsdk/upstream/emscripten:/build/emsdk/node/curren
 ENV STAGING_DIR=/tmp

 COPY scripts/musl.sh /build
+COPY scripts/musl-cve-2026-6042.diff /build/
+COPY scripts/musl-cve-2026-40200.diff /build/
 RUN env \
    CC=arm-linux-gnueabi-gcc CFLAGS="-march=armv5te -marm -mfloat-abi=soft" \
    CXX=arm-linux-gnueabi-g++ CXXFLAGS="-march=armv5te -marm -mfloat-abi=soft" \
--- a/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-various-2/Dockerfile
@@ -68,6 +68,8 @@ ENV \

 WORKDIR /build
 COPY scripts/musl.sh /build
+COPY scripts/musl-cve-2026-6042.diff /build/
+COPY scripts/musl-cve-2026-40200.diff /build/
 RUN env \
    CC=arm-linux-gnueabi-gcc-9 CFLAGS="-march=armv7-a" \
    CXX=arm-linux-gnueabi-g++-9 CXXFLAGS="-march=armv7-a" \
--- a/src/ci/docker/host-x86_64/dist-x86_64-musl/Dockerfile
+++ b/src/ci/docker/host-x86_64/dist-x86_64-musl/Dockerfile
@@ -25,6 +25,8 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 WORKDIR /build/

 COPY scripts/musl-toolchain.sh /build/
+COPY scripts/musl-cve-2026-6042.diff /build/
+COPY scripts/musl-cve-2026-40200.diff /build/
 # We need to mitigate rust-lang/rust#34978 when compiling musl itself as well
 RUN CFLAGS="-Wa,-mrelax-relocations=no -Wa,--compress-debug-sections=none -Wl,--compress-debug-sections=none" \
    CXXFLAGS="-Wa,-mrelax-relocations=no -Wa,--compress-debug-sections=none -Wl,--compress-debug-sections=none" \
--- a/src/ci/docker/host-x86_64/test-various/Dockerfile
+++ b/src/ci/docker/host-x86_64/test-various/Dockerfile
@@ -35,6 +35,8 @@ ENV PATH="/node/bin:${PATH}"

 WORKDIR /build/
 COPY scripts/musl-toolchain.sh /build/
+COPY scripts/musl-cve-2026-6042.diff /build/
+COPY scripts/musl-cve-2026-40200.diff /build/
 RUN bash musl-toolchain.sh x86_64 && rm -rf build
 WORKDIR /

--- a/src/ci/docker/scripts/musl-cve-2026-40200.diff
+++ b/src/ci/docker/scripts/musl-cve-2026-40200.diff
@@ -0,0 +1,179 @@
+>From 228da39e38c1cae13cbe637e771412c1984dba5d Mon Sep 17 00:00:00 2001
+From: Rich Felker <dalias@aerifal.cx>
+Date: Thu, 9 Apr 2026 22:51:30 -0400
+Subject: [PATCH 1/3] qsort: fix leonardo heap corruption from bug in
+ doubleword ctz primitive
+
+the pntz function, implementing a "count trailing zeros" variant for a
+bit vector consisting of two size_t words, erroneously returned zero
+rather than the number of bits in the low word when the first bit set
+was the low bit of the high word.
+
+as a result, a loop in the trinkle function which should have a
+guaranteed small bound on the number of iterations, could run
+unboundedly, thereby overflowing a stack-based working-space array
+which was sized for the bound.
+
+CVE-2026-40200 has been assigned for this issue.
+---
+ src/stdlib/qsort.c | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/src/stdlib/qsort.c b/src/stdlib/qsort.c
+index ab79dc6f..13219ab3 100644
+--- a/src/stdlib/qsort.c
+++ b/src/stdlib/qsort.c
+@@ -34,11 +34,11 @@
+ 
+ typedef int (*cmpfun)(const void *, const void *, void *);
+ 
+/* returns index of first bit set, excluding the low bit assumed to always
+ * be set, starting from low bit of p[0] up through high bit of p[1] */
+ static inline int pntz(size_t p[2]) {
+-	int r = ntz(p[0] - 1);
+-	if(r != 0 || (r = 8*sizeof(size_t) + ntz(p[1])) != 8*sizeof(size_t)) {
+-		return r;
+-	}
+	if (p[0] != 1) return ntz(p[0] - 1);
+	if (p[1]) return 8*sizeof(size_t) + ntz(p[1]);
+ 	return 0;
+ }
+ 
+-- 
+2.21.0
+
+
+>From b3291b9a9f77f1f993d2b4f8c68a26cf09221ae7 Mon Sep 17 00:00:00 2001
+From: Rich Felker <dalias@aerifal.cx>
+Date: Thu, 9 Apr 2026 23:40:53 -0400
+Subject: [PATCH 2/3] qsort: hard-preclude oob array writes independent of any
+ invariants
+
+while the root cause of CVE-2026-40200 was a faulty ctz primitive, the
+fallout of the bug would have been limited to erroneous sorting or
+infinite loop if not for the stores to a stack-based array that
+depended on trusting invariants in order not to go out of bounds.
+
+increase the size of the array to a power of two so that we can mask
+indices into it to force them into range. in the absence of any
+further bug, the masking is a no-op, but it does not have any
+measurable performance cost, and it makes spatial memory safety
+trivial to prove (and for readers not familiar with the algorithms to
+trust).
+---
+ src/stdlib/qsort.c | 20 +++++++++++++-------
+ 1 file changed, 13 insertions(+), 7 deletions(-)
+
+diff --git a/src/stdlib/qsort.c b/src/stdlib/qsort.c
+index 13219ab3..e4bce9f7 100644
+--- a/src/stdlib/qsort.c
+++ b/src/stdlib/qsort.c
+@@ -89,10 +89,16 @@ static inline void shr(size_t p[2], int n)
+ 	p[1] >>= n;
+ }
+ 
+/* power-of-two length for working array so that we can mask indices and
+ * not depend on any invariant of the algorithm for spatial memory safety.
+ * the original size was just 14*sizeof(size_t)+1 */
+#define AR_LEN  (16 * sizeof(size_t))
+#define AR_MASK (AR_LEN - 1)
+
+ static void sift(unsigned char *head, size_t width, cmpfun cmp, void *arg, int pshift, size_t lp[])
+ {
+ 	unsigned char *rt, *lf;
+-	unsigned char *ar[14 * sizeof(size_t) + 1];
+	unsigned char *ar[AR_LEN];
+ 	int i = 1;
+ 
+ 	ar[0] = head;
+@@ -104,16 +110,16 @@ static void sift(unsigned char *head, size_t width, cmpfun cmp, void *arg, int p
+ 			break;
+ 		}
+ 		if(cmp(lf, rt, arg) >= 0) {
+-			ar[i++] = lf;
+			ar[i++ & AR_MASK] = lf;
+ 			head = lf;
+ 			pshift -= 1;
+ 		} else {
+-			ar[i++] = rt;
+			ar[i++ & AR_MASK] = rt;
+ 			head = rt;
+ 			pshift -= 2;
+ 		}
+ 	}
+-	cycle(width, ar, i);
+	cycle(width, ar, i & AR_MASK);
+ }
+ 
+ static void trinkle(unsigned char *head, size_t width, cmpfun cmp, void *arg, size_t pp[2], int pshift, int trusty, size_t lp[])
+@@ -121,7 +127,7 @@ static void trinkle(unsigned char *head, size_t width, cmpfun cmp, void *arg, si
+ 	unsigned char *stepson,
+ 	              *rt, *lf;
+ 	size_t p[2];
+-	unsigned char *ar[14 * sizeof(size_t) + 1];
+	unsigned char *ar[AR_LEN];
+ 	int i = 1;
+ 	int trail;
+ 
+@@ -142,7 +148,7 @@ static void trinkle(unsigned char *head, size_t width, cmpfun cmp, void *arg, si
+ 			}
+ 		}
+ 
+-		ar[i++] = stepson;
+		ar[i++ & AR_MASK] = stepson;
+ 		head = stepson;
+ 		trail = pntz(p);
+ 		shr(p, trail);
+@@ -150,7 +156,7 @@ static void trinkle(unsigned char *head, size_t width, cmpfun cmp, void *arg, si
+ 		trusty = 0;
+ 	}
+ 	if(!trusty) {
+-		cycle(width, ar, i);
+		cycle(width, ar, i & AR_MASK);
+ 		sift(head, width, cmp, arg, pshift, lp);
+ 	}
+ }
+-- 
+2.21.0
+
+
+>From 5122f9f3c99fee366167c5de98b31546312921ab Mon Sep 17 00:00:00 2001
+From: Luca Kellermann <mailto.luca.kellermann@gmail.com>
+Date: Fri, 10 Apr 2026 03:03:22 +0200
+Subject: [PATCH 3/3] qsort: fix shift UB in shl and shr
+
+if shl() or shr() are called with n==8*sizeof(size_t), n is adjusted
+to 0. the shift by (sizeof(size_t) * 8 - n) that then follows will
+consequently shift by the width of size_t, which is UB and in practice
+produces an incorrect result.
+
+return early in this case. the bitvector p was already shifted by the
+required amount.
+---
+ src/stdlib/qsort.c | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/src/stdlib/qsort.c b/src/stdlib/qsort.c
+index e4bce9f7..28607450 100644
+--- a/src/stdlib/qsort.c
+++ b/src/stdlib/qsort.c
+@@ -71,6 +71,7 @@ static inline void shl(size_t p[2], int n)
+ 		n -= 8 * sizeof(size_t);
+ 		p[1] = p[0];
+ 		p[0] = 0;
+		if (!n) return;
+ 	}
+ 	p[1] <<= n;
+ 	p[1] |= p[0] >> (sizeof(size_t) * 8 - n);
+@@ -83,6 +84,7 @@ static inline void shr(size_t p[2], int n)
+ 		n -= 8 * sizeof(size_t);
+ 		p[0] = p[1];
+ 		p[1] = 0;
+		if (!n) return;
+ 	}
+ 	p[0] >>= n;
+ 	p[0] |= p[1] << (sizeof(size_t) * 8 - n);
+-- 
+2.21.0
+
+
--- a/src/ci/docker/scripts/musl-cve-2026-6042.diff
+++ b/src/ci/docker/scripts/musl-cve-2026-6042.diff
@@ -0,0 +1,321 @@
+>From 67219f0130ec7c876ac0b299046460fad31caabf Mon Sep 17 00:00:00 2001
+From: Rich Felker <dalias@aerifal.cx>
+Date: Mon, 30 Mar 2026 16:00:50 -0400
+Subject: [PATCH] fix pathological slowness & incorrect mappings in iconv
+ gb18030 decoder
+
+in order to implement the "UTF" aspect of gb18030 (ability to
+represent arbitrary unicode characters not present in the 2-byte
+mapping), we have to apply the index obtained from the encoded 4-byte
+sequence into the set of unmapped characters. this was done by
+scanning repeatedly over the table of mapped characters and counting
+off mapped characters below a running index by which to adjust the
+running index by on each iteration. this iterative process eventually
+leaves us with the value of the Nth unmapped character replacing the
+index, but depending on which particular character that is, the number
+of iterations needed to find it can be in the tens of thousands, and
+each iteration traverses the whole 126x190 table in the inner loop.
+this can lead to run times exceeding an entire second per character on
+moderate-speed machines.
+
+on top of that, the transformation logic produced wrong results for
+BMP characters above the the surrogate range, as a result of not
+correctly accounting for it being excluded, and for characters outside
+the BMP, as a result of a misunderstanding of how gb18030 encodes
+them.
+
+this patch replaces the unmapped character lookup with a single linear
+search of a list of unmapped ranges. there are only 206 such ranges,
+and these are permanently assigned and unchangeable as a consequence
+of the character encoding having to be stable, so a simple array of
+16-bit start/length values for each range consumes only 824 bytes, a
+very reasonable size cost here.
+
+this new table accounts for the previously-incorrect surrogate
+handling, and non-BMP characters are handled correctly by a single
+offset, without the need for any unmapped-range search.
+
+there are still a small number of mappings that are incorrect due to
+late changes made in the definition of gb18030, swapping PUA
+codepoints with proper Unicode characters. correcting these requires a
+postprocessing step that will be added later.
+---
+ src/locale/gb18030utf.h | 206 ++++++++++++++++++++++++++++++++++++++++
+ src/locale/iconv.c      |  33 +++++--
+ 2 files changed, 230 insertions(+), 9 deletions(-)
+ create mode 100644 src/locale/gb18030utf.h
+
+diff --git a/src/locale/gb18030utf.h b/src/locale/gb18030utf.h
+new file mode 100644
+index 00000000..322a2440
+--- /dev/null
+++ b/src/locale/gb18030utf.h
+@@ -0,0 +1,206 @@
+{ 0x80, 36 },
+{ 0xa5, 2 },
+{ 0xa9, 7 },
+{ 0xb2, 5 },
+{ 0xb8, 31 },
+{ 0xd8, 8 },
+{ 0xe2, 6 },
+{ 0xeb, 1 },
+{ 0xee, 4 },
+{ 0xf4, 3 },
+{ 0xf8, 1 },
+{ 0xfb, 1 },
+{ 0xfd, 4 },
+{ 0x102, 17 },
+{ 0x114, 7 },
+{ 0x11c, 15 },
+{ 0x12c, 24 },
+{ 0x145, 3 },
+{ 0x149, 4 },
+{ 0x14e, 29 },
+{ 0x16c, 98 },
+{ 0x1cf, 1 },
+{ 0x1d1, 1 },
+{ 0x1d3, 1 },
+{ 0x1d5, 1 },
+{ 0x1d7, 1 },
+{ 0x1d9, 1 },
+{ 0x1db, 1 },
+{ 0x1dd, 28 },
+{ 0x1fa, 87 },
+{ 0x252, 15 },
+{ 0x262, 101 },
+{ 0x2c8, 1 },
+{ 0x2cc, 13 },
+{ 0x2da, 183 },
+{ 0x3a2, 1 },
+{ 0x3aa, 7 },
+{ 0x3c2, 1 },
+{ 0x3ca, 55 },
+{ 0x402, 14 },
+{ 0x450, 1 },
+{ 0x452, 7102 },
+{ 0x2011, 2 },
+{ 0x2017, 1 },
+{ 0x201a, 2 },
+{ 0x201e, 7 },
+{ 0x2027, 9 },
+{ 0x2031, 1 },
+{ 0x2034, 1 },
+{ 0x2036, 5 },
+{ 0x203c, 112 },
+{ 0x20ad, 86 },
+{ 0x2104, 1 },
+{ 0x2106, 3 },
+{ 0x210a, 12 },
+{ 0x2117, 10 },
+{ 0x2122, 62 },
+{ 0x216c, 4 },
+{ 0x217a, 22 },
+{ 0x2194, 2 },
+{ 0x219a, 110 },
+{ 0x2209, 6 },
+{ 0x2210, 1 },
+{ 0x2212, 3 },
+{ 0x2216, 4 },
+{ 0x221b, 2 },
+{ 0x2221, 2 },
+{ 0x2224, 1 },
+{ 0x2226, 1 },
+{ 0x222c, 2 },
+{ 0x222f, 5 },
+{ 0x2238, 5 },
+{ 0x223e, 10 },
+{ 0x2249, 3 },
+{ 0x224d, 5 },
+{ 0x2253, 13 },
+{ 0x2262, 2 },
+{ 0x2268, 6 },
+{ 0x2270, 37 },
+{ 0x2296, 3 },
+{ 0x229a, 11 },
+{ 0x22a6, 25 },
+{ 0x22c0, 82 },
+{ 0x2313, 333 },
+{ 0x246a, 10 },
+{ 0x249c, 100 },
+{ 0x254c, 4 },
+{ 0x2574, 13 },
+{ 0x2590, 3 },
+{ 0x2596, 10 },
+{ 0x25a2, 16 },
+{ 0x25b4, 8 },
+{ 0x25be, 8 },
+{ 0x25c8, 3 },
+{ 0x25cc, 2 },
+{ 0x25d0, 18 },
+{ 0x25e6, 31 },
+{ 0x2607, 2 },
+{ 0x260a, 54 },
+{ 0x2641, 1 },
+{ 0x2643, 2110 },
+{ 0x2e82, 2 },
+{ 0x2e85, 3 },
+{ 0x2e89, 2 },
+{ 0x2e8d, 10 },
+{ 0x2e98, 15 },
+{ 0x2ea8, 2 },
+{ 0x2eab, 3 },
+{ 0x2eaf, 4 },
+{ 0x2eb4, 2 },
+{ 0x2eb8, 3 },
+{ 0x2ebc, 14 },
+{ 0x2ecb, 293 },
+{ 0x2ffc, 4 },
+{ 0x3004, 1 },
+{ 0x3018, 5 },
+{ 0x301f, 2 },
+{ 0x302a, 20 },
+{ 0x303f, 2 },
+{ 0x3094, 7 },
+{ 0x309f, 2 },
+{ 0x30f7, 5 },
+{ 0x30ff, 6 },
+{ 0x312a, 246 },
+{ 0x322a, 7 },
+{ 0x3232, 113 },
+{ 0x32a4, 234 },
+{ 0x3390, 12 },
+{ 0x339f, 2 },
+{ 0x33a2, 34 },
+{ 0x33c5, 9 },
+{ 0x33cf, 2 },
+{ 0x33d3, 2 },
+{ 0x33d6, 113 },
+{ 0x3448, 43 },
+{ 0x3474, 298 },
+{ 0x359f, 111 },
+{ 0x360f, 11 },
+{ 0x361b, 765 },
+{ 0x3919, 85 },
+{ 0x396f, 96 },
+{ 0x39d1, 14 },
+{ 0x39e0, 147 },
+{ 0x3a74, 218 },
+{ 0x3b4f, 287 },
+{ 0x3c6f, 113 },
+{ 0x3ce1, 885 },
+{ 0x4057, 264 },
+{ 0x4160, 471 },
+{ 0x4338, 116 },
+{ 0x43ad, 4 },
+{ 0x43b2, 43 },
+{ 0x43de, 248 },
+{ 0x44d7, 373 },
+{ 0x464d, 20 },
+{ 0x4662, 193 },
+{ 0x4724, 5 },
+{ 0x472a, 82 },
+{ 0x477d, 16 },
+{ 0x478e, 441 },
+{ 0x4948, 50 },
+{ 0x497b, 2 },
+{ 0x497e, 4 },
+{ 0x4984, 1 },
+{ 0x4987, 20 },
+{ 0x499c, 3 },
+{ 0x49a0, 22 },
+{ 0x49b8, 703 },
+{ 0x4c78, 39 },
+{ 0x4ca4, 111 },
+{ 0x4d1a, 148 },
+{ 0x4daf, 81 },
+{ 0x9fa6, 14426 },
+{ 0xe76c, 1 },
+{ 0xe7c8, 1 },
+{ 0xe7e7, 13 },
+{ 0xe815, 1 },
+{ 0xe819, 5 },
+{ 0xe81f, 7 },
+{ 0xe827, 4 },
+{ 0xe82d, 4 },
+{ 0xe833, 8 },
+{ 0xe83c, 7 },
+{ 0xe844, 16 },
+{ 0xe856, 14 },
+{ 0xe865, 4295 },
+{ 0xf92d, 76 },
+{ 0xf97a, 27 },
+{ 0xf996, 81 },
+{ 0xf9e8, 9 },
+{ 0xf9f2, 26 },
+{ 0xfa10, 1 },
+{ 0xfa12, 1 },
+{ 0xfa15, 3 },
+{ 0xfa19, 6 },
+{ 0xfa22, 1 },
+{ 0xfa25, 2 },
+{ 0xfa2a, 1030 },
+{ 0xfe32, 1 },
+{ 0xfe45, 4 },
+{ 0xfe53, 1 },
+{ 0xfe58, 1 },
+{ 0xfe67, 1 },
+{ 0xfe6c, 149 },
+{ 0xff5f, 129 },
+{ 0xffe6, 26 },
+diff --git a/src/locale/iconv.c b/src/locale/iconv.c
+index 52178950..4151411d 100644
+--- a/src/locale/iconv.c
+++ b/src/locale/iconv.c
+@@ -74,6 +74,10 @@ static const unsigned short gb18030[126][190] = {
+ #include "gb18030.h"
+ };
+ 
+static const unsigned short gb18030utf[][2] = {
+#include "gb18030utf.h"
+};
+
+ static const unsigned short big5[89][157] = {
+ #include "big5.h"
+ };
+@@ -224,6 +228,8 @@ static unsigned uni_to_jis(unsigned c)
+ 	}
+ }
+ 
+#define countof(a) (sizeof (a) / sizeof *(a))
+
+ size_t iconv(iconv_t cd, char **restrict in, size_t *restrict inb, char **restrict out, size_t *restrict outb)
+ {
+ 	size_t x=0;
+@@ -430,15 +436,24 @@ size_t iconv(iconv_t cd, char **restrict in, size_t *restrict inb, char **restri
+ 				d = *((unsigned char *)*in + 3);
+ 				if (d-'0'>9) goto ilseq;
+ 				c += d-'0';
+-				c += 128;
+-				for (d=0; d<=c; ) {
+-					k = 0;
+-					for (int i=0; i<126; i++)
+-						for (int j=0; j<190; j++)
+-							if (gb18030[i][j]-d <= c-d)
+-								k++;
+-					d = c+1;
+-					c += k;
+				/* Starting at 90 30 81 30 (189000), mapping is
+				 * linear without gaps, to U+10000 and up. */
+				if (c >= 189000) {
+					c -= 189000;
+					c += 0x10000;
+					if (c >= 0x110000) goto ilseq;
+					break;
+				}
+				/* Otherwise we must process an index into set
+				 * of characters unmapped by 2-byte table. */
+				for (int i=0; ; i++) {
+					if (i==countof(gb18030utf))
+						goto ilseq;
+					if (c<gb18030utf[i][1]) {
+						c += gb18030utf[i][0];
+						break;
+					}
+					c -= gb18030utf[i][1];
+ 				}
+ 				break;
+ 			}
+-- 
+2.21.0
+
+
--- a/src/ci/docker/scripts/musl-toolchain.sh
+++ b/src/ci/docker/scripts/musl-toolchain.sh
@@ -48,6 +48,12 @@ cd musl-cross-make
 # A version that includes support for building musl 1.2.5
 git checkout 3635262e4524c991552789af6f36211a335a77b3

+# Patch CVE-2026-6042: https://www.openwall.com/lists/oss-security/2026/04/09/19
+# Patch CVE-2026-40200: https://www.openwall.com/lists/musl/2026/04/10/3
+# These should be removed when musl-cross-make adds them, or we upgrade to musl >= 1.2.7.
+cp /build/musl-cve-2026-6042.diff ./patches/musl-1.2.5/0003-cve-2026-6042.diff
+cp /build/musl-cve-2026-40200.diff ./patches/musl-1.2.5/0004-cve-2026-40200.diff
+
 hide_output make -j$(nproc) TARGET=$TARGET MUSL_VER=1.2.5 LINUX_HEADERS_SITE=$LINUX_HEADERS_SITE LINUX_VER=$LINUX_VER
 hide_output make install TARGET=$TARGET MUSL_VER=1.2.5 LINUX_HEADERS_SITE=$LINUX_HEADERS_SITE LINUX_VER=$LINUX_VER OUTPUT=$OUTPUT

--- a/src/ci/docker/scripts/musl.sh
+++ b/src/ci/docker/scripts/musl.sh
@@ -71,6 +71,19 @@ EOF
 			*outb -= k;
 			break;
 EOF
+
+  # Apply patches for CVE-2026-6042 and CVE-2026-40200.
+  #
+  # At the time of adding these patches no release containing them has been published by the musl
+  # project, so we just apply them directly on top of the version we were distributing already. The
+  # patches should be removed once we upgrade to musl >= 1.2.7.
+  #
+  # Advisory: https://www.openwall.com/lists/oss-security/2026/04/09/19
+  # Patches:  https://www.openwall.com/lists/musl/2026/04/03/2/1
+  patch -p1 -d $MUSL </build/musl-cve-2026-6042.diff
+  # Advisory: https://www.openwall.com/lists/musl/2026/04/10/3
+  # Patches:  https://www.openwall.com/lists/musl/2026/04/10/3/1
+  patch -p1 -d $MUSL </build/musl-cve-2026-40200.diff
 fi

 cd $MUSL
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -712,7 +712,6 @@ auto:
        --target=aarch64-pc-windows-gnullvm,i686-pc-windows-gnullvm
        --enable-full-tools
        --enable-profiler
-        --enable-llvm-link-shared
      DIST_REQUIRE_ALL_TOOLS: 1
      CODEGEN_BACKENDS: llvm,cranelift
      CC_i686_pc_windows_gnullvm: i686-w64-mingw32-clang
@@ -725,7 +724,6 @@ auto:
        --build=x86_64-pc-windows-gnullvm
        --enable-full-tools
        --enable-profiler
-        --enable-llvm-link-shared
      DIST_REQUIRE_ALL_TOOLS: 1
      CODEGEN_BACKENDS: llvm,cranelift
    <<: *job-windows
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -1,5 +1,4 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(assert_matches))]
 #![cfg_attr(bootstrap, feature(if_let_guard))]
 #![doc(
    html_root_url = "https://doc.rust-lang.org/nightly/",
@@ -7,6 +6,7 @@
 )]
 #![feature(ascii_char)]
 #![feature(ascii_char_variants)]
+#![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(file_buffered)]
 #![feature(formatting_options)]
--- a/src/llvm-project
+++ b/src/llvm-project
--- a/src/stage0
+++ b/src/stage0
@@ -13,544 +13,405 @@ nightly_branch=main
 # All changes below this comment will be overridden the next time the
 # tool is executed.

-compiler_channel_manifest_hash=198f721db4d4f48112a8afadd11b63165d14038596d94402e36d16c7e528cda8
-compiler_git_commit_hash=9b1f8ff42d110b0ca138116745be921df5dc97e7
-compiler_date=2026-01-20
-compiler_version=beta
-rustfmt_channel_manifest_hash=9136a5de582c2615de15a18c3fed0ba01bdfe0a1edc45467ced81b91ea6d2668
-rustfmt_git_commit_hash=5c49c4f7c8393c861b849441d27f5d40e0f1e33b
-rustfmt_date=2026-01-21
-rustfmt_version=nightly
+compiler_channel_manifest_hash=aaa177def36e01d539bee6bde95295230b9ce378f81057845db8d0ebe97898ee
+compiler_git_commit_hash=4a4ef493e3a1488c6e321570238084b38948f6db
+compiler_date=2026-03-05
+compiler_version=1.94.0

-dist/2026-01-20/rustc-beta-aarch64-apple-darwin.tar.gz=5cc0e51c8a3130f63cd6d13f5c0cab6723ae9fbab0e0a6b95ba11be873eb1b3a
-dist/2026-01-20/rustc-beta-aarch64-apple-darwin.tar.xz=c7c7fb474f9b1d2b5a7cff6d4c1503fc3e51624dec02b91c44b437a2fbc1c8fe
-dist/2026-01-20/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=998f017140a97b52cc028410ebaa69dd9d3c40e66e666681cfbae2b567985bb0
-dist/2026-01-20/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=a73ea4d00dd8465721f3257420494ba24ffc620450949b768f375cb7420eb72d
-dist/2026-01-20/rustc-beta-aarch64-pc-windows-msvc.tar.gz=8a9354bb17d8f8bce4a2313f24216b6c52d01f9b54d178b3f4fe51942ef23bff
-dist/2026-01-20/rustc-beta-aarch64-pc-windows-msvc.tar.xz=de2e668147224840fa33f4dbf7d4bf97bdee18c29805dcc285e1ed6699f68235
-dist/2026-01-20/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=012e6afd73999fab248497b052c0b7a20c7570bc1a9082806bee1c9171c671a3
-dist/2026-01-20/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=662fdd1472e45b2ca15f1c3fbe6439d9d58f0b7edbfbc54f87a78644c273e52d
-dist/2026-01-20/rustc-beta-aarch64-unknown-linux-musl.tar.gz=bba6f41e853989d3b7728d3f1169afa7137196cbc4696aeb43974b5b545b9e18
-dist/2026-01-20/rustc-beta-aarch64-unknown-linux-musl.tar.xz=70717b6bca2409266fdd670d2dcad076f000e6a0da0d6696b27e81c2ae0c132b
-dist/2026-01-20/rustc-beta-aarch64-unknown-linux-ohos.tar.gz=54829f68a0fc79b84e80a0d47bc322954f09a59c0a06493bc56bb3ed1552b27e
-dist/2026-01-20/rustc-beta-aarch64-unknown-linux-ohos.tar.xz=eb62be9276e425186c3adb0ce918a8d6de03f6f5b7f4e8fa6988369cd965450a
-dist/2026-01-20/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=103e62ea960d1d89524c8383bd2dc9ef236eb8334e3813d861092305cf22ed78
-dist/2026-01-20/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=b78e4ce929bba3bd6222a0ff21dc98dbe91f37ab59c5b00b997c67307f7dbcab
-dist/2026-01-20/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=76b0e61c0e412744651e847ca7388832b06173a9d78b92f6311fd3bbb9c56a13
-dist/2026-01-20/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=0fa5e9c25a4e5c404e6e2cb8c71212c80259d9cddf6462138a540fa83ecb15a6
-dist/2026-01-20/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=e86e88bdff894de048566f5e50f9fbedb7465a9cd3ca8e5f60e1a2be36c1bb8f
-dist/2026-01-20/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=2415d59e1b95ac67cd7dd7d4df0eb24e1c4086134127b0664856fa10f8b45b39
-dist/2026-01-20/rustc-beta-i686-pc-windows-gnu.tar.gz=3ea0d68636eb5d46bbcc14fcd89201f6b1d3e3dc2b5b6aae62eab881e6a51888
-dist/2026-01-20/rustc-beta-i686-pc-windows-gnu.tar.xz=110b6c903c2e835dee00e699bcdded24152421e77ef595f1de59135a4562a88f
-dist/2026-01-20/rustc-beta-i686-pc-windows-msvc.tar.gz=1a92b391333148cc6e4edfb405712fc91e7985d9eecfddadf57c1b028a9fd3f5
-dist/2026-01-20/rustc-beta-i686-pc-windows-msvc.tar.xz=92cac54e86536bdd2955e7612884c58a6112f701e923552259c5b18317f6fbcd
-dist/2026-01-20/rustc-beta-i686-unknown-linux-gnu.tar.gz=da3501275f4583d4e0edca756eaaffe8844276a3479a47348fa41e6ec9f2bddf
-dist/2026-01-20/rustc-beta-i686-unknown-linux-gnu.tar.xz=1373a0d9a5c1d9fa8c6e0001423187084e43f1670583a134497b0d9cb9172737
-dist/2026-01-20/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=215901dbf0a4281ec49ed87ab9a615e0576a19b29fa7678d6cd82e73a34af665
-dist/2026-01-20/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=df87f0d1b6db8fb4092ee2cd854fc60cbf61cfa648059f376bb438a51eb4400d
-dist/2026-01-20/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=c1ee374b6daca40863eb3c4a6b5158d745d08f98a5fab103ca348efb7e23c93a
-dist/2026-01-20/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=7ad8372e9b1f333050c57b9e645c19c45766babaef7ff654c1944415001c1eca
-dist/2026-01-20/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=85803d3595fe9d52de6e10e415a8509e9c006dee044640b20ca1cb85adc42122
-dist/2026-01-20/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=4981ce9ab5bb0a8b8d8b6d41836b533193195e415669bf054e8cd30db4a7480b
-dist/2026-01-20/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=4ccb74c4e2d2768f0774ed05feaa22d0dcb2613f6e5dfe8e4d10059c195fbd4f
-dist/2026-01-20/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=c807173335735810b0fc53d368eb142c93014509e1bb834f23260fccc9b6caa4
-dist/2026-01-20/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=679d2047f602d36782709a34db884efb252887502035131bd6426c1035a10e99
-dist/2026-01-20/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=41c41dbfaf76abddf39633ac1c4fa3b228428ea4dcbd85c07961c6d4350b93fd
-dist/2026-01-20/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=0b05419ba70cea7cb2f3171bceefa35844721c26e34ce36bd2a37ab437d0813e
-dist/2026-01-20/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=77a7e18d4841114c555d6624beffa355ea1685ab74ea0974014252cd2ced8adb
-dist/2026-01-20/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=af4a951fd83e6e22f902b8dde0ed7cdd3342f6d91dcf844488be3fb88e0edadf
-dist/2026-01-20/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=30f471ac01b7ac6e6052c0b11fd1fa33dba0af2abdfc8eaf11fa5a48627d5c07
-dist/2026-01-20/rustc-beta-s390x-unknown-linux-gnu.tar.gz=788dd17f29c7594bb425ec9f2686453eeaeedf45c11388b714b1b6f0b35fb018
-dist/2026-01-20/rustc-beta-s390x-unknown-linux-gnu.tar.xz=2117b3e3ad7f252e0790500add59204038b9e4709710df7757ffe2dbc0d264bf
-dist/2026-01-20/rustc-beta-sparcv9-sun-solaris.tar.gz=4ef69aa3d5ec31ce15ee7c38667aac9b1c101b948ee3095da23bde2fee75d3a4
-dist/2026-01-20/rustc-beta-sparcv9-sun-solaris.tar.xz=815f1800251b3bb79a681dfdcfc192971465c260ed7c6a57ee964b80962f2ab4
-dist/2026-01-20/rustc-beta-x86_64-apple-darwin.tar.gz=c2ec3532fa91de3fdb0e321db0505bb991349f6029ddcd460998b2141504a38d
-dist/2026-01-20/rustc-beta-x86_64-apple-darwin.tar.xz=5c73b88d90f6ae44541d7f4c3dfcce184279f619f74bf3865147008d08ea7889
-dist/2026-01-20/rustc-beta-x86_64-pc-solaris.tar.gz=d278027e01143a16596be0efd73673f721f66618050687f344e98bbb9c248128
-dist/2026-01-20/rustc-beta-x86_64-pc-solaris.tar.xz=8bcc061f863c77b33638f66cc5c2288a3af75a3ce9ac85c9ff6ef2664916f572
-dist/2026-01-20/rustc-beta-x86_64-pc-windows-gnu.tar.gz=2458c5b4cf577e02dddd5bf41b1ef774f3cbb100ed6efbd290f44fdd2539dda0
-dist/2026-01-20/rustc-beta-x86_64-pc-windows-gnu.tar.xz=8bdbce81fb1a1ededf46e8c59e90213110f96c9bdeb3432a9440998968438173
-dist/2026-01-20/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=ea6132e6b43420787771edd7c1737b22e93e70c87234460053b9061d4404f763
-dist/2026-01-20/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=06ad990dc69585f8e465b28bf9974e009f846dcaaa0af651fb01b0f6b7d64eb9
-dist/2026-01-20/rustc-beta-x86_64-pc-windows-msvc.tar.gz=3e4700196332989cf177a182f545602e7731e16484b05ae1c30545cbb936d7b8
-dist/2026-01-20/rustc-beta-x86_64-pc-windows-msvc.tar.xz=7c381cfed5cf944beb19ba1349a779c88fbb4a007d2670fb2d5d63d8a2dbe976
-dist/2026-01-20/rustc-beta-x86_64-unknown-freebsd.tar.gz=a2448467346e77904fba417cf6758982711391b1eea6f576d438b886813d9281
-dist/2026-01-20/rustc-beta-x86_64-unknown-freebsd.tar.xz=9153cf38b57677a9f433a2cf70086a13f913445142692513a2b23155d4ae22c5
-dist/2026-01-20/rustc-beta-x86_64-unknown-illumos.tar.gz=b1118dde7d41c97409fc2febd068331c08d8bcca6d281078cfe0a4ce44789fa8
-dist/2026-01-20/rustc-beta-x86_64-unknown-illumos.tar.xz=7f4e7002f9cd612541a4809f907f6e18c0eb1765c621a0a944e87e28c5c6bb8a
-dist/2026-01-20/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=cbb5bd4b16665096beb06875c8eab8fb1a0de0043e6d70057bfc826ec4f8894f
-dist/2026-01-20/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=04382df840d1a3e24bf8c6f17fe7b39d2ca455204e161a51a0644be30a0c9176
-dist/2026-01-20/rustc-beta-x86_64-unknown-linux-musl.tar.gz=635629efe95735dd0e606e930b466170a40876c295903acdc308a8709976d1c3
-dist/2026-01-20/rustc-beta-x86_64-unknown-linux-musl.tar.xz=005a9e66acb005844eb48c616ad9fde6f830d45099cd68c56868a63bf85ca9a6
-dist/2026-01-20/rustc-beta-x86_64-unknown-netbsd.tar.gz=dbd411c130ef46a8d2618930906615358b77f2805d35cb5c898c63e5220bbaac
-dist/2026-01-20/rustc-beta-x86_64-unknown-netbsd.tar.xz=d6de09699651dee3946be112bda37221caafb0f0679181255a512d9045bfd7d0
-dist/2026-01-20/rust-std-beta-aarch64-apple-darwin.tar.gz=cc56445cdf88e1e987991c654b65076132e687e1f81ae0ecde119316db7ee6f8
-dist/2026-01-20/rust-std-beta-aarch64-apple-darwin.tar.xz=157b72888a9c6b358152c5e7876c2a9a28dcc2bc637d24a9e80c2f7b3b2d7c73
-dist/2026-01-20/rust-std-beta-aarch64-apple-ios.tar.gz=337b5e932725b7e7323b3954cc2cbeaddd7060dec14cac5aefae3d139207e0ae
-dist/2026-01-20/rust-std-beta-aarch64-apple-ios.tar.xz=941011b45dd518033aee4529fb96c3c18fba386beac6b80b0bde7c67f3e20cbd
-dist/2026-01-20/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=56d61f46311c4e60b23337c83a60bf628769da2ae2f998aad704d8e0bdaf46f2
-dist/2026-01-20/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=28c1904b991c23789bb6a947842a01640e6c94826a895f7e251490d7e1245ecf
-dist/2026-01-20/rust-std-beta-aarch64-apple-ios-sim.tar.gz=47ce08569d02aa034403416d9082c9c37b248a0c2c95d5e3bc494135686c61cf
-dist/2026-01-20/rust-std-beta-aarch64-apple-ios-sim.tar.xz=6d8498fcbf8cf374dc0df7799263f498f9c9bd5696e56d1d405b8c9af1b26b92
-dist/2026-01-20/rust-std-beta-aarch64-linux-android.tar.gz=d192fdcad5fce22b0e33d7112e8e82846efc7df2955e45ed054e33af8f561b0a
-dist/2026-01-20/rust-std-beta-aarch64-linux-android.tar.xz=d1b676986e7f14009468d4de953316594cec57454ab66e2c33442045bd786bca
-dist/2026-01-20/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=b118206b25b341e54b6a1924fba1af128682d439a50922142eabd955492f1506
-dist/2026-01-20/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=b6942f69d9cf556692975ddd6e9c6492fc27775543681eda9bbf7b47f7d8e837
-dist/2026-01-20/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=fc1c722efb6c101abf8a9c19be977917f5255b528094a61d47488f2a106df18e
-dist/2026-01-20/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=45f76965465de191ffd41391899db000183b3ffe7e09122071b66b53ce3157e5
-dist/2026-01-20/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=e18ae77c355b0f18dd50196cc066a821b349fd51444f60d2cd0513d645f860f6
-dist/2026-01-20/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=dd09b9a2b3123f93bb75d869cefae9629d774afa1ae836baadd4718fad38d03c
-dist/2026-01-20/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=4e5cd07f6d08ee4508866a8746677c4078cb8ae3575fd0d6b360900601f8afd7
-dist/2026-01-20/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=d1431f472132af6df49700e7713f57127a9436c4997e02cace5fef111aee2677
-dist/2026-01-20/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=a7816e9fd0aa5ea9f8069e7bdb29d851197324de17145af343503d6519d09381
-dist/2026-01-20/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=4d0a144e7483d51c5a6c78a727ccc93e0bb13174bcb06746431804f558c130b3
-dist/2026-01-20/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=b6e562eb9e07dfe65e84b43fd1ff9886ac7b36952d97c6bcdb56232895797914
-dist/2026-01-20/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=b52b1e208ab363e1f2a2d8076afaa4db22d83b86ba0eb78c8caee322d270fe8a
-dist/2026-01-20/rust-std-beta-aarch64-unknown-none.tar.gz=8d199014e8362b55551f4e05e25ab2a5a7df482ff0f69716dd4fb7fa86c24320
-dist/2026-01-20/rust-std-beta-aarch64-unknown-none.tar.xz=8fe7e72b6cc670c085411f93c821db270c3bee61e96961c199c6dce1ac81898e
-dist/2026-01-20/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=aa1bf4114d684bd97f97b47f38279075670995db4ba545d5428cc8756664113d
-dist/2026-01-20/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=54ef07430e12fab3107e90f4780a8d831626db8158f86e2ea4dce8d0a7a6f080
-dist/2026-01-20/rust-std-beta-aarch64-unknown-uefi.tar.gz=248c804b45350e176e7cf9d3fd9fc1111a5e92f28a709829474f4bc7f73a9868
-dist/2026-01-20/rust-std-beta-aarch64-unknown-uefi.tar.xz=4bc2a262d351cb47e91f075e2febbba413e3bbba38dde88f86c9ad7647d62b4e
-dist/2026-01-20/rust-std-beta-arm-linux-androideabi.tar.gz=25fe2b01984a70d184f00692b437a670bc9765172171a04c1027e58d8eb41320
-dist/2026-01-20/rust-std-beta-arm-linux-androideabi.tar.xz=bdf81424c056768e5b2de3d8f47f0fa8c6961609bd771f57014b091751e06137
-dist/2026-01-20/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=043e50c2670339b87b0544b38fea2ae2d232bdd39c36f452ac2fce36347c57d1
-dist/2026-01-20/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=143f95f8a2d3d2bd8981de4d9d329a33c90d91b7496f9ba7df02f270f3df0155
-dist/2026-01-20/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=40c2c0205bde6a79ed5d04a3a14ee0f764dd8d18ccfdd85c90f20cb42c832c08
-dist/2026-01-20/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=3099ccc2867df16e9b1217dd04e81ba109443e80da32a70169ac7b262ebf95fe
-dist/2026-01-20/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=424dc7f5da843c2d31e5b05be1ecebd284504905da218a33ddd200db09cca2f8
-dist/2026-01-20/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=062bfea00af6a21989bf65bff127ff3e8fd7a7fe3d219adddccf88ba0bb66662
-dist/2026-01-20/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=74b0625bec34ecba335939d2f43e3b5762d11671e67870c1bd02f3d48e540c80
-dist/2026-01-20/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=738a1803a385c41f95af4a0e43a8e5aa8d1aa368ab4a9253c4a1a26471e02779
-dist/2026-01-20/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=c4eeebec7e64ba5e4ec37e6e971b81acabf72f9183ba6133839048de208dbb62
-dist/2026-01-20/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=13953caa8c05ee02d3c4ae0e94e0a0e635cf3ba7afc4873f3f14485d39ae8797
-dist/2026-01-20/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=6d3a651bbe5abc175a94e725ea2f0e4c36608f42de4a66610f879d8ddd694af0
-dist/2026-01-20/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=01a8574f91e57e8327017566eb9be470473b45cfee3bf6a9793715421a4d0735
-dist/2026-01-20/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=6387160de6758466609c206ddd853be3cf376388f6cf17b616f2a5cfa587232a
-dist/2026-01-20/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=bbb47df59bcc69584d8cd2915e2bb04b80585b495823e7f8494db1fa93bfcdc7
-dist/2026-01-20/rust-std-beta-armv7-linux-androideabi.tar.gz=44b233bc802b61a535ba1cdfec7e2019d16d7a4e5f004289d329aca394515bc6
-dist/2026-01-20/rust-std-beta-armv7-linux-androideabi.tar.xz=e21f2779120fd6f421562c9298594d4477b1cc50b12153dc486665055a45aeef
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=e5c97d03ed3abd6ddb966e9eec940a90f1d47fe9a30b32618f0e0a9ca12f59b6
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=ce82bf2aba7b75c6dcb19a7eee70acc934a3b76e01a12048a0f008f971d5ca80
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=f5446ab9d2cd61669a22a0f1ae4cba1af43e3c681bcb8f76c4c74ab02a6be5d9
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=aaa788f52d1a35307c3483e18d5c2c942fd3bab5770557999d5f96eff65e9054
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=f0d13f8c265bfd2bd262f465f4dbe3a5199a0c64d1e7f732698d4a6a3ce485ae
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=f63d8760019bb5147afe3f41b7bee32e77bf145bde7cbd66d967a80cf8732af5
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=74025d9b500d5d42046ed5d5f61f8e5dfddaca6d4f8e3a70e54770a517206b74
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=13434d08a93291ca7cdb393723c53550a8fe75edc20533bc6f08500cf700270d
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=0fe9c1366b0e98bd6539d16f912a6e05b8927282540d087471c64f69e3cf6b4b
-dist/2026-01-20/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=2fd56632b57cb681ac6076c554c8666504bf995202e5075588f7c34ed8085807
-dist/2026-01-20/rust-std-beta-armv7a-none-eabi.tar.gz=278acce49b80ffb09a9782d16e0d6a720700c872c75113dd2bcdb85a3026845f
-dist/2026-01-20/rust-std-beta-armv7a-none-eabi.tar.xz=e0e52abb27568171ecf80f45690febe6e396d0af5bc38d6e73e7377fabd69899
-dist/2026-01-20/rust-std-beta-armv7a-none-eabihf.tar.gz=a553da7e46e629be7e12329fe236c9abe473e1ccf1a06f6aaf2e0a0d5f3d691b
-dist/2026-01-20/rust-std-beta-armv7a-none-eabihf.tar.xz=002fe75542e437e718845832e570982e785202505a8041fecb3123514b2f961b
-dist/2026-01-20/rust-std-beta-armv7r-none-eabi.tar.gz=254b5d4747b7ff23620490fbcf66084c8ed25dc0e771eb90e670d87bc0c7f0b7
-dist/2026-01-20/rust-std-beta-armv7r-none-eabi.tar.xz=b6c86fbb8dc2583eca27a7b041fc4f7fe711c663a8cb46f155b468cdc6c7229c
-dist/2026-01-20/rust-std-beta-armv7r-none-eabihf.tar.gz=ce2a9737eeda7f8982ecc41e720f9ed4b762288d8223735df5cca77ac2236c78
-dist/2026-01-20/rust-std-beta-armv7r-none-eabihf.tar.xz=acd2ab7fa3a80031880e4ce5061fb2c560ff083b729953225a179e5f8ed0061b
-dist/2026-01-20/rust-std-beta-armv8r-none-eabihf.tar.gz=5ad87901a799ae80d3e91b5e17a657d329ae7bd34606cebc5c986a628480c4dc
-dist/2026-01-20/rust-std-beta-armv8r-none-eabihf.tar.xz=fa83c2e59bc76031d342aaa57708c68dac145f6e658a645bca872d201e7fca9c
-dist/2026-01-20/rust-std-beta-i586-unknown-linux-gnu.tar.gz=fcebb4149026d36215fbac5c30d7b135ceafc963878becc49f4393424230f087
-dist/2026-01-20/rust-std-beta-i586-unknown-linux-gnu.tar.xz=03698b5571e5e7be170ec4ba882158736b232d69ba8465c289827c5509569c9e
-dist/2026-01-20/rust-std-beta-i586-unknown-linux-musl.tar.gz=b390bd31913d3b018166df661729e9ee552d46789b6c9ca2d3d5e21026a2195a
-dist/2026-01-20/rust-std-beta-i586-unknown-linux-musl.tar.xz=d11de928cb1857eccd2125dabe724d70461d287d3a05e53d0c39c7a020a6b83b
-dist/2026-01-20/rust-std-beta-i686-linux-android.tar.gz=8a54e4c05cf8e42c0633c32ff66b6a6d9704688076fb0ccfc3a6ec7eebbce329
-dist/2026-01-20/rust-std-beta-i686-linux-android.tar.xz=875d34834e32b35e76de275d38063be134de8672a692a9739f9abe6197ae25e2
-dist/2026-01-20/rust-std-beta-i686-pc-windows-gnu.tar.gz=38c84e49a2f8f8df4966b3092af8d4cf82a952c89d3bf57ee19a0eab428cd67e
-dist/2026-01-20/rust-std-beta-i686-pc-windows-gnu.tar.xz=651da8be90cb2ca29bdbc96bd9fe56d1654fccc2f80eda79d9358159120405a4
-dist/2026-01-20/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=74bdff560b2c21c66e7ebc8e028f05260a9f4d542893f843a49cc0a5904e2e92
-dist/2026-01-20/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=34dbf2186ee00a37482cc2c5540631d0fe879167977685fe1f5f9687b4a13e1a
-dist/2026-01-20/rust-std-beta-i686-pc-windows-msvc.tar.gz=ef96af22d000a26b7ccf071c2a57910c761a95d4ba7490eb5a5a6422851ef4bb
-dist/2026-01-20/rust-std-beta-i686-pc-windows-msvc.tar.xz=6680b37f26878c91012b20297c8ad3ff318cb1800a7434f3392fb606cd78227a
-dist/2026-01-20/rust-std-beta-i686-unknown-freebsd.tar.gz=491599ff71f37c43ffc190f6f48833ac97e7abf2b23399c8f7a7395dfb54cc9e
-dist/2026-01-20/rust-std-beta-i686-unknown-freebsd.tar.xz=46a91f11cd54ee4b1cad3b1b93a3b865404b6c87cd077fd9e4b89d84bc5ba836
-dist/2026-01-20/rust-std-beta-i686-unknown-linux-gnu.tar.gz=a4e8882af3628b45a7e09909cdda626df3b18fcac88ee2d295bd16f6aa0b09d6
-dist/2026-01-20/rust-std-beta-i686-unknown-linux-gnu.tar.xz=0f0899389080913cbac8dd531ca3d3eb8503653a551b71f59d238015e025dfe7
-dist/2026-01-20/rust-std-beta-i686-unknown-linux-musl.tar.gz=75e9760f5b416021f8f82f8a20283c6307584df12046680a2981ed306cfcb542
-dist/2026-01-20/rust-std-beta-i686-unknown-linux-musl.tar.xz=b51312fd213eaa7e0f8e374b2421c61822e8912734fbb228f97b045d27121e6d
-dist/2026-01-20/rust-std-beta-i686-unknown-uefi.tar.gz=b643b865409e819267c925fe69c84914d71eb634d17591edad1738dabaed9c2a
-dist/2026-01-20/rust-std-beta-i686-unknown-uefi.tar.xz=03a9a056d82ef3aeca9ff64e2d3ab5f0bdc0f8ff496393beb63fefbc5e633e84
-dist/2026-01-20/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=3f770cac4814cf73bd31aba5c59005cf60aa4f5a40da64d037c9a7235e248291
-dist/2026-01-20/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=fa74c6b92a7e61e8f2a33e2c3a2163bfe91273664f1a59e435c6748fe16cb43f
-dist/2026-01-20/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=96cfb6c20488f53791be313e70e147f3257353f39588e7949c487b69fbd0c937
-dist/2026-01-20/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=7c16dcd6685ef79d8b4e84b2bb06bedcec67498e3112a1322c663118ef49d02d
-dist/2026-01-20/rust-std-beta-loongarch64-unknown-none.tar.gz=2bc1dd28e95012670733527d59b391bd578218f38aebcb6990e629e8130d10c8
-dist/2026-01-20/rust-std-beta-loongarch64-unknown-none.tar.xz=d65dc641b81e561ab30823c99cdee32615b9ca56d0a6a75450f44eb25ee66ac6
-dist/2026-01-20/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=04fda933fde52c3bb35b52dc38fe973b30d2e1a2369d1d500d20781e7014b65a
-dist/2026-01-20/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=d2ce8dbade8c3a7c8ad9fb697d6f4b8551845263e8e9993772679c9a2e8334ff
-dist/2026-01-20/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=819464b843b4218f3e77613094615701e3b6b31fdff1ef8781c98d482f7bb6a7
-dist/2026-01-20/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=fa5dca88bcec7f44f8ac52f207ba8029e167de23d377e03ba7f60e8e2211b2c8
-dist/2026-01-20/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=bd5667a613dcb10a5d7d86f63123acd967e8572c16c0d39969dfadfc8c7182ca
-dist/2026-01-20/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=4b1092fcd8481a8e611b7f621348ae09f22eec3b50d1ca1aefdcd8c7d22a7d5c
-dist/2026-01-20/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=3a9f61f1da7d463ee4a06bda52dc534b8550beb09c82227c21ff02b0e2b94b44
-dist/2026-01-20/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=cc2c6a28f7b5182675c18f1cc87ba87a215eb91bfce45726970a23554c98ce25
-dist/2026-01-20/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=14b80b314e8778a057c45164ca13f5c66a621a2f882143fd3bf21f2804a7547e
-dist/2026-01-20/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=ad7082205aeff5014dfb7923bbf313cbfa8bcd97da098be6f267a4c45c0d53a1
-dist/2026-01-20/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=eaad6ab10d812cf3e5eec9b829614d011f9f9afc171c9e9226660ad54e40fb2e
-dist/2026-01-20/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=6bb3bf669bf53eb5b13e9387c057b33bff4e6ed63af92e0a611c3813032ef3dd
-dist/2026-01-20/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=2520f4f0569554108302f174dd1586752f6e987956e3e9a451ead4174a7a534e
-dist/2026-01-20/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=935a00898ae51312b31a74f626f54901f1ea20a7ad34c46b0afe52e73030336d
-dist/2026-01-20/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=704b2ffb62e06b81ba554eec92ecf764660cf34afa2a6c24baeb352da70505b9
-dist/2026-01-20/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=f673b92435126d88ab3282b25e20738aedb997db4c4a5ea74d49b8f4498c45e9
-dist/2026-01-20/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=b8cde078357091c89532baca3d1703db779a762e32b2f0dd10a2be6b10fabae1
-dist/2026-01-20/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=fc5ca415261fbaa65ffde2641bab65473201aa966d3bf99f11030af32f79685d
-dist/2026-01-20/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=636f2ba1ba6b443a76d7a03561a001a874e10559cfc0d2941a003eb6b2eab810
-dist/2026-01-20/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=5cbe945f2db55cdf1b06e0424f342aa509bb0689a131a309812da45a33e6b56b
-dist/2026-01-20/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=89dbfe19f8841cd04d59b8cfed9475df1accc991d60c0f14f66ec78341182abf
-dist/2026-01-20/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=975bf46c3ac09ff68d6f2f3ac151c173a626e730243d52834de8c2304ffec18f
-dist/2026-01-20/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.gz=22e2d02b26cef510ad3c9dbe3d90bc37e024a3845e6a6310dad9a550910823e2
-dist/2026-01-20/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.xz=9c3f58c9bebf264afb837cba63a09ae77ac5ca22f4063d290eca7e79c27253f9
-dist/2026-01-20/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=c8151863450d144882557691a8903912605f713fc9d1423d71270aff7e0cfa9d
-dist/2026-01-20/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=c896fc03d5df106d1ffd92a9d8eefbe68ded5298ef7802816460a184da99ecf7
-dist/2026-01-20/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=753981a75540a01945ed929105f5f484e58e2c2e16d8e1a00217fd1cc1fbfc2b
-dist/2026-01-20/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=d6186cd8f829c57357c1d494e11d0a1ddf58d10f7cc0fc063eca63099bab832b
-dist/2026-01-20/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=f89ffb6abceef381d0305f35b4366349d7a1739ede655071b105511b602a1f8e
-dist/2026-01-20/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=02a077f1aca2d02ab9d14531ea2c3728d7e4ed6551b065aaea0a7831f9d5a7d4
-dist/2026-01-20/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=88e3800176211ee1f149a7073caf1b9c81fc51e77b8f2f20fd0fed19382cddc1
-dist/2026-01-20/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=3824e9b78247a6213456b015dc7158702e05adda4b7147a6336a106dc94dc740
-dist/2026-01-20/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=95456e51cb0c764293879722c4a54d89c5fe362f7fd5aad886591df807fc95f7
-dist/2026-01-20/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=9b448fc6cee52ec53baca1bd5f93387e2f94f8f90d27172f50b10173e9e5b891
-dist/2026-01-20/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=407517411ae7ba6c7914bb64ed326e04e269bb5a8dfe0f832cc3176d04f7198d
-dist/2026-01-20/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=b026f85cef121272c1e5cfbb289a65c398c463b9c9f3b03fe8691bc58b5778f8
-dist/2026-01-20/rust-std-beta-sparcv9-sun-solaris.tar.gz=c768d7d28d68c0e0b38d9e20abfe150e0bf883b5033f59d82b57daf63b7e5aa8
-dist/2026-01-20/rust-std-beta-sparcv9-sun-solaris.tar.xz=084fcfaa613aad7ee636c51d17c50455c6561b1287feef061e92d3acc3ee2be4
-dist/2026-01-20/rust-std-beta-thumbv6m-none-eabi.tar.gz=e14071a8e9b46f2d9a4f1e07c44bb28d884dfa1764d15fb7a2b255ac1aece1d7
-dist/2026-01-20/rust-std-beta-thumbv6m-none-eabi.tar.xz=d4ed2c2cab6e1522a8b571151da07a52350e795b5cb40a25409de49ea93fbd82
-dist/2026-01-20/rust-std-beta-thumbv7em-none-eabi.tar.gz=b8669b9842251cc2192a57471968765b431ebaa8753a1e6e18296e9cd6a157c8
-dist/2026-01-20/rust-std-beta-thumbv7em-none-eabi.tar.xz=dad30dafe030d3527762152d3df1b4e32d752341c8a53a7bb0946c818b85cfea
-dist/2026-01-20/rust-std-beta-thumbv7em-none-eabihf.tar.gz=758a607c2f1d4000e6f70ef504da421d3177b810f42c0869d11063a6ffe31fbe
-dist/2026-01-20/rust-std-beta-thumbv7em-none-eabihf.tar.xz=354853d1edf7546feef1de3256608d1c1dddb41774063b4356fa62de5bbefbee
-dist/2026-01-20/rust-std-beta-thumbv7m-none-eabi.tar.gz=080c85f6510a78226c9f538a9735f4c878a2e1ae5ecc37e96dc68a618ed0c3c0
-dist/2026-01-20/rust-std-beta-thumbv7m-none-eabi.tar.xz=840ee359261a182053592c27f6428593bb5c20ff9c9574a09613f1c75fb9a2cf
-dist/2026-01-20/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=14569501fcc481b5453e912bc5ed6f3b106c2d3f5068582beedc120d488c720a
-dist/2026-01-20/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=50fb6c749858767db6e1bfe52205bf7761c2d287c3b8e2f882137c5096912745
-dist/2026-01-20/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=05d86630c938e3902d339e9cee306a97e459de5f4588aeac2075c5686f79cd35
-dist/2026-01-20/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=1ff3979060d0b74ef841148ad0b3c124989a49b97fbc2cec01f0f342a758f610
-dist/2026-01-20/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=6031caa8a04bbc2cbfa2bad982743dfba1d74215b21fb799c5d5ea21d598aebe
-dist/2026-01-20/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=4ab93e3d8b24dee229b76cecfd17acf37a785eceeb6f18b9b0131b18ee879dff
-dist/2026-01-20/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=02f3083cedee8072f7028de80f22a5ae769af34163ef60736012d262b2d971f2
-dist/2026-01-20/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=87cb4cf2256f8027a05543182431f8fc95f1fa51c10faefedb45de5eaccee3d2
-dist/2026-01-20/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=900474351bc843213c48e3d6a9e6de76555184b3993853ed547115e85f003545
-dist/2026-01-20/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=4cce3bd9620f6f895ea6fb9a26008ea6c482680059982a39ffd77c20bb803150
-dist/2026-01-20/rust-std-beta-wasm32-unknown-emscripten.tar.gz=fd050397dc018d910262d8269b55eae0f78582094b7c7eb7b69891f25768f60c
-dist/2026-01-20/rust-std-beta-wasm32-unknown-emscripten.tar.xz=665e65eed6dd420566b971104b649521468df5eef5510b1a7fa2c5414f5dab94
-dist/2026-01-20/rust-std-beta-wasm32-unknown-unknown.tar.gz=2588ec7952e575d48d2584f7697c782b4daa61c35a54919d434552034c0f494a
-dist/2026-01-20/rust-std-beta-wasm32-unknown-unknown.tar.xz=42718adabbe3effd1e89c08b446e8a18851d13ec7a50e426898402fbba00204c
-dist/2026-01-20/rust-std-beta-wasm32-wasip1.tar.gz=9659b9e17e7fb0ecb14885dc404a47f17a35612490fcf834040050876c4a87b0
-dist/2026-01-20/rust-std-beta-wasm32-wasip1.tar.xz=c81860bb8271c0d6fb2df38b1b4a0ba006b47af9aab9c6fd88610780d708ff79
-dist/2026-01-20/rust-std-beta-wasm32-wasip1-threads.tar.gz=138cfe4a6414bcac1a4fed1713840f245fe57ab732e86b46ea66f89b38814837
-dist/2026-01-20/rust-std-beta-wasm32-wasip1-threads.tar.xz=b3b7ff4265e0d22aaea372e8355265d30f38fc73ab4e491eb9e36e261e107e5d
-dist/2026-01-20/rust-std-beta-wasm32-wasip2.tar.gz=2b0ed2d38970294665f8c5515f2b23b8c447d19159c2317d456efe723ccdc282
-dist/2026-01-20/rust-std-beta-wasm32-wasip2.tar.xz=eb208d4ff325e675a5396acca80ac4594f1d8487136b044cb063140c38c9f900
-dist/2026-01-20/rust-std-beta-wasm32v1-none.tar.gz=2fc3a05f25b26e82b7589eba95b06f60923d83dc6d75566ee64967dd27392be0
-dist/2026-01-20/rust-std-beta-wasm32v1-none.tar.xz=733cfb74da7faae63b7d471d069c18e35e6d3ebd49bb7af929aeddc16a6bf41c
-dist/2026-01-20/rust-std-beta-x86_64-apple-darwin.tar.gz=77a9a5614f59a026cbd265ad97d7acda3ecfbc441e550f82146e4eecae43c0d5
-dist/2026-01-20/rust-std-beta-x86_64-apple-darwin.tar.xz=8fb75751c0494fb331cfcd40de32877fb4eb3419d31867296d0c4c9b65884764
-dist/2026-01-20/rust-std-beta-x86_64-apple-ios.tar.gz=db33e16445c89a739ef351699dad17ff7f0317c299ffe3a45dad681ef023b3fc
-dist/2026-01-20/rust-std-beta-x86_64-apple-ios.tar.xz=55377880102139275bcc523f0936e47a88486887f0d66ecfe0b90bdb4ecbd2e3
-dist/2026-01-20/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=ecb3e64fe4b05426446a7cf49d203c82501bdf4222724189c2e0718b2392360e
-dist/2026-01-20/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=e39ef0d40e8beccb2704ee197b2d3986314aa0ec56dff73c284cc8920518c4dc
-dist/2026-01-20/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=e8fb4aeb988c62140928da488091c73e96181b2c87af9716e80a3eb8fb841448
-dist/2026-01-20/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=7f42f9dd7a47b784186d7ede3643185e92a1d85932e6238668097efa7f45cfd0
-dist/2026-01-20/rust-std-beta-x86_64-linux-android.tar.gz=098e55a9e7ed0dec4235682cd70836cf5e1b327de7dfcf8e18c49faf3d3e7b56
-dist/2026-01-20/rust-std-beta-x86_64-linux-android.tar.xz=1e8ec49d649cdcfb9ee49740639f1f123d3c9d8b722553f104858fccae0e6d1d
-dist/2026-01-20/rust-std-beta-x86_64-pc-solaris.tar.gz=b21ec57c249842b9407ffeb67e0732ed69991470b2d6e726adc3d3b06ab79705
-dist/2026-01-20/rust-std-beta-x86_64-pc-solaris.tar.xz=da37239ac84b376190f99bc7c103f315a153b33c22393a453a80e2f0c3867c55
-dist/2026-01-20/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=63dda15c97c519e336382ad12e02f8d59b19310ca87be4bfccd668616ad839e9
-dist/2026-01-20/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=4a3fcde123276fe18e70fde97c04cd5e5083cd2079911a4be9f203fc079820cb
-dist/2026-01-20/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=124d9b525f103c033f4f3178fbef407ffe54a1ccfa2f93c5ca29923717bcb10e
-dist/2026-01-20/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=7eb9ec5f20575d9a1aa3d252b3c92a077c8edb845cb16eb8df127cffea5c12f1
-dist/2026-01-20/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=72944c39dbb92c4d08d962cc0de6aa70e4c2519d457796db9d81ce26850690f4
-dist/2026-01-20/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=4fd4289e64c6a0f26de760a6dfe42065dcba2b7c1a68b3ce21080d89f21cc439
-dist/2026-01-20/rust-std-beta-x86_64-unknown-freebsd.tar.gz=175fa2f4353203445f3accfc9a3958f94490b69ad3b3dbde4fa706c95dfb4208
-dist/2026-01-20/rust-std-beta-x86_64-unknown-freebsd.tar.xz=8baa09381fa21da8b0d5c24212696975ca83f7bfb3ee29bd64a8f2c47bda9bfe
-dist/2026-01-20/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=81fe291afe4619e75e3d7fc509e5dd6dee7e60e2fbb35410da13ddadcc6ae4f2
-dist/2026-01-20/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=498874af8343cfe6bc588f0bf6a90c393586c9d683feeab34dcf5a2dadf2cdeb
-dist/2026-01-20/rust-std-beta-x86_64-unknown-illumos.tar.gz=69de9a4ceeb07503f5d8a9e0a263a25b005657ce42ca0a83c52579869f2883d5
-dist/2026-01-20/rust-std-beta-x86_64-unknown-illumos.tar.xz=a218bab24c2b85fbc11ca846da6090f6fb0cee74d86ff4a540a98297379d4588
-dist/2026-01-20/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=58e74c1f7459b13130713007dfc70c7444f0627f016154dbd564a84016c1df72
-dist/2026-01-20/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=ae2b69792ddff5f60b2c0060d59b2b17491769f6fcf6abd44b64435c5920e7cc
-dist/2026-01-20/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=8efeaae9589fd41ef558bb6587f1619c356c2da2ab2a7ae63b31961cc2a7c2be
-dist/2026-01-20/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=451dcc4dbdf2b9e9b08165745ceb7d9d5c2c93f65288023b24d818d567a3d827
-dist/2026-01-20/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=cbf91ce153ae8a9108e0396beab208cf1c263351fe4638eb1f4ff90d5f00e018
-dist/2026-01-20/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=b5392dae5fef54f9418318ecedab57404f03aef618231a6431162078a283aa34
-dist/2026-01-20/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=b071ea7128235d11560e6e58666311f96940454070a641bca27709bfbe608bb4
-dist/2026-01-20/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=8a85c937fed532e558e5d0919913071a5873db08fe3f8c7121c708df2f2c10ae
-dist/2026-01-20/rust-std-beta-x86_64-unknown-netbsd.tar.gz=e77192be66c874d102d68848bc750007328a4034047c1379138a6e12e5cb5c7d
-dist/2026-01-20/rust-std-beta-x86_64-unknown-netbsd.tar.xz=ce899ed2702c32b813e5f754cc0af85ce0a7bd08770440291de758b30457abc9
-dist/2026-01-20/rust-std-beta-x86_64-unknown-none.tar.gz=2b5a6e82c398ddd10cbfc28714ee82778126906a102af59f6689eeb485cfa59c
-dist/2026-01-20/rust-std-beta-x86_64-unknown-none.tar.xz=75f5a1f61f3fbd5f59b8da5b3d68612d879356a3a76a3325e115cda69bbec8ba
-dist/2026-01-20/rust-std-beta-x86_64-unknown-redox.tar.gz=c42257ac8de158a1baeae3a0ccc786f7ce44e2119e222a0ae145c8d087d25ff5
-dist/2026-01-20/rust-std-beta-x86_64-unknown-redox.tar.xz=93bee91a6cf012da2a244bb77c2ecf6b5079d4139510e0cadf827e3f1d0f949f
-dist/2026-01-20/rust-std-beta-x86_64-unknown-uefi.tar.gz=bb7721b8cece5bc774bc24cd75126e9be5625a1fbb46f7df343069b8f9941e0c
-dist/2026-01-20/rust-std-beta-x86_64-unknown-uefi.tar.xz=fb5b68cdaab325cb6c7ac91803b694f3c13df87af9069426a26bb33a0029e378
-dist/2026-01-20/cargo-beta-aarch64-apple-darwin.tar.gz=68018a555a01fd5fb0a614668c64502d512ec21b8bad10186928d6ee351743a2
-dist/2026-01-20/cargo-beta-aarch64-apple-darwin.tar.xz=61ccbaeb46baa8a5cb984f6bb389c2b2e9e56784ae5f94500cd85c876e84e9a6
-dist/2026-01-20/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=6c94f4be14fc692f0cf30abdbaf6500aedf2de4bb30fd6cea3c6df004cfab3e5
-dist/2026-01-20/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=e5b104152c93682c2c04d0735547611cb9ddf0ca97655da9181a72186bf1e148
-dist/2026-01-20/cargo-beta-aarch64-pc-windows-msvc.tar.gz=6e362f5864b79406982592c497e8e8706cc543452d12856baf440df6d8e1c2b4
-dist/2026-01-20/cargo-beta-aarch64-pc-windows-msvc.tar.xz=80634e4cc4b3a90660be35e50b358c924a44d28feae7350a7cd4540aa58cb759
-dist/2026-01-20/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=0826dccf72f8a52127ce935fef0b260c41a1e6e677c0e0b35c3180395efa257e
-dist/2026-01-20/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=bc1cea64723b5ff68c3cb7a7848a1e3d058d60d4dd01b68e2bb0dc9f7e377883
-dist/2026-01-20/cargo-beta-aarch64-unknown-linux-musl.tar.gz=e959fc9b4dced7f1fc7ddb5be1f59cbaa80e67fba4c8b811e66c980920f50a89
-dist/2026-01-20/cargo-beta-aarch64-unknown-linux-musl.tar.xz=7f44f2e9696333dcc1bdd9ad27761025573a2a29f16ece6e952136278bf0c0c7
-dist/2026-01-20/cargo-beta-aarch64-unknown-linux-ohos.tar.gz=39100832eb910130177359850f1dbc63c7006f763313313d046132b9b408ec2b
-dist/2026-01-20/cargo-beta-aarch64-unknown-linux-ohos.tar.xz=4da74538df99ffc89f5a4e4b920f8b91b63809814032d9be4747d856c2481391
-dist/2026-01-20/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=1640df82cffe0e12b78ba50c778441d468da647508275a1624d9ddee42bf80a4
-dist/2026-01-20/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=f7e5ae4dffa52e89d5cf0983255e2c4e12b482c1b9bd8f9121a27f9d859291ae
-dist/2026-01-20/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=76fd2a8a2a0cf4583c16c0f0d58c19651a259d947b5f570e934c9ea8a288ec95
-dist/2026-01-20/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=159491a9f53719b0cef45c38483632fb3ea3cb1d8edc3a2069eb6bdfc74af59a
-dist/2026-01-20/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=debd3631a510f713276a2ff7feb163414e1c5617df75c7b8fb012568f2bf0f37
-dist/2026-01-20/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=d1ee0a450c4d2f34d76a0b4f904e344f68de0102777aca20c2e1c4bd6249006d
-dist/2026-01-20/cargo-beta-i686-pc-windows-gnu.tar.gz=cd339637c333db74c684597d9c817aa80bde1b3a2ca436678b16cf3b4954a8c1
-dist/2026-01-20/cargo-beta-i686-pc-windows-gnu.tar.xz=aad0ae08d8da64076f20479de9efe6cb4dac0ef3b35940b86b13d1035c033dfb
-dist/2026-01-20/cargo-beta-i686-pc-windows-msvc.tar.gz=2b24c735d2cbc73d9cdda6877e15e443a975acae78d9e7a6756464b2cca30b0e
-dist/2026-01-20/cargo-beta-i686-pc-windows-msvc.tar.xz=8e5ae923bd2627354783c5ea036c31bac672c5ebabe01cd09ae591ae982d25ba
-dist/2026-01-20/cargo-beta-i686-unknown-linux-gnu.tar.gz=3d4b141d6a79db23e5fca439c2dcd60b578404a0487fa8444d2310b7d48962d8
-dist/2026-01-20/cargo-beta-i686-unknown-linux-gnu.tar.xz=98ee2d83f2d9a2a8bad7706f9dd3fc94b4292c5ebe68abf1daa295e5f762617f
-dist/2026-01-20/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=5cf7b73a394c70935b3a3734db36e59b8118ebe576e5a8115c8cb134ec08a0a0
-dist/2026-01-20/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=f02d05725f2d0f50588ab2c6a07794225787f25b914498d68a863b0572e3a35e
-dist/2026-01-20/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=6a040c1db1261aa353fa0b76b604d390ba55b128a8e228d5fa6f3aa7a2f9d649
-dist/2026-01-20/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=de23eb854b648a895993402f9b8331819ac407047c52e4ed688e04377d31ac52
-dist/2026-01-20/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=b228b304546200fbc1336d2d4411a9a6b5b87a5e345c880d879a8f79ee491a80
-dist/2026-01-20/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=5b5c759ffff62c12b1629d2e7b651a1155ce88e7588be2a2d0b4d9ca3d0a726a
-dist/2026-01-20/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=8436db28b1d269969e6607c8838ccb2147b1bd0c7a284826c11cd4ce35b89847
-dist/2026-01-20/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=9c585cf6ac5893c156e1b9d747656d9575611f75bb8032267a898b34845069d9
-dist/2026-01-20/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=e5b2ec927cd671d52e0506d4df7185750fdb564692a14ea49d8c23dc53a534b2
-dist/2026-01-20/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=69a1b43bb32d784719903694eb7ede8301b86ecea3eebfc58844c41cd393f84f
-dist/2026-01-20/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=95adea6787309366ec745933daacdc1a821f981bdacdd648697eb9dbb6a5a8b9
-dist/2026-01-20/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=3d67b80fdc9f47822082664b7f5dc1cc0b456db00ef479c8744f660de7873902
-dist/2026-01-20/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=cc1b3ad4ca1f4bf0ef3a7b5e5d58985d40fad6142099776bfea8c6e81fece140
-dist/2026-01-20/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=9f0a936690f17b320c84a70b3135526bfc7aa5d36d5cfb97547c5fc53b657c04
-dist/2026-01-20/cargo-beta-s390x-unknown-linux-gnu.tar.gz=d44fde497ca4c2a750453f75a0eec1200ac928ddd8078cc233c53fe2b066b19a
-dist/2026-01-20/cargo-beta-s390x-unknown-linux-gnu.tar.xz=fa6d932e55b8aa814e428b973a62fb7db6a603e728b114f7e2165e90721ec05e
-dist/2026-01-20/cargo-beta-sparcv9-sun-solaris.tar.gz=ed500af7a213c1892eceb574cf06b1f3c621355f5084f998cb501b5f87345e07
-dist/2026-01-20/cargo-beta-sparcv9-sun-solaris.tar.xz=29e4a58324e846421f10e33c7aaeb9bdf6bef646c59aade71468f29c4b16b789
-dist/2026-01-20/cargo-beta-x86_64-apple-darwin.tar.gz=8ed894b81f29b0a4d27333d0ed5e68de0e5f98163b5ce7a3e71c66e3b1cc2f12
-dist/2026-01-20/cargo-beta-x86_64-apple-darwin.tar.xz=52b7f245f126a55054aca75f61e44a29c5adbb80aa4524287d414703de8e8332
-dist/2026-01-20/cargo-beta-x86_64-pc-solaris.tar.gz=7bd13a3901013768bc18fa4a317c5998478a4ba2fcd865329fc2d29a39e5fe61
-dist/2026-01-20/cargo-beta-x86_64-pc-solaris.tar.xz=791386564dad9e76d2904311a5bbbd0383df8a8557d59e2f110a745d332eba75
-dist/2026-01-20/cargo-beta-x86_64-pc-windows-gnu.tar.gz=a4adf7a0298ffed28396c2863d8ed61d37255602295a34c5c7570c03221a85e2
-dist/2026-01-20/cargo-beta-x86_64-pc-windows-gnu.tar.xz=2e274955324ff915c569e9069e9a88ce6984803d3dc2d86d8f46b634b2ff0e42
-dist/2026-01-20/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=dfc4395f5415555772b1ac9de9b9c7ea27154ae74382a323c4878f5bd0775bcb
-dist/2026-01-20/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=3b512d1cc1550612bf321a645752b46f6c13ac42ef2dfd010d44f678bacb2e44
-dist/2026-01-20/cargo-beta-x86_64-pc-windows-msvc.tar.gz=6c438b7e06c492118c41a990a16c7e369781e0d603482ac4af43c2e416edd52c
-dist/2026-01-20/cargo-beta-x86_64-pc-windows-msvc.tar.xz=9c2c2d29221a02ed062d59bce2e66679c89e30a1b0fe06f66ffdd8d5aa6978f9
-dist/2026-01-20/cargo-beta-x86_64-unknown-freebsd.tar.gz=900cdde5911be20bff4ddb571b48584c2bc5d2aa86ef15f4c285a3f84a683e7c
-dist/2026-01-20/cargo-beta-x86_64-unknown-freebsd.tar.xz=6b3143539a6d938a236364eb8c6b5a042f154daaa120e2ae00e7610c60e5e0a7
-dist/2026-01-20/cargo-beta-x86_64-unknown-illumos.tar.gz=b5444471825952571816fd9862fd395b24baf33afa7b029e6c86421dcd8c2093
-dist/2026-01-20/cargo-beta-x86_64-unknown-illumos.tar.xz=d5b06bba257688118366ee99b4f9f0e744236aca8a8b445146ff0875f84d2cc5
-dist/2026-01-20/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=83876014627bddf2919ae79ba4f96bef45087691cfcaff7a9736d4c2ad9948a9
-dist/2026-01-20/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=f6d9fb70437613afddad7b6ae5114173154167701ff532e3303a0af1212fc35e
-dist/2026-01-20/cargo-beta-x86_64-unknown-linux-musl.tar.gz=d4614e938888253e68f38ef5fd3a78b243b068c6e4c675e7ba320a85dbfefb5c
-dist/2026-01-20/cargo-beta-x86_64-unknown-linux-musl.tar.xz=05db3574910b1d8d6ae8ebd938008d8d38aeeb1e3b6b59dfbbad6cbeb1bca315
-dist/2026-01-20/cargo-beta-x86_64-unknown-netbsd.tar.gz=16b8c2c5e61f8ff700024e4dd958e93b6f1376e3a06f4d7184ce0849f1dd860a
-dist/2026-01-20/cargo-beta-x86_64-unknown-netbsd.tar.xz=f8b0133051d851c42da4c774793b91c68e5073dfd51a7e55e7360bbadb034dc4
-dist/2026-01-20/clippy-beta-aarch64-apple-darwin.tar.gz=f7cfef036026ec14dc58c3ce72e247b2abfc3b14d77a69dfc66ca7c02dfac56e
-dist/2026-01-20/clippy-beta-aarch64-apple-darwin.tar.xz=dc4af216099b3d12b0bec8914ad8dfd0bb0f0c6e09c98c54b0f0208a1aa63fc6
-dist/2026-01-20/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=dce2a442cccf2d571db1f57a44361ed4ee8fd1c6364a12d5fed2afa5c2bb03bb
-dist/2026-01-20/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=232fc9cc1f2c49b893a139d4551b13acb439d06d0188c736439004dd0632f294
-dist/2026-01-20/clippy-beta-aarch64-pc-windows-msvc.tar.gz=fc62e5afc9d5f3feafdf666e4db4fe49b28df1e6155af1d4a2f72de82c923ee6
-dist/2026-01-20/clippy-beta-aarch64-pc-windows-msvc.tar.xz=880ae8ad600f0ec4fd5a6d8dfa581477d4e60f5d5c184e30e44f0f7b2254100d
-dist/2026-01-20/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=ccce4428c7962a7f0afa8e80a714a7b9b0377afe385330326c65ec819c7dbbdb
-dist/2026-01-20/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=30423c514d1f0ac7f091c4573bdefed369325107b34a8aaeb4d5c94c347e927a
-dist/2026-01-20/clippy-beta-aarch64-unknown-linux-musl.tar.gz=d1b1c05f6f7dbcbb3aeff8db0138c4d06ff42d7db61fccacaebffeeea105fd9d
-dist/2026-01-20/clippy-beta-aarch64-unknown-linux-musl.tar.xz=11e49da32d955bfad341153b4b0e929f0786d380a9e9480fe89e409a0c399eda
-dist/2026-01-20/clippy-beta-aarch64-unknown-linux-ohos.tar.gz=6d2975db64417367af5216eb2c1d873e214e7fccf1ea74ce4a1ad92cc42f9f94
-dist/2026-01-20/clippy-beta-aarch64-unknown-linux-ohos.tar.xz=45d2c04bb0e80d9b6e3a0bb257d1d483837e423450d93beae96c99fc9fd8ce8b
-dist/2026-01-20/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=8000aa8009d7277981d9bd535947afb85a0002408e433db61332b1a4860492d9
-dist/2026-01-20/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=5934f3238d15d6ad4c739d9a4583dd7ac1a66a767ed876c093becb87c7d3f568
-dist/2026-01-20/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=d7d2ee5e23e543fb75ccfd4329df70a9d41b4e567815034f83bf56110a55acf1
-dist/2026-01-20/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=d453d595d4af2106724441f381e77dadd4734aeff6f1040ed66e07ac8d7b7074
-dist/2026-01-20/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=580508614f633e31e913443581ce17dbcc0e8778412b19ada22e80faa164ac58
-dist/2026-01-20/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=b035f1890147e91f09f16dd4787df44f790b9fbd3089f784eadcc4a62969a79e
-dist/2026-01-20/clippy-beta-i686-pc-windows-gnu.tar.gz=1ad03bd2b785f50261fc19204474ee99880dd0637e9cd7837eeb6f03c61ae822
-dist/2026-01-20/clippy-beta-i686-pc-windows-gnu.tar.xz=659adaa8aeb3155461989dae4d9de803652fe22a17add9257d44a60ef962e626
-dist/2026-01-20/clippy-beta-i686-pc-windows-msvc.tar.gz=2b1b31b8fc2e73630f2b457d2795a2b4dace68c69410c54571edc7f642c3ed34
-dist/2026-01-20/clippy-beta-i686-pc-windows-msvc.tar.xz=8071e38db44b00ea6d1b5fbf8428406d2a4138f0d05df2e0ebca245995ca508c
-dist/2026-01-20/clippy-beta-i686-unknown-linux-gnu.tar.gz=76b77a78d8f28b0d71ad03b5c7a56574378a8e1a9366754197fcd278640430ca
-dist/2026-01-20/clippy-beta-i686-unknown-linux-gnu.tar.xz=c70373e4e3bd2a2c5b2c98a26aadc3626adbe30365ebaa67d2c6754fecceb7be
-dist/2026-01-20/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=a41df8095cb7587ba984b7bf1e2d1bf024c69ba3301f829ec1d1bdda1b8b4fc4
-dist/2026-01-20/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=ec6a573da42202239275c2fb0454016d213f0e4e2a6f923c8a27a576d586199a
-dist/2026-01-20/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=bf0fdb37814bf8e8917d6a282e6e3a243e28f6962b79159aea5e0bcedf16ebc6
-dist/2026-01-20/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=c968aed1e04970f170b8a9350c69265eb9147ad12f1ef51b2e8b38994147f686
-dist/2026-01-20/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=60e18cfc96bf3e31f019a4e8c9bc33b06931c3d0784c69ca06d26cba0bc780e3
-dist/2026-01-20/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=a9e0907635db2ae0bf67aefb3f709266c6b538fb3c7dad1ba4401959a8a2eee7
-dist/2026-01-20/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=0bfbc082f733c5e11b85a96ae2261ac0eef097660f170f0b4d06602daeb08513
-dist/2026-01-20/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=de78563496c3017aa234783ea1d33693279870f7a4c7c20d197187a525762d81
-dist/2026-01-20/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=1d657f6310b161ccac78f7b630e28a50620b1afbfb056a53cd94543a3e75ad30
-dist/2026-01-20/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=edfe6128c0d45f69155605379a2f5684de11779c1f2778ed92c5ec428f293c34
-dist/2026-01-20/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=b3afd87d12e3117408b6e8047c20cded8400ea5c37a4eeb014b8a24b9dcf6cc6
-dist/2026-01-20/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=77391e9ac30a1e60f30b1893fffe5241ab2bcf7636d125dd71ff885dfac2b7c0
-dist/2026-01-20/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=926303f213e55c98571e2f901491ab4d17f446ac6f45de356b6965093df54219
-dist/2026-01-20/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=edd50203651d647ad23e1a729327d7ba9c8e9b6a27a0f4cc3142afa3517aeba8
-dist/2026-01-20/clippy-beta-s390x-unknown-linux-gnu.tar.gz=c04a8c4d6a04b204b2efc549e21ce06e72dbbffcd73ee33cb56eba6dc203086c
-dist/2026-01-20/clippy-beta-s390x-unknown-linux-gnu.tar.xz=fa5b4a1c53b98885294572536e218eb9325491fed01af40f3c6383f8dbff5560
-dist/2026-01-20/clippy-beta-sparcv9-sun-solaris.tar.gz=95f86bc253baa53f720282f43274091cf43ca940e97eb349c4943068b5f0b458
-dist/2026-01-20/clippy-beta-sparcv9-sun-solaris.tar.xz=b605395af4e223ae367bf1beafbed1e956983997b48f81e71b5fdecf96268102
-dist/2026-01-20/clippy-beta-x86_64-apple-darwin.tar.gz=2b3b01bd6d6b8cc28e5562b5f1eb5349f738a5fd9a30476c951e318714b50ac9
-dist/2026-01-20/clippy-beta-x86_64-apple-darwin.tar.xz=11d1ce0a7246929e7cd15506d846a48f258d63eadbdaf24a451f1b70e1581467
-dist/2026-01-20/clippy-beta-x86_64-pc-solaris.tar.gz=4f57f33c563555eb7b4256116564a458b517cdc353adabb7bca41b592529e900
-dist/2026-01-20/clippy-beta-x86_64-pc-solaris.tar.xz=14243b22bcbec5b294be7c2844f55c4f1274a164c6cf012f3cb6164776069982
-dist/2026-01-20/clippy-beta-x86_64-pc-windows-gnu.tar.gz=74c09292424154c7ffb03a440eb46c0f71a37756002bcce5d0d14000ffd274c0
-dist/2026-01-20/clippy-beta-x86_64-pc-windows-gnu.tar.xz=4d902583e62f6355e786cc3f37a8d708cbff1ecaa1ab341b799f2b4b54b3b9aa
-dist/2026-01-20/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=ef8f5a386a8749142c4039c31823f742f88db4d401b1d276a555d42ffbe353f3
-dist/2026-01-20/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=30cfea6a64414b471896d592756761c87646f06e6bfcd82e0c906c932b83b28f
-dist/2026-01-20/clippy-beta-x86_64-pc-windows-msvc.tar.gz=0a302c0457662833894a3e55e6748a83fc787cabf756fc5a9d79412478694552
-dist/2026-01-20/clippy-beta-x86_64-pc-windows-msvc.tar.xz=ce09b46b20b7fce72a5e6081dc7ab98f5607b6a4145506f2d1d982ef7244bf1b
-dist/2026-01-20/clippy-beta-x86_64-unknown-freebsd.tar.gz=d8bd34c3bff9fdd878631faf0597cd0c412c1057e1b49c0b7389d363b0da59e8
-dist/2026-01-20/clippy-beta-x86_64-unknown-freebsd.tar.xz=ff2be9e56354cc83444420b7273502b58043fb02c83903e02e84e51d92522d10
-dist/2026-01-20/clippy-beta-x86_64-unknown-illumos.tar.gz=ab0f8fa1b33d20d336dd0db526cff16524c701987bdbe337758be39d58e7f267
-dist/2026-01-20/clippy-beta-x86_64-unknown-illumos.tar.xz=495c84f3c712105152438428e0d9f021ea9ecba702622e09414b7f7e36a1db24
-dist/2026-01-20/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=cf7303b5c60576390900a1fff488aa86a1c1c78a0bb120fbcb6b9af3bfd63811
-dist/2026-01-20/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=803f29605e90e31c47e6ae33c3372f183738ec4492d284ef5f97e736aacbf739
-dist/2026-01-20/clippy-beta-x86_64-unknown-linux-musl.tar.gz=ae482a158faacc4553b57c8acf6e4662d4f1f903b69a22dfe69b1532315cc8f5
-dist/2026-01-20/clippy-beta-x86_64-unknown-linux-musl.tar.xz=bfe63363bd713b6ab862081a8208c4d8212a0aa542a603aaee595277e546f07e
-dist/2026-01-20/clippy-beta-x86_64-unknown-netbsd.tar.gz=905da9ea5d1713ff3bd7b1997f20f4cad58f00c4a863b28164b42d738300a628
-dist/2026-01-20/clippy-beta-x86_64-unknown-netbsd.tar.xz=45f890606a33a3ca0cb07015df19d2e1862531100448f55ffa77f79c1f7b9751
-dist/2026-01-20/rust-beta-aarch64-pc-windows-gnullvm.msi=6d26fbdb64ee9c02e7794bf3b011e19ae1587a4cf5c5e78a5b8d0419a8a03547
-dist/2026-01-20/rust-beta-aarch64-pc-windows-msvc.msi=eb21e2dcd91047d24ea166385c429069703abcb23206cdd914b8f19390229101
-dist/2026-01-20/rust-beta-i686-pc-windows-gnu.msi=6eb532574513a21ac1a8d6d2839d17e7534a452adf37d944069d383d5769944a
-dist/2026-01-20/rust-beta-i686-pc-windows-msvc.msi=77b733b05099cfa7c0073d7a748ec2bcc9f040d865897518e0f1786688e9b8d2
-dist/2026-01-20/rust-beta-x86_64-pc-windows-gnu.msi=1273f7f4055ee165476843034d5411e267729d4789dd439939582160d57f29f7
-dist/2026-01-20/rust-beta-x86_64-pc-windows-gnullvm.msi=b22d27a6b3db65eac75b8ad1cd3484bd344ec22c653b3ee939ea6e7649cd69a5
-dist/2026-01-20/rust-beta-x86_64-pc-windows-msvc.msi=5ccaf24b67a8096f1090e27a1c71ff69e721de076ea2fafbcc8f788988bd51d6
-dist/2026-01-20/rust-beta-aarch64-apple-darwin.pkg=5280c8dadec5a0bee55f4a682b20df0330369bce0eb1528036078e779248bf6f
-dist/2026-01-20/rust-beta-x86_64-apple-darwin.pkg=51b525faa1b74c7d90b9a5b0858697d22aeb214e7d85c5dfb6d56cef1d2351d6
-dist/2026-01-20/rustc-beta-src.tar.gz=6737690a0fa28bcfdb154384a49428a7d752586f8e8ea22bd1e2029e6da2a2bc
-dist/2026-01-20/rustc-beta-src.tar.xz=3184947f6744d0b049fcbc528f9cad6b0861daba8f883650d7cf0591e144d52e
-dist/2026-01-21/rustfmt-nightly-aarch64-apple-darwin.tar.gz=affc4e2ba7673815113ebd077d40981b0eba06bd321f503b8fda8f4ad041993c
-dist/2026-01-21/rustfmt-nightly-aarch64-apple-darwin.tar.xz=63ff46d1b84d4a5f0aae251fd6636fde72a9ead0f379bb5af709aa781f9010f0
-dist/2026-01-21/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=37f974a21309fde6201af7f738cc243ee1f5d18f4f43833c5dec95623bc48681
-dist/2026-01-21/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=a69d9654017ff44ec6cb0b2c47ba62c07f0ba114d1f50bb8322994d646f99c50
-dist/2026-01-21/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=08bac0b794d237022227043b4bca1a94561eaad7f047dc050c2ddd9a638f9382
-dist/2026-01-21/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=14919590f33efb9a005a7dedab82cd74d520799c46ecd9243a9c265a0d7fc7dc
-dist/2026-01-21/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=d0047fc62080e4a30f398de07c2dda5f6b2c1b28afbf1acd6932d826cf111827
-dist/2026-01-21/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=18c1476d5052da02ea353a6b7881c9125231f044b1ed64edbf4a996ac5e677eb
-dist/2026-01-21/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=380ca0dfa172a5eb6f2f3e1254e4d4c2cf96518d991ca09a6c582cad8a8b9bf7
-dist/2026-01-21/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=8c4aec7b93972e480b0ca9664fd231b47c4197ea0ae06ecbbf978aec7238b787
-dist/2026-01-21/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.gz=68573867ceec9311464e45e31bb2e4b65d68eca62a488afc2309a40a3c1bb003
-dist/2026-01-21/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.xz=affab0babcbb414de642817ae1f667c36e429e22d0db6e4dad62321fdb35b126
-dist/2026-01-21/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=435f927bcbc1a5b3625abcdb1c38aaaa26d8cae0928740b425246c92bf2427e0
-dist/2026-01-21/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=7d6482df5e8e0530f39e1661bc9ba56765512e800c1e2a387657f62c67fc4062
-dist/2026-01-21/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=b7c509220780e000f6f5f21527d6faa4e53fc099aab70b566c2f6ae16a407caf
-dist/2026-01-21/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=c2a8ba39291834512596eb7861f486af6c6e34123da36c0030841f9fa0b8265f
-dist/2026-01-21/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=7da502260349e6d6b7f79280f8973f1a5368821ab4bd88f92df7f2b04ccd0529
-dist/2026-01-21/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=0a0390f87cd6c3c8e522a8729ac836285521ac563afb6d3d1b42117ef846922b
-dist/2026-01-21/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=d19be564735e74a31cc3ce32afd0b19bb1e2bc8cda682661d8de179ae1c6daf4
-dist/2026-01-21/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=ecc5e809442b3e775158d81a16844d9cccf89d48e5e404780459c4b9a3257d2a
-dist/2026-01-21/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=8a888e80fb00b3f7351848947a1f44f1a7fa63ca52c279c7da4067e0db6c3be2
-dist/2026-01-21/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=dd3cdf3a1a3984e2e563bb83aa0e97548a5d02f10aa1d0da50127bc56869428d
-dist/2026-01-21/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=8670a561b2c7e356415d930b3ddbb561c6957351cb4bc048a804edc14a92a308
-dist/2026-01-21/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=51899130ab87607e203a6c9f27f0c22ad34642e6df40df2ab77f4863b582697e
-dist/2026-01-21/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=1485f91c3cefeeab023faef5a8b93f7c2af91d4c47d5ac79683ff58f7c1557c1
-dist/2026-01-21/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=05a3d5b87af407b42f6985b84515463d924b8af126cb927f57de5e1bc0f8ab07
-dist/2026-01-21/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=def8a13af57f5a8603b3efad06031a78ad8b0ff111123970594ed61c52a28e9a
-dist/2026-01-21/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=f4b47d15291cf78830c88d5bb404035f9ce5dffbb5b6bc79ea987ae0995b3e30
-dist/2026-01-21/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=8d4574b8a8407d0740ef3978ef6ee44f59fc7586893ad76ad176785ca12f091d
-dist/2026-01-21/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=f59e764f38cfcfc620f522f99be7fa2ed36ef23b8d45887da78839afb0a91083
-dist/2026-01-21/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=2a98d3ac86e927646884c50338fc87ef218ea026c5b3ff1a899bccb6ed67a4d3
-dist/2026-01-21/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=6b282883509ff1b1b74e7e484f124018e5044dc13e83cd626a12690577be9a02
-dist/2026-01-21/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=b18dc4ee75f208fabf5fd5765572d33bc7f8862fefc1628bcd61438e83ab525f
-dist/2026-01-21/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=d1b158a365a28d440459aeeff4154106d7e340db2b64f2defc53c6b102d839c0
-dist/2026-01-21/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=62eff4eac793fd4b4e4ccd377e9d6925812a65196e5d17b6c80aca7b2387b624
-dist/2026-01-21/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=fd95f22a380c281cfa919c45d060418d753923cc14dfc4f13885ba9aa23425ef
-dist/2026-01-21/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=f139664d1bb30c7c0e01ebe66c0a24372fa22c95f32d49e9d4422c36eb83005b
-dist/2026-01-21/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=00317b285892b5f294db45957214cea31b7cbf238c329b752fe6b38d89a74574
-dist/2026-01-21/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=29e9bb3622b98e198fb552ba83de4c54b60c60ee3a06824eff9e814ebf5b4f78
-dist/2026-01-21/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=8fd331c828e5a4b9b0ed29c4931b299d08464db303985398f466aee05f214338
-dist/2026-01-21/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=3f590d494a001ddeeab24ca3754a8344b0397839cf3df82d6ab571804910a9b7
-dist/2026-01-21/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=ad4a1b9d2446cb037cd1429c77781473c2c50892fa3e3c97a15abf4a34952a95
-dist/2026-01-21/rustfmt-nightly-x86_64-apple-darwin.tar.gz=ac4b6f7d51288d756765fa72faff773a5f57681ffed9b9230db3f116f4b1ce5e
-dist/2026-01-21/rustfmt-nightly-x86_64-apple-darwin.tar.xz=e8dc9b7c5230e2fcff79cc78da9e426cf46e3b0925524e672376ca454d928aea
-dist/2026-01-21/rustfmt-nightly-x86_64-pc-solaris.tar.gz=300937f554725ab7faa68bdc37655c93a40c49dc29a9a2706f188ecd26fdd76b
-dist/2026-01-21/rustfmt-nightly-x86_64-pc-solaris.tar.xz=6c5c7d56a4434cf282499a6c7e6c6aa6029313a1fb92a6d09e6a42d4b11df2e1
-dist/2026-01-21/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=297c396dc372f7e5230c012c082d45b322adf7ef959d560d213cc338d556eb60
-dist/2026-01-21/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=43b9f55634b0d276d348271696f024ad01744ab96a8d5ac66b88bd9f7c471efa
-dist/2026-01-21/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=40330c41b78296e15401f48732b8de62120085c5455bef223906f220919506b1
-dist/2026-01-21/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=e437a17c2aecfa01c35ae3a2cbd199b0dc6b6c1039be7e45b089e05ae5cabaee
-dist/2026-01-21/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=7915476f152fd05c8b1b3f2114a2762fa2241ec873e40a817bc478934ed5b631
-dist/2026-01-21/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=931f4b5d7028e34fe56b01d4f6d2796fad15e99868054390d0b0e929b96a794a
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=0246e43067b01d5418926c978da82d99341610ab6449911993bb92b4934f2bbb
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=18dd4a5564dadaa55e3ce102cefc98ebcfaaf5aa8d51e5176ef6419be45efaab
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=ad3c0773583835431b7b284005ca0cc859b27e1bc7a68201746bd969af16755d
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=528856180a0b335f1fe28e10021a921ceaca8db61fb98d2d732831dff0bc3467
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=2e517f4312bc3fe31ed294fea9df818bd271f8d97b094a199275c8c229284c69
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=69a37d60e9de3e3e718e08d31b7c5807c06d482e9d3b1d0679571493e9cd26db
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=ee8cf1139bd721c7e1d8bf2755ca1778e2d324d117c714c06ab1e9fa3af5c27a
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=032bfb8c944a2edf113703a8154bc2fd27a73112a6f5fcd6cd137617df1d0966
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=93f89369e38d2f452ec887b1c6e5e987320ebde2675613e8f370ce46adcb2e6d
-dist/2026-01-21/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=e6db8c3bcd35c942ff6b97e600f5021c57c8da8b0523f93d4367de27a1e19d28
-dist/2026-01-21/rustc-nightly-aarch64-apple-darwin.tar.gz=05ca50a36c2b8681ba6467f71800942da3120ed74b80f25a9a53f859fb2c4cca
-dist/2026-01-21/rustc-nightly-aarch64-apple-darwin.tar.xz=aefda689c6c6aed7eb68ca8acac0809c1cbbbb35fa96e60f50bf79a0f80147f8
-dist/2026-01-21/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=9554e05afa28b776f85b50100582d1287320046612eebd1b1e1eb9e99b425559
-dist/2026-01-21/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=fb0d1852343fbd21b94001729f9185202c704a3f0ce387079225112ed1795b36
-dist/2026-01-21/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=795158ddd8aaf40878fb477145f327c91f3c51cad195272f80e693488ca815e5
-dist/2026-01-21/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=d816aa3f7b5f81550f02982300b9b0d8c258d1ed5a1dac837e45db1067eee984
-dist/2026-01-21/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=62852a17246080ae06159eaa290910fefc5a6ad43e3e801e348a1e04998b2002
-dist/2026-01-21/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=ce688272bec1372fd1c27c5e6c228c1a6696376ed33c034da7070fa0353c1c5c
-dist/2026-01-21/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=1d6c4f926c4fd7f09b4bff2f0754191fc94758fd80dec401a18b6f5cac907ac2
-dist/2026-01-21/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=1f75d8d3e04da5d44770b45073fc71bf54d08a079a9aeba34effa7e620e4ffdd
-dist/2026-01-21/rustc-nightly-aarch64-unknown-linux-ohos.tar.gz=312ffa2180b4f0e99d577e584a8c8e89ec763d83ea3347b3c905e5bd0871e0c9
-dist/2026-01-21/rustc-nightly-aarch64-unknown-linux-ohos.tar.xz=7dbdc7c25ef72dd904d7565b8d4b038dcfb51ea451107ab100027a6e8dccae88
-dist/2026-01-21/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=628f2ef937685ec2642fc49b834bd30fcc1c64ad6019feb659877e20b3e3884d
-dist/2026-01-21/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=bad0dc6b0454ab24527aed9640fc68f422ec3efbe7fe7d9c4c07fa273d3915a7
-dist/2026-01-21/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=a2635ca207aa8461296a6b40283f92865ddb15b95927ccb28eee332fb9d1e9bd
-dist/2026-01-21/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=9558ef1d896813b02203b5b5f784627d74a678c62fc7f3580b5d2a4bfda9ed44
-dist/2026-01-21/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=fa8e5603562a361dc2335e4aed12dc9d997ef53a0eb6ad6fd9503a70d2816f7a
-dist/2026-01-21/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=3f6f152fd6f8dc3dd9ee204f4ee1408a82a619e817c08c739b90c56d992fa3f6
-dist/2026-01-21/rustc-nightly-i686-pc-windows-gnu.tar.gz=f1bcd3ef4d74260eac3fec3ab623c5bdb506c5ebd506602957601e24c11516b0
-dist/2026-01-21/rustc-nightly-i686-pc-windows-gnu.tar.xz=29f5072a55299a2a93a2842318608735967e46b744af550aa19fc6b43ebce2f0
-dist/2026-01-21/rustc-nightly-i686-pc-windows-msvc.tar.gz=77001ad2709e35f22be3410afcb061d060eee6d2a7690ad93371d85c77163d87
-dist/2026-01-21/rustc-nightly-i686-pc-windows-msvc.tar.xz=88d617bef85fc9b99d730346f22a884363db3f111e1301d9fe0f807966e13bd3
-dist/2026-01-21/rustc-nightly-i686-unknown-linux-gnu.tar.gz=a8dd200f6f6df430c023707797f3793670d0e5df1f71d74edc67c300c9ea9ee7
-dist/2026-01-21/rustc-nightly-i686-unknown-linux-gnu.tar.xz=c7578f1360c23af97bdd3d76b802f0ab5da289f1000f49909803a5aa957ab2b6
-dist/2026-01-21/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=ebdbe1939f4fe80b7b90222eac5a76dcf40c99dff11342cd3f8b4af32d5e85e3
-dist/2026-01-21/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=4c8894c0c888075cb54834b00250871ca8c71d42d1ad2bded20e8678deff3683
-dist/2026-01-21/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=40851b65b3ab065ddf184096ed58b8deddd80bc33047f5d4524361ef99123f16
-dist/2026-01-21/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=657f707ea176d03b36bc73abedc8947c6f1b47e8836f8154a21770273fa05bd8
-dist/2026-01-21/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=4cec47f661bd413f415a21f0951a028f2f7aecd22cb708713f08a7ea1d5828fe
-dist/2026-01-21/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=f9984bf28f179296a1d66de91920c5b6e482430f3aab278db82fb8d4a6b96e00
-dist/2026-01-21/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=8433b87fb9d5f257e4439f2d5db3559b9c54dcf7f504331b1f9e10b4290e3d61
-dist/2026-01-21/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=e84f672d2e4cc6a6e3d13e1cf429f498fe64327bb85e82d6437cdd527332b462
-dist/2026-01-21/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=981e05ff04a005d193d2f5feb12656f2bd5d2dbad4e8bf7d40421eafe52b7f44
-dist/2026-01-21/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=fa05d796d40ecc3b8d552f86c690b465044462b0820cd3774eb8957c1fc05c99
-dist/2026-01-21/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=74dd0095d0ac98a29b217728edd3cb1f521ab59fbc2a3927281d26cfbc5d5829
-dist/2026-01-21/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=4a4f61d37ae4f9a2c26069cd6422acdbb3ee43a6a4b4e32a20ca76a855a5b40f
-dist/2026-01-21/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=1038bec45e312d6c7c5802914ee31603fe0a14628786c216ef4feef0399ccb26
-dist/2026-01-21/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=534d286cb8b5131e34263edb189253f4f83c4274678017d4161c92ddcd2b925c
-dist/2026-01-21/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=01c14dda8ba60125208377dffbfecd074ef9c42acd21a1cd330a6b772d419e6a
-dist/2026-01-21/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=d52e035c78aec546b820dd085ddc097dc30b111ce6b6616751f15e60a294e7c1
-dist/2026-01-21/rustc-nightly-sparcv9-sun-solaris.tar.gz=c0abaeca6731e2c0b2d6437bc3d7c0c240cabc6373773a5c53614c6170c82d91
-dist/2026-01-21/rustc-nightly-sparcv9-sun-solaris.tar.xz=6dbfcee73e53c92e7f80e81bae9c86da392ff46667867bec5a5eb771b734c52a
-dist/2026-01-21/rustc-nightly-x86_64-apple-darwin.tar.gz=0a5c541c832312723e6d1ca0dca655f380118c57d29d1629310bdfd116628a98
-dist/2026-01-21/rustc-nightly-x86_64-apple-darwin.tar.xz=78f631995200a5a48156321ad3abb8d97983080134c2404681a48b5007dda2c3
-dist/2026-01-21/rustc-nightly-x86_64-pc-solaris.tar.gz=fe0d0240075ba8545845323c1966cac7c45d14f34f5fdee547e1b1c3847e3453
-dist/2026-01-21/rustc-nightly-x86_64-pc-solaris.tar.xz=09a3e0be0f2bc5ab6af1726e479150be43b7dd9e3bd459998d7bdb30a4f16b73
-dist/2026-01-21/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=7ca059132ba0615d17b6c32f5f74b86bdceac13940198cb6b9b6bb0b821db118
-dist/2026-01-21/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=93aad27c0870881af1f58e91e4015fd3ef6c023fcf9877b34c301e5c0a23b4cb
-dist/2026-01-21/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=a731ea06a52953dd1741be00ec0d9c651080c1725c9298f22afcce2500bb74e4
-dist/2026-01-21/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=81cb2094a2aa287cf940bc637990771b3243434f54523dfe5133ad476967cf30
-dist/2026-01-21/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=cfb755273c592a5bce52728454eb4b880022e2ee6cecec9f9f4206599ea0ee5d
-dist/2026-01-21/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=2d3ded1d4a048146a56182d106fe82a6357fdf688921701fa2d1a93733a05eb9
-dist/2026-01-21/rustc-nightly-x86_64-unknown-freebsd.tar.gz=49355564096356792020a1fef64a3e413f35790e40b572e36e26307c38fad144
-dist/2026-01-21/rustc-nightly-x86_64-unknown-freebsd.tar.xz=2178ff7a29f514adc3cbd93940956fa397611e90ab51da87b5087071512bb15f
-dist/2026-01-21/rustc-nightly-x86_64-unknown-illumos.tar.gz=1851080c6461ab09568fa537f604dfba79bc55e06b434029d69445d8963b1f27
-dist/2026-01-21/rustc-nightly-x86_64-unknown-illumos.tar.xz=a6d4ddfd1985471c05bd70d18a56da3afae4039c2680813338e1189b1240d28b
-dist/2026-01-21/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=40b6c623ded8ea06fbb97303cdf8a8c1fbf3bf16ca38bfda8b7e118480c6fb1f
-dist/2026-01-21/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=8ac14c7783ca3e8b4fa8fb7df22f3950418c7a37ddb1f327d336de72e25e92b9
-dist/2026-01-21/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=2bd8b16b8632b290516dd1638ce088905d06784fb638eb765ab0b7ed6a9d6528
-dist/2026-01-21/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=5e7fd38662525448b8d223be07894bf600686c2bc28d926074967d9717b14063
-dist/2026-01-21/rustc-nightly-x86_64-unknown-netbsd.tar.gz=e5d06dce9f4659a7ceb9ad5f88226e447c5e095a2944d0727b475d9990d7d7b6
-dist/2026-01-21/rustc-nightly-x86_64-unknown-netbsd.tar.xz=48f8198fe59877d31cdb01d6560fda88e3a194a75eb4c664b5397061ca877f3d
-dist/2026-01-21/rust-nightly-aarch64-pc-windows-gnullvm.msi=003330d02b7ccdf87a54aef9afe5d5d164f433ceec98d7f8e22ed8349f5c07a6
-dist/2026-01-21/rust-nightly-aarch64-pc-windows-msvc.msi=ab2d63a49e1d9c3c9fb2e5b59fb456b022680adf6b0707ee2223a4fb4eb66aaf
-dist/2026-01-21/rust-nightly-i686-pc-windows-gnu.msi=fff10ea8984cee03280c4b10d2f6c740a88d26216aea661ee67580c64f69e8f2
-dist/2026-01-21/rust-nightly-i686-pc-windows-msvc.msi=f78b7b22d7505e361201ac502596e9cddf04a625af287801c89b8e46908f82fe
-dist/2026-01-21/rust-nightly-x86_64-pc-windows-gnu.msi=f26775794a4079aa09bdd69706c6d3b8b5c67d4264a1859302939f2a647b6d88
-dist/2026-01-21/rust-nightly-x86_64-pc-windows-gnullvm.msi=114a595e1091daa04a3652a0c8b2dd21992848118bdacba4b076ea28f8e7dbd9
-dist/2026-01-21/rust-nightly-x86_64-pc-windows-msvc.msi=2813a6cf26e45fff004e2f531d61d1cb08187ebf0f3c6395d017a4c5e3ce5032
-dist/2026-01-21/rust-nightly-aarch64-apple-darwin.pkg=17093b3b31ec58273f7bbd52014436ed001b14ff76dabd1df4018d9a8e95e0ca
-dist/2026-01-21/rust-nightly-x86_64-apple-darwin.pkg=e758c7a74f3599f2bd10a58c78b8d0a60bcfe356b87d65c8430081556f0b4cdd
-dist/2026-01-21/rustc-nightly-src.tar.gz=0af498197bb5c995f078770a208c609b60baf20b27fa54c5888d9e38c66bcf8e
-dist/2026-01-21/rustc-nightly-src.tar.xz=2e44bad1f973ebe58ae463559752d7e2a93511927e847957867ee781140b15bc
+dist/2026-03-05/rustc-1.94.0-aarch64-apple-darwin.tar.gz=5be5bfd855ceaf741c7d9996940690a0a2958e5e44365bb63122d865ee6a9d2b
+dist/2026-03-05/rustc-1.94.0-aarch64-apple-darwin.tar.xz=6ba00a4f486af11826335cd7fe405592d959f50afb9489176fc1463cbe75dbf2
+dist/2026-03-05/rustc-1.94.0-aarch64-pc-windows-gnullvm.tar.gz=752c0714a743396e1a518a5d4a247617232b6fc5d5b77640c53c714d825d1027
+dist/2026-03-05/rustc-1.94.0-aarch64-pc-windows-gnullvm.tar.xz=aa07a0a803c8cd89d2d2b7720bd4fd21e1386de906c2d6240b842e2c6957aa72
+dist/2026-03-05/rustc-1.94.0-aarch64-pc-windows-msvc.tar.gz=6bad008ddc6e6db1ee19d7964b239cfd8e4265c5c8c159affed28a496e8623e4
+dist/2026-03-05/rustc-1.94.0-aarch64-pc-windows-msvc.tar.xz=6d88d89c200a147357ded65e9bc426e14ebb6f5046d9772f3916b6a1ac60cdd5
+dist/2026-03-05/rustc-1.94.0-aarch64-unknown-linux-gnu.tar.gz=523029e8b5a95fac52c5f1aa9cecd9fb480077e90396501d721bad86a470d866
+dist/2026-03-05/rustc-1.94.0-aarch64-unknown-linux-gnu.tar.xz=7261b2fcdb88aef8b21f4b9f915d9a75c959674193f5b38e13fab4569684fc5b
+dist/2026-03-05/rustc-1.94.0-aarch64-unknown-linux-musl.tar.gz=754a2a6f001ae13bfd8b7e19fdbb2b0b54ebb39a81b9db9b94bede8ed3423175
+dist/2026-03-05/rustc-1.94.0-aarch64-unknown-linux-musl.tar.xz=05fbca7a22bcae6d6c2fee8b32225297a3055f5de53d3c22e20a918390625b4b
+dist/2026-03-05/rustc-1.94.0-aarch64-unknown-linux-ohos.tar.gz=35cd3d9a87559d00a3976ac749b3252abe2f2a019cd5e7c49c1e06c1550e3765
+dist/2026-03-05/rustc-1.94.0-aarch64-unknown-linux-ohos.tar.xz=290c43104fdf697fd52ca5776ba38073e50396c915148cc88c57afc100922d5b
+dist/2026-03-05/rustc-1.94.0-arm-unknown-linux-gnueabi.tar.gz=2ef7e22a0180161603d993fed35fa9342853fd92c5f800ec91f5481aa27e9ec8
+dist/2026-03-05/rustc-1.94.0-arm-unknown-linux-gnueabi.tar.xz=e30c6b170b8c1e12a5e023d3ddc5f09f5c5910de1303c5d0b671518a4656a521
+dist/2026-03-05/rustc-1.94.0-arm-unknown-linux-gnueabihf.tar.gz=d75c8b40d2dbd3b874e77b1978ce54b2e26390b5e0c740824b9f737e38893bf1
+dist/2026-03-05/rustc-1.94.0-arm-unknown-linux-gnueabihf.tar.xz=9d7fdad7144340b4eeebd17e75981e92b067435efe7d18e572a39a37441d5c71
+dist/2026-03-05/rustc-1.94.0-armv7-unknown-linux-gnueabihf.tar.gz=dd404a37a712b7c5ebc23aaa07082d53780e1db414db4bbbde407661641b38a0
+dist/2026-03-05/rustc-1.94.0-armv7-unknown-linux-gnueabihf.tar.xz=b565cea122ba14eb92fa17cb7a84c5a0c4a4f2b146f054a629af4b0b44704aaf
+dist/2026-03-05/rustc-1.94.0-i686-pc-windows-gnu.tar.gz=ea6f99b940f9505b5ae2178df6827967f6d122e5231a9a7c476c4aa81d546253
+dist/2026-03-05/rustc-1.94.0-i686-pc-windows-gnu.tar.xz=e5b4ae6073749c103032583fedb73f3381b44930f755f8e7854935cf134df9af
+dist/2026-03-05/rustc-1.94.0-i686-pc-windows-msvc.tar.gz=2ec119acb944698cfaf47336cb0fc282472e455fb0689ce6a40d794dfa6bcbd6
+dist/2026-03-05/rustc-1.94.0-i686-pc-windows-msvc.tar.xz=0fceb26af2bd862cc8fcedda80882a26d0c9ccc45024d92388d7d2499d9421f5
+dist/2026-03-05/rustc-1.94.0-i686-unknown-linux-gnu.tar.gz=8ce8b6cb387a0dd0f69073efdd47a40f8542f5ae7f67a73b72895852f5d2786e
+dist/2026-03-05/rustc-1.94.0-i686-unknown-linux-gnu.tar.xz=4d399ca0126adf0225340dc291623a47256b39be1d2567ad76dcd8990c2d6935
+dist/2026-03-05/rustc-1.94.0-loongarch64-unknown-linux-gnu.tar.gz=6afed7b84198f7bb8c99cc42876698bdbab69a86f3b69ef424f0df5a0cf9cb7e
+dist/2026-03-05/rustc-1.94.0-loongarch64-unknown-linux-gnu.tar.xz=5392936010d422d7b8e5b83ba6c314da16f0d2b33fe57fdaf340b1e8a4a3a0fa
+dist/2026-03-05/rustc-1.94.0-loongarch64-unknown-linux-musl.tar.gz=c0d447f2067cc783bb651ea10badfead35d668414a06aa960157630e75b3eec6
+dist/2026-03-05/rustc-1.94.0-loongarch64-unknown-linux-musl.tar.xz=fe2bd805598d2b38338f14484a8aea0fbd32b656903d65dd3a3c92ed5f03f710
+dist/2026-03-05/rustc-1.94.0-powerpc-unknown-linux-gnu.tar.gz=3cdd5526ea379883051ed2476d6a1b8dfbce329b1cab2db18ae449a3f8ffca97
+dist/2026-03-05/rustc-1.94.0-powerpc-unknown-linux-gnu.tar.xz=443475d3e1ec21d1f34b09f0cd6d1f10551535a736048ce7e21d7fa4faeb63c3
+dist/2026-03-05/rustc-1.94.0-powerpc64-unknown-linux-gnu.tar.gz=2c8db5f6170739facbc96d467846d2072a63e8a16106ca5fcfa6baf1cfe9cfc4
+dist/2026-03-05/rustc-1.94.0-powerpc64-unknown-linux-gnu.tar.xz=89874c3bebc35ace3b0d0dd225154e583a88caafe2c3d04476b21e4a6650f715
+dist/2026-03-05/rustc-1.94.0-powerpc64le-unknown-linux-gnu.tar.gz=1dab70d5a5c0a3b20afd6a7741c6eadcd5ea1a12c0c09890d61903eff1ccb413
+dist/2026-03-05/rustc-1.94.0-powerpc64le-unknown-linux-gnu.tar.xz=7fcdb850568508c0737e9079383f2aade49b1ee159620e67e041d0b756bfe4b5
+dist/2026-03-05/rustc-1.94.0-powerpc64le-unknown-linux-musl.tar.gz=ada02e4261129562c3a34868b3f9e269dda64a344edfb6a2de92bede31db517c
+dist/2026-03-05/rustc-1.94.0-powerpc64le-unknown-linux-musl.tar.xz=fea7a7e45a12fbd297d6074389552f1f68c103b197b1e5f2ca7582d2af0840d4
+dist/2026-03-05/rustc-1.94.0-riscv64gc-unknown-linux-gnu.tar.gz=dfc5b61a02170e45d9d7beca69d44214cfba7febd2075209f9ddbaec57ddab8c
+dist/2026-03-05/rustc-1.94.0-riscv64gc-unknown-linux-gnu.tar.xz=ad0e35e45ceb4e874653444c393bc3b969da78729d92dc3d8852b0fd2eddcec6
+dist/2026-03-05/rustc-1.94.0-s390x-unknown-linux-gnu.tar.gz=b16c91785cdc48502d736042c52fa33628c9597681caa1b4b78798c1939d194d
+dist/2026-03-05/rustc-1.94.0-s390x-unknown-linux-gnu.tar.xz=9167f4a85ef250d6e613bdd3993d723fd225df67665fd2dbe61b0c780009c8e3
+dist/2026-03-05/rustc-1.94.0-sparcv9-sun-solaris.tar.gz=5a664c111df1ea4307efda819119e7c19d5f65d69b8da7aa13832402cf4e289a
+dist/2026-03-05/rustc-1.94.0-sparcv9-sun-solaris.tar.xz=9195ba45e031cf8c5e66ab51cf7bf46d1d8d26ed15c56d4fa4e55c73c8d9bc89
+dist/2026-03-05/rustc-1.94.0-x86_64-apple-darwin.tar.gz=f344db02d665a32564b6fcaf1dee5a8dc2d136f03468cf35af753168450bbb9c
+dist/2026-03-05/rustc-1.94.0-x86_64-apple-darwin.tar.xz=b1374b0fb63f5abcd8eb65607e43a499bfdc5e8160746d1f6f993aee9313f320
+dist/2026-03-05/rustc-1.94.0-x86_64-pc-solaris.tar.gz=7722321d6420159cf3ece3f1046895d654cdcee0c27073af5c3437923d3cd185
+dist/2026-03-05/rustc-1.94.0-x86_64-pc-solaris.tar.xz=96b0a95ded5f9d89ae7ca926347fdf132370d0013e0f175712e8c9564c4fdfb8
+dist/2026-03-05/rustc-1.94.0-x86_64-pc-windows-gnu.tar.gz=efd049565504b5f7f26c80ac0a41026f17cb8536d67034b7d06bb118e83bc8db
+dist/2026-03-05/rustc-1.94.0-x86_64-pc-windows-gnu.tar.xz=6badaefeafc37127dc59cde7275edd45bec6e234bf589f0bac14cabc39488f70
+dist/2026-03-05/rustc-1.94.0-x86_64-pc-windows-gnullvm.tar.gz=451b8ad4f65e44b792fe23da622426746c164d2ee13fce932721c7a3e706ae8e
+dist/2026-03-05/rustc-1.94.0-x86_64-pc-windows-gnullvm.tar.xz=69c5223805fa0889e7dfdd49c941aefc90ae4639070831ea920d5dbd0478649f
+dist/2026-03-05/rustc-1.94.0-x86_64-pc-windows-msvc.tar.gz=16600415241e4559f87a48761a63ed269d769ea8c44d3c019c9b8eabb3c5f80a
+dist/2026-03-05/rustc-1.94.0-x86_64-pc-windows-msvc.tar.xz=e0f59503778b563d3ee6d4edecd52b44056779ffe456181bad1fb4dc069802e6
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-freebsd.tar.gz=8de2fcb23bfe514e8a887e5435b5af858a562c63c4f51ea6e2f4b966b5942276
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-freebsd.tar.xz=98a9d60df972d764d71849341691a8f2636cb028b22569158566a9d69cdcb03e
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-illumos.tar.gz=0c60580794a6e0981dd7b5e43f66f68c5f7c042df2d9809edb95dc07f2f1f9a2
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-illumos.tar.xz=64e5f7b32601553795f43e7288dda8984bbb620a72f79130fae0cec2d05cecdb
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-linux-gnu.tar.gz=b8c57ca524c86b2454502628a0d76f2de8cf1ae2c0a098dcdf1216ffaa4747e8
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-linux-gnu.tar.xz=31a0d3ac9383dfdeb4fce86eeed5ade3230131c635264c0eab7252dbf235f28e
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-linux-musl.tar.gz=1a2e93f609e1524f186c1f408d3f50b219dd3968ffece25ba3809265b22be0ec
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-linux-musl.tar.xz=70fd1a4cdc6920bfbd352606505d5fb3ccbed7d09c125d2e603908a0ae06fc16
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-netbsd.tar.gz=d56469bc29e33b96d757289ea4e69765342851606d291a8bd696399df58c171c
+dist/2026-03-05/rustc-1.94.0-x86_64-unknown-netbsd.tar.xz=e2866ab15bdc4b798955129570217fab99f4a03e2e6d3b0bf01aaf288848f4b4
+dist/2026-03-05/rust-std-1.94.0-aarch64-apple-darwin.tar.gz=5fa2aab3f8b11563fde18acafcb1444ac1a398d333950835dbe328c0335e8636
+dist/2026-03-05/rust-std-1.94.0-aarch64-apple-darwin.tar.xz=d3293668128b0a7838ef2544ae341eadd4437460ca22098af723349885a10ba2
+dist/2026-03-05/rust-std-1.94.0-aarch64-apple-ios.tar.gz=43cc6486869f861372a0c2f38e900d3c460840e6204299176ab5425d7866a5e3
+dist/2026-03-05/rust-std-1.94.0-aarch64-apple-ios.tar.xz=41ec1d18f4762f85231a19cf8aba3385da78fece2ff900a435c62881a3a3b44b
+dist/2026-03-05/rust-std-1.94.0-aarch64-apple-ios-macabi.tar.gz=2b5cb34b48d7986857e83bb28a357ba15b565f584e92394d14260e271dea029b
+dist/2026-03-05/rust-std-1.94.0-aarch64-apple-ios-macabi.tar.xz=914f085065539ea1038d2832a5af1c22852cd5e9a063356b20e46698e72e770e
+dist/2026-03-05/rust-std-1.94.0-aarch64-apple-ios-sim.tar.gz=018329d232178a963818d9017bda4e3c612e1e6700bc738166478234f888baa1
+dist/2026-03-05/rust-std-1.94.0-aarch64-apple-ios-sim.tar.xz=b4d16842b8f98ff2f431d6ab4aced298f4028ca00f0f5d588bc6efc94faa0680
+dist/2026-03-05/rust-std-1.94.0-aarch64-linux-android.tar.gz=0aad8d116086f7323c48e5ee7ce11d2c218a83c93be267ddd6d11702703dbd9d
+dist/2026-03-05/rust-std-1.94.0-aarch64-linux-android.tar.xz=402c80df672a4b9fc948b6dc8bde21a63e1093eb1c8a2c2bd42221c309d9eba2
+dist/2026-03-05/rust-std-1.94.0-aarch64-pc-windows-gnullvm.tar.gz=8afeb73b427d9039f44cddee301245a043f60220c44ba98581d3afec1f6e4406
+dist/2026-03-05/rust-std-1.94.0-aarch64-pc-windows-gnullvm.tar.xz=8c89521f6826a1d2bf07b27c95405f4d6bf7c24f3de832c02758c41d4c1a511f
+dist/2026-03-05/rust-std-1.94.0-aarch64-pc-windows-msvc.tar.gz=3060d60232ab87ac8a1a3327a64c005c6438760c23739b95669c2678640eea86
+dist/2026-03-05/rust-std-1.94.0-aarch64-pc-windows-msvc.tar.xz=d7964debd444dca92e771c953c3cd582fb927031b536c1439e1a831014d5f0d1
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-fuchsia.tar.gz=389cf92e6a4b1562436629b2cad55ad19755210dd8694c11e8f1ce2ef84b8a7f
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-fuchsia.tar.xz=87e11d97055540a0675bdc3dacf3d3d8cca5f806171ad0b51d0427f7cb9510c9
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-linux-gnu.tar.gz=208bcd75dbb01ebb1e5a6a4bcb7ed2e3cf2b6ca7c50885e8430c2cc803d3561c
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-linux-gnu.tar.xz=c781b3ef4fefa5508fbe05820eddc95e46351d905a30921cc020febd9c596a2e
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-linux-musl.tar.gz=32f7881cfde924a798cb226272f908811aa097da3ff360a12dd8979a13ba4dc3
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-linux-musl.tar.xz=3513032b2953d795bd3ac1489de4e8174e72500a31b4e7d1b349a23ab78a7a7b
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-linux-ohos.tar.gz=cb3d8c0f122370625643160a082e0ce86f1c9ace474600499f66da69edb95259
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-linux-ohos.tar.xz=1bc5ba1f4d7cad4ea61eae4ed372ee5485a1d92027755518c1d9cefd250dc2fe
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-none.tar.gz=8002bc1903d543a3e9c32da517f13be7da336b4720d4b988621c17ba6d997d59
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-none.tar.xz=854a9f8cea0ba889f553a7ea664c2a6479fc1fc49a4b56f84f99fc37001c4322
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-none-softfloat.tar.gz=7862b6054352ac453f7f6cb9a0bb9347c7b99058e683f8357eb78334aa8ee0c3
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-none-softfloat.tar.xz=375c496af31cf208ce67613c0aa1bde1894b5d674b00050cd46f7f954ed4a668
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-uefi.tar.gz=257972889c2e734f036fc5c5a30c516f00b26445f50d4dbd9a0fe6f6242d54b7
+dist/2026-03-05/rust-std-1.94.0-aarch64-unknown-uefi.tar.xz=f038d9e3df557d4aecdcf65989896179bcf0ecbc4d62bde71d33d7b914d3c253
+dist/2026-03-05/rust-std-1.94.0-arm-linux-androideabi.tar.gz=a38917a2e9e278375f40b40f8b227593d6bb5a267553946f7fa2cf9a162fd588
+dist/2026-03-05/rust-std-1.94.0-arm-linux-androideabi.tar.xz=d2113ef50ed0b974f33b41102b961588c26abaf34f45a289a293b3d31ba01113
+dist/2026-03-05/rust-std-1.94.0-arm-unknown-linux-gnueabi.tar.gz=7dc1848cd977964b7ccd80c0c0d5b3eccc57a4fee3dcbf5fa7aaf71d92b4a5b5
+dist/2026-03-05/rust-std-1.94.0-arm-unknown-linux-gnueabi.tar.xz=ad364b54b668e866315900ebff0d225616c556ab5228599792470aede05ba42c
+dist/2026-03-05/rust-std-1.94.0-arm-unknown-linux-gnueabihf.tar.gz=cd79238fddcedab36e9c40ffa145657a855d81158a50ed18176e261724e82c66
+dist/2026-03-05/rust-std-1.94.0-arm-unknown-linux-gnueabihf.tar.xz=d5db943974fe05306ae43d100b0b7f3540108b93ef52de670675ce966af8a0fd
+dist/2026-03-05/rust-std-1.94.0-arm-unknown-linux-musleabi.tar.gz=d2164d4b63935da258db99f0a01173bc33b5aca3c8aed485da8aecb157012ace
+dist/2026-03-05/rust-std-1.94.0-arm-unknown-linux-musleabi.tar.xz=c724b1a1b5dddeca563cda9b9695610bb56e681727b3af0a352174960087069a
+dist/2026-03-05/rust-std-1.94.0-arm-unknown-linux-musleabihf.tar.gz=2f4b75755e566971fd8c74357a69e687eaa9343a35e5743db5566fedd9219d05
+dist/2026-03-05/rust-std-1.94.0-arm-unknown-linux-musleabihf.tar.xz=9f8b707760a632b80864e91ea81a1b19c3f5452ff5e18b96da75792be1cf0a3c
+dist/2026-03-05/rust-std-1.94.0-arm64ec-pc-windows-msvc.tar.gz=7464cd0ec0187cf83e1edd572ca62d6e0b144c51f6fa32c5cb6d6235bcb344a5
+dist/2026-03-05/rust-std-1.94.0-arm64ec-pc-windows-msvc.tar.xz=e91a0e4d70098142be2049b5241547efa71855924281da7486e76178e2146472
+dist/2026-03-05/rust-std-1.94.0-armv5te-unknown-linux-gnueabi.tar.gz=946b6a6b954eb12ad4d07fd03a0d492567c274289c9b6b044aa53d7cbf3f065c
+dist/2026-03-05/rust-std-1.94.0-armv5te-unknown-linux-gnueabi.tar.xz=90873cc69546b3af42b13abcbdf393adfe28600cb687b2306e1938ff075f4fc1
+dist/2026-03-05/rust-std-1.94.0-armv5te-unknown-linux-musleabi.tar.gz=afd99c810689b21d7d68542d5d4eec9a958b9a29e05f54adf6a782b78eb7355b
+dist/2026-03-05/rust-std-1.94.0-armv5te-unknown-linux-musleabi.tar.xz=52bab957c67138de31da61145b82efb7fcaf68bcd8e59676ff102eacec6174a0
+dist/2026-03-05/rust-std-1.94.0-armv7-linux-androideabi.tar.gz=7382145003f4aa0789d225884ff7211eaa697a9b27e7443db945ebaacf615e49
+dist/2026-03-05/rust-std-1.94.0-armv7-linux-androideabi.tar.xz=e0b6883364f939300c281d96d6778ecf7fd97fe867b11936f0aa5c9a29f488ad
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-gnueabi.tar.gz=8fef491a08cc6a2a5ee36be21f5e08fc7c554d5f874a75a60107db0f77dfc373
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-gnueabi.tar.xz=9b1d8143881d510785d89413ea09b9fe910b64e3f300ab30e52e7fdd652ea66a
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-gnueabihf.tar.gz=b799402e64aa63bc9c8f6ffa12c84050c305646e4f133822fb15660171a2747c
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-gnueabihf.tar.xz=4b1744a8e48f58c2741afc1e076d0629a86051d785bd36e2c97f329eab6a5b49
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-musleabi.tar.gz=a81924f8f3336d15fbb136f53a8a0f3dce5e14050e6512c8b8bf5d2246e691d2
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-musleabi.tar.xz=fc2754f50ece0c7d3d32b2e0034b19c8b8bba9b471e0eb00f8ece7fa0bcb2837
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-musleabihf.tar.gz=eb6d0f4eb9e7e835a3718096234267b20912d24ca1719df3cbf58321f6c4aa72
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-musleabihf.tar.xz=abfc0e7c1eaff1e3332b5c6262d12da309035a228261d07155add44464ed52f4
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-ohos.tar.gz=54cdcdb909d5b0024b3f04cd684b221b892395a1b6ed2d79be3ecbdacb20f360
+dist/2026-03-05/rust-std-1.94.0-armv7-unknown-linux-ohos.tar.xz=3a79738c10220f3b4123e2f5441f0bdcd3491284e8cf2ed3a88f438d2bfbcb2b
+dist/2026-03-05/rust-std-1.94.0-armv7a-none-eabi.tar.gz=96f3425cff29e24029a0997e88e82cd08b7f532b98b53f6b3a85138d37c40da0
+dist/2026-03-05/rust-std-1.94.0-armv7a-none-eabi.tar.xz=20f4d3290a4450c209c221784c6d0c723b49d6a6bf388e81bbe976318123fd02
+dist/2026-03-05/rust-std-1.94.0-armv7a-none-eabihf.tar.gz=76f557e43489fb468d227368ffe35ead6494cae940c54b15e398c1446545171e
+dist/2026-03-05/rust-std-1.94.0-armv7a-none-eabihf.tar.xz=193ea800c46f2d173207c971a193aa6e8cdaf2adbb51d6e993983583a4cc27db
+dist/2026-03-05/rust-std-1.94.0-armv7r-none-eabi.tar.gz=edf0051a217c5b54afad8e34e3767ecd60678fbb4edb940f88c6da1219d86626
+dist/2026-03-05/rust-std-1.94.0-armv7r-none-eabi.tar.xz=7bc5153574d248810143cb940a2731460db8cd769bef766c691509919a496ae5
+dist/2026-03-05/rust-std-1.94.0-armv7r-none-eabihf.tar.gz=a5649f8ac88a7adfd2050bcc06aff611f066a36296d0593ab2ed3079e5346c67
+dist/2026-03-05/rust-std-1.94.0-armv7r-none-eabihf.tar.xz=fe5a447fb3e7052cacb511e60c44d9819a45d1f3f5c787f3fe4ecf9df9631084
+dist/2026-03-05/rust-std-1.94.0-armv8r-none-eabihf.tar.gz=1bb0482e3c3b4fb13864855503037f4e5f99593d131850f1af8828f2c7795242
+dist/2026-03-05/rust-std-1.94.0-armv8r-none-eabihf.tar.xz=af3d0e76f8873622de30aeec1c9ae687f68537e4a5a18cca098842c78cb7c69a
+dist/2026-03-05/rust-std-1.94.0-i586-unknown-linux-gnu.tar.gz=84659713515948976a322075b0419f828a364437f3d1ccb9ada056a5261f9af7
+dist/2026-03-05/rust-std-1.94.0-i586-unknown-linux-gnu.tar.xz=9347cfdc1383f4d71db1d63960f289977abc93ee575ca84748516995a05fac94
+dist/2026-03-05/rust-std-1.94.0-i586-unknown-linux-musl.tar.gz=9b02537c3d649fa3c2b996bdfae6b7da4bfd1498a4b2bc3448e82d4e37422b7e
+dist/2026-03-05/rust-std-1.94.0-i586-unknown-linux-musl.tar.xz=bf74e474afbabb15e2efe57848981652dab867bbe27c4c3ef45c37920e3da8f1
+dist/2026-03-05/rust-std-1.94.0-i686-linux-android.tar.gz=efededb44040a161a27f0383d6414efb9a474af54b677ca8e153c95db8a89de4
+dist/2026-03-05/rust-std-1.94.0-i686-linux-android.tar.xz=9093a894d87568a4b5eb4a144758bf49d4b62743677f747848afc3807c23f126
+dist/2026-03-05/rust-std-1.94.0-i686-pc-windows-gnu.tar.gz=0a5ccfcd2234b40ac220b4ab3c62cd2f32483f3eb11d83b66e31187efa3a996d
+dist/2026-03-05/rust-std-1.94.0-i686-pc-windows-gnu.tar.xz=188490bde6649163347050a70fd81c6d9e2e972ef12ba646f7f4fa106e21a956
+dist/2026-03-05/rust-std-1.94.0-i686-pc-windows-gnullvm.tar.gz=44ad95e57dffc26e8d070e87c5a22d50bb668192b1c7ffa5239f394ca9c95d76
+dist/2026-03-05/rust-std-1.94.0-i686-pc-windows-gnullvm.tar.xz=ba61dc038c3f4102a832a3381935192e88b0a1f79ff50b6d5590d476bdfa6879
+dist/2026-03-05/rust-std-1.94.0-i686-pc-windows-msvc.tar.gz=6ac341cbd8666549b40bb58337395d29cf1e45e3f0e7105162fba004728839e9
+dist/2026-03-05/rust-std-1.94.0-i686-pc-windows-msvc.tar.xz=388cc2bb17ef9f12864c08e462cdbe3222d5ddafd84969dcf4ed944da27efcbd
+dist/2026-03-05/rust-std-1.94.0-i686-unknown-freebsd.tar.gz=87f430bf73cd032ddfe71f7d2a537f171e1bd0ec971db0dda9be4b9d60b5b94e
+dist/2026-03-05/rust-std-1.94.0-i686-unknown-freebsd.tar.xz=3ce634092bcecb000c793c9d4bb0ccc6fd45c66fa8259fbb4f18c59844c4b13b
+dist/2026-03-05/rust-std-1.94.0-i686-unknown-linux-gnu.tar.gz=cacd9733d594bd061c17baba0f7ec7c0456c10509441068b5a268e9648bb91c7
+dist/2026-03-05/rust-std-1.94.0-i686-unknown-linux-gnu.tar.xz=528c1dda491b25bb855426f48757773f4740c75d3c7271efffe7412c2fd5730d
+dist/2026-03-05/rust-std-1.94.0-i686-unknown-linux-musl.tar.gz=7733ed61268a6188c746661badd4fa04909be5576f543df2da1823e8fab62133
+dist/2026-03-05/rust-std-1.94.0-i686-unknown-linux-musl.tar.xz=90ff16d879f774048c9b81d07188af4b63ed73a31848759cf560a9f51baa175f
+dist/2026-03-05/rust-std-1.94.0-i686-unknown-uefi.tar.gz=642d74b55611590d3e76832c4771040d58b9c93e96a835d9bbc223a4035bee7d
+dist/2026-03-05/rust-std-1.94.0-i686-unknown-uefi.tar.xz=8c095069ec09d6e1d0b7e00f340fd7ea925a31acbad845d5956e1bc4a7d47733
+dist/2026-03-05/rust-std-1.94.0-loongarch64-unknown-linux-gnu.tar.gz=187b1a9a5077bf6b2fb655ca1370c1e77f6c26bdc5ad3db9ebd3b28fafc65114
+dist/2026-03-05/rust-std-1.94.0-loongarch64-unknown-linux-gnu.tar.xz=a42ebd0c280f987f8c604fcb4549886f8954e7d025d54da3e63a5621ed268dd5
+dist/2026-03-05/rust-std-1.94.0-loongarch64-unknown-linux-musl.tar.gz=47e3f0e49df998480245e547ca30447e45bf9fb2e96025db14bc2d61cb05a83a
+dist/2026-03-05/rust-std-1.94.0-loongarch64-unknown-linux-musl.tar.xz=69f7d01d02d50959c8bfbec2205a4a85577ed342674023445018e302a5567fbf
+dist/2026-03-05/rust-std-1.94.0-loongarch64-unknown-none.tar.gz=2f8b010060a2adf5e91e028c038b4ef292b854f874866f77bedb65fc7d7ff7c0
+dist/2026-03-05/rust-std-1.94.0-loongarch64-unknown-none.tar.xz=ee747abfd06f057e34ec51324267cdfcd3e7a4b1acd45a5cfb78e61dc8e621a2
+dist/2026-03-05/rust-std-1.94.0-loongarch64-unknown-none-softfloat.tar.gz=fad94562507b4385645672f0f2e71cc54ef15e8dab1dbea87b71e1f78cbb982b
+dist/2026-03-05/rust-std-1.94.0-loongarch64-unknown-none-softfloat.tar.xz=aa9599a9c4839144344579ec25a21899fd0614c37ad0e9ef92fbef0da085c424
+dist/2026-03-05/rust-std-1.94.0-nvptx64-nvidia-cuda.tar.gz=8b4df93c758a26b1af1fb87f9740288caff767dcc87918369fc5bdd0296c18e8
+dist/2026-03-05/rust-std-1.94.0-nvptx64-nvidia-cuda.tar.xz=d99eafec04ac537b5669320c67d05b36515ba7fbd1b70548b112c59e9950c4d7
+dist/2026-03-05/rust-std-1.94.0-powerpc-unknown-linux-gnu.tar.gz=f2a83e6edeb9aeebdbf081ad1630ac12642bf880348c7620e456018690ff897c
+dist/2026-03-05/rust-std-1.94.0-powerpc-unknown-linux-gnu.tar.xz=23e32cab484d7787b7966a0508c49baf231bcdb4a79a421ee85ca69e81f2a06f
+dist/2026-03-05/rust-std-1.94.0-powerpc64-unknown-linux-gnu.tar.gz=4c637fdf3b2255f4798f1c77e5c50ba1c49cefb755809df32d0f7633853a61fc
+dist/2026-03-05/rust-std-1.94.0-powerpc64-unknown-linux-gnu.tar.xz=7713b676a37fbd0a52a711c2e3c205a917f8b05614e17cd9f7f37874a88469a3
+dist/2026-03-05/rust-std-1.94.0-powerpc64le-unknown-linux-gnu.tar.gz=befa4be0764862c832722ee8f1d93afe2dd59d27021d3602e8475416d48f2e81
+dist/2026-03-05/rust-std-1.94.0-powerpc64le-unknown-linux-gnu.tar.xz=094f3955828d6630b70a9c7c71e3165c3ffc7a301929601dde08501def623347
+dist/2026-03-05/rust-std-1.94.0-powerpc64le-unknown-linux-musl.tar.gz=813c9fceed88f63cc36c0316eec5ed41637f50cdc893fce4c7322a3b35333f1a
+dist/2026-03-05/rust-std-1.94.0-powerpc64le-unknown-linux-musl.tar.xz=f3956b29463ec58d730f054ff2334755f929c602181ad67a25af9725c8500f68
+dist/2026-03-05/rust-std-1.94.0-riscv32i-unknown-none-elf.tar.gz=0045789cbf13cb6679dea21a3e08a8c96338103f7de6b6bd9fc1939f9b7a5e20
+dist/2026-03-05/rust-std-1.94.0-riscv32i-unknown-none-elf.tar.xz=2a2ebf4797bbac3718f1394cce676833da8847e5c3b67105eb4f474aa4561075
+dist/2026-03-05/rust-std-1.94.0-riscv32im-unknown-none-elf.tar.gz=5d08e75c0248151f18360ac20d17c1fa51930449831a78d49d29bf9961854434
+dist/2026-03-05/rust-std-1.94.0-riscv32im-unknown-none-elf.tar.xz=33d4896a1718547644200b64e5c1480037e2fad0862e80452b6904e9735841e2
+dist/2026-03-05/rust-std-1.94.0-riscv32imac-unknown-none-elf.tar.gz=b073f296f8a5303a9d63f50a2fd482e8074dd98021ece4cc30bff0a4b1a063b0
+dist/2026-03-05/rust-std-1.94.0-riscv32imac-unknown-none-elf.tar.xz=642e1767dac85c5c143a8aaaaa0f34618314d08db54aca9756af4ee55027a1f5
+dist/2026-03-05/rust-std-1.94.0-riscv32imafc-unknown-none-elf.tar.gz=be2033fd6ee49366fa0c2f347606de2af7680d1fd1a1737d12030883eadf3498
+dist/2026-03-05/rust-std-1.94.0-riscv32imafc-unknown-none-elf.tar.xz=2b7e619ad01ccab667c1b68c162701eb0562d8b3923de6567cc991ec73a12169
+dist/2026-03-05/rust-std-1.94.0-riscv32imc-unknown-none-elf.tar.gz=8197609b95dd0c80455b4b47a765b4b2a95c027a743f51f46aaf19584f029ea0
+dist/2026-03-05/rust-std-1.94.0-riscv32imc-unknown-none-elf.tar.xz=5d10c7ab74cd5d10451480ec894ac5b98940a8527c333465eeec4a45b1125d43
+dist/2026-03-05/rust-std-1.94.0-riscv64a23-unknown-linux-gnu.tar.gz=4548bd12b89e85b1d08ab07cca44ebc145b7cc1cf0f789b96a7c0053c5b06afd
+dist/2026-03-05/rust-std-1.94.0-riscv64a23-unknown-linux-gnu.tar.xz=f0b68c16c81b96562e039ff298dbf6a833cab112340c3b4bbd44dd3b45db6a31
+dist/2026-03-05/rust-std-1.94.0-riscv64gc-unknown-linux-gnu.tar.gz=68396963ba07d2de5f0eaaaf959332c81609fca2eca85d1fd6273a588c38601f
+dist/2026-03-05/rust-std-1.94.0-riscv64gc-unknown-linux-gnu.tar.xz=32e9b7006f1269e48fb65af6298f6e8a222e1a8a2a20b112528bfb3dad2f65a8
+dist/2026-03-05/rust-std-1.94.0-riscv64gc-unknown-linux-musl.tar.gz=13d600ecb9c23d57f491525867ed0a2345c0d8a5f2c2155b434e602ea12aa87d
+dist/2026-03-05/rust-std-1.94.0-riscv64gc-unknown-linux-musl.tar.xz=2c63d21143c7f1d44f3e3b1c9a82f3101576344c3fd1feb2d43ffc9d035e94f1
+dist/2026-03-05/rust-std-1.94.0-riscv64gc-unknown-none-elf.tar.gz=fd7e556d4b64b21a5c54120f92bc3a237fa30c29436cc3222f7db6a0a7f5516a
+dist/2026-03-05/rust-std-1.94.0-riscv64gc-unknown-none-elf.tar.xz=071a1ae54f7dead1b8147b9bae7d831a5554a37a1133f8cd52b265a765595a12
+dist/2026-03-05/rust-std-1.94.0-riscv64imac-unknown-none-elf.tar.gz=e2f34ad99fe522186a60d6e8da5fd6f47472711be1364dd43a86fc48353ca59f
+dist/2026-03-05/rust-std-1.94.0-riscv64imac-unknown-none-elf.tar.xz=e92f152a756b93278aeb1d7610e29524609ba32413ff62777f854cfcf70b2488
+dist/2026-03-05/rust-std-1.94.0-s390x-unknown-linux-gnu.tar.gz=28bc2060b12149fa5ec7d1ffc570c8c6eb2f558c08a967d623a99ef4483797da
+dist/2026-03-05/rust-std-1.94.0-s390x-unknown-linux-gnu.tar.xz=ea69833addbc9521664464418c7468871f7a80b16fd2c385f6213a6c99cedfe9
+dist/2026-03-05/rust-std-1.94.0-sparc64-unknown-linux-gnu.tar.gz=90bdcb3e5c21f89c5820a46f2ad8186cfb0002c2bfbd211fee6c7851386eea21
+dist/2026-03-05/rust-std-1.94.0-sparc64-unknown-linux-gnu.tar.xz=8f611aa779732057742fa289e7581bde48af1c97014c1f92fd21b5682eff1a16
+dist/2026-03-05/rust-std-1.94.0-sparcv9-sun-solaris.tar.gz=0349aa4f6d8f27158e0e4b0873d4b6922f9d39c97aa2f9394101b9202f0526cc
+dist/2026-03-05/rust-std-1.94.0-sparcv9-sun-solaris.tar.xz=1b28e2f73177efd96b673cc39a9704c49aa164b7fb90b42f2f29c701a8615ffe
+dist/2026-03-05/rust-std-1.94.0-thumbv6m-none-eabi.tar.gz=9d944ed5b77831ec9f4535fac3a290b6ac0cd8135b5ee48e907dc28af6a1a5f0
+dist/2026-03-05/rust-std-1.94.0-thumbv6m-none-eabi.tar.xz=b022df94f6efa3bd2a6c4042472e114d2325bf058983b3ac7d586e24c8d77f25
+dist/2026-03-05/rust-std-1.94.0-thumbv7em-none-eabi.tar.gz=bc7e7bbb410f0ffda3ad87c0e4201711abe2c1763628d922a3b1ffda64ea2d5d
+dist/2026-03-05/rust-std-1.94.0-thumbv7em-none-eabi.tar.xz=41894db05c4d8f421bf0dba7d0bed995685032393779f92b4ea1f3e6468badfb
+dist/2026-03-05/rust-std-1.94.0-thumbv7em-none-eabihf.tar.gz=a640aacbef30b4e677f145063c420fc1673ca064476c885f6841e0639b72a2dc
+dist/2026-03-05/rust-std-1.94.0-thumbv7em-none-eabihf.tar.xz=be7e81535e7118fbad58a5dc31a1acfa7f2a36a2348aed23595169418559d67f
+dist/2026-03-05/rust-std-1.94.0-thumbv7m-none-eabi.tar.gz=5362eeafde4d8f7ec3ed0dcf48b5255e44786cf8264f38afe56a56c19f520477
+dist/2026-03-05/rust-std-1.94.0-thumbv7m-none-eabi.tar.xz=4702e615be264df97b120fd075bed4e46710cc9a03c48115ce2ee3abfbf3822e
+dist/2026-03-05/rust-std-1.94.0-thumbv7neon-linux-androideabi.tar.gz=1aee0f50cc22aafb4c9968632dc3c0dcf4462965ac22cdad8f053bbd3b72bdc7
+dist/2026-03-05/rust-std-1.94.0-thumbv7neon-linux-androideabi.tar.xz=654de5867be6f4b19da8eb0947d8a3c42603e944e1a840d0b2d40e23acb51e2f
+dist/2026-03-05/rust-std-1.94.0-thumbv7neon-unknown-linux-gnueabihf.tar.gz=3cf09a2fc53ba07de0e49b8e2c27d08be60a47521a2b5e3b119896eb66ef9158
+dist/2026-03-05/rust-std-1.94.0-thumbv7neon-unknown-linux-gnueabihf.tar.xz=8ded898146c4088746ce5e1659407f60c0ec9cbf350dedc0cf47fed69c882e2c
+dist/2026-03-05/rust-std-1.94.0-thumbv8m.base-none-eabi.tar.gz=1516f612b42bca261a656545ea24bbf3533dc12cd2157c5d48a718e3076cdc65
+dist/2026-03-05/rust-std-1.94.0-thumbv8m.base-none-eabi.tar.xz=3050829a82a5d609ea62dd77992f10fdd55b771d8ace71c1c00e8a46111c3407
+dist/2026-03-05/rust-std-1.94.0-thumbv8m.main-none-eabi.tar.gz=d7a391447f23173e833e06c77fdeba594b104682ad46545002042a2f79f80291
+dist/2026-03-05/rust-std-1.94.0-thumbv8m.main-none-eabi.tar.xz=5c1fb5ed8ad31580241b6e095583a2cac0ef90ea29dad7705c8a0ce0933a7797
+dist/2026-03-05/rust-std-1.94.0-thumbv8m.main-none-eabihf.tar.gz=657243ca43b8016da960584246368b6a1d3279fc1c966a5ddad4165887a1c649
+dist/2026-03-05/rust-std-1.94.0-thumbv8m.main-none-eabihf.tar.xz=573e9570bea039316ae3b55e323cbc741617ace1e0b87df8f3ecbbdf34b3de8a
+dist/2026-03-05/rust-std-1.94.0-wasm32-unknown-emscripten.tar.gz=2f9048f9254278249492b132ae2ac3b969aadafd659a1d2fe63a591dcb7651cc
+dist/2026-03-05/rust-std-1.94.0-wasm32-unknown-emscripten.tar.xz=0a607ba5d78afb47e9f5f134633ed5a954ece5558298e081084abe44f5265463
+dist/2026-03-05/rust-std-1.94.0-wasm32-unknown-unknown.tar.gz=ef956630b775c48f371b6c82de8de71e6633970c5aadbc4b6f1a1accced382bb
+dist/2026-03-05/rust-std-1.94.0-wasm32-unknown-unknown.tar.xz=bc65af3c0bfa2e5b20e299358710a26ce33a3674c762a2a010bc383c5b7fc202
+dist/2026-03-05/rust-std-1.94.0-wasm32-wasip1.tar.gz=a047bdd69f04b7c992a74daeaa5908aecf60fd29e8e9e57f53935d65c64d281d
+dist/2026-03-05/rust-std-1.94.0-wasm32-wasip1.tar.xz=acbacacdca3e0ec0d93ff46d5f3579ae8cd5133b86e31a893da22cd94e28d0bf
+dist/2026-03-05/rust-std-1.94.0-wasm32-wasip1-threads.tar.gz=719fa85ec896417cb0fb9bcde774786b4a04484642c48da3b6a08540ac2bf500
+dist/2026-03-05/rust-std-1.94.0-wasm32-wasip1-threads.tar.xz=311b9fe1e94c90c16695899e670f0d76a366d493cdda29008191ce2d436cd22c
+dist/2026-03-05/rust-std-1.94.0-wasm32-wasip2.tar.gz=1a544ad7b2c86dc0353cd07995112f976e2bb179279fff34a064f93ff7987444
+dist/2026-03-05/rust-std-1.94.0-wasm32-wasip2.tar.xz=e947e730da3fea212453b2835765802d9b0c80e19405cab188a6854834196e6c
+dist/2026-03-05/rust-std-1.94.0-wasm32v1-none.tar.gz=39a7d34248f2c287807e77250445f3e96358eb5867e6608178806120b8d210d7
+dist/2026-03-05/rust-std-1.94.0-wasm32v1-none.tar.xz=11325e62682d6e7244ea7a150b39babcf3b7540d5b3c039feaee578be613e585
+dist/2026-03-05/rust-std-1.94.0-x86_64-apple-darwin.tar.gz=f5107737a1ce338e84425c6ff58eed3e4729235689a754f8dd345c8acc64d2de
+dist/2026-03-05/rust-std-1.94.0-x86_64-apple-darwin.tar.xz=cf716b5a5fab007398ce76536a85a3449df074b66e7c762c0f5de1d6c56a1342
+dist/2026-03-05/rust-std-1.94.0-x86_64-apple-ios.tar.gz=914b2b3d78f9c207726bbb78b0bc8edc19834c4ebe198f82b2b106221e0de1f7
+dist/2026-03-05/rust-std-1.94.0-x86_64-apple-ios.tar.xz=60e70b80469dd3900dd8b1705831f5f02ac44fa97088b8a81fdda110ed421091
+dist/2026-03-05/rust-std-1.94.0-x86_64-apple-ios-macabi.tar.gz=06770d79a33c841459b4cee317c1734c07f62b9a4ed60fbbf8764e80583916f9
+dist/2026-03-05/rust-std-1.94.0-x86_64-apple-ios-macabi.tar.xz=f39f4c1121dafcf8ea70a21c91be9552e30ea76debcad9bff28be945aaa79282
+dist/2026-03-05/rust-std-1.94.0-x86_64-fortanix-unknown-sgx.tar.gz=f6a25bc2fecb3d3b1701f23762c0af22a7892ff165aea369eead02a827502582
+dist/2026-03-05/rust-std-1.94.0-x86_64-fortanix-unknown-sgx.tar.xz=b3e66517623058c55550bd9fa925d2e45d44966185432a3ad27d03d91e9167d1
+dist/2026-03-05/rust-std-1.94.0-x86_64-linux-android.tar.gz=de5f6c49c66c0d64f2005aed0275dc3182f8c8b11ae19212dd46e13dd9efe5ab
+dist/2026-03-05/rust-std-1.94.0-x86_64-linux-android.tar.xz=488c8a581612ac4779a05f05967b76a96e0ff0bdd1ab8d99c13a859c19056b01
+dist/2026-03-05/rust-std-1.94.0-x86_64-pc-solaris.tar.gz=035c5c90f79ba78e76acb12d4937855529c2fde64165f984b7fe8b148d74abc5
+dist/2026-03-05/rust-std-1.94.0-x86_64-pc-solaris.tar.xz=c9b7ed2099b2bf5bf01949a42e3047264f3a6a09791d54a69541c13d62fef590
+dist/2026-03-05/rust-std-1.94.0-x86_64-pc-windows-gnu.tar.gz=7f7fdb1e573788c67eac11cf8e7ddff7221f21f45d3d4e0f1357d7b2b59167f8
+dist/2026-03-05/rust-std-1.94.0-x86_64-pc-windows-gnu.tar.xz=c9f98d62213d0559c8d2ee6d7eafbafbf5dfe04921c9e7cb15b66a770903bc33
+dist/2026-03-05/rust-std-1.94.0-x86_64-pc-windows-gnullvm.tar.gz=881b1cd467ac69dd8b0cf3e3f099bcc5051c64f5e7841ea7a018f31fc8899a87
+dist/2026-03-05/rust-std-1.94.0-x86_64-pc-windows-gnullvm.tar.xz=54c28d0030fab585457a431c555e5d23502132364d0483e5b3b2dfbfc3929cc6
+dist/2026-03-05/rust-std-1.94.0-x86_64-pc-windows-msvc.tar.gz=af8f332cafe924b0bbdb4d44bf68190d218a35dcbb5beddfb9ef0cb7fda11087
+dist/2026-03-05/rust-std-1.94.0-x86_64-pc-windows-msvc.tar.xz=f8e2b43e52957e8224d97de68d6ec5da01613eb98bce4199de80071678b5fda0
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-freebsd.tar.gz=6ad6013d2af3750b9553518c34d5b2e7ed48808ebcfeef27e0d829635e3b3b9e
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-freebsd.tar.xz=081972f2f386ee859c15ed619695a9440896a80d1814d0e29d7620b7ef96207c
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-fuchsia.tar.gz=f383e2aecf5efb657d9cff002d909314bfe178179a309d01e54328a472c19eea
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-fuchsia.tar.xz=6c18112553cf72cf991352208cce2bc96c712ca7b209acdd098abac894d674ef
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-illumos.tar.gz=32c5d3a787b59b2de6241a35633fe4033bf8531063eb6c767b832014479a0a5d
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-illumos.tar.xz=4072122fd3ff7e5c7a24634c4a30040eb38f3c89a1f6f61e46b3619f5be65e24
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-linux-gnu.tar.gz=c07c49819f14578b4a1d010ca77179305d2f2de484a11f18e12d1c3c6aeaf373
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-linux-gnu.tar.xz=dd33653107c36e040082050d9e547e64dac5b456ba74069430d838c00c189a05
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-linux-gnux32.tar.gz=563107df7ede12e3d7ca786d1c789dcfbc9d067cb98224a302bcc6f249c04827
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-linux-gnux32.tar.xz=9e23432e8ce73f1ff568f089c4f9ffe6e96c7f99a19b40f5bb63ed8f2333ffe5
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-linux-musl.tar.gz=74a0e509ada9e9dd8e40a987abfdc677c6aa3487506bd6afaf9ede9466e3b189
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-linux-musl.tar.xz=b6786b5c490df2dcef76829039177799058f94e17725b42f912a057c0f6224f2
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-linux-ohos.tar.gz=732280e0c0a8f64cca4c5be73bab84f71174c2c6d2d1932a21d43a7729571049
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-linux-ohos.tar.xz=2886003eccaed0f2848b5afc4d7a4d03a0f8ce704c83201aa46da42ffd939bf0
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-netbsd.tar.gz=e92ba09414705840fbe8aa311c9c35a328ffbd43d2da2b8623392c19ed22628a
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-netbsd.tar.xz=f763e56ca1ce3f819fb2136638d774777dd696f836cc52e6564431859a0f5159
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-none.tar.gz=5069095d97c07747842d935c9ab7f32dd0eb14c8da46f018231de97632e00227
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-none.tar.xz=8509489165a8aa60a0590aeaa668f63423b3e7a33bb93e8e5719ff5404b6f6aa
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-redox.tar.gz=48a0cdf77f5376fd9dbf797f519c7ccba8831e873652ae4ff4822b092ee09d38
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-redox.tar.xz=1a07201a4d3f5d5d4cf74989249973272a420e3bb10e603eaad26ba21e0d35d2
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-uefi.tar.gz=34764ab662f04223ecfaaa38e63fd2d94f8902256a8838f456632faf662167fe
+dist/2026-03-05/rust-std-1.94.0-x86_64-unknown-uefi.tar.xz=31b56e8178dd2319e51ccc474959d247db2767cda7149fe3704d636df9aee1c9
+dist/2026-03-05/cargo-1.94.0-aarch64-apple-darwin.tar.gz=8091cb41d6b7fc27478cc0a51266231f41938be53b1cab5da8ab93d07e6f796f
+dist/2026-03-05/cargo-1.94.0-aarch64-apple-darwin.tar.xz=7497ab873993cf38b806548c85bf818ffd71d1c3cf77b5bb4c3d3f1769588a08
+dist/2026-03-05/cargo-1.94.0-aarch64-pc-windows-gnullvm.tar.gz=8894b5591b6f52be755edf89a1d71bfeb03764a1a868ef92973809a0aa69e6f0
+dist/2026-03-05/cargo-1.94.0-aarch64-pc-windows-gnullvm.tar.xz=6e5018e17bc52926e2718f92c76e202a755d6965a7fa08bd5030535e577bb385
+dist/2026-03-05/cargo-1.94.0-aarch64-pc-windows-msvc.tar.gz=8bba8f572fa6f3f4cf8444b829a0feb699a8ada1a35841acfb802f1e89f9d01f
+dist/2026-03-05/cargo-1.94.0-aarch64-pc-windows-msvc.tar.xz=0eacb6af29cacb850af4b390e698b2c8060f639a70e6b9f0575cdcc82b0822b2
+dist/2026-03-05/cargo-1.94.0-aarch64-unknown-linux-gnu.tar.gz=bb205f17bbb1d9d914305ee33515c519e1d35eb693571691ec4da8401e5b4660
+dist/2026-03-05/cargo-1.94.0-aarch64-unknown-linux-gnu.tar.xz=d57ab7b23b52cba46e58c78327904d0c7db19892988677b0d59495c8af4bb790
+dist/2026-03-05/cargo-1.94.0-aarch64-unknown-linux-musl.tar.gz=ccdefb257682c05320b3f71778377e69a4be2886a7e104d3b0304bb81616c7b3
+dist/2026-03-05/cargo-1.94.0-aarch64-unknown-linux-musl.tar.xz=3dc246b499ce827a038d933845f6c2965c85f15eb6d1d7e835df445fa540cf0f
+dist/2026-03-05/cargo-1.94.0-aarch64-unknown-linux-ohos.tar.gz=4f454b54916a9b93588696919afe94b61d5550a2ca746cda53eaee9ba995ad31
+dist/2026-03-05/cargo-1.94.0-aarch64-unknown-linux-ohos.tar.xz=9cc50a60755efbe78a900ddecd40419a16b920eab478fa2cf02245533284ceb9
+dist/2026-03-05/cargo-1.94.0-arm-unknown-linux-gnueabi.tar.gz=94df8d45573cd069c2be6e28bb34a1ce514c4ba5db74c29ac3df97ef686d257b
+dist/2026-03-05/cargo-1.94.0-arm-unknown-linux-gnueabi.tar.xz=285e2473af98b876a7b06b9ead23a3960af35a987e515256cb3ce4d35a5b72db
+dist/2026-03-05/cargo-1.94.0-arm-unknown-linux-gnueabihf.tar.gz=dd44cbdff19de6b98bbad332579fc13b967db1ec62d1bab5327c6768346a9d35
+dist/2026-03-05/cargo-1.94.0-arm-unknown-linux-gnueabihf.tar.xz=c42884cd5fc5f5a52b7b0417a695323732e4d20443a6108881f81b66c261b392
+dist/2026-03-05/cargo-1.94.0-armv7-unknown-linux-gnueabihf.tar.gz=c7eeb410da2d31bb99ef2bd141ed7451b07228d2e076b80536dfaf3d92152ebf
+dist/2026-03-05/cargo-1.94.0-armv7-unknown-linux-gnueabihf.tar.xz=de22052ed80fe689729881a6709af255d14c8b0e7fcde7413db2354e1c895ad1
+dist/2026-03-05/cargo-1.94.0-i686-pc-windows-gnu.tar.gz=392e0cb9652a122bed6c2979fd7743d89672d8ad8d082f9034c549d6f9bc7041
+dist/2026-03-05/cargo-1.94.0-i686-pc-windows-gnu.tar.xz=82eb07a25b52824e542797644926f0480372c4bc815a8deb760abc315e2baf6a
+dist/2026-03-05/cargo-1.94.0-i686-pc-windows-msvc.tar.gz=f0b487ee5869dd1ad8771139be95f7a4f772f8e4bbebca85c5144568f2b5833d
+dist/2026-03-05/cargo-1.94.0-i686-pc-windows-msvc.tar.xz=dd5f70ad750ec122190ea7b5eec4d03a9b5744b978ecdc771c9ee6e30fbe75c9
+dist/2026-03-05/cargo-1.94.0-i686-unknown-linux-gnu.tar.gz=eeab287ef4b52ef7a4e8a979dccc02b7f73e09eaef15dc754e5a26ca14017bb2
+dist/2026-03-05/cargo-1.94.0-i686-unknown-linux-gnu.tar.xz=8699cfc772af3f651bf61e84a5b292e2ea62de9e1ab12d70e1384e57a5e91690
+dist/2026-03-05/cargo-1.94.0-loongarch64-unknown-linux-gnu.tar.gz=1b797fd9c2ce6ece7ecf3cbf7f476d11fe1b9e25009e7575dae1b21748594806
+dist/2026-03-05/cargo-1.94.0-loongarch64-unknown-linux-gnu.tar.xz=83bda8ec4b506646eddab2b7b67e67f2fd9fccb74693a2558383868d82b85668
+dist/2026-03-05/cargo-1.94.0-loongarch64-unknown-linux-musl.tar.gz=eb780975f38d092177c4c533d29f47e00911ad99b3a160cde0d0917a34e95895
+dist/2026-03-05/cargo-1.94.0-loongarch64-unknown-linux-musl.tar.xz=a2a023ed1ad083355c946775f6f8f19c99bf9222467e148fc5541022c6abdd4f
+dist/2026-03-05/cargo-1.94.0-powerpc-unknown-linux-gnu.tar.gz=cb811ea88ab57bbac3ff9d309fa2b84381a4f258c9d2fb88ec3a5b0cefe4a132
+dist/2026-03-05/cargo-1.94.0-powerpc-unknown-linux-gnu.tar.xz=3274ccfb125035dc5846649b0bdce855f15c7a1824507360840c6a152599e4cf
+dist/2026-03-05/cargo-1.94.0-powerpc64-unknown-linux-gnu.tar.gz=74e51bc7a6683a95b7876dd23b79d9691d671c8b9f39641e8a712d8e22cb4176
+dist/2026-03-05/cargo-1.94.0-powerpc64-unknown-linux-gnu.tar.xz=3c618a93585244a6fd70a857061b781590262f5f430f710f3687d5eaf54940bd
+dist/2026-03-05/cargo-1.94.0-powerpc64le-unknown-linux-gnu.tar.gz=9f42031ee4e113ea4dbfc85702a2f19d98c5237abc71e3c7467214c0120252e6
+dist/2026-03-05/cargo-1.94.0-powerpc64le-unknown-linux-gnu.tar.xz=6b44ebc7f08464e3a60ff16580729a99e727c7d4c2368a2d4b62d1acf4fd5c11
+dist/2026-03-05/cargo-1.94.0-powerpc64le-unknown-linux-musl.tar.gz=485b8c79c12aac3e02ee9056a6a9112bfec0c7208832d96a90710275f90e62b2
+dist/2026-03-05/cargo-1.94.0-powerpc64le-unknown-linux-musl.tar.xz=fe9e280b426a8cc279ad1a1be3d01828b033f15be20044c9bc4548e2ec988fb7
+dist/2026-03-05/cargo-1.94.0-riscv64gc-unknown-linux-gnu.tar.gz=b0690a4b23fd996c46e8beebb1d7c1a4fd0e090a864b09aac66a6f4c6f7334e5
+dist/2026-03-05/cargo-1.94.0-riscv64gc-unknown-linux-gnu.tar.xz=61795ca964c0b08faef359db32c3409e3348ed2bd7b4cad481b3c8cf8654b5d6
+dist/2026-03-05/cargo-1.94.0-s390x-unknown-linux-gnu.tar.gz=ae7d912055507193ef588790b48026658403b9927cf4e36f6b272be156ebb87a
+dist/2026-03-05/cargo-1.94.0-s390x-unknown-linux-gnu.tar.xz=f32f72efff179de4871fb5f5a3e030092d279ca70a71f0a4e49b3c8f69ef7ac4
+dist/2026-03-05/cargo-1.94.0-sparcv9-sun-solaris.tar.gz=87a73bec71c8d200735507370f0102069f4c2f10053cb466c873b52113b120ec
+dist/2026-03-05/cargo-1.94.0-sparcv9-sun-solaris.tar.xz=d7bf13336a8f88c855a2aa3744212a114167458ab3c53540aabfb0bab9fb9e2c
+dist/2026-03-05/cargo-1.94.0-x86_64-apple-darwin.tar.gz=ac5cfac1afdb70fe2b0983a3fd2e54e2f5d007fc98d5cda59976a9e339c63893
+dist/2026-03-05/cargo-1.94.0-x86_64-apple-darwin.tar.xz=3beb7874010ebd757780284c0c9da47fc9f0b18091d7415d7b7231a8c19ec44f
+dist/2026-03-05/cargo-1.94.0-x86_64-pc-solaris.tar.gz=c58e932f3151a2ed10f464c856db70fa1df771732f75c27af47140db3d002171
+dist/2026-03-05/cargo-1.94.0-x86_64-pc-solaris.tar.xz=2a410e0091293ab4725e448b3405c4f19ead284be35ae2ab00f8a093568a50fd
+dist/2026-03-05/cargo-1.94.0-x86_64-pc-windows-gnu.tar.gz=6566679ffbe072e44ea4b24e60628681ade6fc2f71a747314a93475bc6838e1f
+dist/2026-03-05/cargo-1.94.0-x86_64-pc-windows-gnu.tar.xz=254ff0b8f3f4169d79ff622fb2b87cdd64d6f237ca05b7299b25a1196454f0e1
+dist/2026-03-05/cargo-1.94.0-x86_64-pc-windows-gnullvm.tar.gz=41f9653c99e76536516e9cd50ce051ff1b48c6015de0092c0b1d5b760072d344
+dist/2026-03-05/cargo-1.94.0-x86_64-pc-windows-gnullvm.tar.xz=1841e859b598fe01f9fd2f722ee39843d9f8c6f246f83c67ac4b478e59ed0cd9
+dist/2026-03-05/cargo-1.94.0-x86_64-pc-windows-msvc.tar.gz=bd6c2b719654a4e8320e6423cf01362972c893bc5f72f905d45847a537333fb9
+dist/2026-03-05/cargo-1.94.0-x86_64-pc-windows-msvc.tar.xz=6cf7113e1d5633721739a3bd6fee7148d6394bbab748fbede941210100374741
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-freebsd.tar.gz=a274b5aaf0346e39285c01a52593eab9b0d28e71b54c160f71b1ee53541f3d89
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-freebsd.tar.xz=90d8648f73f8ffb36c5b4f9d06e5bc8e7878aa5ab4365a2f8134ab321f82fea7
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-illumos.tar.gz=d407ff236962c1771266a7a601b8d631cb7fa45d21586758f9269c7d3852aeeb
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-illumos.tar.xz=0fcee9d18d66d341606cb9aa155f79ab2968bd7aae71644bfb8d5f053399911e
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-linux-gnu.tar.gz=6d77b3f9396cc23aa4f3ae2822b1349c4b2cf746dee4228212b5bed94200f421
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-linux-gnu.tar.xz=8e17624f3de39e079845bfb25ed15a042f4b50ceca78e37c56c4b9b15949b9f7
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-linux-musl.tar.gz=fd33ea96ddf146901da76da82a71e9583f3775fde4a8bb429d5c09c876567ea8
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-linux-musl.tar.xz=3a9736d69a3342944ad58fd3abd0caa6e7ae91033b781272fa60afb665d2178e
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-netbsd.tar.gz=000c92c920432d9337c2de9827051aaf5a98260505fa00a8b60bd7c8d9d112a4
+dist/2026-03-05/cargo-1.94.0-x86_64-unknown-netbsd.tar.xz=85d89504731581aee980b8589a1854eb1334d02de009ac4e75899eb06e4b6e1f
+dist/2026-03-05/clippy-1.94.0-aarch64-apple-darwin.tar.gz=71ac5cdf078bd04e16d70306cb84d7f0f09ba517537460214fcd69d661233283
+dist/2026-03-05/clippy-1.94.0-aarch64-apple-darwin.tar.xz=42a683cbac0b81b96ad3b887cdade36a57ef3a131c203583ca7e3ce0be98f415
+dist/2026-03-05/clippy-1.94.0-aarch64-pc-windows-gnullvm.tar.gz=fef339b5be0da6d993ab4f24c42f233ffa06528969c93eed16467b4967329fdd
+dist/2026-03-05/clippy-1.94.0-aarch64-pc-windows-gnullvm.tar.xz=5cd5d336ad7d1d92030263237940ca245e76d3e1230ee7a81168e5134275a1b9
+dist/2026-03-05/clippy-1.94.0-aarch64-pc-windows-msvc.tar.gz=6427225cea6463fb34062061255dec2c547517407204162a2d9fffd99703180c
+dist/2026-03-05/clippy-1.94.0-aarch64-pc-windows-msvc.tar.xz=44468016e27457640c7ab62b7ceaddb44308e8ec77ee4344c1bd36113448c8eb
+dist/2026-03-05/clippy-1.94.0-aarch64-unknown-linux-gnu.tar.gz=1eff48d6930a63ebfa1ca0e5b708a1caa1e29000a9626046f027c09b98b56405
+dist/2026-03-05/clippy-1.94.0-aarch64-unknown-linux-gnu.tar.xz=f7450c414e394450b53be602d37c374e2a2c5a2f51be2b54faf3d1e3272160b1
+dist/2026-03-05/clippy-1.94.0-aarch64-unknown-linux-musl.tar.gz=d01da8de6f991cb5bb7161bc3d657d414d16dccd06d128659d531af07061bd75
+dist/2026-03-05/clippy-1.94.0-aarch64-unknown-linux-musl.tar.xz=d32af736ededa3fe98217afd54007e5dd2ce12fae0eaf88c4ccbd7909db23ff1
+dist/2026-03-05/clippy-1.94.0-aarch64-unknown-linux-ohos.tar.gz=97ddde6ca5d989733cd126edddf2308ececd7efee8dcc6ac5a10a44ad35903b0
+dist/2026-03-05/clippy-1.94.0-aarch64-unknown-linux-ohos.tar.xz=8cf2f70db10da520c53ac7540e910a111b4920c258edc2b6faf595730cae2d71
+dist/2026-03-05/clippy-1.94.0-arm-unknown-linux-gnueabi.tar.gz=81aa40d89569dc67d5d25e1e0f1476ff4c56483de3dd6f91cfe66beec1ff00cd
+dist/2026-03-05/clippy-1.94.0-arm-unknown-linux-gnueabi.tar.xz=69bed7097064a500248e3b00b98dfe14e856690568f826dec710239d158f2fc6
+dist/2026-03-05/clippy-1.94.0-arm-unknown-linux-gnueabihf.tar.gz=bdc2fbffa5af98744ce95f7a232932bc4b4f1df3b8db35abe2d9d0c10443563f
+dist/2026-03-05/clippy-1.94.0-arm-unknown-linux-gnueabihf.tar.xz=8f3cd42d02ba88256c3d643dac07ad9357251adcdbc594fabf35a3b24a41daec
+dist/2026-03-05/clippy-1.94.0-armv7-unknown-linux-gnueabihf.tar.gz=50e2385b4693fbdb8b876e4df8e77aa113592aa35eabed3cf3ccc813bb481584
+dist/2026-03-05/clippy-1.94.0-armv7-unknown-linux-gnueabihf.tar.xz=d25607427b1723ee4238c62758aa728d316737e9dcb59844fb67808fffd423fd
+dist/2026-03-05/clippy-1.94.0-i686-pc-windows-gnu.tar.gz=a9f363c012fa8949d30759c34fd94d7cf556425ccd0ac8e6ca1988cb39f8274d
+dist/2026-03-05/clippy-1.94.0-i686-pc-windows-gnu.tar.xz=51c64d1d7833352b1704b724262f293927d9530753d47f494c42b414f912efff
+dist/2026-03-05/clippy-1.94.0-i686-pc-windows-msvc.tar.gz=ef1e9edae6a12c5d2044e5f9ef44a05f4aad527c5297824e22ef0caa27dda315
+dist/2026-03-05/clippy-1.94.0-i686-pc-windows-msvc.tar.xz=4d088d9f746a1e33c1c8768a0a8a4337d7a6d52602ed359f25c99706bd45aa54
+dist/2026-03-05/clippy-1.94.0-i686-unknown-linux-gnu.tar.gz=e4aa0cbea963720b386cbba0c751dfd03aa44d9903bba83da5ef60e4deca157d
+dist/2026-03-05/clippy-1.94.0-i686-unknown-linux-gnu.tar.xz=54a3219f0541c080bc8e600c3cfe63d60963eb361c79fd645dd1b171019c4dac
+dist/2026-03-05/clippy-1.94.0-loongarch64-unknown-linux-gnu.tar.gz=5e31441297c5de1d69dacf038b83674d2befe865971d01cd29c96bad24d95146
+dist/2026-03-05/clippy-1.94.0-loongarch64-unknown-linux-gnu.tar.xz=98de442bc183acef748ae1f177498045bf8cbcf03ece6e75c2befa98fae8841b
+dist/2026-03-05/clippy-1.94.0-loongarch64-unknown-linux-musl.tar.gz=9f0049d38b941dc00c9f82f4f3152f7a602efd21aa6da8cfff9d7306ea0d0f08
+dist/2026-03-05/clippy-1.94.0-loongarch64-unknown-linux-musl.tar.xz=a6a3f5f5c5308a7c1d78e48854497be956e8827eac3fc65e8d145b4dcbbefcbb
+dist/2026-03-05/clippy-1.94.0-powerpc-unknown-linux-gnu.tar.gz=57a15ddb6f92ad2964a4d8ee05e3f64c1cde9940a2307281056f1f81216b6303
+dist/2026-03-05/clippy-1.94.0-powerpc-unknown-linux-gnu.tar.xz=3a38eb50a04557801e50e2ab04e9e5db8f3f8f22dfea53d9a483efe1ea251129
+dist/2026-03-05/clippy-1.94.0-powerpc64-unknown-linux-gnu.tar.gz=f2c1494571e1b4f1a67362fa0f1854f4ea33037751eb7be0f48074a93e4ead8b
+dist/2026-03-05/clippy-1.94.0-powerpc64-unknown-linux-gnu.tar.xz=209d292768bf89c8fc65f434257f7be39a7155e2b4590d917f3d873ce7f35fd3
+dist/2026-03-05/clippy-1.94.0-powerpc64le-unknown-linux-gnu.tar.gz=d8e18b595548d0a3b8f141c09cce87fffacb2dc7453ae0545d709fa0bf392103
+dist/2026-03-05/clippy-1.94.0-powerpc64le-unknown-linux-gnu.tar.xz=11dc62c3b286dad9e22d9f0005dd75dcbb527da02b44f0729351dba5277f39c8
+dist/2026-03-05/clippy-1.94.0-powerpc64le-unknown-linux-musl.tar.gz=37fb3d38db89c408be66eb403aa3aa6d6b558434c6df42ec99c0b472f960896a
+dist/2026-03-05/clippy-1.94.0-powerpc64le-unknown-linux-musl.tar.xz=e7bdb6863dcc6c8eac7eab78974c5a103e57de50444949b6576d65f2d8717793
+dist/2026-03-05/clippy-1.94.0-riscv64gc-unknown-linux-gnu.tar.gz=917bb69a6d8fb52bc3212a31eebd6bd051c3b347aa6614d734bc4ecf9aba3bb8
+dist/2026-03-05/clippy-1.94.0-riscv64gc-unknown-linux-gnu.tar.xz=c6ca11e8d361fcce46c684239ea2debfc53b97def7db0c2ff7014894de22b220
+dist/2026-03-05/clippy-1.94.0-s390x-unknown-linux-gnu.tar.gz=9d5953c67f04e241377b68612fe19b72ed97566197c7971654c3a497daa0728b
+dist/2026-03-05/clippy-1.94.0-s390x-unknown-linux-gnu.tar.xz=8195f54d3ade3cbb7beb51df21cdc8ba30b6c72dbb9d9106eee10ea781a15062
+dist/2026-03-05/clippy-1.94.0-sparcv9-sun-solaris.tar.gz=70204e04553a13cd47ccd39458420d59b98a171448f6dc2c2575f800fb1f23d1
+dist/2026-03-05/clippy-1.94.0-sparcv9-sun-solaris.tar.xz=ff99164058591a2e0d19b9ac282f8b321438da10f2b0ae50c224ebd167af8c86
+dist/2026-03-05/clippy-1.94.0-x86_64-apple-darwin.tar.gz=786bc32b0d4ccfca221119c16d4add0397d1d46981b9e0255d5d537004462fdd
+dist/2026-03-05/clippy-1.94.0-x86_64-apple-darwin.tar.xz=1393cc688bc4d784a9d66619d2eec683a1ddb30b263f03ab615c0a2b18053126
+dist/2026-03-05/clippy-1.94.0-x86_64-pc-solaris.tar.gz=c30e69bb8b417e6fd316ca59da79bc32cb5c2c0f9f47335867e8e891dc5d5a55
+dist/2026-03-05/clippy-1.94.0-x86_64-pc-solaris.tar.xz=a8bf3af8ece0fa0790c9abfd105c39632a59b541b12940ebc0c5e336a90c60d9
+dist/2026-03-05/clippy-1.94.0-x86_64-pc-windows-gnu.tar.gz=531771f2c0e553dfa37fb8f0d9a8186183d9b88aab8aa9fdb6a0147e773191d6
+dist/2026-03-05/clippy-1.94.0-x86_64-pc-windows-gnu.tar.xz=6b8d715d2983fdcb5117fb0673b771d4067842cd535f4ff6ffe4897f32d4408f
+dist/2026-03-05/clippy-1.94.0-x86_64-pc-windows-gnullvm.tar.gz=e514ec87499ea6b4e88bddf21c99946fbac4f6766c4c9de811334fc89de82d91
+dist/2026-03-05/clippy-1.94.0-x86_64-pc-windows-gnullvm.tar.xz=fd73c4db5a2694c790b4e25c537a13120babfe7914b7ca18d2082a833c1d2371
+dist/2026-03-05/clippy-1.94.0-x86_64-pc-windows-msvc.tar.gz=a8aaaa149faef03e8d79f2a5611a8560c184a6999911fb6b8ddd5e8685cf5a9b
+dist/2026-03-05/clippy-1.94.0-x86_64-pc-windows-msvc.tar.xz=e4dcc5a796857589e364064493abb3afb469e0e36e90155e7b0a2c5ce4bb7503
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-freebsd.tar.gz=a5ff59cba9ee392643d8b13e8fee7b1858b97b7aaa16e3d110348ba887639270
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-freebsd.tar.xz=de9c6b5e9d1512b6c85df3e1cd98e69fce34521e23104f96b4ca110a9ff12720
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-illumos.tar.gz=1e172d144974ffa9fa5eb1002ab6ade471e68fcd21b33adc02a137a199e68a59
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-illumos.tar.xz=52bba39ed5c747914b288398a75f1248454389af7530f3d7192ce61eb42a0e09
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-linux-gnu.tar.gz=c32a2e5ea048c4ec3a0152d6b7a584e9807cc3f1d017d3de79a213ddba8d9211
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-linux-gnu.tar.xz=935529b0b9150084fa9cc1734c6598efe86b6e7d76f31ad3f8d4bb79ebf6031a
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-linux-musl.tar.gz=1cfdbc2eab8b1f26ee94ad83d7c0c43b7d9df7313a53878361e653ff8f60277d
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-linux-musl.tar.xz=64576507462a7c5cd21b678e70d1daa73401959c1a5de9622b32ca3a8376a675
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-netbsd.tar.gz=03ced88d7507e4d30fd839515c46aef3d1a83963c4a15dff741cc4fba5d770a2
+dist/2026-03-05/clippy-1.94.0-x86_64-unknown-netbsd.tar.xz=038f13937be82ff2347efb0b87ff617017268249873706f55ba1f9af280aa2c8
+dist/2026-03-05/rust-1.94.0-aarch64-pc-windows-gnullvm.msi=a3acfe3836789fe088101256e3cbdc9caff141be0d9b7a73637df7e5caa49ef5
+dist/2026-03-05/rust-1.94.0-aarch64-pc-windows-msvc.msi=e6d004bf63a5c7ef03f3871f16805f8166cb2f6f812d6327ee878baaf6936680
+dist/2026-03-05/rust-1.94.0-i686-pc-windows-gnu.msi=56b661730a6d8dc1c3bfe5c1191dadcc799d3f6d07f995b3610381c9a9082688
+dist/2026-03-05/rust-1.94.0-i686-pc-windows-msvc.msi=d75cc47621767dd39ca6c9caf0df3dcb4055376fba804d4edd8e28fad29e8e22
+dist/2026-03-05/rust-1.94.0-x86_64-pc-windows-gnu.msi=3227b03bb6ecd12bda954e8dab5303302f19f8b3f55cf569518ff5ec89a602fd
+dist/2026-03-05/rust-1.94.0-x86_64-pc-windows-gnullvm.msi=3f0bb5e93847e0aee20926c229c90c15ab6aea0d13aef5e4018defd82df3587b
+dist/2026-03-05/rust-1.94.0-x86_64-pc-windows-msvc.msi=09ce8b5bb81f477211d5192eea240ce3982fc945e09eda9697ae787d59bfaaba
+dist/2026-03-05/rust-1.94.0-aarch64-apple-darwin.pkg=cd63d0ad27448184e8d2f3a50244cfa776e11154a5fcd76d9be2473bed4c6a56
+dist/2026-03-05/rust-1.94.0-x86_64-apple-darwin.pkg=662348e4570fee31767d0e1874eab48caf0ad6d88baa75b2c7ca104a4af6309c
+dist/2026-03-05/rustc-1.94.0-src.tar.gz=b83f921cd3f321ff614f9c06a8b870d89299fc02888b48a5549683a36823474c
+dist/2026-03-05/rustc-1.94.0-src.tar.xz=0b53ae34f5c0c3612cfe1de139f9167a018cd5737bc2205664fd69ba9b25f600
--- a/src/tools/cargo
+++ b/src/tools/cargo
--- a/src/tools/clippy/clippy_lints/src/dbg_macro.rs
+++ b/src/tools/clippy/clippy_lints/src/dbg_macro.rs
@@ -5,7 +5,7 @@ use clippy_utils::macros::{MacroCall, macro_backtrace};
 use clippy_utils::source::snippet_with_applicability;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
-use rustc_hir::{Arm, Closure, ClosureKind, CoroutineKind, Expr, ExprKind, LetStmt, LocalSource, Node, Stmt, StmtKind};
+use rustc_hir::{Closure, ClosureKind, CoroutineKind, Expr, ExprKind, LetStmt, LocalSource, Node, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
 use rustc_session::impl_lint_pass;
 use rustc_span::{Span, SyntaxContext};
@@ -92,27 +92,33 @@ impl LateLintPass<'_> for DbgMacro {
                                (macro_call.span, String::from("()"))
                            }
                        },
-                        ExprKind::Match(first, arms, _) => {
-                            let vals = collect_vals(first, arms);
-                            let suggestion = match *vals.as_slice() {
-                                // dbg!(1) => 1
-                                [val] => {
-                                    snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability)
-                                        .to_string()
+                        // dbg!(1)
+                        ExprKind::Match(val, ..) => (
+                            macro_call.span,
+                            snippet_with_applicability(cx, val.span.source_callsite(), "..", &mut applicability)
+                                .to_string(),
+                        ),
+                        // dbg!(2, 3)
+                        ExprKind::Tup(
+                            [
+                                Expr {
+                                    kind: ExprKind::Match(first, ..),
+                                    ..
                                },
-                                // dbg!(2, 3) => (2, 3)
-                                [first, .., last] => {
-                                    let snippet = snippet_with_applicability(
-                                        cx,
-                                        first.span.source_callsite().to(last.span.source_callsite()),
-                                        "..",
-                                        &mut applicability,
-                                    );
-                                    format!("({snippet})")
+                                ..,
+                                Expr {
+                                    kind: ExprKind::Match(last, ..),
+                                    ..
                                },
-                                _ => unreachable!(),
-                            };
-                            (macro_call.span, suggestion)
+                            ],
+                        ) => {
+                            let snippet = snippet_with_applicability(
+                                cx,
+                                first.span.source_callsite().to(last.span.source_callsite()),
+                                "..",
+                                &mut applicability,
+                            );
+                            (macro_call.span, format!("({snippet})"))
                        },
                        _ => unreachable!(),
                    };
@@ -165,39 +171,3 @@ fn is_async_move_desugar<'tcx>(expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx
 fn first_dbg_macro_in_expansion(cx: &LateContext<'_>, span: Span) -> Option<MacroCall> {
    macro_backtrace(span).find(|mc| cx.tcx.is_diagnostic_item(sym::dbg_macro, mc.def_id))
 }
-
-/// Extracts all value expressions from the `match`-tree generated by `dbg!`.
-///
-/// E.g. from
-/// ```rust, ignore
-/// match 1 {
-///     tmp_1 => match 2 {
-///         tmp_2 => {
-///             /* printing */
-///             (tmp_1, tmp_2)
-///         }
-///     }
-/// }
-/// ```
-/// this extracts `1` and `2`.
-fn collect_vals<'hir>(first: &'hir Expr<'hir>, mut arms: &'hir [Arm<'hir>]) -> Vec<&'hir Expr<'hir>> {
-    let mut vals = vec![first];
-    loop {
-        let [arm] = arms else {
-            unreachable!("dbg! macro expansion only has single-arm matches")
-        };
-
-        match is_async_move_desugar(arm.body)
-            .unwrap_or(arm.body)
-            .peel_drop_temps()
-            .kind
-        {
-            ExprKind::Block(..) => return vals,
-            ExprKind::Match(val, a, _) => {
-                vals.push(val);
-                arms = a;
-            },
-            _ => unreachable!("dbg! macro expansion only results in block or match expressions"),
-        }
-    }
-}
--- a/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
@@ -12,7 +12,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::{Arm, Expr, HirId, HirIdMap, HirIdMapEntry, HirIdSet, Pat, PatExpr, PatExprKind, PatKind, RangeEnd};
 use rustc_lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
 use rustc_lint::{LateContext, LintContext};
-use rustc_middle::ty;
+use rustc_middle::ty::{self, TypeckResults};
 use rustc_span::{ByteSymbol, ErrorGuaranteed, Span, Symbol};

 use super::MATCH_SAME_ARMS;
@@ -61,7 +61,10 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {

        let check_eq_with_pat = |expr_a: &Expr<'_>, expr_b: &Expr<'_>| {
            let mut local_map: HirIdMap<HirId> = HirIdMap::default();
-            let eq_fallback = |a: &Expr<'_>, b: &Expr<'_>| {
+            let eq_fallback = |a_typeck_results: &TypeckResults<'tcx>,
+                               a: &Expr<'_>,
+                               b_typeck_results: &TypeckResults<'tcx>,
+                               b: &Expr<'_>| {
                if let Some(a_id) = a.res_local_id()
                    && let Some(b_id) = b.res_local_id()
                    && let entry = match local_map.entry(a_id) {
@@ -71,7 +74,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>]) {
                    }
                    // the names technically don't have to match; this makes the lint more conservative
                    && cx.tcx.hir_name(a_id) == cx.tcx.hir_name(b_id)
-                    && cx.typeck_results().expr_ty(a) == cx.typeck_results().expr_ty(b)
+                    && a_typeck_results.expr_ty(a) == b_typeck_results.expr_ty(b)
                    && pat_contains_local(lhs.pat, a_id)
                    && pat_contains_local(rhs.pat, b_id)
                {
--- a/src/tools/clippy/clippy_lints/src/methods/filter_map.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/filter_map.rs
@@ -9,6 +9,7 @@ use rustc_hir as hir;
 use rustc_hir::def::Res;
 use rustc_hir::{Closure, Expr, ExprKind, PatKind, PathSegment, QPath, UnOp};
 use rustc_lint::LateContext;
+use rustc_middle::ty::TypeckResults;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::Span;
 use rustc_span::symbol::{Ident, Symbol};
@@ -136,7 +137,9 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
                    // .map(|y| y[.acceptable_method()].unwrap())
                    && let simple_equal = (receiver.res_local_id() == Some(filter_param_id)
                        && map_arg_peeled.res_local_id() == Some(map_param_id))
-                    && let eq_fallback = (|a: &Expr<'_>, b: &Expr<'_>| {
+                    && let eq_fallback =
+                    (|a_typeck_results: &TypeckResults<'tcx>, a: &Expr<'_>,
+                     b_typeck_results: &TypeckResults<'tcx>, b: &Expr<'_>| {
                        // in `filter(|x| ..)`, replace `*x` with `x`
                        let a_path = if !is_filter_param_ref
                            && let ExprKind::Unary(UnOp::Deref, expr_path) = a.kind
@@ -144,7 +147,7 @@ impl<'tcx> OffendingFilterExpr<'tcx> {
                        // let the filter closure arg and the map closure arg be equal
                        a_path.res_local_id() == Some(filter_param_id)
                            && b.res_local_id() == Some(map_param_id)
-                            && cx.typeck_results().expr_ty_adjusted(a) == cx.typeck_results().expr_ty_adjusted(b)
+                            && a_typeck_results.expr_ty_adjusted(a) == b_typeck_results.expr_ty_adjusted(b)
                    })
                    && (simple_equal
                        || SpanlessEq::new(cx).expr_fallback(eq_fallback).eq_expr(receiver, map_arg_peeled))
--- a/src/tools/clippy/clippy_lints/src/methods/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs
@@ -4761,6 +4761,8 @@ pub struct Methods {
    allowed_dotfiles: FxHashSet<&'static str>,
    format_args: FormatArgsStorage,
    allow_unwrap_types: Vec<String>,
+    unwrap_allowed_ids: FxHashSet<rustc_hir::def_id::DefId>,
+    unwrap_allowed_aliases: Vec<rustc_hir::def_id::DefId>,
 }

 impl Methods {
@@ -4778,6 +4780,8 @@ impl Methods {
            allowed_dotfiles,
            format_args,
            allow_unwrap_types: conf.allow_unwrap_types.clone(),
+            unwrap_allowed_ids: FxHashSet::default(),
+            unwrap_allowed_aliases: Vec::new(),
        }
    }
 }
@@ -4953,6 +4957,19 @@ pub fn method_call<'tcx>(recv: &'tcx Expr<'tcx>) -> Option<(Symbol, &'tcx Expr<'
 }

 impl<'tcx> LateLintPass<'tcx> for Methods {
+    fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+        for s in &self.allow_unwrap_types {
+            let def_ids = clippy_utils::paths::lookup_path_str(cx.tcx, clippy_utils::paths::PathNS::Type, s);
+            for def_id in def_ids {
+                if cx.tcx.def_kind(def_id) == rustc_hir::def::DefKind::TyAlias {
+                    self.unwrap_allowed_aliases.push(def_id);
+                } else {
+                    self.unwrap_allowed_ids.insert(def_id);
+                }
+            }
+        }
+    }
+
    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
        if expr.span.from_expansion() {
            return;
@@ -4976,7 +4993,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                    self.allow_expect_in_tests,
                    self.allow_unwrap_in_consts,
                    self.allow_expect_in_consts,
-                    &self.allow_unwrap_types,
+                    &self.unwrap_allowed_ids,
+                    &self.unwrap_allowed_aliases,
                );
            },
            ExprKind::MethodCall(..) => {
@@ -5730,7 +5748,8 @@ impl Methods {
                        false,
                        self.allow_expect_in_consts,
                        self.allow_expect_in_tests,
-                        &self.allow_unwrap_types,
+                        &self.unwrap_allowed_ids,
+                        &self.unwrap_allowed_aliases,
                        unwrap_expect_used::Variant::Expect,
                    );
                    expect_fun_call::check(cx, &self.format_args, expr, method_span, recv, arg);
@@ -5743,7 +5762,8 @@ impl Methods {
                        true,
                        self.allow_expect_in_consts,
                        self.allow_expect_in_tests,
-                        &self.allow_unwrap_types,
+                        &self.unwrap_allowed_ids,
+                        &self.unwrap_allowed_aliases,
                        unwrap_expect_used::Variant::Expect,
                    );
                },
@@ -5764,7 +5784,8 @@ impl Methods {
                        false,
                        self.allow_unwrap_in_consts,
                        self.allow_unwrap_in_tests,
-                        &self.allow_unwrap_types,
+                        &self.unwrap_allowed_ids,
+                        &self.unwrap_allowed_aliases,
                        unwrap_expect_used::Variant::Unwrap,
                    );
                },
@@ -5776,7 +5797,8 @@ impl Methods {
                        true,
                        self.allow_unwrap_in_consts,
                        self.allow_unwrap_in_tests,
-                        &self.allow_unwrap_types,
+                        &self.unwrap_allowed_ids,
+                        &self.unwrap_allowed_aliases,
                        unwrap_expect_used::Variant::Unwrap,
                    );
                },
--- a/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs
@@ -44,7 +44,8 @@ pub(super) fn check(
    is_err: bool,
    allow_unwrap_in_consts: bool,
    allow_unwrap_in_tests: bool,
-    allow_unwrap_types: &[String],
+    unwrap_allowed_ids: &rustc_data_structures::fx::FxHashSet<rustc_hir::def_id::DefId>,
+    unwrap_allowed_aliases: &[rustc_hir::def_id::DefId],
    variant: Variant,
 ) {
    let ty = cx.typeck_results().expr_ty(recv).peel_refs();
@@ -66,51 +67,39 @@ pub(super) fn check(

    let method_suffix = if is_err { "_err" } else { "" };

-    let ty_name = ty.to_string();
-    if allow_unwrap_types
-        .iter()
-        .any(|allowed_type| ty_name.starts_with(allowed_type) || ty_name == *allowed_type)
+    if let ty::Adt(adt, _) = ty.kind()
+        && unwrap_allowed_ids.contains(&adt.did())
    {
        return;
    }

-    for s in allow_unwrap_types {
-        let def_ids = clippy_utils::paths::lookup_path_str(cx.tcx, clippy_utils::paths::PathNS::Type, s);
-        for def_id in def_ids {
-            if let ty::Adt(adt, _) = ty.kind()
-                && adt.did() == def_id
-            {
-                return;
-            }
-            if cx.tcx.def_kind(def_id) == DefKind::TyAlias {
-                let alias_ty = cx.tcx.type_of(def_id).instantiate_identity();
-                if let (ty::Adt(adt, substs), ty::Adt(alias_adt, alias_substs)) = (ty.kind(), alias_ty.kind())
-                    && adt.did() == alias_adt.did()
-                {
-                    let mut all_match = true;
-                    for (arg, alias_arg) in substs.iter().zip(alias_substs.iter()) {
-                        if let (Some(arg_ty), Some(alias_arg_ty)) = (arg.as_type(), alias_arg.as_type()) {
-                            if matches!(alias_arg_ty.kind(), ty::Param(_)) {
-                                continue;
-                            }
-                            if let (ty::Adt(arg_adt, _), ty::Adt(alias_arg_adt, _)) =
-                                (arg_ty.peel_refs().kind(), alias_arg_ty.peel_refs().kind())
-                            {
-                                if arg_adt.did() != alias_arg_adt.did() {
-                                    all_match = false;
-                                    break;
-                                }
-                            } else if arg_ty != alias_arg_ty {
-                                all_match = false;
-                                break;
-                            }
-                        }
+    for &def_id in unwrap_allowed_aliases {
+        let alias_ty = cx.tcx.type_of(def_id).instantiate_identity();
+        if let (ty::Adt(adt, substs), ty::Adt(alias_adt, alias_substs)) = (ty.kind(), alias_ty.kind())
+            && adt.did() == alias_adt.did()
+        {
+            let mut all_match = true;
+            for (arg, alias_arg) in substs.iter().zip(alias_substs.iter()) {
+                if let (Some(arg_ty), Some(alias_arg_ty)) = (arg.as_type(), alias_arg.as_type()) {
+                    if matches!(alias_arg_ty.kind(), ty::Param(_)) {
+                        continue;
                    }
-                    if all_match {
-                        return;
+                    if let (ty::Adt(arg_adt, _), ty::Adt(alias_arg_adt, _)) =
+                        (arg_ty.peel_refs().kind(), alias_arg_ty.peel_refs().kind())
+                    {
+                        if arg_adt.did() != alias_arg_adt.did() {
+                            all_match = false;
+                            break;
+                        }
+                    } else if arg_ty != alias_arg_ty {
+                        all_match = false;
+                        break;
                    }
                }
            }
+            if all_match {
+                return;
+            }
        }
    }

@@ -149,7 +138,8 @@ pub(super) fn check_call(
    allow_unwrap_in_tests: bool,
    allow_expect_in_consts: bool,
    allow_expect_in_tests: bool,
-    allow_unwrap_types: &[String],
+    unwrap_allowed_ids: &rustc_data_structures::fx::FxHashSet<rustc_hir::def_id::DefId>,
+    unwrap_allowed_aliases: &[rustc_hir::def_id::DefId],
 ) {
    let Some(recv) = args.first() else {
        return;
@@ -167,7 +157,8 @@ pub(super) fn check_call(
                false,
                allow_unwrap_in_consts,
                allow_unwrap_in_tests,
-                allow_unwrap_types,
+                unwrap_allowed_ids,
+                unwrap_allowed_aliases,
                Variant::Unwrap,
            );
        },
@@ -179,7 +170,8 @@ pub(super) fn check_call(
                false,
                allow_expect_in_consts,
                allow_expect_in_tests,
-                allow_unwrap_types,
+                unwrap_allowed_ids,
+                unwrap_allowed_aliases,
                Variant::Expect,
            );
        },
@@ -191,7 +183,8 @@ pub(super) fn check_call(
                true,
                allow_unwrap_in_consts,
                allow_unwrap_in_tests,
-                allow_unwrap_types,
+                unwrap_allowed_ids,
+                unwrap_allowed_aliases,
                Variant::Unwrap,
            );
        },
@@ -203,7 +196,8 @@ pub(super) fn check_call(
                true,
                allow_expect_in_consts,
                allow_expect_in_tests,
-                allow_unwrap_types,
+                unwrap_allowed_ids,
+                unwrap_allowed_aliases,
                Variant::Expect,
            );
        },
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -26,7 +26,8 @@ use std::slice;

 /// Callback that is called when two expressions are not equal in the sense of `SpanlessEq`, but
 /// other conditions would make them equal.
-type SpanlessEqCallback<'a> = dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a;
+type SpanlessEqCallback<'a, 'tcx> =
+    dyn FnMut(&TypeckResults<'tcx>, &Expr<'_>, &TypeckResults<'tcx>, &Expr<'_>) -> bool + 'a;

 /// Determines how paths are hashed and compared for equality.
 #[derive(Copy, Clone, Debug, Default)]
@@ -59,7 +60,7 @@ pub struct SpanlessEq<'a, 'tcx> {
    cx: &'a LateContext<'tcx>,
    maybe_typeck_results: Option<(&'tcx TypeckResults<'tcx>, &'tcx TypeckResults<'tcx>)>,
    allow_side_effects: bool,
-    expr_fallback: Option<Box<SpanlessEqCallback<'a>>>,
+    expr_fallback: Option<Box<SpanlessEqCallback<'a, 'tcx>>>,
    path_check: PathCheck,
 }

@@ -94,7 +95,10 @@ impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
    }

    #[must_use]
-    pub fn expr_fallback(self, expr_fallback: impl FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
+    pub fn expr_fallback(
+        self,
+        expr_fallback: impl FnMut(&TypeckResults<'tcx>, &Expr<'_>, &TypeckResults<'tcx>, &Expr<'_>) -> bool + 'a,
+    ) -> Self {
        Self {
            expr_fallback: Some(Box::new(expr_fallback)),
            ..self
@@ -505,7 +509,7 @@ impl HirEqInterExpr<'_, '_, '_> {
            (ExprKind::Block(l, _), ExprKind::Block(r, _)) => self.eq_block(l, r),
            (ExprKind::Binary(l_op, ll, lr), ExprKind::Binary(r_op, rl, rr)) => {
                l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-                    || swap_binop(self.inner.cx, l_op.node, ll, lr).is_some_and(|(l_op, ll, lr)| {
+                    || self.swap_binop(l_op.node, ll, lr).is_some_and(|(l_op, ll, lr)| {
                        l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
                    })
            },
@@ -639,7 +643,15 @@ impl HirEqInterExpr<'_, '_, '_> {
            ) => false,
        };
        (is_eq && (!self.should_ignore(left) || !self.should_ignore(right)))
-            || self.inner.expr_fallback.as_mut().is_some_and(|f| f(left, right))
+            || self
+                .inner
+                .maybe_typeck_results
+                .is_some_and(|(left_typeck_results, right_typeck_results)| {
+                    self.inner
+                        .expr_fallback
+                        .as_mut()
+                        .is_some_and(|f| f(left_typeck_results, left, right_typeck_results, right))
+                })
    }

    fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
@@ -921,6 +933,40 @@ impl HirEqInterExpr<'_, '_, '_> {
        self.right_ctxt = right;
        true
    }
+
+    fn swap_binop<'a>(
+        &self,
+        binop: BinOpKind,
+        lhs: &'a Expr<'a>,
+        rhs: &'a Expr<'a>,
+    ) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
+        match binop {
+            // `==` and `!=`, are commutative
+            BinOpKind::Eq | BinOpKind::Ne => Some((binop, rhs, lhs)),
+            // Comparisons can be reversed
+            BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
+            BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
+            BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
+            BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
+            // Non-commutative operators
+            BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Rem | BinOpKind::Sub | BinOpKind::Div => None,
+            // We know that those operators are commutative for primitive types,
+            // and we don't assume anything for other types
+            BinOpKind::Mul
+            | BinOpKind::Add
+            | BinOpKind::And
+            | BinOpKind::Or
+            | BinOpKind::BitAnd
+            | BinOpKind::BitXor
+            | BinOpKind::BitOr => self.inner.maybe_typeck_results.and_then(|(typeck_lhs, _)| {
+                typeck_lhs
+                    .expr_ty_adjusted(lhs)
+                    .peel_refs()
+                    .is_primitive()
+                    .then_some((binop, rhs, lhs))
+            }),
+        }
+    }
 }

 /// Some simple reductions like `{ return }` => `return`
@@ -966,39 +1012,6 @@ fn reduce_exprkind<'hir>(cx: &LateContext<'_>, kind: &'hir ExprKind<'hir>) -> &'
    }
 }

-fn swap_binop<'a>(
-    cx: &LateContext<'_>,
-    binop: BinOpKind,
-    lhs: &'a Expr<'a>,
-    rhs: &'a Expr<'a>,
-) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
-    match binop {
-        // `==` and `!=`, are commutative
-        BinOpKind::Eq | BinOpKind::Ne => Some((binop, rhs, lhs)),
-        // Comparisons can be reversed
-        BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
-        BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
-        BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
-        BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
-        // Non-commutative operators
-        BinOpKind::Shl | BinOpKind::Shr | BinOpKind::Rem | BinOpKind::Sub | BinOpKind::Div => None,
-        // We know that those operators are commutative for primitive types,
-        // and we don't assume anything for other types
-        BinOpKind::Mul
-        | BinOpKind::Add
-        | BinOpKind::And
-        | BinOpKind::Or
-        | BinOpKind::BitAnd
-        | BinOpKind::BitXor
-        | BinOpKind::BitOr => cx
-            .typeck_results()
-            .expr_ty_adjusted(lhs)
-            .peel_refs()
-            .is_primitive()
-            .then_some((binop, rhs, lhs)),
-    }
-}
-
 /// Checks if the two `Option`s are both `None` or some equal values as per
 /// `eq_fn`.
 pub fn both<X>(l: Option<&X>, r: Option<&X>, mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -3,7 +3,7 @@
 #![feature(macro_metavar_expr)]
 #![feature(never_type)]
 #![feature(rustc_private)]
-#![cfg_attr(bootstrap, feature(assert_matches))]
+#![feature(assert_matches)]
 #![feature(unwrap_infallible)]
 #![recursion_limit = "512"]
 #![allow(clippy::missing_errors_doc, clippy::missing_panics_doc, clippy::must_use_candidate)]
--- a/src/tools/clippy/tests/ui/if_same_then_else.rs
+++ b/src/tools/clippy/tests/ui/if_same_then_else.rs
@@ -305,3 +305,20 @@ fn issue16416_prim(x: bool, a: u32, b: u32) {
    //~v if_same_then_else
    _ = if x { a >= b } else { b <= a };
 }
+
+mod issue16505 {
+    macro_rules! foo {
+        (< $hi:literal : $lo:literal > | $N:tt bits) => {{
+            const NEW_N_: usize = $hi - $lo + 1;
+            NEW_N_
+        }};
+    }
+
+    fn bar(x: bool) {
+        _ = if x {
+            foo!(<2:0> | 3 bits) == foo!(<3:1> | 3 bits)
+        } else {
+            foo!(<3:1> | 3 bits) == foo!(<2:0> | 3 bits)
+        };
+    }
+}
--- a/src/tools/clippy/tests/ui/match_same_arms.fixed
+++ b/src/tools/clippy/tests/ui/match_same_arms.fixed
@@ -140,3 +140,19 @@ fn main() {
        _ => false,
    };
 }
+
+fn issue16678() {
+    // ICE in Rust 1.94.0
+    match true {
+        true => {
+            fn wrapper(_arg: ()) {
+                _arg;
+            }
+        },
+        false => {
+            fn wrapper(_arg: ()) {
+                _arg;
+            }
+        },
+    }
+}
--- a/src/tools/clippy/tests/ui/match_same_arms.rs
+++ b/src/tools/clippy/tests/ui/match_same_arms.rs
@@ -149,3 +149,19 @@ fn main() {
        _ => false,
    };
 }
+
+fn issue16678() {
+    // ICE in Rust 1.94.0
+    match true {
+        true => {
+            fn wrapper(_arg: ()) {
+                _arg;
+            }
+        },
+        false => {
+            fn wrapper(_arg: ()) {
+                _arg;
+            }
+        },
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
bors	59807616e1	Auto merge of #155283 - jieyouxu:revert-gnullvm-link-shared-stable, r=Mark-Simulacrum [stable] Revert "Build shared LLVM lib for windows-gnullvm" This reverts commit `1d1280a`. Looks like this causes problems (rust-lang/rust#155268) with certain LLVM bin tools not finding `libLLVM` on `*-windows-gnullvm`. This PR is a _minimal_ revert to return us to known state to alleviate time pressure to investigate.	2026-04-14 19:55:32 +00:00
Jieyou Xu	9b3eeb3f0f	Revert "Build shared LLVM lib for windows-gnullvm" This reverts commit `1d1280aae1`. Looks like this causes problems with certain LLVM bin tools not finding `libLLVM` on `*-windows-gnullvm`. This commit is a _minimal_ revert to return us to known state to alleviate time pressure to investigate.	2026-04-14 19:48:39 +08:00
bors	6efb623524	Auto merge of #155210 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum [stable] Rust 1.95.0 release https://forge.rust-lang.org/release/process.html#stable-pr This also backports: * Patch musl's CVE-2026-6042 and CVE-2026-40200 rust-lang/rust#155171 and cherry picks latest release notes. r? me	2026-04-13 00:01:55 +00:00
Mark Rousskov	d8994639a6	Switch channel to stable	2026-04-12 15:51:55 -04:00
Josh Stone	41fadcd0ba	Patch musl's CVE-2026-6042 and CVE-2026-40200 - [CVE-2026-6042] is a denial of service in `iconv`. - [CVE-2026-40200] is an out-of-bounds write in `qsort`. Neither is relevant to Rust itself, but they could be used in mixed- language projects that link with our `self-contained/libc.a`. [CVE-2026-6042]: https://www.openwall.com/lists/oss-security/2026/04/09/19 [CVE-2026-40200]: https://www.openwall.com/lists/musl/2026/04/10/3	2026-04-12 15:51:49 -04:00
Mark Rousskov	0c3f2ab0d4	Cherry-pick latest release notes	2026-04-12 15:50:14 -04:00
bors	2c8c85df04	Auto merge of #154999 - cuviper:beta-next, r=cuviper [beta] reverts and backports This reverts two `dbg!` changes to avoid regressions[^1][^2] in the upcoming 1.95 release: - std: avoid tearing `dbg!` prints rust-lang/rust#149869 - don't drop arguments' temporaries in `dbg!` rust-lang/rust#154074 - ... which was previously backported in rust-lang/rust#154725 This also reverts a stabilization over a late issue[^3] of semantics: - Stabilize `assert_matches` rust-lang/rust#137487 And a few other backport/reverts from `main`: - Revert performing basic const checks in typeck on stable rust-lang/rust#154930 / rust-lang/rust#155033 - Revert "`-Znext-solver` Remove the forced ambiguity hack from search graph" rust-lang/rust#154712 - Clarify that core::range ranges do not have special syntax rust-lang/rust#155002 Clippy is backporting 2 ICE fixes and 1 perf regression (via rust-lang/rust#155051): - https://github.com/rust-lang/rust-clippy/pull/16685 already backported in https://github.com/rust-lang/rust/pull/154211 to stable. This makes sure that it doesn't regress again in beta/next stable - https://github.com/rust-lang/rust-clippy/pull/16659 The ICE that is being fixed here was introduced in the 1.95 release cycle - https://github.com/rust-lang/rust-clippy/pull/16652 Perf regression introduced in the 1.95 release cycle. [^1]: rust-lang/rust#153850 [^2]: rust-lang/rust#154988 [^3]: rust-lang/rust#154406	2026-04-09 20:25:44 +00:00
Alejandra González	b6da6b8278	Optimize `allow_unwrap_types` evaluation to eliminate performance regression (#16652 ) Fixes https://github.com/rust-lang/rust-clippy/pull/16605 This PR addresses the 6.2% compilation performance regression introduced by the original `allow_unwrap_types` implementation (which natively allocated AST strings on every `unwrap` call via `bumpalo`). The implementation has been refactored to pre-resolve types securely without a performance penalty: Pre-Resolution Cache via `LateLintPass`: Instead of executing `ty.to_string()` and `lookup_path_str` inside the immediate `unwrap_expect_used` hot check for every method call encountered, `allow-unwrap-types` configuration strings are now parsed exactly once per crate compilation during the `LateLintPass::check_crate` hook in `clippy_lints/src/methods/mod.rs`. `DefId` Native Storage: The parsed `DefId` representations are stored in-memory using highly efficient caching maps directly on the main `Methods` struct: - `unwrap_allowed_ids: FxHashSet<DefId>`: Allows instant O(1) lookups for standard types. - `unwrap_allowed_aliases: Vec<DefId>`: Tracks type aliases requiring signature substitution checking later. Execution Relief: Inside `unwrap_expect_used::check()`, string manipulation is completely removed and `ty::Adt` checking uses lightning-fast `.contains(&adt.did())` operations to categorically avoid regression allocation loops. This implementation strongly parallels the pre-resolution type-routing logic in `clippy_config::types::create_disallowed_map` without altering the core `clippy.toml` config requirements. <!-- TRIAGEBOT_START --> <!-- TRIAGEBOT_SUMMARY_START --> ### Summary Notes - [Beta-nomination](https://github.com/rust-lang/rust-clippy/pull/16652#issuecomment-3976671413) by [samueltardieu](https://github.com/samueltardieu) Managed by `@rustbot`—see [help](https://forge.rust-lang.org/triagebot/note.html) for details <!-- TRIAGEBOT_SUMMARY_END --> <!-- TRIAGEBOT_END --> changelog: none	2026-04-09 10:17:13 -07:00
Jason Newcomb	c79919aded	Fix ICE in `swap_binop()` (#16659 ) Make `swap_binop()` a method of `HirEqInterExpr`, and use the proper typeck to check the type of an expression. changelog: none (fix of a regression, should be backported) Fixes rust-lang/rust-clippy#16505 <!-- TRIAGEBOT_START --> <!-- TRIAGEBOT_SUMMARY_START --> ### Summary Notes - [Beta-nomination](https://github.com/rust-lang/rust-clippy/pull/16659#issuecomment-3993931812) by [samueltardieu](https://github.com/samueltardieu) Managed by `@rustbot`—see [help](https://forge.rust-lang.org/triagebot/note.html) for details <!-- TRIAGEBOT_SUMMARY_END --> <!-- TRIAGEBOT_END -->	2026-04-09 10:17:13 -07:00
Jason Newcomb	0c9d5f0d25	Fix ICE in `match_same_arms` (#16685 ) The wrong `TypeckResults` was used in the fallback equality function passed by the `match_same_arms` and `filter_map` lints. Previously, those fallback functions had no way of using the proper `TypeckResults`. Those (one per expression being compared) are now passed to the registered fallback function. changelog: [`match_same_arms`]: fix internal compiler error Fixes rust-lang/rust-clippy#16678 Fixes rust-lang/rust-clippy#16686 <!-- TRIAGEBOT_START --> <!-- TRIAGEBOT_SUMMARY_START --> ### Summary Notes - [Beta nomination](https://github.com/rust-lang/rust-clippy/pull/16685#issuecomment-4017155418) by [samueltardieu](https://github.com/samueltardieu) Managed by `@rustbot`—see [help](https://forge.rust-lang.org/triagebot/note.html) for details <!-- TRIAGEBOT_SUMMARY_END --> <!-- TRIAGEBOT_END -->	2026-04-09 10:17:13 -07:00
Jake Goulding	6ae56934ab	Clarify that `core::range::{Range,RangeFrom,RangeToInclusive}` do not have special syntax I'm ignoring the fact that there's a feature to change the behavior of the syntax. I just want to help prevent confusing the people reading the docs. (cherry picked from commit `eef4363403`)	2026-04-09 08:40:07 -07:00
Jake Goulding	2b3d5e6a41	Clarify that `core::range::RangeInclusive` does not have special syntax I'm ignoring the fact that there's a feature to change the behavior of the syntax. I just want to help prevent confusing the people reading the docs. (cherry picked from commit `092f0ca1bd`)	2026-04-09 08:36:50 -07:00
Rémy Rakic	524789f8ab	Revert "Rollup merge of #149904 - ShoyuVanilla:ns-remove-sg-hack, r=lcnr" This reverts commit `c108ad5617`, reversing changes made to `485f76b835`. (cherry picked from commit `22faa52629`)	2026-04-09 08:36:12 -07:00
Oli Scherer	2c2e33ac59	Revert performing basic const checks in typeck on stable	2026-04-09 08:34:04 -07:00
Josh Stone	d0b5e61fe7	Revert "Stabilize assert_matches" This reverts commit `2f3b952349`.	2026-04-08 14:10:50 -07:00
Josh Stone	aad47fb47d	Revert "Rollup merge of #149869 - joboet:torn-dbg, r=Mark-Simulacrum" This reverts commit `cc666ba8f4`, reversing changes made to `2da5959600`.	2026-04-08 10:41:06 -07:00
Josh Stone	cb5a91376e	Revert "don't drop arguments' temporaries in `dbg!`" This reverts commit `4f50466be4`.	2026-04-08 09:45:57 -07:00
Josh Stone	bca08d8c93	Revert "update diagnostic for variables moved by `dbg!`" This reverts commit `1374038f80`.	2026-04-08 09:45:54 -07:00
bors	cc969f3c45	Auto merge of #154725 - cuviper:beta-next, r=cuviper [beta] backports - stdarch subtree update rust-lang/rust#153336 (partial) - aarch64: fix UB in non-power-of-two reads and writes rust-lang/stdarch#2042 - add neon load/store assembly test rust-lang/rust#154094 - don't drop arguments' temporaries in `dbg!` rust-lang/rust#154074 - Init self_decl with a correct vis rust-lang/rust#154313 - Update LLVM to 22.1.2 rust-lang/rust#154344 - [perf] Revert FastISel patch rust-lang/rust#154511 - core: Destabilize beta-stable `RangeInclusiveIter::remainder` rust-lang/rust#154459 - Revert "Fix: On wasm targets, call `panic_in_cleanup` if panic occurs in cleanup" rust-lang/rust#154700 - core: Update the feature gate on `TryFrom<integer> for bool` rust-lang/rust#154691 r? cuviper	2026-04-03 07:29:44 +00:00
Trevor Gross	940fc4d3b3	core: Update the feature gate on `TryFrom<integer> for bool` This implementation was added recently in `f12288ec26` ("TryFrom<integer> for bool") but used an old feature gate and stabilization version. Update to reflect when these were actually added. (cherry picked from commit `02b516afd9`)	2026-04-02 11:39:38 -07:00
Wesley Wiser	5dacf5d54d	Revert "Fix: On wasm targets, call `panic_in_cleanup` if panic occurs in cleanup" This reverts commit `acbfd79acf`. (cherry picked from commit `c9d3a00cd1`)	2026-04-02 11:39:06 -07:00
Trevor Gross	f68f5980c3	core: Move `{RangeIter, RangeFromIter}::remainder` to `new_range_remainder` Split the remainder functions from the rest of `std::range`. (cherry picked from commit `0bb3fe315e`)	2026-04-02 11:38:37 -07:00
Trevor Gross	b7bdc7aee2	core: Destabilize beta-stable `RangeInclusiveIter::remainder` As discussed, make this portion of the range API unstable again. This will now be tracked under `new_range_remainder`. Discussion: https://rust-lang.zulipchat.com/#narrow/channel/327149-t-libs-api.2Fapi-changes/topic/.60RangeFrom.3A.3Aremainder.60.20possible.20panic/with/582108913 (cherry picked from commit `cbc94349d0`)	2026-04-02 11:28:50 -07:00
Nikita Popov	533179a437	[perf] Revert FastISel patch This change caused a significant compile-time regression for debug builds. (cherry picked from commit `1a320616e9`)	2026-04-02 11:07:50 -07:00
dianqk	6db4dfefe1	Update LLVM to 22.1.2 (cherry picked from commit `283d705b31`)	2026-04-02 11:07:43 -07:00
mu001999	195f9764c0	Init self_decl with a correct vis (cherry picked from commit `01795c3eab`)	2026-04-02 11:07:33 -07:00
dianne	1374038f80	update diagnostic for variables moved by `dbg!` (cherry picked from commit `7d1b41cbb3`)	2026-04-02 11:05:25 -07:00
dianne	4f50466be4	don't drop arguments' temporaries in `dbg!` (cherry picked from commit `51816efcc0`)	2026-04-02 11:05:25 -07:00
Folkert de Vries	73caca416f	add neon load/store assembly test (cherry picked from commit `35f9cb6eee`)	2026-04-02 10:43:00 -07:00
Folkert de Vries	e427d29e3c	aarch64: fix UB in non-power-of-two reads and writes (cherry picked from commit `2fa37e7b34`)	2026-04-02 10:41:57 -07:00
bors	8ebd005178	Auto merge of #154307 - ShoyuVanilla:beta-fix, r=jieyouxu [beta] Revert #151380 in beta cc https://rust-lang.zulipchat.com/#narrow/channel/474880-t-compiler.2Fbackports/topic/.23153869.3A.20beta-nominated/with/581306395 r? ghost	2026-04-01 20:23:34 +00:00
bors	66bcd258f0	Auto merge of #154346 - ehuss:beta-backports, r=ehuss [beta] backports - Update cargo - https://github.com/rust-lang/rust/pull/153763: Don't add empty target features for target-cpu=native on macOS - https://github.com/rust-lang/rust/pull/153491: Move `freeze_*` methods to `OpenOptionsExt2`	2026-03-25 05:58:23 +00:00
Jonathan Brouwer	a692f685c7	Rollup merge of #153491 - ChrisDenton:openoptionsext2, r=Mark-Simulacrum Move `freeze_*` methods to `OpenOptionsExt2` Move the unstable `freeze_last_access_time` and `freeze_last_write_time` from `OpenOptionsExt` to a new `OpenOptionsExt2` trait. This should fix rust-lang/rust#153486.	2026-03-24 18:23:04 -07:00
Jonathan Brouwer	470cb0754e	Rollup merge of #153763 - nikic:target-cpu-native-fix, r=lqd Don't add empty target features for target-cpu=native on macOS LLVM does not support host feature detection (only host cpu detection) on apple platforms. As such, the returned feature string will be empty. Adding this empty string to the target-features attribute results in a verifier error on LLVM 22. Fix this by not adding the empty string to the target features. The reason why this was not caught by the target-cpu-native test is that it requires a function that adds some target features, otherwise the attribute is omitted entirely. We achieve this with a somewhat peculiar construction that enables `neon` if it's already enabled. (This is to avoid enabling it on softfloat targets.) Fixes https://github.com/rust-lang/rust/issues/153397.	2026-03-24 18:16:01 -07:00
Eric Huss	5b5a9cf5f0	Update cargo submodule 2 commits in e8eb8435d5cad936237a1ee798c2f983624d0825..f2d3ce0bd7f24a49f8f72d9000448f8838c4e850 2026-03-06 12:51:00 -0600 to 2026-03-21 06:43:08 -0500 - [beta 1.95] Fix symlink_and_directory when running in a long target dir name (rust-lang/cargo#16776) - [beta 1.95] Update tar to 0.4.45 (rust-lang/cargo#16770)	2026-03-24 18:15:16 -07:00
Shoyu Vanilla	63cd511300	Revert "Auto merge of #151380 - ShoyuVanilla:shallow-resolve-to-root-var, r=lcnr" This reverts commit `75b9d89c68`, reversing changes made to `7bee525095`.	2026-03-24 20:57:08 +09:00
bors	951adfe62e	Auto merge of #153958 - fmease:beta-dyn-ace-gingerly-care, r=BoxyUwU [beta] Don't look for non-type-level assoc consts when checking trait object types Beta backport of PR rust-lang/rust#153738. Said PR can't just be rebased onto beta as it needs slight adjustments due to PR RUST-153050 not being part of beta. Directly fixes rust-lang/rust#153731. ~~Blocked on backport acceptance by T-compiler~~ (done) (nomination happened / nomination procedure happens over at rust-lang/rust#153738, not here).	2026-03-19 21:25:41 +00:00
León Orell Valerian Liehr	bdc1b3ffa8	[beta] Don't look for non-type-level assoc consts when checking trait object types	2026-03-17 01:54:26 +01:00
bors	94a8e826a5	Auto merge of #153530 - lnicola:lockfile-path-backport, r=Veykril [beta] backport rust-analyzer `lockfile-path` fix Closes rust-lang/rust-analyzer#21761 Closes rust-lang/rust-analyzer#21783	2026-03-08 21:32:40 +00:00
bors	64e2968f2c	Auto merge of #153463 - cuviper:beta-next, r=cuviper [beta] update stage0 and cargo Update stage0 to 1.94.0 <https://forge.rust-lang.org/release/process.html#beta-stage0-update-friday> --- Update cargo submodule rust-lang/rust#153515 2 commits in f298b8c82da0cba538516b45b04a480fc501d4c0..e8eb8435d5cad936237a1ee798c2f983624d0825 2026-02-24 21:59:20 +0000 to 2026-03-06 12:51:00 -0600 - [beta-1.95] Add missing truncate when writing .crate files (rust-lang/cargo#16713) - [beta 1.95] backport test fixes (rust-lang/cargo#16715)	2026-03-07 09:42:59 +00:00
Laurențiu Nicola	d2cb7e4ef1	Tweak pre-release check for beta	2026-03-07 11:21:06 +02:00
Laurențiu Nicola	b93cdbfcfa	Use -Zlockfile-path on every 1.95 nightly	2026-03-07 11:20:59 +02:00
Weihang Lo	1b95471493	[beta-1.95] Update cargo submodule	2026-03-06 21:45:02 -08:00
Josh Stone	f96caa95f1	update stage0 to 1.94.0	2026-03-05 15:14:40 -08:00
bors	ad726b5063	Auto merge of #153314 - cuviper:beta-next, r=cuviper [beta] prepare Rust 1.95.0-beta Ref: https://forge.rust-lang.org/release/process.html#beta-pr - Replace version placeholders with 1.95.0 - Bump to beta release - library/test: always enable unstable features for miri rust-lang/rust#153369 r? cuviper	2026-03-05 05:16:37 +00:00
Josh Stone	752b6637ce	library/test: always enable unstable features for miri The unstable features of the `test` crate used to be default-enabled, and manually disabled when building the beta and stable channels. Commit `dae8ea92a7` flipped that to default-disabled, only enabled for nightly and dev channels. However, this broke miri testing on the beta/stable channels, because it also uses unstable features -- which should be fine to enable just for its own sysroot build. Now the `test` build script makes that happen by noticing the `MIRI_CALLED_FROM_SETUP` environment variable. (cherry picked from commit `30d7ed4c47`)	2026-03-04 13:48:26 -08:00
Josh Stone	23b953f802	Bump to beta release	2026-03-02 15:01:23 -08:00
Josh Stone	bad24ccbec	Replace version placeholders with 1.95.0	2026-03-02 15:00:53 -08:00