diff --git a/compiler/rustc/src/main.rs b/compiler/rustc/src/main.rs
index 17f768f6dc54a..6609a19fa9e34 100644
--- a/compiler/rustc/src/main.rs
+++ b/compiler/rustc/src/main.rs
@@ -1,7 +1,5 @@
 // We need this feature as it changes `dylib` linking behavior and allows us to link to `rustc_driver`.
 #![feature(rustc_private)]
-// Several crates are depended upon but unused so that they are present in the sysroot
-#![expect(unused_crate_dependencies)]
 
 use std::process::ExitCode;
 
diff --git a/compiler/rustc_arena/src/lib.rs b/compiler/rustc_arena/src/lib.rs
index f2c6ffe44cdfd..4c9258b753d8f 100644
--- a/compiler/rustc_arena/src/lib.rs
+++ b/compiler/rustc_arena/src/lib.rs
@@ -10,7 +10,6 @@
 // tidy-alphabetical-start
 #![allow(clippy::mut_from_ref)] // Arena allocators are one place where this pattern is fine.
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(bootstrap, feature(unwrap_infallible))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]
diff --git a/compiler/rustc_ast_ir/src/lib.rs b/compiler/rustc_ast_ir/src/lib.rs
index e919e7df99ee0..dc2bf67d338e7 100644
--- a/compiler/rustc_ast_ir/src/lib.rs
+++ b/compiler/rustc_ast_ir/src/lib.rs
@@ -7,7 +7,6 @@
 
 // tidy-alphabetical-start
 #![cfg_attr(feature = "nightly", allow(internal_features))]
-#![cfg_attr(feature = "nightly", cfg_attr(bootstrap, feature(never_type)))]
 #![cfg_attr(feature = "nightly", feature(rustc_attrs))]
 // tidy-alphabetical-end
 
diff --git a/compiler/rustc_attr_ir/src/attribute_docs.rs b/compiler/rustc_attr_ir/src/attribute_docs.rs
index a2b00c90b3028..975594771d3fb 100644
--- a/compiler/rustc_attr_ir/src/attribute_docs.rs
+++ b/compiler/rustc_attr_ir/src/attribute_docs.rs
@@ -12,7 +12,7 @@ macro_rules! include_example {
     };
 }
 
-#[cfg_attr(not(bootstrap), doc(attribute = "rustc_dump_clauses"))]
+#[doc(attribute = "rustc_dump_clauses")]
 /// Dumps the list of [`ty::Clause`]s as computed by the [`clauses_of`] query.
 ///
 /// See [`AttributeKind::RustcDumpClauses`] for the internal representation of this attribute.
diff --git a/compiler/rustc_attr_ir/src/data_structures.rs b/compiler/rustc_attr_ir/src/data_structures.rs
index 712ed41ae7759..55c0bedb9c39c 100644
--- a/compiler/rustc_attr_ir/src/data_structures.rs
+++ b/compiler/rustc_attr_ir/src/data_structures.rs
@@ -283,7 +283,6 @@ impl<ScopeId> StrippedCfgItem<ScopeId> {
 #[derive(StableHash, PrintAttribute)]
 pub enum Linkage {
     AvailableExternally,
-    Common,
     ExternalWeak,
     External,
     Internal,
diff --git a/compiler/rustc_attr_ir/src/encode_cross_crate.rs b/compiler/rustc_attr_ir/src/encode_cross_crate.rs
index 66fbbc1e3cbf7..b6733e8c1db54 100644
--- a/compiler/rustc_attr_ir/src/encode_cross_crate.rs
+++ b/compiler/rustc_attr_ir/src/encode_cross_crate.rs
@@ -265,7 +265,6 @@ impl AttributeKind {
             Linkage(linkage, _) => match *linkage {
                 crate::Linkage::Internal => false,
                 crate::Linkage::AvailableExternally
-                | crate::Linkage::Common
                 | crate::Linkage::External
                 | crate::Linkage::ExternalWeak
                 | crate::Linkage::LinkOnceAny
diff --git a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
index f4d0fa35e3f47..ed911a63eb7fe 100644
--- a/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/link_attrs.rs
@@ -685,10 +685,7 @@ impl SingleAttributeParser for LinkageParser {
     ]);
     const TEMPLATE: AttributeTemplate = template!(NameValueStr: [
         "available_externally",
-        "common",
         "extern_weak",
-        "external",
-        "internal",
         "linkonce",
         "linkonce_odr",
         "weak",
@@ -711,10 +708,7 @@ impl SingleAttributeParser for LinkageParser {
         // and don't have to be, LLVM treats them as no-ops.
         let linkage = match value {
             sym::available_externally => Linkage::AvailableExternally,
-            sym::common => Linkage::Common,
             sym::extern_weak => Linkage::ExternalWeak,
-            sym::external => Linkage::External,
-            sym::internal => Linkage::Internal,
             sym::linkonce => Linkage::LinkOnceAny,
             sym::linkonce_odr => Linkage::LinkOnceODR,
             sym::weak => Linkage::WeakAny,
@@ -725,10 +719,7 @@ impl SingleAttributeParser for LinkageParser {
                     name_value.value_span,
                     &[
                         sym::available_externally,
-                        sym::common,
                         sym::extern_weak,
-                        sym::external,
-                        sym::internal,
                         sym::linkonce,
                         sym::linkonce_odr,
                         sym::weak,
diff --git a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
index dde10225e652f..8bb5e6b7fc270 100644
--- a/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/macro_attrs.rs
@@ -1,10 +1,11 @@
+use rustc_ast::ItemKind;
 use rustc_attr_ir::{MacroUseArgs, find_attr};
 use rustc_feature::AttributeStability;
-use rustc_lint_defs::builtin::INVALID_MACRO_EXPORT_ARGUMENTS;
+use rustc_lint_defs::builtin::{INVALID_MACRO_EXPORT_ARGUMENTS, UNUSED_ATTRIBUTES};
 use rustc_structures::CollapseMacroDebuginfo;
 
 use super::prelude::*;
-use crate::diagnostics::MacroOnlyAttribute;
+use crate::diagnostics::{MacroExport, MacroOnlyAttribute};
 
 pub(crate) struct MacroEscapeParser;
 impl NoArgsAttributeParser for MacroEscapeParser {
@@ -175,8 +176,22 @@ impl SingleAttributeParser for MacroExportParser {
                 return None;
             }
         };
+
         Some(AttributeKind::MacroExport { span: cx.attr_span, local_inner_macros })
     }
+
+    fn finalize_check(cx: &mut FinalizeCheckContext<'_, '_>, attr_span: Span) {
+        if cx.target != Target::MacroDef {
+            return;
+        }
+
+        let item = cx.target_item.unwrap();
+        if let ItemKind::MacroDef(_, macro_def) = &item.kind
+            && !macro_def.macro_rules
+        {
+            cx.emit_lint(UNUSED_ATTRIBUTES, MacroExport::OnDeclMacro, attr_span);
+        }
+    }
 }
 
 pub(crate) struct CollapseDebugInfoParser;
diff --git a/compiler/rustc_attr_parsing/src/diagnostics.rs b/compiler/rustc_attr_parsing/src/diagnostics.rs
index a43cd918c8f35..df426cb5e19f5 100644
--- a/compiler/rustc_attr_parsing/src/diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/diagnostics.rs
@@ -2070,3 +2070,10 @@ pub(crate) struct UnusedDuplicate {
     )]
     pub warning: bool,
 }
+
+#[derive(Diagnostic)]
+pub(crate) enum MacroExport {
+    #[diag("`#[macro_export]` has no effect on declarative macro definitions")]
+    #[note("declarative macros follow the same exporting rules as regular items")]
+    OnDeclMacro,
+}
diff --git a/compiler/rustc_attr_parsing/src/interface.rs b/compiler/rustc_attr_parsing/src/interface.rs
index df89ffe57b9a0..95412c34be371 100644
--- a/compiler/rustc_attr_parsing/src/interface.rs
+++ b/compiler/rustc_attr_parsing/src/interface.rs
@@ -510,23 +510,25 @@ impl<'sess> AttributeParser<'sess> {
 
         // Now that all attributes have been parsed, run the deferred checks. These can
         // inspect the fully parsed attributes via `FinalizeCheckContext::parsed_attrs`.
-        for (check, attr_span) in deferred_checks {
-            check(
-                &mut FinalizeCheckContext {
-                    shared: SharedContext {
-                        cx: self,
-                        target_span,
-                        target,
-                        emit_lint: &mut emit_lint,
-                        #[cfg(debug_assertions)]
-                        has_lint_been_emitted: AtomicBool::new(false),
+        if !matches!(self.should_emit, ShouldEmit::Nothing) {
+            for (check, attr_span) in deferred_checks {
+                check(
+                    &mut FinalizeCheckContext {
+                        shared: SharedContext {
+                            cx: self,
+                            target_span,
+                            target,
+                            emit_lint: &mut emit_lint,
+                            #[cfg(debug_assertions)]
+                            has_lint_been_emitted: AtomicBool::new(false),
+                        },
+                        all_attrs: &attr_paths,
+                        parsed_attrs: &attributes,
+                        target_item,
                     },
-                    all_attrs: &attr_paths,
-                    parsed_attrs: &attributes,
-                    target_item,
-                },
-                attr_span,
-            );
+                    attr_span,
+                );
+            }
         }
 
         if !matches!(self.should_emit, ShouldEmit::Nothing) && target == Target::WherePredicate {
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 39361a886bd77..c2233fa495a47 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -2,7 +2,6 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(default_field_values)]
 #![feature(deref_patterns)]
 #![feature(file_buffered)]
diff --git a/compiler/rustc_codegen_gcc/src/base.rs b/compiler/rustc_codegen_gcc/src/base.rs
index 07214096b3e49..acf5c75e4d8cd 100644
--- a/compiler/rustc_codegen_gcc/src/base.rs
+++ b/compiler/rustc_codegen_gcc/src/base.rs
@@ -55,19 +55,14 @@ pub fn global_linkage_to_gcc(linkage: Linkage) -> GlobalKind {
         | Linkage::LinkOnceODR
         | Linkage::WeakAny
         | Linkage::WeakODR
-        | Linkage::ExternalWeak
-        | Linkage::Common => GlobalKind::Exported,
+        | Linkage::ExternalWeak => GlobalKind::Exported,
     }
 }
 
 /// The attribute a global *definition* needs on top of its [`GlobalKind`] to get this linkage.
 #[cfg(feature = "master")]
 pub fn global_linkage_attribute<'gcc>(linkage: Linkage) -> Option<VarAttribute<'gcc>> {
-    match linkage {
-        Linkage::Common => Some(VarAttribute::Common),
-        _ if linkage_needs_weak_attribute(linkage) => Some(VarAttribute::Weak),
-        _ => None,
-    }
+    if linkage_needs_weak_attribute(linkage) { Some(VarAttribute::Weak) } else { None }
 }
 
 /// The type of a function *definition* with an explicit `#[linkage]`.
@@ -85,17 +80,12 @@ pub fn linkage_to_gcc(linkage: Linkage) -> FunctionType {
         | Linkage::LinkOnceODR
         | Linkage::WeakAny
         | Linkage::WeakODR
-        | Linkage::ExternalWeak
-        | Linkage::Common => FunctionType::Exported,
+        | Linkage::ExternalWeak => FunctionType::Exported,
     }
 }
 
 /// Whether a definition with this linkage must carry the `weak` attribute, so that a strong
 /// definition in another object file wins over it instead of clashing with it.
-///
-/// `common` is in here for functions only: GCC honours that attribute on a variable, but drops it
-/// on a function, so a common function falls back to weak. Globals go through
-/// `global_linkage_attribute` instead.
 #[cfg(feature = "master")]
 pub fn linkage_needs_weak_attribute(linkage: Linkage) -> bool {
     match linkage {
@@ -103,8 +93,7 @@ pub fn linkage_needs_weak_attribute(linkage: Linkage) -> bool {
         | Linkage::LinkOnceODR
         | Linkage::WeakAny
         | Linkage::WeakODR
-        | Linkage::ExternalWeak
-        | Linkage::Common => true,
+        | Linkage::ExternalWeak => true,
         Linkage::External | Linkage::AvailableExternally | Linkage::Internal => false,
     }
 }
diff --git a/compiler/rustc_codegen_gcc/src/consts.rs b/compiler/rustc_codegen_gcc/src/consts.rs
index c58ab6d2a9bef..0784064547e0f 100644
--- a/compiler/rustc_codegen_gcc/src/consts.rs
+++ b/compiler/rustc_codegen_gcc/src/consts.rs
@@ -13,8 +13,7 @@ use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_log::tracing::trace;
 use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
 use rustc_middle::mir::interpret::{
-    self, Allocation, ConstAllocation, CtfeProvenance, ErrorHandled, Scalar as InterpScalar,
-    read_target_uint,
+    self, ConstAllocation, CtfeProvenance, ErrorHandled, Scalar as InterpScalar, read_target_uint,
 };
 use rustc_middle::mono::MonoItem;
 use rustc_middle::ty::layout::LayoutOf;
@@ -113,12 +112,7 @@ impl<'gcc, 'tcx> StaticCodegenMethods for CodegenCx<'gcc, 'tcx> {
         // NOTE: Alignment from attributes has already been applied to the allocation.
         set_global_alignment(self, global, alloc.align);
 
-        // A common symbol is storage the linker allocates and zero-fills, so giving the definition
-        // an initializer — even an all-zero one — takes it back out of `.comm`. A non-zero one is
-        // kept: the symbol is then an ordinary definition, which is what GCC does with it too.
-        if attrs.linkage != Some(Linkage::Common) || !is_zero_initializer(alloc) {
-            global.global_set_initializer_rvalue(value);
-        }
+        global.global_set_initializer_rvalue(value);
 
         // As an optimization, all shared statics which do not have interior
         // mutability are placed into read-only memory.
@@ -458,17 +452,6 @@ pub(crate) fn const_alloc_to_gcc_uncached<'gcc>(
     cx.const_struct(&llvals, true)
 }
 
-/// Whether this allocation is all zeroes, and so needs no initializer to be spelled out.
-fn is_zero_initializer(alloc: &Allocation) -> bool {
-    alloc.provenance().ptrs().is_empty()
-        // This `inspect` is okay: it is within the bounds of the allocation, there is no provenance
-        // to misread, and it does not affect interpreter execution.
-        && alloc
-            .inspect_with_uninit_and_ptr_outside_interpreter(0..alloc.size().bytes_usize())
-            .iter()
-            .all(|&byte| byte == 0)
-}
-
 fn codegen_static_initializer<'gcc, 'tcx>(
     cx: &CodegenCx<'gcc, 'tcx>,
     def_id: DefId,
diff --git a/compiler/rustc_codegen_gcc/tests/c/import_linkage.c b/compiler/rustc_codegen_gcc/tests/c/import_linkage.c
index f2beb9603d08b..227fa1c848ddf 100644
--- a/compiler/rustc_codegen_gcc/tests/c/import_linkage.c
+++ b/compiler/rustc_codegen_gcc/tests/c/import_linkage.c
@@ -6,12 +6,9 @@
 
 #include <stdint.h>
 
-int32_t external_value = 1;
 int32_t available_externally_value = 2;
 int32_t linkonce_value = 3;
 int32_t linkonce_odr_value = 4;
 int32_t weak_value = 5;
 int32_t weak_odr_value = 6;
-int32_t common_value = 7;
 int32_t extern_weak_value = 8;
-int32_t internal_value = 9;
diff --git a/compiler/rustc_codegen_gcc/tests/c/static_linkage.c b/compiler/rustc_codegen_gcc/tests/c/static_linkage.c
index 787e61f9cf105..00360d8633e68 100644
--- a/compiler/rustc_codegen_gcc/tests/c/static_linkage.c
+++ b/compiler/rustc_codegen_gcc/tests/c/static_linkage.c
@@ -1,9 +1,6 @@
 /* Strong definitions of the statics that `tests/run/static_linkage.rs` also defines, but weakly.
  * The linker has to keep these and drop the Rust ones; a backend that emits the Rust definitions
- * as ordinary global symbols fails the link with a duplicate definition instead.
- *
- * `internal_static` is the opposite case: the Rust side keeps its own, and the two definitions
- * coexist because the Rust one is local. */
+ * as ordinary global symbols fails the link with a duplicate definition instead. */
 
 #include <stdint.h>
 
@@ -11,8 +8,6 @@ int32_t weak_static = 1;
 int32_t weak_odr_static = 2;
 int32_t linkonce_static = 3;
 int32_t linkonce_odr_static = 4;
-int32_t common_static = 5;
-int32_t internal_static = 200;
 
 /* `available_externally` promises the real definition lives elsewhere: a backend may read this one
  * or emit an equivalent copy of the Rust initializer, so the two have to hold the same value. */
@@ -29,9 +24,5 @@ int32_t c_read_all(void)
         return 13;
     if (linkonce_odr_static != 4)
         return 14;
-    if (common_static != 5)
-        return 15;
-    if (internal_static != 200)
-        return 16;
     return 0;
 }
diff --git a/compiler/rustc_codegen_gcc/tests/run/import_linkage.rs b/compiler/rustc_codegen_gcc/tests/run/import_linkage.rs
index bf5cb9e532799..58008ecbc9746 100644
--- a/compiler/rustc_codegen_gcc/tests/run/import_linkage.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/import_linkage.rs
@@ -19,8 +19,6 @@ extern crate mini_core;
 use mini_core::*;
 
 extern "C" {
-    #[linkage = "external"]
-    static external_value: *const i32;
     #[linkage = "available_externally"]
     static available_externally_value: *const i32;
     #[linkage = "linkonce"]
@@ -31,15 +29,8 @@ extern "C" {
     static weak_value: *const i32;
     #[linkage = "weak_odr"]
     static weak_odr_value: *const i32;
-    #[linkage = "common"]
-    static common_value: *const i32;
     #[linkage = "extern_weak"]
     static extern_weak_value: *const i32;
-    // An import is an undefined reference whatever the flavour says. Upstream bug: rustc lowers
-    // this one to an internal declaration, which LLVM's verifier rejects ("Global is external, but
-    // doesn't have external or weak linkage!") and which crashes cg_llvm at -O3.
-    #[linkage = "internal"]
-    static internal_value: *const i32;
 
     // Nothing defines this one, so it stays null instead of breaking the link.
     #[linkage = "extern_weak"]
@@ -49,9 +40,6 @@ extern "C" {
 #[no_mangle]
 extern "C" fn main(_argc: i32, _argv: *const *const u8) -> i32 {
     unsafe {
-        if *external_value != 1 {
-            return 1;
-        }
         if *available_externally_value != 2 {
             return 2;
         }
@@ -67,15 +55,9 @@ extern "C" fn main(_argc: i32, _argv: *const *const u8) -> i32 {
         if *weak_odr_value != 6 {
             return 6;
         }
-        if *common_value != 7 {
-            return 7;
-        }
         if *extern_weak_value != 8 {
             return 8;
         }
-        if *internal_value != 9 {
-            return 9;
-        }
         if undefined_value as usize != 0 {
             return 10;
         }
diff --git a/compiler/rustc_codegen_gcc/tests/run/static_linkage.rs b/compiler/rustc_codegen_gcc/tests/run/static_linkage.rs
index 7b911c064d797..3c9303fa8cf16 100644
--- a/compiler/rustc_codegen_gcc/tests/run/static_linkage.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/static_linkage.rs
@@ -7,8 +7,7 @@
 // `tests/c/static_linkage.c`, which defines the overridable ones strongly.
 //
 // If `predefine_static` were to ignore its `linkage` argument outright, every static would come out as
-// an ordinary global symbol: the overridable ones would clash with the C definitions at link time, and
-// `internal` would export a symbol it should have kept private.
+// an ordinary global symbol: the overridable ones would clash with the C definitions at link time.
 
 #![feature(linkage, no_core)]
 #![no_std]
@@ -34,16 +33,6 @@ pub static linkonce_static: i32 = 0;
 #[no_mangle]
 pub static linkonce_odr_static: i32 = 0;
 
-// `common` is only valid on a mutable global: LLVM rejects a constant one.
-#[linkage = "common"]
-#[no_mangle]
-pub static mut common_static: i32 = 0;
-
-// Private to this crate, so the C definition of the same name is a different object.
-#[linkage = "internal"]
-#[no_mangle]
-pub static internal_static: i32 = 100;
-
 // Not overridden by the C side: the definition here is the one that survives.
 #[linkage = "weak"]
 #[no_mangle]
@@ -66,9 +55,6 @@ extern "C" fn main(_argc: i32, _argv: *const *const u8) -> i32 {
         return result;
     }
 
-    if internal_static != 100 {
-        return 1;
-    }
     if only_weak_static != 6 {
         return 2;
     }
diff --git a/compiler/rustc_codegen_gcc/tests/run/weak_function_linkage.rs b/compiler/rustc_codegen_gcc/tests/run/weak_function_linkage.rs
index 677f01353401a..406b85df10b02 100644
--- a/compiler/rustc_codegen_gcc/tests/run/weak_function_linkage.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/weak_function_linkage.rs
@@ -41,9 +41,6 @@ extern "C" fn linkonce_odr_function() -> i32 {
     4
 }
 
-// `#[linkage = "common"]` is absent on purpose: a common symbol is `SHN_COMMON`, which the object
-// format only allows for objects, so no backend can give a function that linkage.
-
 // Not overridden by the C side: the definition here is the one that runs.
 #[linkage = "weak"]
 #[no_mangle]
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index cf278694399f3..77cb37edec770 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -237,7 +237,6 @@ pub(crate) fn linkage_to_llvm(linkage: Linkage) -> llvm::Linkage {
         Linkage::WeakODR => llvm::Linkage::WeakODRLinkage,
         Linkage::Internal => llvm::Linkage::InternalLinkage,
         Linkage::ExternalWeak => llvm::Linkage::ExternalWeakLinkage,
-        Linkage::Common => llvm::Linkage::CommonLinkage,
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index 7a05bf718663c..a5a4f0b3ddb25 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -67,30 +67,30 @@ pub(crate) fn maybe_sign_fn_ptr<'ll, 'tcx>(
 }
 
 /*
-* A note on nomenclature of linking: "extern", "foreign", and "upcall".
-*
-* An "extern" is an LLVM symbol we wind up emitting an undefined external
-* reference to. This means "we don't have the thing in this compilation unit,
-* please make sure you link it in at runtime". This could be a reference to
-* C code found in a C library, or rust code found in a rust crate.
-*
-* Most "externs" are implicitly declared (automatically) as a result of a
-* user declaring an extern _module_ dependency; this causes the rust driver
-* to locate an extern crate, scan its compilation metadata, and emit extern
-* declarations for any symbols used by the declaring crate.
-*
-* A "foreign" is an extern that references C (or other non-rust ABI) code.
-* There is no metadata to scan for extern references so in these cases either
-* a header-digester like bindgen, or manual function prototypes, have to
-* serve as declarators. So these are usually given explicitly as prototype
-* declarations, in rust code, with ABI attributes on them noting which ABI to
-* link via.
-*
-* An "upcall" is a foreign call generated by the compiler (not corresponding
-* to any user-written call in the code) into the runtime library, to perform
-* some helper task such as bringing a task to life, allocating memory, etc.
-*
-*/
+ * A note on nomenclature of linking: "extern", "foreign", and "upcall".
+ *
+ * An "extern" is an LLVM symbol we wind up emitting an undefined external
+ * reference to. This means "we don't have the thing in this compilation unit,
+ * please make sure you link it in at runtime". This could be a reference to
+ * C code found in a C library, or rust code found in a rust crate.
+ *
+ * Most "externs" are implicitly declared (automatically) as a result of a
+ * user declaring an extern _module_ dependency; this causes the rust driver
+ * to locate an extern crate, scan its compilation metadata, and emit extern
+ * declarations for any symbols used by the declaring crate.
+ *
+ * A "foreign" is an extern that references C (or other non-rust ABI) code.
+ * There is no metadata to scan for extern references so in these cases either
+ * a header-digester like bindgen, or manual function prototypes, have to
+ * serve as declarators. So these are usually given explicitly as prototype
+ * declarations, in rust code, with ABI attributes on them noting which ABI to
+ * link via.
+ *
+ * An "upcall" is a foreign call generated by the compiler (not corresponding
+ * to any user-written call in the code) into the runtime library, to perform
+ * some helper task such as bringing a task to life, allocating memory, etc.
+ *
+ */
 
 /// A structure representing an active landing pad for the duration of a basic
 /// block.
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 19bbf0cf3d8d8..93ef87eea026d 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -5,7 +5,6 @@
 //! This API is completely unstable and subject to change.
 
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(trim_prefix_suffix))]
 #![feature(extern_types)]
 #![feature(file_buffered)]
 #![feature(impl_trait_in_assoc_type)]
diff --git a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
index 2fa6f3fc06550..5433b9da6f2b6 100644
--- a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
@@ -228,7 +228,6 @@ fn prefix_and_suffix<'tcx>(
                 // LTO can fail when internal linkage is used.
                 emit_fatal("naked functions may not have internal linkage")
             }
-            Linkage::Common => emit_fatal("Functions may not have common linkage"),
             Linkage::AvailableExternally => {
                 // this would make the function equal an extern definition
                 emit_fatal("Functions may not have available_externally linkage")
diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index a853dd63d3435..981813f13c97f 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -1,5 +1,4 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(array_try_map)]
 #![feature(decl_macro)]
 #![feature(deref_patterns)]
diff --git a/compiler/rustc_data_structures/src/lib.rs b/compiler/rustc_data_structures/src/lib.rs
index 4ebd6ef9f92b3..aae378939452b 100644
--- a/compiler/rustc_data_structures/src/lib.rs
+++ b/compiler/rustc_data_structures/src/lib.rs
@@ -10,12 +10,10 @@
 #![allow(internal_features)]
 #![allow(rustc::default_hash_types)]
 #![allow(rustc::potential_query_instability)]
-#![cfg_attr(bootstrap, feature(allocator_api))]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(bootstrap, feature(unwrap_infallible))]
-#![cfg_attr(not(bootstrap), feature(allocator_ext))]
 #![cfg_attr(test, feature(test))]
 #![deny(unsafe_op_in_unsafe_fn)]
+#![feature(allocator_ext)]
 #![feature(ascii_char)]
 #![feature(ascii_char_variants)]
 #![feature(auto_traits)]
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index 210f04a115831..7940dc3978496 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -5,7 +5,6 @@
 //! This API is completely unstable and subject to change.
 
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(trim_prefix_suffix))]
 #![feature(decl_macro)]
 #![feature(file_buffered)]
 #![feature(panic_backtrace_config)]
diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs
index 37a3594e374ea..4eb7408244728 100644
--- a/compiler/rustc_feature/src/accepted.rs
+++ b/compiler/rustc_feature/src/accepted.rs
@@ -47,7 +47,7 @@ declare_features! (
     /// Allows `#[target_feature(...)]` on aarch64 platforms
     (accepted, aarch64_target_feature, "1.61.0", Some(44839)),
     /// Allows `extern "custom" fn()`.
-    (accepted, abi_custom, "CURRENT_RUSTC_VERSION", Some(140829)),
+    (accepted, abi_custom, "1.100.0", Some(140829)),
     /// Allows using the `efiapi` ABI.
     (accepted, abi_efiapi, "1.68.0", Some(65815)),
     /// Allows the sysV64 ABI to be specified on all platforms
@@ -336,7 +336,7 @@ declare_features! (
     /// Allows specifying the whole-archive link modifier
     (accepted, native_link_modifiers_whole_archive, "1.61.0", Some(81490)),
     /// Allows the `!` type.
-    (accepted, never_type, "CURRENT_RUSTC_VERSION", Some(35121)),
+    (accepted, never_type, "1.100.0", Some(35121)),
     /// Allows using non lexical lifetimes (RFC 2094).
     (accepted, nll, "1.63.0", Some(43234)),
     /// Allows using `#![no_std]`.
diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index 5e89a060e3335..eca2567ab20ff 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -55,7 +55,7 @@ declare_features! (
     /// Allows using the `amdgpu-kernel` ABI.
     (removed, abi_amdgpu_kernel, "1.77.0", Some(51575), None, 120495),
     (removed, abi_c_cmse_nonsecure_call, "1.90.0", Some(81391), Some("renamed to abi_cmse_nonsecure_call"), 142146),
-    (removed, abi_unadjusted, "CURRENT_RUSTC_VERSION", None, Some("merged into link_llvm_intrinsics"), 161398),
+    (removed, abi_unadjusted, "1.100.0", None, Some("merged into link_llvm_intrinsics"), 161398),
     (removed, advanced_slice_patterns, "1.42.0", Some(62254),
      Some("merged into `#![feature(slice_patterns)]`"), 67712),
     (removed, allocator, "1.0.0", None, None),
@@ -67,7 +67,7 @@ declare_features! (
     (removed, await_macro, "1.38.0", Some(50547),
      Some("subsumed by `.await` syntax"), 62293),
     /// Allows using `box` in patterns (RFC 469).
-    (removed, box_patterns, "CURRENT_RUSTC_VERSION", Some(29641), Some("superseded by `deref_patterns`")),
+    (removed, box_patterns, "1.100.0", Some(29641), Some("superseded by `deref_patterns`")),
     /// Allows using the `box $expr` syntax.
     (removed, box_syntax, "1.70.0", Some(49733), Some("replaced with `#[rustc_box]`"), 108471),
     /// Allows capturing disjoint fields in a closure/coroutine (RFC 2229).
@@ -167,7 +167,7 @@ declare_features! (
         ),
         133768
     ),
-    (removed, generic_const_args, "CURRENT_RUSTC_VERSION", Some(151972), Some("renamed to `gca_const_items`")),
+    (removed, generic_const_args, "1.100.0", Some(151972), Some("renamed to `gca_const_items`")),
     (removed, import_shadowing, "1.0.0", None, None),
     /// Allows in-band quantification of lifetime bindings (e.g., `fn foo(x: &'a u8) -> &'a u8`).
     (removed, in_band_lifetimes, "1.61.0", Some(44524),
@@ -193,12 +193,12 @@ declare_features! (
            which is available from cargo build scripts with `cargo:rustc-link-arg` now"), 83820),
     (removed, macro_reexport, "1.0.0", Some(29638),
      Some("subsumed by `pub use`"), 49982),
-    (removed, macroless_const_item_generic_const_args, "CURRENT_RUSTC_VERSION", Some(162540), Some("renamed to `gca_macroless_items`")),
-    (removed, macroless_generic_const_args, "CURRENT_RUSTC_VERSION", Some(159006), Some("renamed to `gca_macroless_args`")),
+    (removed, macroless_const_item_generic_const_args, "1.100.0", Some(162540), Some("renamed to `gca_macroless_items`")),
+    (removed, macroless_generic_const_args, "1.100.0", Some(159006), Some("renamed to `gca_macroless_args`")),
     /// Allows using `#[main]` to replace the entrypoint `#[lang = "start"]` calls.
     (removed, main, "1.53.0", Some(29634), None, 84217),
     (removed, managed_boxes, "1.0.0", None, None),
-    (removed, min_generic_const_args, "CURRENT_RUSTC_VERSION", Some(132980), Some("renamed to `gca_min_const_items`")),
+    (removed, min_generic_const_args, "1.100.0", Some(132980), Some("renamed to `gca_min_const_items`")),
     /// Allows the use of type alias impl trait in function return positions
     (removed, min_type_alias_impl_trait, "1.56.0", Some(63063),
      Some("removed in favor of full type_alias_impl_trait"), 87564),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index cb6a1d39b1dd8..1af55be52abde 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -235,7 +235,7 @@ declare_features! (
     /// Allows checking whether or not the backend correctly supports unstable float types.
     (internal, cfg_target_has_reliable_f16_f128, "1.88.0", None),
     /// Allows checking whether or not the backend correctly supports the unstable `f16b` type.
-    (internal, cfg_target_has_reliable_f16b, "CURRENT_RUSTC_VERSION", None),
+    (internal, cfg_target_has_reliable_f16b, "1.100.0", None),
     /// Allows checking whether or not the target might have thread support.
     (internal, cfg_target_has_threads, "1.99.0", None),
     /// Allows identifying the `compiler_builtins` crate.
@@ -257,7 +257,7 @@ declare_features! (
     /// Allows `#[link(..., cfg(..))]`; perma-unstable per #37406
     (internal, link_cfg, "1.14.0", None),
     /// Allows using `#[link_name="__enzyme_*"]`.
-    (internal, link_enzyme_intrinsics, "CURRENT_RUSTC_VERSION", None),
+    (internal, link_enzyme_intrinsics, "1.100.0", None),
     /// Allows using `?Trait` trait bounds in more contexts.
     (internal, more_maybe_bounds, "1.82.0", None),
     /// Allow negative trait bounds. This is an internal-only feature for testing the trait solver!
@@ -273,7 +273,7 @@ declare_features! (
     /// Allows using the `#[stable]` and `#[unstable]` attributes.
     (internal, staged_api, "1.0.0", None),
     /// Perma-unstable, only used in the test suite for binders (`for<'a>`).
-    (internal, test_binder_constraints, "CURRENT_RUSTC_VERSION", None),
+    (internal, test_binder_constraints, "1.100.0", None),
     /// Perma-unstable, only used to test the `incomplete_features` lint.
     (incomplete, test_incomplete_feature, "1.96.0", None),
     /// Added for testing unstable lints; perma-unstable.
@@ -530,7 +530,7 @@ declare_features! (
     /// Allow using 16-bit (half precision) floating point numbers.
     (unstable, f16, "1.78.0", Some(116909)),
     /// Allow using bfloat16 floating point numbers.
-    (unstable, f16b, "CURRENT_RUSTC_VERSION", Some(160630)),
+    (unstable, f16b, "1.100.0", Some(160630)),
     /// Allows the use of `#[ffi_const]` on foreign functions.
     (unstable, ffi_const, "1.45.0", Some(58328)),
     /// Allows the use of `#[ffi_pure]` on foreign functions.
@@ -548,7 +548,7 @@ declare_features! (
     /// Support delegating implementation of functions to other already implemented functions.
     (incomplete, fn_delegation, "1.76.0", Some(118212)),
     /// Traits for function pointers and items
-    (unstable, fn_static, "CURRENT_RUSTC_VERSION", Some(148768)),
+    (unstable, fn_static, "1.100.0", Some(148768)),
     /// Allows using forced keywords `k#fn`.
     (unstable, forced_keywords, "CURRENT_RUSTC_VERSION", Some(153839)),
     /// Allows impls for the Freeze trait.
@@ -563,7 +563,7 @@ declare_features! (
     (incomplete, gca_macroless_args, "1.99.0", Some(159006)),
     /// Allows directly represented gca_const_items as the rhs of const items without the
     /// `gca!` macro.
-    (incomplete, gca_macroless_items, "CURRENT_RUSTC_VERSION", Some(162540)),
+    (incomplete, gca_macroless_items, "1.100.0", Some(162540)),
     /// Enables the generic const args MVP (paths to type const items and constructors
     /// for ADTs and primitives).
     (incomplete, gca_min_const_items, "1.84.0", Some(132980)),
diff --git a/compiler/rustc_hir/src/lib.rs b/compiler/rustc_hir/src/lib.rs
index 92ef008610098..0f6041b44b2f2 100644
--- a/compiler/rustc_hir/src/lib.rs
+++ b/compiler/rustc_hir/src/lib.rs
@@ -3,7 +3,6 @@
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
 
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(associated_type_defaults)]
 #![feature(closure_track_caller)]
 #![feature(const_default)]
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index c0abcc3a6119a..1cd9d008194fc 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -56,7 +56,6 @@ This API is completely unstable and subject to change.
 */
 
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(bootstrap, feature(unwrap_infallible))]
 #![feature(default_field_values)]
 #![feature(gen_blocks)]
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 474a390171514..5efb2775c77fe 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -1,6 +1,4 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(never_type))]
-#![cfg_attr(bootstrap, feature(trim_prefix_suffix))]
 #![feature(deref_patterns)]
 #![feature(iter_intersperse)]
 #![feature(iter_order_by)]
diff --git a/compiler/rustc_lint_defs/src/builtin.rs b/compiler/rustc_lint_defs/src/builtin.rs
index 2a0901e0243b6..a722f0e103ea1 100644
--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@@ -2825,8 +2825,7 @@ declare_lint! {
     ///
     /// ### Example
     ///
-    #[cfg_attr(bootstrap, doc = "```rust,ignore")]
-    #[cfg_attr(not(bootstrap), doc = "```rust,compile_fail")]
+    /// ```rust,compile_fail
     /// #![feature(staged_api)]
     /// #![stable(feature = "test", since = "1.0.0")]
     ///
@@ -2837,9 +2836,9 @@ declare_lint! {
     /// pub use self::S as T;
     ///
     /// fn main() {}
-    #[doc = "```"]
+    /// ```
     ///
-    #[cfg_attr(not(bootstrap), doc = "{{produces}}")]
+    /// {{produces}}
     ///
     /// ### Explanation
     ///
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs
index b522fa00872de..fb918c2fba487 100644
--- a/compiler/rustc_macros/src/lib.rs
+++ b/compiler/rustc_macros/src/lib.rs
@@ -3,7 +3,6 @@
     rustc::default_hash_types,
     reason = "we like performance but can't use `rustc_data_structures`"
 )]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![deny(
     rustc::potential_query_instability,
     reason = "macros shall produce deterministic output/errors"
diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs
index dd963fc8773c7..1706fece29a8b 100644
--- a/compiler/rustc_metadata/src/lib.rs
+++ b/compiler/rustc_metadata/src/lib.rs
@@ -1,6 +1,5 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(error_iter)]
 #![feature(file_buffered)]
 #![feature(gen_blocks)]
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index 7dd920c7e39bd..5348ee0ccaac1 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -1544,10 +1544,12 @@ impl CrateMetadata {
 
     fn get_proc_macro_quoted_span(&self, tcx: TyCtxt<'_>, index: usize) -> Span {
         self.root
-            .tables
+            .proc_macro_data
+            .as_ref()
+            .expect("missing proc macro data")
             .proc_macro_quoted_spans
             .get(self, index)
-            .unwrap_or_else(|| panic!("Missing proc macro quoted span: {index:?}"))
+            .unwrap_or_else(|| panic!("missing proc macro quoted span: {index:?}"))
             .decode((self, tcx))
     }
 
diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index 40b61a52d2310..03493d0e1b6a9 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -404,35 +404,42 @@ impl<'a, 'tcx> TyEncoder<'tcx> for EncodeContext<'a, 'tcx> {
 
 // Shorthand for `$self.$tables.$table.set_some($def_id.index, $self.lazy($value))`, which would
 // normally need extra variables to avoid errors about multiple mutable borrows.
-macro_rules! record {
+// Also those macros greatly simplify refactorings and modifications of writing to tables.
+macro_rules! record_some_lazy {
     ($self:ident.$tables:ident.$table:ident[$def_id:expr] <- $value:expr) => {{
-        {
-            let value = $value;
-            let lazy = $self.lazy(value);
-            $self.$tables.$table.set_some($def_id.index, lazy);
-        }
+        let value = $value;
+        let lazy = $self.lazy(value);
+        $self.$tables.$table.set_some($def_id.index, lazy);
     }};
 }
 
+macro_rules! record_some {
+    ($self:ident.$tables:ident.$table:ident[$def_id:expr] <- $value:expr) => {
+        $self.$tables.$table.set_some($def_id.index, $value)
+    };
+}
+
+macro_rules! record_value {
+    ($self:ident.$tables:ident.$table:ident[$def_id:expr] <- $value:expr) => {
+        $self.$tables.$table.set($def_id.index, $value)
+    };
+}
+
 // Shorthand for `$self.$tables.$table.set_some($def_id.index, $self.lazy_array($value))`, which would
 // normally need extra variables to avoid errors about multiple mutable borrows.
 macro_rules! record_array {
     ($self:ident.$tables:ident.$table:ident[$def_id:expr] <- $value:expr) => {{
-        {
-            let value = $value;
-            let lazy = $self.lazy_array(value);
-            $self.$tables.$table.set_some($def_id.index, lazy);
-        }
+        let value = $value;
+        let lazy = $self.lazy_array(value);
+        $self.$tables.$table.set_some($def_id.index, lazy);
     }};
 }
 
 macro_rules! record_defaulted_array {
     ($self:ident.$tables:ident.$table:ident[$def_id:expr] <- $value:expr) => {{
-        {
-            let value = $value;
-            let lazy = $self.lazy_array(value);
-            $self.$tables.$table.set($def_id.index, lazy);
-        }
+        let value = $value;
+        let lazy = $self.lazy_array(value);
+        $self.$tables.$table.set($def_id.index, lazy);
     }};
 }
 
@@ -527,18 +534,18 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             for def_id in std::iter::once(CRATE_DEF_ID)
                 .chain(self.tcx.resolutions(()).proc_macros.iter().copied())
             {
-                let def_key = self.lazy(defs.def_key(def_id));
+                let def_key = defs.def_key(def_id);
                 let def_path_hash = defs.def_path_hash(def_id);
-                self.tables.def_keys.set_some(def_id.local_def_index, def_key);
-                self.tables
-                    .def_path_hashes
-                    .set(def_id.local_def_index, def_path_hash.local_hash().as_u64());
+                let def_id = def_id.to_def_id();
+
+                record_some_lazy!(self.tables.def_keys[def_id] <- def_key);
+                record_value!(self.tables.def_path_hashes[def_id] <- def_path_hash.local_hash().as_u64())
             }
         } else {
             for (def_index, def_key, def_path_hash) in defs.enumerated_keys_and_path_hashes() {
-                let def_key = self.lazy(def_key);
-                self.tables.def_keys.set_some(def_index, def_key);
-                self.tables.def_path_hashes.set(def_index, def_path_hash.local_hash().as_u64());
+                let def_id = LocalDefId { local_def_index: def_index }.to_def_id();
+                record_some_lazy!(self.tables.def_keys[def_id] <- def_key);
+                record_value!(self.tables.def_path_hashes[def_id] <- def_path_hash.local_hash().as_u64())
             }
         }
     }
@@ -1444,7 +1451,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         if state.is_doc_hidden {
             attr_flags |= AttrFlags::IS_DOC_HIDDEN;
         }
-        self.tables.attr_flags.set(def_id.local_def_index, attr_flags);
+
+        record_value!(self.tables.attr_flags[def_id.to_def_id()] <- attr_flags)
     }
 
     fn encode_def_ids(&mut self) {
@@ -1461,7 +1469,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         for local_id in tcx.iter_local_def_id() {
             let def_id = local_id.to_def_id();
             let def_kind = tcx.def_kind(local_id);
-            self.tables.def_kind.set_some(def_id.index, def_kind);
+            record_some!(self.tables.def_kind[def_id] <- def_kind);
 
             // The `DefCollector` will sometimes create unnecessary `DefId`s
             // for trivial const arguments which are directly lowered to
@@ -1482,33 +1490,33 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 && let hir::Node::Field(field) = tcx.hir_node_by_def_id(local_id)
                 && let Some(anon) = field.default
             {
-                record!(self.tables.default_fields[def_id] <- anon.def_id.to_def_id());
+                record_some_lazy!(self.tables.default_fields[def_id] <- anon.def_id.to_def_id());
             }
 
             if should_encode_span(def_kind) {
                 let def_span = tcx.def_span(local_id);
-                record!(self.tables.def_span[def_id] <- def_span);
+                record_some_lazy!(self.tables.def_span[def_id] <- def_span);
             }
             if should_encode_attrs(def_kind) {
                 self.encode_attrs(local_id);
             }
             if should_encode_expn_that_defined(def_kind) {
-                record!(self.tables.expn_that_defined[def_id] <- self.tcx.expn_that_defined(def_id));
+                record_some_lazy!(self.tables.expn_that_defined[def_id] <- self.tcx.expn_that_defined(def_id));
             }
             if should_encode_span(def_kind)
                 && let Some(ident_span) = tcx.def_ident_span(def_id)
             {
-                record!(self.tables.def_ident_span[def_id] <- ident_span);
+                record_some_lazy!(self.tables.def_ident_span[def_id] <- ident_span);
             }
             if def_kind.has_codegen_attrs() {
-                record!(self.tables.codegen_fn_attrs[def_id] <- self.tcx.codegen_fn_attrs(def_id));
+                record_some_lazy!(self.tables.codegen_fn_attrs[def_id] <- self.tcx.codegen_fn_attrs(def_id));
             }
             if should_encode_visibility(def_kind) {
                 let vis = self
                     .tcx
                     .local_visibility(local_id)
                     .map_id(|mod_id| mod_id.to_local_def_id().local_def_index);
-                record!(self.tables.visibility[def_id] <- vis);
+                record_some_lazy!(self.tables.visibility[def_id] <- vis);
             }
             if should_encode_stability(def_kind) {
                 self.encode_stability(def_id);
@@ -1521,46 +1529,46 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 record_array!(self.tables.variances_of[def_id] <- v);
             }
             if should_encode_fn_sig(def_kind) {
-                record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id));
+                record_some_lazy!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id));
             }
             if should_encode_generics(def_kind) {
                 let g = tcx.generics_of(def_id);
-                record!(self.tables.generics_of[def_id] <- g);
-                record!(self.tables.explicit_clauses_of[def_id] <- self.tcx.explicit_clauses_of(def_id));
+                record_some_lazy!(self.tables.generics_of[def_id] <- g);
+                record_some_lazy!(self.tables.explicit_clauses_of[def_id] <- self.tcx.explicit_clauses_of(def_id));
                 let inferred_outlives = self.tcx.inferred_outlives_of(def_id);
                 record_defaulted_array!(self.tables.inferred_outlives_of[def_id] <- inferred_outlives);
 
                 for param in &g.own_params {
                     if let ty::GenericParamDefKind::Const { has_default: true, .. } = param.kind {
                         let default = self.tcx.const_param_default(param.def_id);
-                        record!(self.tables.const_param_default[param.def_id] <- default);
+                        record_some_lazy!(self.tables.const_param_default[param.def_id] <- default);
                     }
                 }
             }
             if tcx.is_conditionally_const(def_id) {
-                record!(self.tables.const_conditions[def_id] <- self.tcx.const_conditions(def_id));
+                record_some_lazy!(self.tables.const_conditions[def_id] <- self.tcx.const_conditions(def_id));
             }
             if should_encode_type(tcx, local_id, def_kind) {
-                record!(self.tables.type_of[def_id] <- self.tcx.type_of(def_id));
+                record_some_lazy!(self.tables.type_of[def_id] <- self.tcx.type_of(def_id));
             }
             if should_encode_constness(def_kind) {
                 let constness = self.tcx.constness(def_id);
-                self.tables.constness.set(def_id.index, constness);
+                record_value!(self.tables.constness[def_id] <- constness)
             }
             if let DefKind::Fn | DefKind::AssocFn = def_kind {
                 let asyncness = tcx.asyncness(def_id);
-                self.tables.asyncness.set(def_id.index, asyncness);
+                record_value!(self.tables.asyncness[def_id] <- asyncness);
                 record_array!(self.tables.fn_arg_idents[def_id] <- tcx.fn_arg_idents(def_id));
             }
             if let Some(name) = tcx.intrinsic(def_id) {
-                record!(self.tables.intrinsic[def_id] <- name);
+                record_some_lazy!(self.tables.intrinsic[def_id] <- name);
             }
             if let DefKind::TyParam | DefKind::Trait = def_kind {
                 let default = self.tcx.object_lifetime_default(def_id);
-                record!(self.tables.object_lifetime_default[def_id] <- default);
+                record_some_lazy!(self.tables.object_lifetime_default[def_id] <- default);
             }
             if let DefKind::Trait = def_kind {
-                record!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id));
+                record_some_lazy!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id));
                 record_defaulted_array!(self.tables.explicit_super_clauses_of[def_id] <-
                     self.tcx.explicit_super_clauses_of(def_id).skip_binder());
                 record_defaulted_array!(self.tables.explicit_implied_clauses_of[def_id] <-
@@ -1574,7 +1582,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 }
             }
             if let DefKind::TraitAlias = def_kind {
-                record!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id));
+                record_some_lazy!(self.tables.trait_def[def_id] <- self.tcx.trait_def(def_id));
                 record_defaulted_array!(self.tables.explicit_super_clauses_of[def_id] <-
                     self.tcx.explicit_super_clauses_of(def_id).skip_binder());
                 record_defaulted_array!(self.tables.explicit_implied_clauses_of[def_id] <-
@@ -1595,28 +1603,28 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             if let DefKind::Closure | DefKind::SyntheticCoroutineBody = def_kind
                 && let Some(coroutine_kind) = self.tcx.coroutine_kind(def_id)
             {
-                self.tables.coroutine_kind.set(def_id.index, Some(coroutine_kind))
+                record_value!(self.tables.coroutine_kind[def_id] <- Some(coroutine_kind))
             }
             if def_kind == DefKind::Closure
                 && tcx.type_of(def_id).skip_binder().is_coroutine_closure()
             {
                 let coroutine_for_closure = self.tcx.coroutine_for_closure(def_id);
-                self.tables
-                    .coroutine_for_closure
-                    .set_some(def_id.index, coroutine_for_closure.into());
+                record_some!(self.tables.coroutine_for_closure[def_id] <- coroutine_for_closure.into());
 
                 // If this async closure has a by-move body, record it too.
                 if tcx.needs_coroutine_by_move_body_def_id(coroutine_for_closure) {
-                    self.tables.coroutine_by_move_body_def_id.set_some(
-                        coroutine_for_closure.index,
-                        self.tcx.coroutine_by_move_body_def_id(coroutine_for_closure).into(),
-                    );
+                    let id = self.tcx.coroutine_by_move_body_def_id(coroutine_for_closure);
+                    record_some!(
+                        self.tables.coroutine_by_move_body_def_id[coroutine_for_closure] <- id.into()
+                    )
                 }
             }
             if let DefKind::Static { .. } = def_kind {
                 if !self.tcx.is_foreign_item(def_id) {
                     match self.tcx.eval_static_initializer(def_id) {
-                        Ok(data) => record!(self.tables.eval_static_initializer[def_id] <- data),
+                        Ok(data) => {
+                            record_some_lazy!(self.tables.eval_static_initializer[def_id] <- data)
+                        }
                         Err(err) => match err {
                             interpret::ErrorHandled::Reported(_, _) => {
                                 self.tcx.dcx().delayed_bug(format!(
@@ -1640,50 +1648,49 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 self.encode_info_for_macro(local_id);
             }
             if let DefKind::TyAlias = def_kind {
-                self.tables
-                    .type_alias_is_checked
-                    .set(def_id.index, self.tcx.type_alias_is_checked(def_id));
+                record_value!(self.tables.type_alias_is_checked[def_id] <- self.tcx.type_alias_is_checked(def_id));
+
                 if self.tcx.type_alias_is_checked(def_id) {
-                    record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id));
+                    record_some_lazy!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id));
                 }
             }
             if let DefKind::OpaqueTy = def_kind {
                 self.encode_explicit_item_bounds(def_id);
                 self.encode_explicit_item_self_bounds(def_id);
-                record!(self.tables.opaque_ty_origin[def_id] <- self.tcx.opaque_ty_origin(def_id));
+                record_some_lazy!(self.tables.opaque_ty_origin[def_id] <- self.tcx.opaque_ty_origin(def_id));
                 self.encode_precise_capturing_args(def_id);
                 if tcx.is_conditionally_const(def_id) {
                     record_defaulted_array!(self.tables.explicit_implied_const_bounds[def_id]
                         <- tcx.explicit_implied_const_bounds(def_id).skip_binder());
                 }
-                record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id));
+                record_some_lazy!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id));
             }
             if let DefKind::AssocTy = def_kind {
                 let assoc_item = tcx.associated_item(def_id);
                 match assoc_item.container {
                     ty::AssocContainer::Trait => {
-                        record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id));
+                        record_some_lazy!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id));
                     }
                     ty::AssocContainer::InherentImpl => {
-                        record!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id));
+                        record_some_lazy!(self.tables.args_known_to_outlive_alias_params[def_id] <- tcx.args_known_to_outlive_alias_params(def_id));
                     }
                     ty::AssocContainer::TraitImpl(_) => {}
                 }
             }
             if let DefKind::AnonConst = def_kind {
-                record!(self.tables.anon_const_kind[def_id] <- self.tcx.anon_const_kind(def_id));
+                record_some_lazy!(self.tables.anon_const_kind[def_id] <- self.tcx.anon_const_kind(def_id));
             }
             if let DefKind::Const | DefKind::AssocConst = def_kind {
-                record!(self.tables.const_of_item[def_id] <- self.tcx.const_of_item(def_id));
+                record_some_lazy!(self.tables.const_of_item[def_id] <- self.tcx.const_of_item(def_id));
             }
             if tcx.impl_method_has_trait_impl_trait_tys(def_id)
                 && let Ok(table) = self.tcx.collect_return_position_impl_trait_in_trait_tys(def_id)
             {
-                record!(self.tables.collect_return_position_impl_trait_in_trait_tys[def_id] <- table);
+                record_some_lazy!(self.tables.collect_return_position_impl_trait_in_trait_tys[def_id] <- table);
             }
             if let DefKind::Impl { .. } | DefKind::Trait = def_kind {
                 let table = tcx.associated_types_for_impl_traits_in_trait_or_impl(def_id);
-                record!(self.tables.associated_types_for_impl_traits_in_trait_or_impl[def_id] <- table);
+                record_some_lazy!(self.tables.associated_types_for_impl_traits_in_trait_or_impl[def_id] <- table);
             }
         }
 
@@ -1695,7 +1702,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         }
 
         for (def_id, res_map) in &tcx.resolutions(()).doc_link_resolutions {
-            record!(self.tables.doc_link_resolutions[def_id.to_def_id()] <- res_map);
+            record_some_lazy!(self.tables.doc_link_resolutions[def_id.to_def_id()] <- res_map);
         }
 
         for (def_id, traits) in &tcx.resolutions(()).doc_link_traits_in_scope {
@@ -1722,10 +1729,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         let def_id = local_def_id.to_def_id();
         let tcx = self.tcx;
         let adt_def = tcx.adt_def(def_id);
-        record!(self.tables.repr_options[def_id] <- adt_def.repr());
+        record_some_lazy!(self.tables.repr_options[def_id] <- adt_def.repr());
 
         let params_in_repr = self.tcx.params_in_repr(def_id);
-        record!(self.tables.params_in_repr[def_id] <- params_in_repr);
+        record_some_lazy!(self.tables.params_in_repr[def_id] <- params_in_repr);
 
         if adt_def.is_enum() {
             let module_children = tcx.module_children_local(local_def_id);
@@ -1745,7 +1752,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 ctor: variant.ctor.map(|(kind, def_id)| (kind, def_id.index)),
                 is_non_exhaustive: variant.is_field_list_non_exhaustive(),
             };
-            record!(self.tables.variant_data[variant.def_id] <- data);
+            record_some_lazy!(self.tables.variant_data[variant.def_id] <- data);
 
             record_array!(self.tables.associated_item_or_field_def_ids[variant.def_id] <- variant.fields.iter().map(|f| {
                 assert!(f.did.is_local());
@@ -1753,8 +1760,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             }));
 
             for field in &variant.fields {
-                self.tables.safety.set(field.did.index, field.safety);
-                record!(
+                record_value!(self.tables.safety[field.did] <- field.safety);
+                record_some_lazy!(
                     self.tables.mut_restriction[field.did] <- field.mut_restriction
                 );
             }
@@ -1762,16 +1769,16 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             if let Some((CtorKind::Fn, ctor_def_id)) = variant.ctor {
                 let fn_sig = tcx.fn_sig(ctor_def_id);
                 // FIXME only encode signature for ctor_def_id
-                record!(self.tables.fn_sig[variant.def_id] <- fn_sig);
+                record_some_lazy!(self.tables.fn_sig[variant.def_id] <- fn_sig);
             }
         }
 
         if let Some(destructor) = tcx.adt_destructor(local_def_id) {
-            record!(self.tables.adt_destructor[def_id] <- destructor);
+            record_some_lazy!(self.tables.adt_destructor[def_id] <- destructor);
         }
 
         if let Some(destructor) = tcx.adt_async_destructor(local_def_id) {
-            record!(self.tables.adt_async_destructor[def_id] <- destructor);
+            record_some_lazy!(self.tables.adt_async_destructor[def_id] <- destructor);
         }
     }
 
@@ -1787,7 +1794,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // items - we encode information about proc-macros later on.
         if self.is_proc_macro {
             // Encode this here because we don't do it in encode_def_ids.
-            record!(self.tables.expn_that_defined[def_id] <- tcx.expn_that_defined(local_def_id));
+            record_some_lazy!(self.tables.expn_that_defined[def_id] <- tcx.expn_that_defined(local_def_id));
         } else {
             let module_children = tcx.module_children_local(local_def_id);
 
@@ -1826,10 +1833,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         let item = tcx.associated_item(def_id);
 
         if matches!(item.container, AssocContainer::Trait | AssocContainer::TraitImpl(_)) {
-            self.tables.defaultness.set(def_id.index, item.defaultness(tcx));
+            record_value!(self.tables.defaultness[def_id] <- item.defaultness(tcx));
         }
 
-        record!(self.tables.assoc_container[def_id] <- item.container);
+        record_some_lazy!(self.tables.assoc_container[def_id] <- item.container);
 
         if let AssocContainer::Trait = item.container
             && item.is_type()
@@ -1842,7 +1849,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             }
         }
         if let ty::AssocKind::Type { data: ty::AssocTypeData::Rpitit(rpitit_info) } = item.kind {
-            record!(self.tables.opt_rpitit_info[def_id] <- rpitit_info);
+            record_some_lazy!(self.tables.opt_rpitit_info[def_id] <- rpitit_info);
             if matches!(rpitit_info, ty::ImplTraitInTraitData::Trait { .. }) {
                 record_array!(
                     self.tables.assumed_wf_types_for_rpitit[def_id]
@@ -1878,53 +1885,53 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
             debug!("EntryBuilder::encode_mir({:?})", def_id);
             if encode_opt {
-                record!(self.tables.optimized_mir[def_id.to_def_id()] <- tcx.optimized_mir(def_id));
-                self.tables
-                    .cross_crate_inlinable
-                    .set(def_id.to_def_id().index, self.tcx.cross_crate_inlinable(def_id));
-                record!(self.tables.closure_saved_names_of_captured_variables[def_id.to_def_id()]
+                record_some_lazy!(self.tables.optimized_mir[def_id.to_def_id()] <- tcx.optimized_mir(def_id));
+
+                record_value!(self.tables.cross_crate_inlinable[def_id.to_def_id()] <- self.tcx.cross_crate_inlinable(def_id));
+
+                record_some_lazy!(self.tables.closure_saved_names_of_captured_variables[def_id.to_def_id()]
                     <- tcx.closure_saved_names_of_captured_variables(def_id));
 
                 if self.tcx.is_coroutine(def_id.to_def_id())
                     && let Some(witnesses) = tcx.mir_coroutine_witnesses(def_id)
                 {
-                    record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses);
+                    record_some_lazy!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses);
                 }
             }
             let mut is_trivial = false;
             if encode_const {
                 if let Some((val, ty)) = tcx.trivial_const(def_id) {
                     is_trivial = true;
-                    record!(self.tables.trivial_const[def_id.to_def_id()] <- (val, ty));
+                    record_some_lazy!(self.tables.trivial_const[def_id.to_def_id()] <- (val, ty));
                 } else {
                     is_trivial = false;
-                    record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id));
+                    record_some_lazy!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id));
                 }
 
                 // FIXME(generic_const_exprs): this feels wrong to have in `encode_mir`
                 let abstract_const = tcx.thir_abstract_const(def_id);
                 if let Ok(Some(abstract_const)) = abstract_const {
-                    record!(self.tables.thir_abstract_const[def_id.to_def_id()] <- abstract_const);
+                    record_some_lazy!(self.tables.thir_abstract_const[def_id.to_def_id()] <- abstract_const);
                 }
 
                 if should_encode_const(tcx.def_kind(def_id)) {
                     let qualifs = tcx.mir_const_qualif(def_id);
-                    record!(self.tables.mir_const_qualif[def_id.to_def_id()] <- qualifs);
+                    record_some_lazy!(self.tables.mir_const_qualif[def_id.to_def_id()] <- qualifs);
                     let body = tcx.hir_maybe_body_owned_by(def_id);
                     if let Some(body) = body {
                         let const_data = rendered_const(self.tcx, &body, def_id);
-                        record!(self.tables.rendered_const[def_id.to_def_id()] <- const_data);
+                        record_some_lazy!(self.tables.rendered_const[def_id.to_def_id()] <- const_data);
                     }
                 }
             }
             if !is_trivial {
-                record!(self.tables.promoted_mir[def_id.to_def_id()] <- tcx.promoted_mir(def_id));
+                record_some_lazy!(self.tables.promoted_mir[def_id.to_def_id()] <- tcx.promoted_mir(def_id));
             }
 
             if self.tcx.is_coroutine(def_id.to_def_id())
                 && let Some(witnesses) = tcx.mir_coroutine_witnesses(def_id)
             {
-                record!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses);
+                record_some_lazy!(self.tables.mir_coroutine_witnesses[def_id.to_def_id()] <- witnesses);
             }
         }
 
@@ -1950,7 +1957,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // the stability attributes are even enabled before using their queries.
         if self.feat.staged_api() || self.tcx.sess.opts.unstable_opts.force_unstable_if_unmarked {
             if let Some(stab) = self.tcx.lookup_stability(def_id) {
-                record!(self.tables.lookup_stability[def_id] <- stab)
+                record_some_lazy!(self.tables.lookup_stability[def_id] <- stab)
             }
         }
     }
@@ -1961,7 +1968,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // the stability attributes are even enabled before using their queries.
         if self.feat.staged_api() || self.tcx.sess.opts.unstable_opts.force_unstable_if_unmarked {
             if let Some(stab) = self.tcx.lookup_const_stability(def_id) {
-                record!(self.tables.lookup_const_stability[def_id] <- stab)
+                record_some_lazy!(self.tables.lookup_const_stability[def_id] <- stab)
             }
         }
     }
@@ -1972,7 +1979,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // the stability attributes are even enabled before using their queries.
         if self.feat.staged_api() || self.tcx.sess.opts.unstable_opts.force_unstable_if_unmarked {
             if let Some(stab) = self.tcx.lookup_default_body_stability(def_id) {
-                record!(self.tables.lookup_default_body_stability[def_id] <- stab)
+                record_some_lazy!(self.tables.lookup_default_body_stability[def_id] <- stab)
             }
         }
     }
@@ -1980,7 +1987,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
     #[instrument(level = "debug", skip(self))]
     fn encode_deprecation(&mut self, def_id: DefId) {
         if let Some(depr) = self.tcx.lookup_deprecation(def_id) {
-            record!(self.tables.lookup_deprecation_entry[def_id] <- depr);
+            record_some_lazy!(self.tables.lookup_deprecation_entry[def_id] <- depr);
         }
     }
 
@@ -1989,8 +1996,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         let tcx = self.tcx;
 
         let (_, macro_def, _) = tcx.hir_expect_item(def_id).expect_macro();
-        self.tables.is_macro_rules.set(def_id.local_def_index, macro_def.macro_rules);
-        record!(self.tables.macro_definition[def_id.to_def_id()] <- &*macro_def.body);
+        record_value!(self.tables.is_macro_rules[def_id.to_def_id()] <- macro_def.macro_rules);
+        record_some_lazy!(self.tables.macro_definition[def_id.to_def_id()] <- &*macro_def.body);
     }
 
     fn encode_native_libraries(&mut self) -> LazyArray<NativeLib> {
@@ -2039,24 +2046,20 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             let tcx = self.tcx;
             let proc_macro_decls_static = tcx.proc_macro_decls_static(()).unwrap().local_def_index;
             let stability = tcx.lookup_stability(CRATE_DEF_ID);
-            for (i, span) in self.tcx.sess.proc_macro_quoted_spans() {
-                let span = self.lazy(span);
-                self.tables.proc_macro_quoted_spans.set_some(i, span);
-            }
 
-            self.tables.def_kind.set_some(LOCAL_CRATE.as_def_id().index, DefKind::Mod);
-            record!(self.tables.def_span[LOCAL_CRATE.as_def_id()] <- tcx.def_span(LOCAL_CRATE.as_def_id()));
+            record_some!(self.tables.def_kind[LOCAL_CRATE.as_def_id()] <- DefKind::Mod);
+            record_some_lazy!(self.tables.def_span[LOCAL_CRATE.as_def_id()] <- tcx.def_span(LOCAL_CRATE.as_def_id()));
             self.encode_attrs(LOCAL_CRATE.as_def_id().expect_local());
             let vis = tcx
                 .local_visibility(CRATE_DEF_ID)
                 .map_id(|mod_id| mod_id.to_local_def_id().local_def_index);
-            record!(self.tables.visibility[LOCAL_CRATE.as_def_id()] <- vis);
+            record_some_lazy!(self.tables.visibility[LOCAL_CRATE.as_def_id()] <- vis);
             if let Some(stability) = stability {
-                record!(self.tables.lookup_stability[LOCAL_CRATE.as_def_id()] <- stability);
+                record_some_lazy!(self.tables.lookup_stability[LOCAL_CRATE.as_def_id()] <- stability);
             }
             self.encode_deprecation(LOCAL_CRATE.as_def_id());
             if let Some(res_map) = tcx.resolutions(()).doc_link_resolutions.get(&CRATE_MOD_ID) {
-                record!(self.tables.doc_link_resolutions[LOCAL_CRATE.as_def_id()] <- res_map);
+                record_some_lazy!(self.tables.doc_link_resolutions[LOCAL_CRATE.as_def_id()] <- res_map);
             }
             if let Some(traits) = tcx.resolutions(()).doc_link_traits_in_scope.get(&CRATE_MOD_ID) {
                 record_array!(self.tables.doc_link_traits_in_scope[LOCAL_CRATE.as_def_id()] <- traits);
@@ -2103,20 +2106,33 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 def_key.disambiguated_data.data = DefPathData::MacroNs(name);
 
                 let def_id = id.to_def_id();
-                self.tables.def_kind.set_some(def_id.index, DefKind::Macro(macro_kind.into()));
+                record_some!(self.tables.def_kind[def_id] <- DefKind::Macro(macro_kind.into()));
+
                 self.encode_attrs(id);
-                record!(self.tables.def_keys[def_id] <- def_key);
-                record!(self.tables.def_ident_span[def_id] <- span);
-                record!(self.tables.def_span[def_id] <- span);
-                record!(self.tables.visibility[def_id] <- ty::Visibility::Public);
+                record_some_lazy!(self.tables.def_keys[def_id] <- def_key);
+                record_some_lazy!(self.tables.def_ident_span[def_id] <- span);
+                record_some_lazy!(self.tables.def_span[def_id] <- span);
+                record_some_lazy!(self.tables.visibility[def_id] <- ty::Visibility::Public);
                 if let Some(stability) = stability {
-                    record!(self.tables.lookup_stability[def_id] <- stability);
+                    record_some_lazy!(self.tables.lookup_stability[def_id] <- stability);
                 }
             }
 
             let macros = self.lazy_array(macros);
 
-            Some(ProcMacroData { proc_macro_decls_static, stability, macros })
+            let mut proc_macro_quoted_spans = TableBuilder::default();
+            for (i, span) in self.tcx.sess.proc_macro_quoted_spans() {
+                proc_macro_quoted_spans.set_some(i, self.lazy(span));
+            }
+
+            let proc_macro_quoted_spans = proc_macro_quoted_spans.encode(&mut self.opaque);
+
+            Some(ProcMacroData {
+                proc_macro_decls_static,
+                stability,
+                macros,
+                proc_macro_quoted_spans,
+            })
         } else {
             None
         }
@@ -2263,15 +2279,13 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
             if of_trait {
                 let header = tcx.impl_trait_header(def_id);
-                record!(self.tables.impl_trait_header[def_id] <- header);
+                record_some_lazy!(self.tables.impl_trait_header[def_id] <- header);
 
                 let impl_is_fully_generic_for_reflection =
                     tcx.impl_is_fully_generic_for_reflection(def_id);
-                self.tables
-                    .impl_is_fully_generic_for_reflection
-                    .set(def_id.index, impl_is_fully_generic_for_reflection);
 
-                self.tables.defaultness.set(def_id.index, tcx.defaultness(def_id));
+                record_value!(self.tables.impl_is_fully_generic_for_reflection[def_id] <- impl_is_fully_generic_for_reflection);
+                record_value!(self.tables.defaultness[def_id] <- tcx.defaultness(def_id));
 
                 let trait_ref = header.trait_ref.instantiate_identity().skip_norm_wip();
                 let simplified_self_ty = fast_reject::simplify_type(
@@ -2288,14 +2302,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 if let Ok(mut an) = trait_def.ancestors(tcx, def_id)
                     && let Some(specialization_graph::Node::Impl(parent)) = an.nth(1)
                 {
-                    self.tables.impl_parent.set_some(def_id.index, parent.into());
+                    record_some!(self.tables.impl_parent[def_id] <- parent.into());
                 }
 
                 // if this is an impl of `CoerceUnsized`, create its
                 // "unsized info", else just store None
                 if tcx.is_lang_item(trait_ref.def_id, LangItem::CoerceUnsized) {
                     let coerce_unsized_info = tcx.coerce_unsized_info(def_id).unwrap();
-                    record!(self.tables.coerce_unsized_info[def_id] <- coerce_unsized_info);
+                    record_some_lazy!(self.tables.coerce_unsized_info[def_id] <- coerce_unsized_info);
                 }
             }
         }
diff --git a/compiler/rustc_metadata/src/rmeta/mod.rs b/compiler/rustc_metadata/src/rmeta/mod.rs
index b70151604f679..f7a437043dade 100644
--- a/compiler/rustc_metadata/src/rmeta/mod.rs
+++ b/compiler/rustc_metadata/src/rmeta/mod.rs
@@ -214,6 +214,7 @@ pub(crate) struct ProcMacroData {
     proc_macro_decls_static: DefIndex,
     stability: Option<Stability>,
     macros: LazyArray<(DefIndex, LazyValue<ProcMacroKind>)>,
+    proc_macro_quoted_spans: LazyTableSingleIdx<usize, Option<LazyValue<Span>>>,
 }
 
 #[derive(MetadataEncodable, LazyDecodable)]
@@ -503,7 +504,6 @@ define_tables! {
     // `DefPathTable` up front, since we may only ever use a few
     // definitions from any given crate.
     def_keys: Table<DefIndex, LazyValue<DefKey>>,
-    proc_macro_quoted_spans: Table<usize, LazyValue<Span>>,
     variant_data: Table<DefIndex, LazyValue<VariantData>>,
     assoc_container: Table<DefIndex, LazyValue<ty::AssocContainer>>,
     macro_definition: Table<DefIndex, LazyValue<ast::DelimArgs>>,
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 5acf9e150bb5c..d964faa30b1f8 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -27,10 +27,8 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::direct_use_of_rustc_type_ir)]
-#![cfg_attr(bootstrap, feature(allocator_api))]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(doc, feature(intra_doc_pointers))]
-#![cfg_attr(not(bootstrap), feature(allocator_ext))]
+#![feature(allocator_ext)]
 #![feature(associated_type_defaults)]
 #![feature(closure_track_caller)]
 #![feature(const_default)]
diff --git a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
index 078a171491520..1133b87002450 100644
--- a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
+++ b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
@@ -5,7 +5,6 @@
 //!
 //! # Example
 //! ```rust
-#![cfg_attr(bootstrap, doc = "#![feature(never_type)]")]
 //! mod a {
 //!     pub mod b {
 //!         pub struct SecretlyUninhabited {
@@ -175,7 +174,6 @@ impl<'tcx> Ty<'tcx> {
     ///
     /// # Example
     /// ```
-    #[cfg_attr(bootstrap, doc = "#![feature(never_type)]")]
     /// # fn main() {}
     /// enum Void {}
     /// mod a {
diff --git a/compiler/rustc_mir_dataflow/src/lib.rs b/compiler/rustc_mir_dataflow/src/lib.rs
index 07e42459c7a99..8e320e0982077 100644
--- a/compiler/rustc_mir_dataflow/src/lib.rs
+++ b/compiler/rustc_mir_dataflow/src/lib.rs
@@ -1,5 +1,4 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(associated_type_defaults)]
 #![feature(deref_patterns)]
 #![feature(exact_size_is_empty)]
diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs
index 9547b5bb93dff..38021f4b76a4d 100644
--- a/compiler/rustc_mir_transform/src/inline.rs
+++ b/compiler/rustc_mir_transform/src/inline.rs
@@ -1161,7 +1161,7 @@ fn new_call_temp<'tcx>(
  * Integrates blocks from the callee function into the calling function.
  * Updates block indices, references to locals and other control flow
  * stuff.
-*/
+ */
 struct Integrator<'a, 'tcx> {
     args: &'a [Local],
     new_locals: RangeFrom<Local>,
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
index 43ce9634cc203..16df895b0f728 100644
--- a/compiler/rustc_monomorphize/src/partitioning.rs
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -1252,7 +1252,6 @@ fn collect_and_partition_mono_items(tcx: TyCtxt<'_>, (): ()) -> MonoItemPartitio
                         Linkage::WeakODR => "WeakODR",
                         Linkage::Internal => "Internal",
                         Linkage::ExternalWeak => "ExternalWeak",
-                        Linkage::Common => "Common",
                     };
 
                     output.push('[');
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index 40febd26806a6..044dc89978124 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -1501,7 +1501,12 @@ where
         alias_const: ty::AliasConst<I>,
     ) -> Result<Option<Const<I>>, NoSolutionOrRerunNonErased> {
         if self.typing_mode().is_erased_not_coherence() {
-            match self.opaque_accesses.rerun_always(RerunReason::EvaluateConst)? {}
+            let resolved = self.deeply_resolve_ignoring_regions(alias_const);
+            // FIXME: get rid of this once GCE is removed
+            let is_gce = self.cx().features().generic_const_exprs();
+            if resolved.has_opaque_types() || is_gce {
+                match self.opaque_accesses.rerun_always(RerunReason::EvaluateConst)? {}
+            }
         }
 
         self.delegate.evaluate_const(param_env, alias_const, |ty| self.normalize(param_env, ty))
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index ed5f6a83c06c1..bea48e553d236 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -203,9 +203,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
             AttributeKind::Naked(..) => self.check_naked(hir_id, target),
             AttributeKind::MayDangle(attr_span) => self.check_may_dangle(hir_id, *attr_span),
-            AttributeKind::MacroExport { span, .. } => {
-                self.check_macro_export(hir_id, *span, target)
-            }
             AttributeKind::RustcLegacyConstGenerics { attr_span, fn_indexes } => {
                 self.check_rustc_legacy_const_generics(item, *attr_span, fn_indexes)
             }
@@ -272,6 +269,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             AttributeKind::LinkSection { .. } => (),
             AttributeKind::LoopMatch(..) => (),
             AttributeKind::MacroEscape => (),
+            AttributeKind::MacroExport { .. } => (),
             AttributeKind::MacroUse { .. } => (),
             AttributeKind::Marker => (),
             AttributeKind::MoveSizeLimit { .. } => (),
@@ -1249,25 +1247,6 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_macro_export(&self, hir_id: HirId, attr_span: Span, target: Target) {
-        if target != Target::MacroDef {
-            return;
-        }
-
-        // special case when `#[macro_export]` is applied to a macro 2.0
-        let (_, macro_definition, _) = self.tcx.hir_node(hir_id).expect_item().expect_macro();
-        let is_decl_macro = !macro_definition.macro_rules;
-
-        if is_decl_macro {
-            self.tcx.emit_node_span_lint(
-                UNUSED_ATTRIBUTES,
-                hir_id,
-                attr_span,
-                diagnostics::MacroExport::OnDeclMacro,
-            );
-        }
-    }
-
     fn check_unused_attribute(&self, hir_id: HirId, attr: &Attribute) {
         // Warn on useless empty attributes.
         // FIXME(jdonszelmann): this lint should be moved to attribute parsing, see `AcceptContext::warn_empty_attribute`
diff --git a/compiler/rustc_passes/src/diagnostics.rs b/compiler/rustc_passes/src/diagnostics.rs
index e8e53a7bbfa1b..8e13cb6df15fe 100644
--- a/compiler/rustc_passes/src/diagnostics.rs
+++ b/compiler/rustc_passes/src/diagnostics.rs
@@ -199,13 +199,6 @@ pub(crate) struct RustcForceInlineCoro {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-pub(crate) enum MacroExport {
-    #[diag("`#[macro_export]` has no effect on declarative macro definitions")]
-    #[note("declarative macros follow the same exporting rules as regular items")]
-    OnDeclMacro,
-}
-
 #[derive(Subdiagnostic)]
 pub(crate) enum UnusedNote {
     #[note("attribute `{$name}` with an empty list has no effect")]
diff --git a/compiler/rustc_pattern_analysis/src/constructor.rs b/compiler/rustc_pattern_analysis/src/constructor.rs
index 6deec10071a16..0f636f323e5fd 100644
--- a/compiler/rustc_pattern_analysis/src/constructor.rs
+++ b/compiler/rustc_pattern_analysis/src/constructor.rs
@@ -114,7 +114,6 @@
 //!
 //! ```rust
 //! # #![feature(exhaustive_patterns)]
-#![cfg_attr(feature = "rustc", cfg_attr(bootstrap, doc = "#![feature(never_type)]"))]
 //! # let x = None::<!>;
 //! match x {
 //!   None => {}
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index ab595de3e39e7..1fe0fbdd2b6cd 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -4105,7 +4105,6 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     /// `Result<T, &!>` could look like:
     /// ```rust
     /// # #![feature(never_patterns)]
-    #[cfg_attr(bootstrap, doc = "#![feature(never_type)]")]
     /// # fn bar(_x: u32) {}
     /// let foo: Result<u32, &!> = Ok(0);
     /// match foo {
@@ -4171,7 +4170,6 @@ impl<'a, 'ast, 'ra, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     /// `Result<T, &!>` could look like:
     /// ```rust
     /// # #![feature(never_patterns)]
-    #[cfg_attr(bootstrap, doc = "#![feature(never_type)]")]
     /// # fn foo() -> Result<bool, &'static !> { Ok(true) }
     /// let (Ok(x) | Err(&!)) = foo();
     /// # let _ = x;
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index f4f0529698fa4..196a499d76baf 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -8,7 +8,6 @@
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
-#![cfg_attr(bootstrap, feature(trim_prefix_suffix))]
 #![feature(arbitrary_self_types)]
 #![feature(const_default)]
 #![feature(const_trait_impl)]
diff --git a/compiler/rustc_serialize/src/lib.rs b/compiler/rustc_serialize/src/lib.rs
index ae7c3854d00b4..364ae2a10a1e7 100644
--- a/compiler/rustc_serialize/src/lib.rs
+++ b/compiler/rustc_serialize/src/lib.rs
@@ -3,7 +3,6 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![allow(rustc::internal)]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
 #![feature(core_intrinsics)]
 #![feature(min_specialization)]
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 3debf3248ff80..a003f20e3512d 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -671,7 +671,6 @@ symbols! {
         cold_path,
         collapse_debuginfo,
         column,
-        common,
         compare_bytes,
         compare_exchange,
         compare_exchange_weak,
@@ -1176,7 +1175,6 @@ symbols! {
         integer_max,
         integer_min,
         integral,
-        internal,
         internal_eq_trait_method_impls,
         internal_features,
         interrupt,
diff --git a/compiler/rustc_trait_selection/src/diagnostics.rs b/compiler/rustc_trait_selection/src/diagnostics.rs
index d673b99d00d05..1b597583d53fc 100644
--- a/compiler/rustc_trait_selection/src/diagnostics.rs
+++ b/compiler/rustc_trait_selection/src/diagnostics.rs
@@ -1935,6 +1935,17 @@ pub fn impl_trait_overcapture_suggestion<'tcx>(
     fn_def_id: LocalDefId,
     captured_args: FxIndexSet<DefId>,
 ) -> Option<AddPreciseCapturingForOvercapture> {
+    let rpit_span = tcx.def_span(opaque_def_id);
+
+    // Every suggestion below is anchored on the opaque's span, so bail if that span is not one
+    // the user can edit. AST lowering marks it with the `impl Trait` desugaring, hence the
+    // question is about the span it desugared from: for an opaque created inside a macro
+    // expansion that span is the expansion site, which for an attribute macro is the attribute
+    // itself, where `+ use<..>` does not even parse.
+    if rpit_span.parent_callsite().is_some_and(|span| !span.can_be_used_for_suggestions()) {
+        return None;
+    }
+
     let generics = tcx.generics_of(fn_def_id);
 
     let mut captured_lifetimes = FxIndexSet::default();
@@ -2036,7 +2047,6 @@ pub fn impl_trait_overcapture_suggestion<'tcx>(
         _ => ("", ""),
     };
 
-    let rpit_span = tcx.def_span(opaque_def_id);
     if !lparen.is_empty() {
         suggs.push((rpit_span.shrink_to_lo(), lparen.to_string()));
     }
diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs
index a5cb7d0c7bb1a..9a3948f0ac440 100644
--- a/compiler/rustc_trait_selection/src/lib.rs
+++ b/compiler/rustc_trait_selection/src/lib.rs
@@ -11,7 +11,6 @@
 //! This API is completely unstable and subject to change.
 
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(bootstrap, feature(unwrap_infallible))]
 #![feature(associated_type_defaults)]
 #![feature(default_field_values)]
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 7d3c0a4a6c1f1..5e834c8c4059d 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -18,7 +18,7 @@ use self::derive_errors::*;
 use super::Certainty;
 use super::delegate::SolverDelegate;
 use crate::error_reporting::InferCtxtErrorExt;
-use crate::traits::{FulfillmentError, FulfillmentErrorCode, ScrubbedTraitError};
+use crate::traits::{FulfillmentError, ScrubbedTraitError};
 
 mod derive_errors;
 
@@ -157,8 +157,7 @@ where
             // the other case.
             TraitErrors::NoErrors
         } else {
-            let errors = collect_remaining_errors_impl(self, infcx);
-            TraitErrors::from_iter(errors.into_iter())
+            TraitErrors::HasErrors(collect_remaining_errors_impl(self, infcx))
         }
     }
 
@@ -367,26 +366,14 @@ where
     cx.obligations
         .pending
         .drain(..)
-        .filter_map(|(obligation, _)| {
-            try_ambiguity_error_for_stalled(infcx, obligation).map(NextSolverError::Ambiguity)
-        })
+        .map(|(obligation, _)| NextSolverError::Ambiguity(obligation))
         .map(|e| E::from_solver_error(infcx, e))
         .collect()
 }
 
-// We evaluate stalled obligations while collecting remaining errors because a
-// previously ambiguous goal may have become successful. In that case we emit a
-// delayed bug instead of producing a fulfillment error. Store the diagnostic
-// information here so error conversion does not reevaluate the goal.
-pub struct NextSolverAmbiguityError<'tcx> {
-    root_obligation: PredicateObligation<'tcx>,
-    code: FulfillmentErrorCode<'tcx>,
-    refine_obligation: bool,
-}
-
 pub enum NextSolverError<'tcx> {
     TrueError(PredicateObligation<'tcx>),
-    Ambiguity(NextSolverAmbiguityError<'tcx>),
+    Ambiguity(PredicateObligation<'tcx>),
 }
 
 impl<'tcx> FromSolverError<'tcx, NextSolverError<'tcx>> for FulfillmentError<'tcx> {
@@ -395,8 +382,8 @@ impl<'tcx> FromSolverError<'tcx, NextSolverError<'tcx>> for FulfillmentError<'tc
             NextSolverError::TrueError(obligation) => {
                 fulfillment_error_for_no_solution(infcx, obligation)
             }
-            NextSolverError::Ambiguity(ambiguity) => {
-                fulfillment_error_for_stalled(infcx, ambiguity)
+            NextSolverError::Ambiguity(obligation) => {
+                fulfillment_error_for_stalled(infcx, obligation)
             }
         }
     }
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs b/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
index 5ccd7ff7ef55b..7df3fa41a1df2 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
@@ -14,7 +14,6 @@ use rustc_next_trait_solver::solve::{GoalEvaluation, MaybeInfo, SolverDelegateEv
 use rustc_span::{bug, span_bug};
 use tracing::{instrument, trace};
 
-use super::NextSolverAmbiguityError;
 use crate::solve::delegate::SolverDelegate;
 use crate::solve::inspect::{self, InferCtxtProofTreeExt, ProofTreeVisitor};
 use crate::solve::{Certainty, deeply_normalize_for_diagnostics};
@@ -84,25 +83,10 @@ pub(super) fn fulfillment_error_for_no_solution<'tcx>(
 }
 
 pub(super) fn fulfillment_error_for_stalled<'tcx>(
-    infcx: &InferCtxt<'tcx>,
-    ambiguity: NextSolverAmbiguityError<'tcx>,
-) -> FulfillmentError<'tcx> {
-    let NextSolverAmbiguityError { root_obligation, code, refine_obligation } = ambiguity;
-
-    let obligation = if refine_obligation {
-        find_best_leaf_obligation(infcx, &root_obligation, true)
-    } else {
-        root_obligation.clone()
-    };
-
-    FulfillmentError { obligation, code, root_obligation }
-}
-
-pub(super) fn try_ambiguity_error_for_stalled<'tcx>(
     infcx: &InferCtxt<'tcx>,
     root_obligation: PredicateObligation<'tcx>,
-) -> Option<NextSolverAmbiguityError<'tcx>> {
-    let evaluation = infcx.probe(|_| {
+) -> FulfillmentError<'tcx> {
+    let (code, refine_obligation) = infcx.probe(|_| {
         match <&SolverDelegate<'tcx>>::from(infcx).evaluate_root_goal(
             root_obligation.as_goal(),
             root_obligation.cause.span,
@@ -116,7 +100,7 @@ pub(super) fn try_ambiguity_error_for_stalled<'tcx>(
                         stalled_on_coroutines: _,
                     }),
                 ..
-            }) => Some((FulfillmentErrorCode::Ambiguity { overflow: None }, true)),
+            }) => (FulfillmentErrorCode::Ambiguity { overflow: None }, true),
             Ok(GoalEvaluation {
                 certainty:
                     Certainty::Maybe(MaybeInfo {
@@ -126,7 +110,7 @@ pub(super) fn try_ambiguity_error_for_stalled<'tcx>(
                         stalled_on_coroutines: _,
                     }),
                 ..
-            }) => Some((
+            }) => (
                 FulfillmentErrorCode::Ambiguity { overflow: Some(suggest_increasing_limit) },
                 // Don't look into overflows because we treat overflows weirdly anyways.
                 // We discard the inference constraints from overflowing goals, so
@@ -135,17 +119,13 @@ pub(super) fn try_ambiguity_error_for_stalled<'tcx>(
                 //
                 // FIXME: We should probably just look into overflows here.
                 false,
-            )),
+            ),
             Ok(GoalEvaluation { certainty: Certainty::Yes, .. }) => {
-                infcx.dcx().span_delayed_bug(
-                    root_obligation.cause.span,
-                    format!(
-                        "did not expect successful goal when collecting ambiguity errors for `{:?}`",
-                        infcx.deeply_resolve_ignoring_regions(root_obligation.predicate),
-                    ),
-                );
-                None
-            },
+                // FIXME: We should ICE here. See the following links for details
+                // - <https://rust-lang.zulipchat.com/#narrow/channel/144729-t-types/topic/resolving.20equal.20regions/near/623484902>
+                // - <https://github.com/rust-lang/rust/issues/161669>
+                (FulfillmentErrorCode::Ambiguity { overflow: None }, false)
+            }
             Err(_) => {
                 span_bug!(
                     root_obligation.cause.span,
@@ -156,9 +136,15 @@ pub(super) fn try_ambiguity_error_for_stalled<'tcx>(
         }
     });
 
-    let (code, refine_obligation) = evaluation?;
-
-    Some(NextSolverAmbiguityError { root_obligation, code, refine_obligation })
+    FulfillmentError {
+        obligation: if refine_obligation {
+            find_best_leaf_obligation(infcx, &root_obligation, true)
+        } else {
+            root_obligation.clone()
+        },
+        code,
+        root_obligation,
+    }
 }
 
 #[instrument(level = "debug", skip(infcx), ret)]
diff --git a/compiler/rustc_transmute/src/lib.rs b/compiler/rustc_transmute/src/lib.rs
index cb5a76b51df1b..a7b07529f0bd1 100644
--- a/compiler/rustc_transmute/src/lib.rs
+++ b/compiler/rustc_transmute/src/lib.rs
@@ -7,7 +7,6 @@
 //! [`Condition`]s for the trait solver to discharge.
 
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(test, feature(test))]
 #![feature(option_into_flat_iter)]
 // tidy-alphabetical-end
diff --git a/compiler/rustc_ty_utils/src/lib.rs b/compiler/rustc_ty_utils/src/lib.rs
index ba37f7f72691a..2b4c17c5fb94c 100644
--- a/compiler/rustc_ty_utils/src/lib.rs
+++ b/compiler/rustc_ty_utils/src/lib.rs
@@ -5,7 +5,6 @@
 //! This API is completely unstable and subject to change.
 
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(deref_patterns)]
 #![feature(iterator_try_collect)]
 #![feature(option_into_flat_iter)]
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index b32e5e991cc74..a1071d2cde5f0 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -31,3 +31,7 @@ check-cfg = [
     'cfg(no_rc)',
     'cfg(no_sync)',
 ]
+
+[lints.cargo]
+# compiler-builtins is claimed unused?
+unused_dependencies = "allow"
diff --git a/library/alloc/src/alloc.rs b/library/alloc/src/alloc.rs
index de65820cf9a75..2174c7df32fcd 100644
--- a/library/alloc/src/alloc.rs
+++ b/library/alloc/src/alloc.rs
@@ -78,7 +78,7 @@ unsafe extern "Rust" {
 /// This may change in the future. You must not rely on it for correctness!
 ///
 /// [*equivalent*]: Allocator#equivalent-allocators
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 #[derive(Copy, Debug)]
 #[derive_const(Clone, Default)]
 // the compiler needs to know when a Box uses the global allocator vs a custom one
@@ -566,7 +566,7 @@ impl Global {
     }
 }
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 const unsafe impl Allocator for Global {
     #[inline]
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index 7504763120532..beb6522e94bb0 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -235,7 +235,7 @@ pub use thin::ThinBox;
 // compiler or ICEs will happen.
 pub struct Box<
     T: ?Sized,
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")] A: Allocator = Global,
+    #[stable(feature = "allocator_api", since = "1.100.0")] A: Allocator = Global,
 >(Unique<T>, A);
 
 /// Monomorphic function for allocating an uninit `Box`.
@@ -443,7 +443,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// let five = Box::new_in(5, System);
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[must_use]
     #[inline]
     pub fn new_in(x: T, alloc: A) -> Self {
@@ -676,7 +676,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// let c = Box::write(uninit, 6);
     /// assert_eq!(*c, 6);
     /// ```
-    #[stable(feature = "box_take", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "box_take", since = "1.100.0")]
     pub fn take(boxed: Self) -> (T, Box<mem::MaybeUninit<T>, A>) {
         // SAFETY: Reading out an initialised value & leaving behind a
         // box with uninit contents.
@@ -704,7 +704,7 @@ impl<T, A: Allocator> Box<T, A> {
     /// assert_eq!(*new, 14);
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[stable(feature = "smart_pointer_map", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "smart_pointer_map", since = "1.100.0")]
     pub fn map<U>(this: Self, f: impl FnOnce(T) -> U) -> Box<U, A> {
         let (value, allocation) = Box::take(this);
         let (raw, alloc) = Box::into_non_null_with_allocator(allocation);
@@ -1562,7 +1562,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [memory layout]: self#memory-layout
     /// [considerations for unsafe code]: self#considerations-for-unsafe-code
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[inline]
     pub unsafe fn from_raw_in(raw: *mut T, alloc: A) -> Self {
         // SAFETY: Upheld by caller.
@@ -1615,7 +1615,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [memory layout]: self#memory-layout
     /// [considerations for unsafe code]: self#considerations-for-unsafe-code
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[inline]
     pub unsafe fn from_non_null_in(raw: NonNull<T>, alloc: A) -> Self {
         // SAFETY: guaranteed by the caller.
@@ -1665,7 +1665,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [memory layout]: self#memory-layout
     #[must_use = "losing the pointer will leak memory"]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     #[inline]
     pub const fn into_raw_with_allocator(b: Self) -> (*mut T, A) {
@@ -1723,7 +1723,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     ///
     /// [memory layout]: self#memory-layout
     #[must_use = "losing the pointer will leak memory"]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[inline]
     pub fn into_non_null_with_allocator(b: Self) -> (NonNull<T>, A) {
         let (ptr, alloc) = Box::into_raw_with_allocator(b);
@@ -1869,7 +1869,7 @@ impl<T: ?Sized, A: Allocator> Box<T, A> {
     /// Note: this is an associated function, which means that you have
     /// to call it as `Box::allocator(&b)` instead of `b.allocator()`. This
     /// is so that there is no conflict with a method on the inner type.
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[inline]
     pub fn allocator(b: &Self) -> &A {
         &b.1
@@ -2490,7 +2490,7 @@ impl<E: Error, A: Allocator> Error for Box<E, A> {
     }
 }
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 unsafe impl<T: ?Sized + Allocator, A: Allocator> Allocator for Box<T, A> {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
diff --git a/library/alloc/src/fmt.rs b/library/alloc/src/fmt.rs
index 0129b04137a50..334d49706dbb9 100644
--- a/library/alloc/src/fmt.rs
+++ b/library/alloc/src/fmt.rs
@@ -595,7 +595,7 @@
 pub use core::fmt::Alignment;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::fmt::Error;
-#[stable(feature = "fmt_numbuffer", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "fmt_numbuffer", since = "1.100.0")]
 pub use core::fmt::NumBuffer;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::fmt::{Arguments, write};
diff --git a/library/alloc/src/rcs/arc.rs b/library/alloc/src/rcs/arc.rs
index e61ea5193eccb..4f612dc2bb19a 100644
--- a/library/alloc/src/rcs/arc.rs
+++ b/library/alloc/src/rcs/arc.rs
@@ -1210,7 +1210,7 @@ impl<T, A: Allocator> Arc<T, A> {
     /// assert_eq!(*new, 14);
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[stable(feature = "smart_pointer_map", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "smart_pointer_map", since = "1.100.0")]
     pub fn map<U>(this: Self, f: impl FnOnce(&T) -> U) -> Arc<U, A> {
         if size_of::<T>() == size_of::<U>()
             && align_of::<T>() == align_of::<U>()
@@ -5148,7 +5148,7 @@ unsafe impl<#[may_dangle] T: ?Sized, A: Allocator> Drop for UniqueArc<T, A> {
     }
 }
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 unsafe impl<T: ?Sized + Allocator, A: Allocator> Allocator for Arc<T, A> {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
diff --git a/library/alloc/src/rcs/rc.rs b/library/alloc/src/rcs/rc.rs
index 04e08c47fb587..f1469c06d8fd3 100644
--- a/library/alloc/src/rcs/rc.rs
+++ b/library/alloc/src/rcs/rc.rs
@@ -1056,7 +1056,7 @@ impl<T, A: Allocator> Rc<T, A> {
     /// assert_eq!(*new, 14);
     /// ```
     #[cfg(not(no_global_oom_handling))]
-    #[stable(feature = "smart_pointer_map", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "smart_pointer_map", since = "1.100.0")]
     pub fn map<U>(this: Self, f: impl FnOnce(&T) -> U) -> Rc<U, A> {
         if size_of::<T>() == size_of::<U>()
             && align_of::<T>() == align_of::<U>()
@@ -4786,7 +4786,7 @@ impl<T: ?Sized, A: Allocator> Drop for UniqueRcUninit<T, A> {
     }
 }
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 unsafe impl<T: ?Sized + Allocator, A: Allocator> Allocator for Rc<T, A> {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index f837d963a572e..8bcad62226a0b 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -436,10 +436,7 @@ mod sve_retain;
 #[rustc_insignificant_dtor]
 #[doc(alias = "list")]
 #[doc(alias = "vector")]
-pub struct Vec<
-    T,
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")] A: Allocator = Global,
-> {
+pub struct Vec<T, #[stable(feature = "allocator_api", since = "1.100.0")] A: Allocator = Global> {
     buf: RawVec<T, A>,
     len: usize,
 }
@@ -791,7 +788,7 @@ impl<T> Vec<T> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[stable(feature = "vec_from_fn", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "vec_from_fn", since = "1.100.0")]
     pub fn from_fn<F>(length: usize, f: F) -> Self
     where
         F: FnMut(usize) -> T,
@@ -969,7 +966,7 @@ const impl<T, A: [const] Allocator + [const] Destruct> Vec<T, A> {
     /// assert_eq!(vec_units.capacity(), usize::MAX);
     /// ```
     #[inline]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
         Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 }
     }
@@ -1061,7 +1058,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// let vec: Vec<i32, System> = Vec::new_in(System);
     /// ```
     #[inline]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[rustc_const_unstable(feature = "allocator_ext", issue = "163177")]
     pub const fn new_in(alloc: A) -> Self {
         Vec { buf: RawVec::new_in(alloc), len: 0 }
@@ -1181,7 +1178,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// }
     /// ```
     #[inline]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     pub const unsafe fn from_raw_parts_in(
         ptr: *mut T,
@@ -1293,7 +1290,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// }
     /// ```
     #[inline]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     pub const unsafe fn from_parts_in(
         ptr: NonNull<T>,
@@ -1346,7 +1343,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// assert_eq!(rebuilt, [4294967295, 0, 1]);
     /// ```
     #[must_use = "losing the pointer will leak memory"]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     pub const fn into_raw_parts_with_allocator(self) -> (*mut T, usize, usize, A) {
         let mut me = ManuallyDrop::new(self);
@@ -1395,7 +1392,7 @@ impl<T, A: Allocator> Vec<T, A> {
     /// assert_eq!(rebuilt, [4294967295, 0, 1]);
     /// ```
     #[must_use = "losing the pointer will leak memory"]
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     pub const fn into_parts_with_allocator(self) -> (NonNull<T>, usize, usize, A) {
         let (ptr, len, capacity, alloc) = self.into_raw_parts_with_allocator();
@@ -2114,7 +2111,7 @@ impl<T, A: Allocator> Vec<T, A> {
     }
 
     /// Returns a reference to the underlying allocator.
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     #[inline]
     pub const fn allocator(&self) -> &A {
diff --git a/library/alloc/src/vec/partial_eq.rs b/library/alloc/src/vec/partial_eq.rs
index 2d5a839cc8c30..aad307c0a0a10 100644
--- a/library/alloc/src/vec/partial_eq.rs
+++ b/library/alloc/src/vec/partial_eq.rs
@@ -33,11 +33,11 @@ __impl_slice_eq1! { [] Cow<'_, [T]>, &[U] where T: Clone, #[stable(feature = "ru
 #[cfg(not(no_global_oom_handling))]
 __impl_slice_eq1! { [] Cow<'_, [T]>, &mut [U] where T: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
 #[cfg(not(no_global_oom_handling))]
-__impl_slice_eq1! { [A: Allocator] Vec<T, A>, Cow<'_, [U]> where U: Clone, #[stable(feature = "partialeq_cow_for_vec_and_slice", since = "CURRENT_RUSTC_VERSION")] }
+__impl_slice_eq1! { [A: Allocator] Vec<T, A>, Cow<'_, [U]> where U: Clone, #[stable(feature = "partialeq_cow_for_vec_and_slice", since = "1.100.0")] }
 #[cfg(not(no_global_oom_handling))]
-__impl_slice_eq1! { [] &[T], Cow<'_, [U]> where U: Clone, #[stable(feature = "partialeq_cow_for_vec_and_slice", since = "CURRENT_RUSTC_VERSION")] }
+__impl_slice_eq1! { [] &[T], Cow<'_, [U]> where U: Clone, #[stable(feature = "partialeq_cow_for_vec_and_slice", since = "1.100.0")] }
 #[cfg(not(no_global_oom_handling))]
-__impl_slice_eq1! { [] &mut [T], Cow<'_, [U]> where U: Clone, #[stable(feature = "partialeq_cow_for_vec_and_slice", since = "CURRENT_RUSTC_VERSION")] }
+__impl_slice_eq1! { [] &mut [T], Cow<'_, [U]> where U: Clone, #[stable(feature = "partialeq_cow_for_vec_and_slice", since = "1.100.0")] }
 __impl_slice_eq1! { const, [A: Allocator, const N: usize] Vec<T, A>, [U; N], #[rustc_const_unstable(feature = "const_cmp", issue = "143800")] #[stable(feature = "rust1", since = "1.0.0")] }
 __impl_slice_eq1! { const, [A: Allocator, const N: usize] Vec<T, A>, &[U; N], #[rustc_const_unstable(feature = "const_cmp", issue = "143800")] #[stable(feature = "rust1", since = "1.0.0")] }
 
diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs
index 11b9da3032ae7..a69c86d68a117 100644
--- a/library/core/src/alloc/mod.rs
+++ b/library/core/src/alloc/mod.rs
@@ -27,15 +27,15 @@ use crate::ptr::{self, NonNull};
 /// that may be due to resource exhaustion or to
 /// something wrong when combining the given input arguments with this
 /// allocator.
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub struct AllocError;
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 impl Error for AllocError {}
 
 // (we need this for downstream impl of trait Error)
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 impl fmt::Display for AllocError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str("memory allocation failed")
@@ -193,7 +193,7 @@ impl fmt::Display for AllocError {
 // and make sure they cannot be triggered before relaxing this:
 // https://rust.tf/156490
 // https://rust.tf/159982
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 pub const unsafe trait Allocator {
     /// Attempts to allocate a block of memory.
@@ -228,7 +228,7 @@ pub const unsafe trait Allocator {
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
 
     /// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized.
@@ -246,7 +246,7 @@ pub const unsafe trait Allocator {
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         let ptr = self.allocate(layout)?;
         // SAFETY: `alloc` returns a valid memory block
@@ -270,7 +270,7 @@ pub const unsafe trait Allocator {
     ///
     /// [*currently allocated*]: #currently-allocated-memory
     /// [*fit*]: #memory-fitting
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout);
 
     /// Attempts to extend the memory block.
@@ -312,7 +312,7 @@ pub const unsafe trait Allocator {
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     unsafe fn grow(
         &self,
         ptr: NonNull<u8>,
@@ -373,7 +373,7 @@ pub const unsafe trait Allocator {
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     unsafe fn grow_zeroed(
         &self,
         ptr: NonNull<u8>,
@@ -440,7 +440,7 @@ pub const unsafe trait Allocator {
     /// call the [`handle_alloc_error`] function, rather than directly invoking `panic!` or similar.
     ///
     /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
-    #[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "allocator_api", since = "1.100.0")]
     unsafe fn shrink(
         &self,
         ptr: NonNull<u8>,
@@ -574,7 +574,7 @@ pub unsafe trait AllocatorClone: Allocator + Clone {}
 #[unstable(feature = "allocator_ext", issue = "163177", implied_by = "allocator_api")]
 pub unsafe trait StaticAllocator: Allocator {}
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 const unsafe impl<A> Allocator for &A
 where
@@ -630,7 +630,7 @@ where
     }
 }
 
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
 const unsafe impl<A> Allocator for &mut A
 where
diff --git a/library/core/src/bool.rs b/library/core/src/bool.rs
index b3d7686b6336e..e4ca53b59323f 100644
--- a/library/core/src/bool.rs
+++ b/library/core/src/bool.rs
@@ -151,8 +151,8 @@ impl bool {
     ///
     /// [`true`]: ../std/keyword.true.html
     /// [`false`]: ../std/keyword.false.html
-    #[stable(feature = "bool_toggle", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "bool_toggle", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "bool_toggle", since = "1.100.0")]
+    #[rustc_const_stable(feature = "bool_toggle", since = "1.100.0")]
     #[inline]
     pub const fn toggle(&mut self) {
         *self = !*self;
diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs
index 47312b2bd5649..3dcf033bbd757 100644
--- a/library/core/src/cell.rs
+++ b/library/core/src/cell.rs
@@ -2376,8 +2376,8 @@ impl<T> UnsafeCell<T> {
     /// assert_eq!(old, 5);
     /// ```
     #[inline]
-    #[stable(feature = "unsafe_cell_access", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "unsafe_cell_access", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "unsafe_cell_access", since = "1.100.0")]
+    #[rustc_const_stable(feature = "unsafe_cell_access", since = "1.100.0")]
     #[rustc_should_not_be_called_on_const_items]
     pub const unsafe fn replace(&self, value: T) -> T {
         // SAFETY: pointer comes from `&self` so naturally satisfies invariants.
@@ -2518,8 +2518,8 @@ impl<T: ?Sized> UnsafeCell<T> {
     /// assert_eq!(val, &5);
     /// ```
     #[inline]
-    #[stable(feature = "unsafe_cell_access", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "unsafe_cell_access", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "unsafe_cell_access", since = "1.100.0")]
+    #[rustc_const_stable(feature = "unsafe_cell_access", since = "1.100.0")]
     #[rustc_should_not_be_called_on_const_items]
     pub const unsafe fn as_ref_unchecked(&self) -> &T {
         // SAFETY: pointer comes from `&self` so naturally satisfies ptr-to-ref invariants.
@@ -2546,8 +2546,8 @@ impl<T: ?Sized> UnsafeCell<T> {
     /// assert_eq!(uc.into_inner(), 6);
     /// ```
     #[inline]
-    #[stable(feature = "unsafe_cell_access", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "unsafe_cell_access", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "unsafe_cell_access", since = "1.100.0")]
+    #[rustc_const_stable(feature = "unsafe_cell_access", since = "1.100.0")]
     #[allow(clippy::mut_from_ref)]
     #[rustc_should_not_be_called_on_const_items]
     pub const unsafe fn as_mut_unchecked(&self) -> &mut T {
diff --git a/library/core/src/clone.rs b/library/core/src/clone.rs
index 126ab37bc0b71..bd6d929c6d2b0 100644
--- a/library/core/src/clone.rs
+++ b/library/core/src/clone.rs
@@ -732,7 +732,7 @@ mod impls {
         bool char
     }
 
-    #[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "never_type", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_clone", issue = "142757")]
     const impl Clone for ! {
         #[inline]
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index 2792c7cde57be..1b57bed2738f7 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -2409,7 +2409,7 @@ mod impls {
 
     ord_impl! { char usize u8 u16 u32 u64 u128 isize i8 i16 i32 i64 i128 }
 
-    #[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "never_type", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     const impl PartialEq for ! {
         #[inline]
@@ -2418,11 +2418,11 @@ mod impls {
         }
     }
 
-    #[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "never_type", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     const impl Eq for ! {}
 
-    #[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "never_type", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     const impl PartialOrd for ! {
         #[inline]
@@ -2431,7 +2431,7 @@ mod impls {
         }
     }
 
-    #[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "never_type", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_cmp", issue = "143800")]
     const impl Ord for ! {
         #[inline]
diff --git a/library/core/src/convert/mod.rs b/library/core/src/convert/mod.rs
index 214c12686c204..b0f74a8afb598 100644
--- a/library/core/src/convert/mod.rs
+++ b/library/core/src/convert/mod.rs
@@ -886,7 +886,7 @@ const impl AsMut<str> for str {
 /// }
 /// ```
 ///
-/// Note: Since [`!`] (the "never" type) was stabilized in Rust CURRENT_RUSTC_VERSION, it is
+/// Note: Since [`!`] (the "never" type) was stabilized in Rust 1.100.0, it is
 /// preferred to use `!` directly unless targeting older Rust versions. `Infallible` may be
 /// deprecated in a future Rust version.
 #[stable(feature = "convert_infallible", since = "1.34.0")]
diff --git a/library/core/src/error.rs b/library/core/src/error.rs
index 7386c52849eab..1b640f2d99803 100644
--- a/library/core/src/error.rs
+++ b/library/core/src/error.rs
@@ -268,7 +268,7 @@ mod private {
     pub struct Internal;
 }
 
-#[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "never_type", since = "1.100.0")]
 impl Error for ! {}
 
 // Copied from `any.rs`.
diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index 43dba18375992..55296a62e947a 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -2881,7 +2881,7 @@ macro_rules! fmt_refs {
 
 fmt_refs! { Debug, Display, Octal, Binary, LowerHex, UpperHex, LowerExp, UpperExp }
 
-#[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "never_type", since = "1.100.0")]
 impl Debug for ! {
     #[inline]
     fn fmt(&self, _: &mut Formatter<'_>) -> Result {
@@ -2889,7 +2889,7 @@ impl Debug for ! {
     }
 }
 
-#[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "never_type", since = "1.100.0")]
 impl Display for ! {
     #[inline]
     fn fmt(&self, _: &mut Formatter<'_>) -> Result {
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index d1a68412247ef..530af0c3af656 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -480,7 +480,7 @@ marker_impls! {
 
 }
 
-#[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "never_type", since = "1.100.0")]
 impl Copy for ! {}
 
 /// Shared references can be copied, but mutable references *cannot*!
diff --git a/library/core/src/mem/drop_guard.rs b/library/core/src/mem/drop_guard.rs
index 31f1f93b65378..81104ccce29f1 100644
--- a/library/core/src/mem/drop_guard.rs
+++ b/library/core/src/mem/drop_guard.rs
@@ -27,7 +27,7 @@ use crate::ops::{Deref, DerefMut};
 ///     // "Chashu likes tuna!!!"
 /// }
 /// ```
-#[stable(feature = "drop_guard", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "drop_guard", since = "1.100.0")]
 #[doc(alias = "ScopeGuard")]
 #[doc(alias = "defer")]
 pub struct DropGuard<T, F>
@@ -54,7 +54,7 @@ where
     /// let value = String::from("Chashu likes tuna");
     /// let guard = DropGuard::new(value, |s| println!("{s}"));
     /// ```
-    #[stable(feature = "drop_guard", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "drop_guard", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_drop_guard", issue = "none")]
     #[must_use]
     pub const fn new(inner: T, f: F) -> Self {
@@ -79,7 +79,7 @@ where
     /// let guard = DropGuard::new(value, |s| println!("{s}"));
     /// assert_eq!(DropGuard::dismiss(guard), "Nori likes chicken");
     /// ```
-    #[stable(feature = "drop_guard", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "drop_guard", since = "1.100.0")]
     #[rustc_const_unstable(feature = "const_drop_guard", issue = "none")]
     #[inline]
     pub const fn dismiss(guard: Self) -> T
@@ -105,7 +105,7 @@ where
     }
 }
 
-#[stable(feature = "drop_guard", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "drop_guard", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 const impl<T, F> Deref for DropGuard<T, F>
 where
@@ -118,7 +118,7 @@ where
     }
 }
 
-#[stable(feature = "drop_guard", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "drop_guard", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 const impl<T, F> DerefMut for DropGuard<T, F>
 where
@@ -129,7 +129,7 @@ where
     }
 }
 
-#[stable(feature = "drop_guard", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "drop_guard", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_drop_guard", issue = "none")]
 const impl<T, F> Drop for DropGuard<T, F>
 where
@@ -146,7 +146,7 @@ where
     }
 }
 
-#[stable(feature = "drop_guard", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "drop_guard", since = "1.100.0")]
 impl<T, F> Debug for DropGuard<T, F>
 where
     T: Debug,
diff --git a/library/core/src/mem/mod.rs b/library/core/src/mem/mod.rs
index e149e2b4a7039..a22e52f3a3bc7 100644
--- a/library/core/src/mem/mod.rs
+++ b/library/core/src/mem/mod.rs
@@ -59,7 +59,7 @@ mod transmutability;
 pub use transmutability::{Assume, TransmuteFrom};
 
 mod drop_guard;
-#[stable(feature = "drop_guard", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "drop_guard", since = "1.100.0")]
 pub use drop_guard::DropGuard;
 
 // This one has to be a re-export (rather than wrapping the underlying intrinsic) so that we can do
@@ -1708,8 +1708,8 @@ pub macro offset_of($Container:ty, $($fields:expr)+ $(,)?) {
 /// ```
 ///
 /// [inhabited]: https://doc.rust-lang.org/reference/glossary.html#inhabited
-#[stable(feature = "mem_conjure_zst", since = "CURRENT_RUSTC_VERSION")]
-#[rustc_const_stable(feature = "mem_conjure_zst", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "mem_conjure_zst", since = "1.100.0")]
+#[rustc_const_stable(feature = "mem_conjure_zst", since = "1.100.0")]
 #[rustc_allow_const_fn_unstable(const_type_name)] // type_name() called only at run time
 pub const unsafe fn conjure_zst<T>() -> T {
     const_assert!(
diff --git a/library/core/src/num/error.rs b/library/core/src/num/error.rs
index d102c456f3b4a..6a8a2d5b636ed 100644
--- a/library/core/src/num/error.rs
+++ b/library/core/src/num/error.rs
@@ -34,7 +34,7 @@ impl fmt::Display for TryFromIntError {
 #[stable(feature = "try_from", since = "1.34.0")]
 impl Error for TryFromIntError {}
 
-#[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "never_type", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 const impl From<!> for TryFromIntError {
     #[inline]
diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs
index 4b84a9de4ce72..5054afdc3490d 100644
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@@ -282,7 +282,7 @@ const _: () = ();
 ///     todo!() as std::iter::Empty<_>
 /// }
 /// ```
-#[stable(feature = "never_type", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "never_type", since = "1.100.0")]
 const _: () = ();
 
 // Required to make auto trait impls render.
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index d89d212111527..6deba9ce9752e 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -2801,7 +2801,7 @@ impl<T> [T] {
     /// assert_eq!(b"hello".trim_prefix(prefix.as_bytes()), b"llo".as_ref());
     /// ```
     #[must_use = "returns the subslice without modifying the original"]
-    #[stable(feature = "trim_prefix_suffix", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "trim_prefix_suffix", since = "1.100.0")]
     pub fn trim_prefix<P: SlicePattern<Item = T> + ?Sized>(&self, prefix: &P) -> &[T]
     where
         T: PartialEq,
@@ -2839,7 +2839,7 @@ impl<T> [T] {
     /// assert_eq!(v.trim_suffix(&[50, 30]), &[10, 40, 30][..]);
     /// ```
     #[must_use = "returns the subslice without modifying the original"]
-    #[stable(feature = "trim_prefix_suffix", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "trim_prefix_suffix", since = "1.100.0")]
     pub fn trim_suffix<P: SlicePattern<Item = T> + ?Sized>(&self, suffix: &P) -> &[T]
     where
         T: PartialEq,
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 99eb935cb2715..017d3f50eba32 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -2556,7 +2556,7 @@ impl str {
     /// ```
     #[must_use = "this returns the remaining substring as a new slice, \
                   without modifying the original"]
-    #[stable(feature = "trim_prefix_suffix", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "trim_prefix_suffix", since = "1.100.0")]
     pub fn trim_prefix<P: Pattern>(&self, prefix: P) -> &str {
         prefix.strip_prefix_of(self).unwrap_or(self)
     }
@@ -2591,7 +2591,7 @@ impl str {
     /// ```
     #[must_use = "this returns the remaining substring as a new slice, \
                   without modifying the original"]
-    #[stable(feature = "trim_prefix_suffix", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "trim_prefix_suffix", since = "1.100.0")]
     pub fn trim_suffix<P: Pattern>(&self, suffix: P) -> &str
     where
         for<'a> P::Searcher<'a>: ReverseSearcher<'a>,
diff --git a/library/panic_unwind/Cargo.toml b/library/panic_unwind/Cargo.toml
index 72c1041b46795..3b7805a205492 100644
--- a/library/panic_unwind/Cargo.toml
+++ b/library/panic_unwind/Cargo.toml
@@ -18,3 +18,6 @@ unwind = { path = "../unwind" }
 
 [target.'cfg(not(all(windows, target_env = "msvc")))'.dependencies]
 libc = { version = "0.2", default-features = false }
+
+[lints.cargo]
+unused_dependencies = "allow"
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index a3709adfc2c37..886f258f8fe98 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -28,7 +28,6 @@
 #![feature(rustc_attrs)]
 #![feature(extend_one)]
 #![feature(f16)]
-#![cfg_attr(bootstrap, feature(mem_conjure_zst))]
 #![recursion_limit = "256"]
 #![allow(internal_features)]
 #![deny(ffi_unwind_calls)]
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 1d35b42a53947..67eebd820ca59 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -167,3 +167,7 @@ check-cfg = [
     'cfg(target_has_reliable_f128)',
     'cfg(target_has_reliable_f128_math)',
 ]
+
+[lints.cargo]
+# panic_abort is not directly used but must be linked in
+unused_dependencies = "allow"
diff --git a/library/std/src/alloc.rs b/library/std/src/alloc.rs
index c6f94944006c9..fa977d16e2311 100644
--- a/library/std/src/alloc.rs
+++ b/library/std/src/alloc.rs
@@ -216,7 +216,7 @@ impl System {
 
 // The Allocator impl checks the layout size to be non-zero and forwards to the
 // platform functions in `std::sys::*::alloc`.
-#[stable(feature = "allocator_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "allocator_api", since = "1.100.0")]
 unsafe impl Allocator for System {
     #[inline]
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
diff --git a/library/std/src/os/unix/net/datagram.rs b/library/std/src/os/unix/net/datagram.rs
index f80a3a887c54d..548dca3592063 100644
--- a/library/std/src/os/unix/net/datagram.rs
+++ b/library/std/src/os/unix/net/datagram.rs
@@ -112,13 +112,12 @@ impl UnixDatagram {
     ///
     #[cfg_attr(target_family = "unix", doc = "```no_run")]
     #[cfg_attr(not(target_family = "unix"), doc = "```ignore (needs unix)")]
-    /// use std::os::unix::net::{UnixDatagram};
+    /// use std::os::unix::net::{SocketAddr, UnixDatagram};
     ///
     /// fn main() -> std::io::Result<()> {
-    ///     let sock1 = UnixDatagram::bind("path/to/socket")?;
-    ///     let addr = sock1.local_addr()?;
+    ///     let addr = SocketAddr::from_pathname("path/to/socket")?;
     ///
-    ///     let sock2 = match UnixDatagram::bind_addr(&addr) {
+    ///     let sock = match UnixDatagram::bind_addr(&addr) {
     ///         Ok(sock) => sock,
     ///         Err(err) => {
     ///             println!("Couldn't bind: {err:?}");
diff --git a/library/std/src/os/unix/net/listener.rs b/library/std/src/os/unix/net/listener.rs
index 793e2378e716d..2e47a4b23a1cb 100644
--- a/library/std/src/os/unix/net/listener.rs
+++ b/library/std/src/os/unix/net/listener.rs
@@ -119,13 +119,12 @@ impl UnixListener {
     ///
     #[cfg_attr(target_family = "unix", doc = "```no_run")]
     #[cfg_attr(not(target_family = "unix"), doc = "```ignore (needs unix)")]
-    /// use std::os::unix::net::{UnixListener};
+    /// use std::os::unix::net::{SocketAddr, UnixListener};
     ///
     /// fn main() -> std::io::Result<()> {
-    ///     let listener1 = UnixListener::bind("path/to/socket")?;
-    ///     let addr = listener1.local_addr()?;
+    ///     let addr = SocketAddr::from_pathname("path/to/socket")?;
     ///
-    ///     let listener2 = match UnixListener::bind_addr(&addr) {
+    ///     let listener = match UnixListener::bind_addr(&addr) {
     ///         Ok(sock) => sock,
     ///         Err(err) => {
     ///             println!("Couldn't bind: {err:?}");
diff --git a/library/std/src/os/windows/process.rs b/library/std/src/os/windows/process.rs
index 3e1fe13ee6fc2..971d88c65ea75 100644
--- a/library/std/src/os/windows/process.rs
+++ b/library/std/src/os/windows/process.rs
@@ -188,7 +188,7 @@ pub impl(self) trait CommandExt {
     /// <https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-showwindow>
     ///
     /// [1]: <https://learn.microsoft.com/en-us/windows/win32/api/processthreadsapi/ns-processthreadsapi-startupinfow>
-    #[stable(feature = "windows_process_extensions_show_window", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "windows_process_extensions_show_window", since = "1.100.0")]
     fn show_window(&mut self, cmd_show: u16) -> &mut process::Command;
 
     /// Forces all arguments to be wrapped in quote (`"`) characters.
@@ -451,23 +451,14 @@ impl CommandExt for process::Command {
     }
 }
 
-#[stable(
-    feature = "windows_process_extensions_main_thread_handle",
-    since = "CURRENT_RUSTC_VERSION"
-)]
+#[stable(feature = "windows_process_extensions_main_thread_handle", since = "1.100.0")]
 pub impl(self) trait ChildExt {
     /// Extracts the main thread raw handle, without taking ownership
-    #[stable(
-        feature = "windows_process_extensions_main_thread_handle",
-        since = "CURRENT_RUSTC_VERSION"
-    )]
+    #[stable(feature = "windows_process_extensions_main_thread_handle", since = "1.100.0")]
     fn main_thread_handle(&self) -> BorrowedHandle<'_>;
 }
 
-#[stable(
-    feature = "windows_process_extensions_main_thread_handle",
-    since = "CURRENT_RUSTC_VERSION"
-)]
+#[stable(feature = "windows_process_extensions_main_thread_handle", since = "1.100.0")]
 impl ChildExt for process::Child {
     fn main_thread_handle(&self) -> BorrowedHandle<'_> {
         self.handle.main_thread_handle()
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index 1f45423bd8285..4eb3796ac026d 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -2770,7 +2770,7 @@ impl Path {
     /// assert_eq!(path.trim_prefix("/haha"), path);
     /// ```
     #[must_use = "this returns the remaining path as a new path, without modifying the original"]
-    #[stable(feature = "trim_prefix_suffix", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "trim_prefix_suffix", since = "1.100.0")]
     pub fn trim_prefix<P>(&self, base: P) -> &Path
     where
         P: AsRef<Path>,
diff --git a/library/std/src/sync/once.rs b/library/std/src/sync/once.rs
index 9b555c32df99d..9b7dd3b78eac7 100644
--- a/library/std/src/sync/once.rs
+++ b/library/std/src/sync/once.rs
@@ -348,7 +348,7 @@ impl fmt::Debug for Once {
     }
 }
 
-#[stable(feature = "once_default", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "once_default", since = "1.100.0")]
 #[rustc_const_unstable(feature = "const_default", issue = "143894")]
 const impl Default for Once {
     /// Creates a new `Once` value, same as [`Once::new`].
diff --git a/library/std_detect/Cargo.toml b/library/std_detect/Cargo.toml
index a6785bb20555d..c03fff827d5cd 100644
--- a/library/std_detect/Cargo.toml
+++ b/library/std_detect/Cargo.toml
@@ -24,3 +24,7 @@ libc = { version = "0.2.0", default-features = false }
 
 [features]
 std_detect_env_override = []
+
+[lints.cargo]
+# libc is definitely used in code but the lint doesn't realize that (unclear why)
+unused_dependencies = "allow"
diff --git a/library/sysroot/Cargo.toml b/library/sysroot/Cargo.toml
index 10562389d62d3..cef5532857b5e 100644
--- a/library/sysroot/Cargo.toml
+++ b/library/sysroot/Cargo.toml
@@ -32,3 +32,8 @@ optimize_for_size = ["std/optimize_for_size"]
 panic-unwind = ["std/panic-unwind"]
 profiler = ["dep:profiler_builtins"]
 windows_raw_dylib = ["std/windows_raw_dylib"]
+
+[lints.cargo]
+# We expect some of these dependencies to not actually be used since this is
+# just an aggregator crate.
+unused_dependencies = "allow"
diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs
index 72895e1f2462f..c8d1cfd599909 100644
--- a/src/librustdoc/doctest.rs
+++ b/src/librustdoc/doctest.rs
@@ -423,33 +423,19 @@ pub(crate) fn run_tests(
     // `running 0 tests...`.
     if ran_edition_tests == 0 || !standalone_tests.is_empty() {
         standalone_tests.sort_by(|a, b| a.desc.name.as_slice().cmp(b.desc.name.as_slice()));
-        cfg_select! {
-            bootstrap => {
-                test::test_main_with_exit_callback(&test_args, standalone_tests, None, || {
-                    let times = times.times_in_secs();
-                    // We ensure temp dir destructor is called.
-                    std::mem::drop(temp_dir.take());
-                    if let Some((total_time, compilation_time)) = times {
-                        test::print_merged_doctests_times(&test_args, total_time, compilation_time);
-                    }
-                });
-            }
-            _ => {
-                // We need a vector of `&TestDescAndFn`.
-                let standalone_test_refs = &standalone_tests.iter().collect::<Vec<_>>();
-                let exit = test::test_main(&test_args, standalone_test_refs);
-                let times = times.times_in_secs();
-                // We ensure temp dir destructor is called.
-                std::mem::drop(standalone_tests);
-                std::mem::drop(temp_dir.take());
-                if let Some((total_time, compilation_time)) = times {
-                    test::print_merged_doctests_times(&test_args, total_time, compilation_time);
-                }
-                // Fall through on success, the caller may want to do more stuff.
-                if exit != std::process::ExitCode::SUCCESS {
-                    exit.exit_process();
-                }
-            }
+        // We need a vector of `&TestDescAndFn`.
+        let standalone_test_refs = &standalone_tests.iter().collect::<Vec<_>>();
+        let exit = test::test_main(&test_args, standalone_test_refs);
+        let times = times.times_in_secs();
+        // We ensure temp dir destructor is called.
+        std::mem::drop(standalone_tests);
+        std::mem::drop(temp_dir.take());
+        if let Some((total_time, compilation_time)) = times {
+            test::print_merged_doctests_times(&test_args, total_time, compilation_time);
+        }
+        // Fall through on success, the caller may want to do more stuff.
+        if exit != std::process::ExitCode::SUCCESS {
+            exit.exit_process();
         }
     } else {
         // If the first condition branch exited successfully, it will
@@ -1175,18 +1161,6 @@ fn generate_test_desc_and_fn(
             no_run: scraped_test.no_run(&rustdoc_options),
             test_type: test::TestType::DocTest,
         },
-        #[cfg(bootstrap)]
-        testfn: test::DynTestFn(Box::new(move || {
-            doctest_run_fn(
-                &rustdoc_test_options,
-                &opts,
-                &test,
-                &scraped_test,
-                &rustdoc_options,
-                &unused_externs,
-            )
-        })),
-        #[cfg(not(bootstrap))]
         testfn: test::DynTestFn(Arc::new(move || {
             doctest_run_fn(
                 &rustdoc_test_options,
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index b907c3ef2cb11..85bae04fcb2e8 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -1,6 +1,4 @@
 // tidy-alphabetical-start
-#![cfg_attr(bootstrap, feature(trim_prefix_suffix))]
-#![cfg_attr(not(bootstrap), feature(exitcode_exit_method))]
 #![doc(
     html_root_url = "https://doc.rust-lang.org/nightly/",
     html_playground_url = "https://play.rust-lang.org/"
@@ -8,6 +6,7 @@
 #![feature(ascii_char)]
 #![feature(ascii_char_variants)]
 #![feature(deref_patterns)]
+#![feature(exitcode_exit_method)]
 #![feature(file_buffered)]
 #![feature(formatting_options)]
 #![feature(iter_intersperse)]
diff --git a/src/stage0 b/src/stage0
index 3426edfafbf16..65357a133fe09 100644
--- a/src/stage0
+++ b/src/stage0
@@ -13,605 +13,588 @@ nightly_branch=main
 # All changes below this comment will be overridden the next time the
 # tool is executed.
 
-compiler_channel_manifest_hash=1612da194f5a1c699d7a20519341ed9aa62e29f28bf3f303ab6801e8e266b103
-compiler_git_commit_hash=cbae9b4cae2b108f6a3d18cfe6075714bb739463
-compiler_date=2026-08-30
+compiler_channel_manifest_hash=748739f565e7977153cc87b1bf606072e31088a751ed351c1a076cfc4ebd04ed
+compiler_git_commit_hash=e3feeb59cd1bdd011a2bfcc0747b55125d9b8527
+compiler_date=2026-09-29
 compiler_version=beta
-rustfmt_channel_manifest_hash=d950b3b494cde6b8448964e1795a86530bff7ee5e729a48ed6341c6ec3ee5ad1
-rustfmt_git_commit_hash=fd7ed57dfd3bdebb745a1d8158638727b0e7047a
-rustfmt_date=2026-08-30
+rustfmt_channel_manifest_hash=4ac7009a2d787fa804178e5a7a067b1f828f85623a160ef7cc417d378814ef3e
+rustfmt_git_commit_hash=c1070d69382b8d2f2eb65119c738a77d9e324c9e
+rustfmt_date=2026-09-29
 rustfmt_version=nightly
 
-dist/2026-08-30/rustc-beta-aarch64-apple-darwin.tar.gz=63da74142f0e917ccbc13cf182bae60d9ec3d545b712ac6150fe8b4e633a2c7a
-dist/2026-08-30/rustc-beta-aarch64-apple-darwin.tar.xz=0c20c4730544923b2ba9ab4ccf98cd22db6759d1d6cc2e5b8c99662b953163ac
-dist/2026-08-30/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=1d67701059998ff993a42c3781b2b735bf537d9db46bdb0b94e6cd9313f69b0c
-dist/2026-08-30/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=093d13372b7bc06246e63a1e18aac59464e71939b951e14ae0ce500f467be92c
-dist/2026-08-30/rustc-beta-aarch64-pc-windows-msvc.tar.gz=d1a51ad8e37b8f482c994527f7062a4b3ac9d1734be81b677a5e270ff121747e
-dist/2026-08-30/rustc-beta-aarch64-pc-windows-msvc.tar.xz=f019195e5c72d6b6e699416d8851555965ccf5f108bddae999e9bf37fec19693
-dist/2026-08-30/rustc-beta-aarch64-unknown-freebsd.tar.gz=f9b8e19c81bb9cbb2c75d841f043b084aa9c3c239b359c761d02d255c16ec928
-dist/2026-08-30/rustc-beta-aarch64-unknown-freebsd.tar.xz=fd02f9f057e75b2f6e5c763dcad6dfd9ec39c8e03a40f2cffb82823edbb2da26
-dist/2026-08-30/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=1f44bbb85ebb6d4c218016661afa545a8e038f1b937e49f81bebd915ba10c608
-dist/2026-08-30/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=e2e2bf7f32709df924efe7b5f530781ea1428ce163e92270a3ee476b7b3a3d1a
-dist/2026-08-30/rustc-beta-aarch64-unknown-linux-musl.tar.gz=5452dc6c27dab927dab0afb5be5f300f1cc9af3c7ccfb88dd605227851fd65d7
-dist/2026-08-30/rustc-beta-aarch64-unknown-linux-musl.tar.xz=1f7c588a39f096f7578fc6bca93f0c85ae40976cf26a51913070119a8b910e07
-dist/2026-08-30/rustc-beta-aarch64-unknown-linux-ohos.tar.gz=8aa1b28d25e4c7a21d3fcb85254d1e2c169ff55b3536a290edacecb6c051ab4b
-dist/2026-08-30/rustc-beta-aarch64-unknown-linux-ohos.tar.xz=27208aaaebbcea8e819d7d9fbf20dd994cc24f727dbee339d34e6a995e2b9864
-dist/2026-08-30/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=73f04b6601665531d79900f59a8f92f3e7a90f196d62e1ea10e20a3e6ca6f8f4
-dist/2026-08-30/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=64b0fb006d621f6003527b41e9e31f9141f3df09a0dfe979ee68054d1346016e
-dist/2026-08-30/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=19e1f450d4aa8d169898170c9bcd2ab7fba9d3453a631c57a5148236805f101e
-dist/2026-08-30/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=f7715866e5e05360279365dc39eefc96436a53f429cd5b283662a81634f7371f
-dist/2026-08-30/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=2e765b6a53cabb0077ad4f8f563862d115c9f152165dc92615a727bdf0d2998b
-dist/2026-08-30/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=09a111ae1c8861099a39d495fcea86c65780bb2b7a6c7bc19fff56915b4f11a5
-dist/2026-08-30/rustc-beta-i686-pc-windows-gnu.tar.gz=02d8f06789c7f48a19e31ddc7c3f8dab995197f7857d410f6df60dad1067b8cf
-dist/2026-08-30/rustc-beta-i686-pc-windows-gnu.tar.xz=91bf9711b7551cb3caf6660824ad5c04f27ed9a0fd086211b3aed56628311d45
-dist/2026-08-30/rustc-beta-i686-pc-windows-msvc.tar.gz=70525d3d60e2ebddb9e7b3341314caa0df4e34bdfcb47bae46927fa13a6ed327
-dist/2026-08-30/rustc-beta-i686-pc-windows-msvc.tar.xz=59d9ecfad856f135df42afd957024ede0a3eb263a7ec4ffbf517e16696054d83
-dist/2026-08-30/rustc-beta-i686-unknown-linux-gnu.tar.gz=317c5379344a6e473a29e432d4aab7399ff3dbe86a72dd279c0c82c495d98c65
-dist/2026-08-30/rustc-beta-i686-unknown-linux-gnu.tar.xz=af6b78184886cff946f408dcd27ce4332fe39b514c49a6c285aa12ee8a895194
-dist/2026-08-30/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=0894c6b942bad197888f596f7d518595f5db700cc21089b39d9b923c0bc2c902
-dist/2026-08-30/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=d10527ec270b021405f4c7c8853296837efa3d4f1804d7e9aaf22c7f76b3ac8d
-dist/2026-08-30/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=82edc27720b2001ef4ccfaa8638c839bd76ca9294723516749544a794a963f76
-dist/2026-08-30/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=efa4d683554b36de9d19d1aa6a6bcd39223e4b8726d5108895071169f976abf6
-dist/2026-08-30/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=453f91a3f885305cdc98ae91bb06fe0cd3bc2f2cad2db05ffc51a9957c5d7dd5
-dist/2026-08-30/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=acb98b89f961c5b309f54e6dd647f68c105f0f95aabbddbe6363055ab842fb4f
-dist/2026-08-30/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=791dc39fa441ecbd5e976da99d988796ad5382f62a85856722dba4fdc4f81491
-dist/2026-08-30/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=005c0e756b757b0d49b6ec9777a9997799d5328f826a4d168a67994591323037
-dist/2026-08-30/rustc-beta-powerpc64-unknown-linux-musl.tar.gz=d3b6748b0471837b8f2f7118e739f4870f2875fb061253c71dbeadcb5a88253d
-dist/2026-08-30/rustc-beta-powerpc64-unknown-linux-musl.tar.xz=9c681f8f3efd7f8130ee8c2a40c39d83f6bd58858e134c8df8bba2b65fc3da1a
-dist/2026-08-30/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=3924195349e7b1b31f6334f0d07d66ca4f3c423fb57b8bdded25fa1746b4d1b1
-dist/2026-08-30/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=3f0decdada02b892f63920829a4af3541f149d44b162b3a98d2aa006f2bf47cb
-dist/2026-08-30/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=c8c0a5745dfcecc41a52876a9658badf7a35417173f143f50a6d304eb99c4dd6
-dist/2026-08-30/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=47992ff2ff6725eac8e6322c1d76df258a54fc928cbcc8d175acfe16b5a4058f
-dist/2026-08-30/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=91747193505f48d0eba8653bf14855c81999afefb632207eac3d7d6f355fd2bd
-dist/2026-08-30/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=95f5717569d3b07ed6808c82a5a3849284ce9b404792806fc06356a11ae54895
-dist/2026-08-30/rustc-beta-riscv64gc-unknown-linux-musl.tar.gz=ff705b94a62127be2bbbaf20a036fd4d9c3fcc23b852bf50b814120637eb28d9
-dist/2026-08-30/rustc-beta-riscv64gc-unknown-linux-musl.tar.xz=da5837ddd0b7ab0b10be836fcf757ce117bbe54e57d7ce696c38e8779be64328
-dist/2026-08-30/rustc-beta-s390x-unknown-linux-gnu.tar.gz=7282b673f837c2998f70a47e44c67d2d88d75f55be6c363a43706f37acde0676
-dist/2026-08-30/rustc-beta-s390x-unknown-linux-gnu.tar.xz=2890fbd6092fac747d44f525623e77c87d5924a878d20be664e20068f729f01c
-dist/2026-08-30/rustc-beta-sparcv9-sun-solaris.tar.gz=b1526015253711f6b54e5e2081e5503461ca94e66edffa3226899c357350475d
-dist/2026-08-30/rustc-beta-sparcv9-sun-solaris.tar.xz=dc7adedded9d7c4022057709f33de27a6ace3d08a264f17bee7c8e1a92e975b8
-dist/2026-08-30/rustc-beta-x86_64-apple-darwin.tar.gz=9f06cb6793158449b822f07b86a2a57c73d12ad05dee33d188027ae20559f197
-dist/2026-08-30/rustc-beta-x86_64-apple-darwin.tar.xz=d506f9e4bfe7d3d223a88392d5416ac0203924e31b6e3f68a32adc1578d74e0b
-dist/2026-08-30/rustc-beta-x86_64-pc-solaris.tar.gz=60825508456e01c09e82986c2c3574dd954e2fbdb16f20db1751437eb2294414
-dist/2026-08-30/rustc-beta-x86_64-pc-solaris.tar.xz=7aa295d6f6ab2eca3d72e1703bc533ac01908dd5080a859c7ab01003d0634d9d
-dist/2026-08-30/rustc-beta-x86_64-pc-windows-gnu.tar.gz=01bda7ca1de22ac2881f0da5bd1db0c31500eab3e4b5273d16b581193788e32c
-dist/2026-08-30/rustc-beta-x86_64-pc-windows-gnu.tar.xz=65229fa0b642f511ecae17f456d5a67aac0338adcb07ad0746eaec97cd0b2d25
-dist/2026-08-30/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=90021d8fc771da2febbc00152c6dd7c3b58845a9a522f74573a2acab9f55a016
-dist/2026-08-30/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=cec531ec82cd3630818985aa6e2e2afdd553e195c87c26873b914c2a159929a2
-dist/2026-08-30/rustc-beta-x86_64-pc-windows-msvc.tar.gz=2d41c0c375f565315155c80e0d241bd8ea132e994b5d87ded8a21302f29d5ab4
-dist/2026-08-30/rustc-beta-x86_64-pc-windows-msvc.tar.xz=6d82171d5e4453c466313f6541fbb62dc74d0c7863651413c687b7f4c27b2a4e
-dist/2026-08-30/rustc-beta-x86_64-unknown-freebsd.tar.gz=0509d78b60e4743b1953f12a70a91adc7ef48cf886826dcb16e87695999c7699
-dist/2026-08-30/rustc-beta-x86_64-unknown-freebsd.tar.xz=a5714f58f8651919a51c8ce28536ce83f86fd7ac72bf067dd97189c1d389c07b
-dist/2026-08-30/rustc-beta-x86_64-unknown-illumos.tar.gz=883ab0b98ded267ff1b7a8fd0d9ffc7529ff6a5e6b1e73c2168faf1c90d92ef0
-dist/2026-08-30/rustc-beta-x86_64-unknown-illumos.tar.xz=58178ca6b6c9ced54a0f7991fbd94f6d92c32eacffbf774444429ea46b1f58d3
-dist/2026-08-30/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=2a164be1423d98988d4c3e9c7635af9150a961b5fb3d2052517987266978fc65
-dist/2026-08-30/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=66764b74fe55573ea5884ac7ac98fd7e5bff95f4ee0f389e3f5ee07eb75e1623
-dist/2026-08-30/rustc-beta-x86_64-unknown-linux-musl.tar.gz=4b7216393d167874d030e24efd637717f8451c89506c4964220632556522e881
-dist/2026-08-30/rustc-beta-x86_64-unknown-linux-musl.tar.xz=645c594846ac499aa29bef08dacf4402f2479413fb98ab255419bbcbaa39440b
-dist/2026-08-30/rustc-beta-x86_64-unknown-netbsd.tar.gz=a1044a20bd4e0894f94d0d2a2f2601bd9e8315be561bb196360950fc959c9ab0
-dist/2026-08-30/rustc-beta-x86_64-unknown-netbsd.tar.xz=c90e60e75e4d2420bb58df22483f028c92eead983b2a5f73e1c87f66196a80d1
-dist/2026-08-30/rust-std-beta-aarch64-apple-darwin.tar.gz=9f02f6d297a31bb6a6bca2648f7e6e381d386365ec2548619f200fce3d1d7109
-dist/2026-08-30/rust-std-beta-aarch64-apple-darwin.tar.xz=d8f4620f3672cae11fdb841a86d44215aeba2e656244286056f7742e966797e3
-dist/2026-08-30/rust-std-beta-aarch64-apple-ios.tar.gz=547510c49fc9c4d993ca76d7d2a38e6e0fc791a8b838fb30e246df78c3480ce8
-dist/2026-08-30/rust-std-beta-aarch64-apple-ios.tar.xz=b54fc751131000c13c58b2863ed238a6d6f750fdb1b1a5e6e1110e05bedc5f7e
-dist/2026-08-30/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=c2c93323193b2f6d796934916c002c0d98203745c98458678d70eaff2546566d
-dist/2026-08-30/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=ab88ae96f66a15ce8fb00296e8f7f292d31f941e89455529ee7544220187cdec
-dist/2026-08-30/rust-std-beta-aarch64-apple-ios-sim.tar.gz=dff0cf3e961505ada60f6fad68cc5f5881b725bb7ef0f0d23b6ae4fb8722f5a1
-dist/2026-08-30/rust-std-beta-aarch64-apple-ios-sim.tar.xz=b6c00ebacb1758e8f3b830a054df06d120e270c4b2a0ef88866b06be2bb95e53
-dist/2026-08-30/rust-std-beta-aarch64-apple-tvos.tar.gz=7f6c1cb3f8b5870449fdbfe1139f27c93b810b1f52da01a93abb8c8656ecc14d
-dist/2026-08-30/rust-std-beta-aarch64-apple-tvos.tar.xz=e40b47e96b7ad06f7e13fa0272b4b8014eb4799bd4c7237f35df513eb7eed7cf
-dist/2026-08-30/rust-std-beta-aarch64-apple-tvos-sim.tar.gz=158c8066d75a93d770ca620ffb64b92d39630b401a909f17e99765b9871ec25c
-dist/2026-08-30/rust-std-beta-aarch64-apple-tvos-sim.tar.xz=635d4e479727b51957b0bbfa14ac5ce7b3282ae146aa04a92ff28963cbf9635f
-dist/2026-08-30/rust-std-beta-aarch64-apple-visionos.tar.gz=28f4a6e679995ac6b4037f29c9cdc161183012edb39e484d31ce24ef044128d5
-dist/2026-08-30/rust-std-beta-aarch64-apple-visionos.tar.xz=b3d6255fb1e052747ddf5c3b3484040cbf03dbc882e92cde98c8656442f84cc5
-dist/2026-08-30/rust-std-beta-aarch64-apple-visionos-sim.tar.gz=09facc091183c715daf223d9bd158d6333c6e3f837627bf318f2c0e1be0851b9
-dist/2026-08-30/rust-std-beta-aarch64-apple-visionos-sim.tar.xz=4943e00b8e0496786ec9c2bfa526da1f44aa162f874f7084f51c95c3ec3a44b1
-dist/2026-08-30/rust-std-beta-aarch64-apple-watchos.tar.gz=ba3e478886aa3b34101334e3ab9a3543a0f5e3d44f44efa48bc7b56c14a3951a
-dist/2026-08-30/rust-std-beta-aarch64-apple-watchos.tar.xz=2e4e7035ab8464d8ba3775b66433b1888044394bf18343bbbb16304ada735368
-dist/2026-08-30/rust-std-beta-aarch64-apple-watchos-sim.tar.gz=7f8ffe07832cc648c8be54b79bc6923594a34e254245e07fe706fccd52b28195
-dist/2026-08-30/rust-std-beta-aarch64-apple-watchos-sim.tar.xz=343aef2c9816bd2007837916a8ee5101c1b0b97692066c5cf844a7230a42a346
-dist/2026-08-30/rust-std-beta-aarch64-linux-android.tar.gz=94b3a90192944d2483e2c4e3bf02a03e43b00540c16873d869a75b6e6d7a675e
-dist/2026-08-30/rust-std-beta-aarch64-linux-android.tar.xz=e26b35a45e9d2331b4ee37f6f9b70f927dc89cd4b956ec76c556577c7b0fa1e4
-dist/2026-08-30/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=24eef069090edc04f787002c971bccbc328775b54d98e3ab63b247a4c1e0e99c
-dist/2026-08-30/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=88cf54b25e9a76e303413bb6d32e064d784e6b83dc282a42d45983d57842ca08
-dist/2026-08-30/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=726999c2b5dbec5ca64e56abbce4d246dcb265d709df96d48a4653e863531ac7
-dist/2026-08-30/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=22e04ac2cd44daff5e5873f8492a1a3345f83034021923ff223cb3905c81e16b
-dist/2026-08-30/rust-std-beta-aarch64-unknown-freebsd.tar.gz=9593926d80f8b3adfa59b2073f48234001d70c08225d03e0f128f0188d2878c3
-dist/2026-08-30/rust-std-beta-aarch64-unknown-freebsd.tar.xz=f43da9dc7737f5881391e92013f773c6fc3888dece33eac141797617d590ecc1
-dist/2026-08-30/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=9d177fcaf3805830b0b0a1661d3306509f5620195877185b0630193220a95feb
-dist/2026-08-30/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=b1c017c1cc05c334f74dbf747d29e692cbf4bdb9c08d5778067266d7816841f4
-dist/2026-08-30/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=b443b40dbe16c1c0805778d34a652b16dd891e5d641ece48f988be00d4ae8c25
-dist/2026-08-30/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=295de2ccd9c9ffaf6648e76a4bd358289fc78ed0ed162d38a69632a6bfae240a
-dist/2026-08-30/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=8fdf744594d28f7425df836f3ad3289ea052e26aa98e0d9659c8f03a85d9713a
-dist/2026-08-30/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=e87932897c88f458d35e53873b2c019f2cebbf11e634689f8e9b97c9320adcd3
-dist/2026-08-30/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=33e0b8fbe21128edbaa3c2da91fac703107964f818624dd87a03179c9a6b4a62
-dist/2026-08-30/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=8c79addb67a5c8b8181fa25df85516bdc4fa69003c2f8c9e8a6c6c60eaba6920
-dist/2026-08-30/rust-std-beta-aarch64-unknown-none.tar.gz=39cafc68fb5044aa42fa274fc7c49bc210472d5cd97ed82cd09c98b73042f66d
-dist/2026-08-30/rust-std-beta-aarch64-unknown-none.tar.xz=78c289e2984f4b99bb9caa4d61833dc94b0588be7aac2309c4c9cf5d75b56703
-dist/2026-08-30/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=b6012253ae93c1a13ea4e8cab50873c206056fd9325d26de402e45669950994d
-dist/2026-08-30/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=d9fb182de0cffbb3a74fe309ba65d79323901da154e9766a88a569247f260d2a
-dist/2026-08-30/rust-std-beta-aarch64-unknown-uefi.tar.gz=f54892f078518f520b32bf76a932cce2c450289cd70c826542477401109eb3dc
-dist/2026-08-30/rust-std-beta-aarch64-unknown-uefi.tar.xz=672c8e38330262341209232c73bb600f2949b3d5a1f5c93d0a95e18539fb94de
-dist/2026-08-30/rust-std-beta-arm-linux-androideabi.tar.gz=887d61d7764ea35bcb2fdd608940a0d3b0d888cd2b8c94f33d242ae71d2269d7
-dist/2026-08-30/rust-std-beta-arm-linux-androideabi.tar.xz=29f1dea85c828ae819c5ebca3d76dd451cf72e9498f9f207f3272162cc159cd1
-dist/2026-08-30/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=b735d7f9cfac1d3a7ad22e0b79979f78aeded3c538dee686728ff9e8c64d6787
-dist/2026-08-30/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=878c84e83139426b209f0ae84a898e005f499d38700f5d8446a6aa4ad81feabf
-dist/2026-08-30/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=bdaf3e6c1fba51bd37e7d23b547642885b97e3e66e3e5805f60ee03332e1548d
-dist/2026-08-30/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=26446f3d1d9e235e11ebe6e21e3c8bb23efe5e8d31671bf2d573af5e39ae7ba3
-dist/2026-08-30/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=21a1317f24f27d3c567c08c8306f3c97a38dad185bde37229e7c279adb52875f
-dist/2026-08-30/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=51ad360481ab758d3023dc615351afba30cf99a162e3f207f5275b5995258412
-dist/2026-08-30/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=57d7204c68646f489e1db251e69d5fbb329e71954100a9a58bc4eea5bd526c34
-dist/2026-08-30/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=01b476bcd78cfc757d9687ad65cad8c15f4bc5bd2e3149a04314e1604257169a
-dist/2026-08-30/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=3b94aba1d51f5a6f039a555122d358bdd8e8f3a1a13e3622842a56acd9e48765
-dist/2026-08-30/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=c814c2d7b7de9f97457932139960d40d869ae6783528a6e0d7edf3af0d34da2d
-dist/2026-08-30/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=2783998a08bf439cc4f6113a2d7f454791a8437bc9bf9b8d3a9d991bf830eddf
-dist/2026-08-30/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=bf7bb1f7e676b0f70786ba671a687701879a7b34f3ebee99e6faab139444c0ca
-dist/2026-08-30/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=0d39dc704bb80630048ca2b6b3706c4e9bbf8c16a1eb24c41e2c818e2c89222d
-dist/2026-08-30/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=98058d9812f279e9797e6e2163d706dfa6676647d6abd64efae52d9602978bfb
-dist/2026-08-30/rust-std-beta-armv7-linux-androideabi.tar.gz=906e3d6b21ca38b6358a9c381aba7aa8e2894a2abe649d12dcef91cc5ab83dca
-dist/2026-08-30/rust-std-beta-armv7-linux-androideabi.tar.xz=bd9c5e2dc8542dd0ebcdb53b40422d364aec9399b93b731879c5cada4947583b
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=a4f1149965d18e306ae5fb29382daa6b0e17b1667d8eae08f0342267d7aa6857
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=58121e6668b93a7bd853dff02ff26fe0c4f5e721f23acb7f092cbdac35835a87
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=7e3ce83fea162bd4eab433bf35402ecc2099a46afeb66b86ea5e54f0b53a93d5
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=4737ebecd9ded896ce25f72c7d2397759bd9243d7399bd6955b90e3fdb4c27d2
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=26d2c719cb467295e3effaeae939241325d6fdfd6d32784e90b6c955cf294ffc
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=d2ec9ee496d74deafee30846ce577333154d4c4221943d53129f3a4c8365118e
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=60007d5b87b54b4f500ce686b1c6740ab7641dda28676a9c56df7b9a36c34141
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=1befc6a2e3b6d7e23bc132ad6fcf4e59934d386e2e467dbbc5ec425d628db846
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=6ee69a47a0ce552fb9b69edeca089004c84de1d380ea45554964be8dc5b854d7
-dist/2026-08-30/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=6a594a15e7a1962f4417997d1b1fcdfe72a3786f019242567a915237a8f12112
-dist/2026-08-30/rust-std-beta-armv7a-none-eabi.tar.gz=af06b8910b044e0c804802c316904d53d0a6072d601353927bf5d733cbb10664
-dist/2026-08-30/rust-std-beta-armv7a-none-eabi.tar.xz=dda99a3c47b6fdaa000172e3a9f52876d168499a24e33716a1277a2c1d3e303b
-dist/2026-08-30/rust-std-beta-armv7a-none-eabihf.tar.gz=42799d4c5f6b596b6f4c565358adacd2982433cf26f16bde99047f63b07ab97a
-dist/2026-08-30/rust-std-beta-armv7a-none-eabihf.tar.xz=0cb9cfeae9a30ec848ef007dd9144398c66be3a755ffe94d9898f2da9057170c
-dist/2026-08-30/rust-std-beta-armv7r-none-eabi.tar.gz=b248ea8f35a5557e53882f362ab00211f15124688f56e57474c66bece0bc5c77
-dist/2026-08-30/rust-std-beta-armv7r-none-eabi.tar.xz=9427d716b04a5b178788fead61b3b41abb4acf482bc3def3c1f9b3513243b156
-dist/2026-08-30/rust-std-beta-armv7r-none-eabihf.tar.gz=b8f8e1359af035a33afde195fe4c3de23412c950e216d1ecf6a80fe471f5eadc
-dist/2026-08-30/rust-std-beta-armv7r-none-eabihf.tar.xz=1a8aa055f437a8e6dc258d60697f10664b2e28e74ee450d256fd38243730a101
-dist/2026-08-30/rust-std-beta-armv8r-none-eabihf.tar.gz=3b512dfdc3365c1e7d19e42755506a2aca6efa880d754d7838e69b19f6a8d607
-dist/2026-08-30/rust-std-beta-armv8r-none-eabihf.tar.xz=f12bca87642b53c9ef4672ad070913a411de0b772a1f4437b9a258a989d8298c
-dist/2026-08-30/rust-std-beta-i586-unknown-linux-gnu.tar.gz=af08b969901c84b02a2501a667bd5cb89454a0817ba66c9fd9a00b03503c922c
-dist/2026-08-30/rust-std-beta-i586-unknown-linux-gnu.tar.xz=ec871b92b19cef0f63baea61298575f50ee568046470d0bc12bfc7bee830e846
-dist/2026-08-30/rust-std-beta-i586-unknown-linux-musl.tar.gz=b6805cd6642b6b1de3e637581313cb26241526112114adca8157179948f967e4
-dist/2026-08-30/rust-std-beta-i586-unknown-linux-musl.tar.xz=5c2827bdd87154ce42ad9939dae78a022d3c3045f9b8698f60292e5ba0a0ff14
-dist/2026-08-30/rust-std-beta-i686-linux-android.tar.gz=c568edbc22aba9c2e2360bcf821e9c60894ef3836fc7846cff4c178b2d746fc9
-dist/2026-08-30/rust-std-beta-i686-linux-android.tar.xz=0bd654f6591c99d139bb83ab7e2699327697feddb12edec50bf4f834c0edcffc
-dist/2026-08-30/rust-std-beta-i686-pc-windows-gnu.tar.gz=701a3087c3810884d3a83345d2ae8b3de6b1514fbf97bbed99a0421abf2fa2b1
-dist/2026-08-30/rust-std-beta-i686-pc-windows-gnu.tar.xz=b8e8bb023d34012e82d708a0d6e4a558c32f0e489b3eb381b88919aa554578fb
-dist/2026-08-30/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=a36eafa511ea809368df67889b2fc0b5a18ed7c2a1e9b21118b160f2b8a63a5b
-dist/2026-08-30/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=f1b0c50faf927e5ba97cf0533287cd132f1e3a2b9cb0338f7a56e1ed4311b0bb
-dist/2026-08-30/rust-std-beta-i686-pc-windows-msvc.tar.gz=847c2c7aed2ca9f03bc2a8a46ce9b2e48e968e8bb9d947349f83ecde27464631
-dist/2026-08-30/rust-std-beta-i686-pc-windows-msvc.tar.xz=e49a11c577a0e860cfac07eaf0fe1a0f502ada16ec7c05c02d0c60293c8aff8d
-dist/2026-08-30/rust-std-beta-i686-unknown-freebsd.tar.gz=c2435372ce00925ed17120ba1586b5d3dac6b4ce979e02698d87a74ad71a7a7e
-dist/2026-08-30/rust-std-beta-i686-unknown-freebsd.tar.xz=113874727b99b497e5b346e908407f41b7b2f85cae272cc555dd3699fe8de8fb
-dist/2026-08-30/rust-std-beta-i686-unknown-linux-gnu.tar.gz=78385dde39126b0eb524a3681bb8607c016110985ef0b2f2da00c86a5961d64d
-dist/2026-08-30/rust-std-beta-i686-unknown-linux-gnu.tar.xz=52480e55a90a54d3174232b4b76f6aaef9055da0ed49733b19ea6c3b8a6db1ea
-dist/2026-08-30/rust-std-beta-i686-unknown-linux-musl.tar.gz=350e1a7c2925462c4c2a8b796874f17fd0e284680f2dc2e930017b585ed661c0
-dist/2026-08-30/rust-std-beta-i686-unknown-linux-musl.tar.xz=fd62e7c69e1d0388aaeba25a9a65c8e327e60dbbc3f57948b9f7000981eb4172
-dist/2026-08-30/rust-std-beta-i686-unknown-uefi.tar.gz=41dd818f059414729cd8978a4b79995b765493885dd89a0587be88b83f844aa0
-dist/2026-08-30/rust-std-beta-i686-unknown-uefi.tar.xz=6fb74e7c1b4b20c8b28966e2ee89ab9b1208fb43f57d8f9fe91e5c5bdfa9e046
-dist/2026-08-30/rust-std-beta-loongarch32-unknown-none.tar.gz=5cf23bf844fd1157b9360303459beed6fb1ca77a2bdefd7d394a1d50385670f8
-dist/2026-08-30/rust-std-beta-loongarch32-unknown-none.tar.xz=d952d3f950b776c68528bba94c76a06fb2d55d363fcedeecb1155d6de3a31d3b
-dist/2026-08-30/rust-std-beta-loongarch32-unknown-none-softfloat.tar.gz=1967abcc458e9f5efc46f052733490cde533ea074a3ddc0d2fcbf002be4ddc79
-dist/2026-08-30/rust-std-beta-loongarch32-unknown-none-softfloat.tar.xz=bcc63e232b44d653196104d93629ead81c19c1facd03d97207da744c353167d7
-dist/2026-08-30/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=d8946832080fa2e13498bbe7e0cc5611f1c93da1a7b5e3b19c836d03fe784c15
-dist/2026-08-30/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=fda84558d60dae4383d6556545bfd0f292f4ca7226db012948c3c2c32b514c6f
-dist/2026-08-30/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=63e4aaee66fdf0444becbab59ecbd7a1955d27e5e7420507bfe78e482558a4e7
-dist/2026-08-30/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=6bc088d81bf425614dea2f31fb0bcf229566cfd912078ba997e272492f5dfeb8
-dist/2026-08-30/rust-std-beta-loongarch64-unknown-none.tar.gz=aed26cd5efdefbc5b636d3a31566c816eda9dde7061efff48b327254b2fc9653
-dist/2026-08-30/rust-std-beta-loongarch64-unknown-none.tar.xz=dd470e7c8ed1a37cd140161988578a31297de2f3739a1d0a1994618f61c4c290
-dist/2026-08-30/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=be92ce71185bb0bf4d0b220806e6d0251c80eb70d6ef133c205e8121863d0f41
-dist/2026-08-30/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=1417b6cf3730f228ac07f045b8ee6506c2df0d8ae7b262e61ea7625c2ee866af
-dist/2026-08-30/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=1b10411f90f9ceb94ba6e901ea347a7b14c784250b26c7ebf578ea0f0f774c34
-dist/2026-08-30/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=5998d419985fe62e015ff1d01f83907a7606c28364c0edbf540db598dd446ec6
-dist/2026-08-30/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=efba4705562534e2f6ef97857cef856c4d1c88281cb307c7f6696bac05eac943
-dist/2026-08-30/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=d716a06bf4bc9ad2f2d3ae17997cc3b377b8dbd1dfefaf93ae7d4f8c6a913af8
-dist/2026-08-30/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=7576dd106e174a21eaad65bf48351233ad8cdec1c5f172f6531efc1edeb40f59
-dist/2026-08-30/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=e187119c3fda1b444c340f4d123f95fb23274b624683c844676a15ca2457c209
-dist/2026-08-30/rust-std-beta-powerpc64-unknown-linux-musl.tar.gz=43e4647b626a5c8eb34ef930c70b89ae1efc4d7cb93ea35ea91ab82d52e20ae5
-dist/2026-08-30/rust-std-beta-powerpc64-unknown-linux-musl.tar.xz=ca4204801a3326475c726e3916d9a89c1b8f4f9eb8f2115dac4f005f080355de
-dist/2026-08-30/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=a5d389199f5e64c7f25a97cbd80082a9b07481d79bdea6052ccac4d5e46ee390
-dist/2026-08-30/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=8979ec9fa392b43e9e0e166a68dfb4a0fdf23e28bb54abcd305b5e0e99811a72
-dist/2026-08-30/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=39b9c96f6c01f8ad15e7b5e3cb1550258d9380ea43126c25745c38b7fdb57583
-dist/2026-08-30/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=cf68b7783e218d0b5fac2bc6a431b3c8dedbf016c10c510558771cbdb8c473a0
-dist/2026-08-30/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=adac96c3877930f85c8a9ae7a3afce44bf9030c1bf389dc3e21e7ab0c83c9cf7
-dist/2026-08-30/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=138e96b975fd2bcf54525775a02ab05e1f9ad80095d01116f33693b4359bf0d6
-dist/2026-08-30/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=e7be47333fba57452ed7bf22bdb165a60ea243f9a593df5e8eac32796b0d5d7f
-dist/2026-08-30/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=9b4ed1df7fc906cac3f1c9bbb5e546b58e9c6402b9573c4f69c160df8c5e00b8
-dist/2026-08-30/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=43898c8585bea709bcd682eeea33e914ab8be343ca27dfb82c3524e5ece2d37c
-dist/2026-08-30/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=af236521d4556f90cc003dd17f692de787befc62e8c2df11242262f7c2afff22
-dist/2026-08-30/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=2f8125c2d07bb57d821662f06b7eaf00d8b98a7386be372cbd6cd517eb6c6e7b
-dist/2026-08-30/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=1a86efb62f35f60d7b1860c37430e039cecfdad2053f6e449577200d715cbe58
-dist/2026-08-30/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=6f09dc0d0bb9775d0f4b52277913e5fe8795c3d77e178e1682af563f3ab3a030
-dist/2026-08-30/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=0de9f4b1fe08f33dba23effeefa4695a4201094cc587bfdebfb4408e9d58cc8b
-dist/2026-08-30/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.gz=dd2e782f2bda2c8f220727b85f8d702efb70977c2232c48bc5d9858264501de3
-dist/2026-08-30/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.xz=d1ba75a8d572591380bba39dd6fed42025f481642993329dc7c20479ea92a6b8
-dist/2026-08-30/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=d01ef2e3a1ec1c69b3a80aad302d066ea4fe406ff752c9b65f7ef1beebba0c22
-dist/2026-08-30/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=fb919571c31f43ef03b35908bf9ca85ba6bcc053ca289380ba2552c4e64104ba
-dist/2026-08-30/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=b187f1deba8ea1bb3d3e793c3cb2a6b7f309940e4edbe8b406a023bce82d8785
-dist/2026-08-30/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=741cbbf9d91e955303f253ecd885168737dc01369feb33f738290668be01b146
-dist/2026-08-30/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=ed5c5a046e9896c7d9ad35c76db1c0216ed31c0661d30e29f3f7b5c8211aeb48
-dist/2026-08-30/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=1ae3c3dd12bc5e669d953521862fff3cec12b6f9f71bb8e3e7b24290d05114cd
-dist/2026-08-30/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=3d3bd0667e139054169ec2ece3d16219269c858ffef37c4e9615b5bcf1e3c83b
-dist/2026-08-30/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=d350e91efad53a550ef8c825e7f7ce12e99bf250afd9a93ed9fd155b72287947
-dist/2026-08-30/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=eac3ec8b4eb9a3b9a127d2e6fffc4b4a752449eb7595950c9af0dc83ea969b72
-dist/2026-08-30/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=d081593cc03f52a6937fb3bef0a2103a02b43cb4705d1747b8b513e1f0983834
-dist/2026-08-30/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=17db3b6de8e015e9c572899bedea98996a47d725c59664e338053ed590e4e33b
-dist/2026-08-30/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=2e79e7c3eb7515581a8bbee2d02dd8242d7d3d1529eb067a387338b2ae5a63e6
-dist/2026-08-30/rust-std-beta-sparcv9-sun-solaris.tar.gz=72474e747dbdc104c817c90e96e209cf4adc2a441aea37d9c6dc3f89ceaa1a5b
-dist/2026-08-30/rust-std-beta-sparcv9-sun-solaris.tar.xz=65cb719203ec265623fffd66f905257c0eb284c0795e736adcc8dfd31750378d
-dist/2026-08-30/rust-std-beta-thumbv6m-none-eabi.tar.gz=25f399a7944d8db8a44c49c0adfe7800fa4b12585c49fe2ed69a1b417571b786
-dist/2026-08-30/rust-std-beta-thumbv6m-none-eabi.tar.xz=02183d46df50acf3edbd6778eccf24e357f9d49d87ae0d8808ef47f98cfbfd51
-dist/2026-08-30/rust-std-beta-thumbv7a-none-eabi.tar.gz=839004d3d6ac180bec0e467a7bbd2ea1ddb47a0f29a92f8b2a074f628cfd0395
-dist/2026-08-30/rust-std-beta-thumbv7a-none-eabi.tar.xz=7b9b6c32078adb895fd07f3f72b2db25e9358bfa4a0470d7cfdc3cc7b5a827d4
-dist/2026-08-30/rust-std-beta-thumbv7a-none-eabihf.tar.gz=5e962fec3cc8661e9a62f15c688ac76bc83685e19c163d3b899ec423766429de
-dist/2026-08-30/rust-std-beta-thumbv7a-none-eabihf.tar.xz=8db16b6186b89b3e9e0c5560a12bb09d08263e04aa0f9ee878d25dba9852447b
-dist/2026-08-30/rust-std-beta-thumbv7em-none-eabi.tar.gz=0150636fdc64ec355916eec21d1dec8f5e73881dd21cb78907a2f06c14a896e8
-dist/2026-08-30/rust-std-beta-thumbv7em-none-eabi.tar.xz=9e4dc0a8492ea92703df7e00994c0e1728d2eb3152947e9b8550d6ae05a76d0d
-dist/2026-08-30/rust-std-beta-thumbv7em-none-eabihf.tar.gz=fe3fd11562d4c428ae2757d42f17ee17bf9485c7e7fda2f6a54406ac6ae14444
-dist/2026-08-30/rust-std-beta-thumbv7em-none-eabihf.tar.xz=97735c5e6f77e59ca7540eb303eaa2432f632f867fc7567f1d25540504e889b6
-dist/2026-08-30/rust-std-beta-thumbv7m-none-eabi.tar.gz=e8afd6861c77eff9e8296e1846c01c06d6b83a858bf76099a79588f167999efb
-dist/2026-08-30/rust-std-beta-thumbv7m-none-eabi.tar.xz=0421b81a17afc3af31e46a8bfe32a9b178a6a29ba58e25d71be991d1ab84babf
-dist/2026-08-30/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=9612f99fa78f59fcaed30feb3c8660c3ff7e731011226d6114cc49e3f765bb2d
-dist/2026-08-30/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=405ab112b26871dc310a7fe3c67d821544f48b4acace5d406c491529555cc890
-dist/2026-08-30/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=884b25035258fc7cfc7b2a0e95358553a3c7812954ec7a18dde82fd77cad24b4
-dist/2026-08-30/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=3648213c47d2e29931f4837914b3aa5d00575ffda7d75654c6d3cd1aece8474a
-dist/2026-08-30/rust-std-beta-thumbv7r-none-eabi.tar.gz=680435027aab539feae6b3904717139e20640eb783c7da2ee31f3d06c1c6ac1d
-dist/2026-08-30/rust-std-beta-thumbv7r-none-eabi.tar.xz=8fad51ba8f85f7762f40382c1a177c86f8b7ae1a23e41871f560449f34ac099a
-dist/2026-08-30/rust-std-beta-thumbv7r-none-eabihf.tar.gz=0a187507505715a5a4497c0422adba69c03e496618e20023d46aa1a261a7e793
-dist/2026-08-30/rust-std-beta-thumbv7r-none-eabihf.tar.xz=b8bdb79d81f1fd5dbdc090b3306f4ec33673dcfe24350c44e1544d00bb8bbe42
-dist/2026-08-30/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=430646899a6bba8c9233eec0987224e2ed42b6cee3aa37ce12bd8aae66097a21
-dist/2026-08-30/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=36576d200890f00ba9e22cbdb337262ef12dc99271c8006832ebe0752c333ccb
-dist/2026-08-30/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=2b3cdc315cfbb7bb1a55705cd30934ceb14b7b098ac9e9b86af2091acc1b46ed
-dist/2026-08-30/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=ecbee4d541806d2f4559e53e4da549293f4bb881c2f5d99107043251a1f80790
-dist/2026-08-30/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=8f925d1d913c67ffd9d28c8d02b47aade2388472015f4917a0f3166a8a789bb7
-dist/2026-08-30/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=c9ba654ccafd0cf8e876770f3133ae143da10f37058978cb67a547f64aa5812f
-dist/2026-08-30/rust-std-beta-thumbv8r-none-eabihf.tar.gz=615b2c19357545860fb64ec3b6715c004a4bf29299d8d2130b022acdc7c46ccc
-dist/2026-08-30/rust-std-beta-thumbv8r-none-eabihf.tar.xz=27d47d56201190afbaf2e2339d3f56964ff59972a90c994ea551438ed4703eea
-dist/2026-08-30/rust-std-beta-wasm32-unknown-emscripten.tar.gz=8ccf1bbfc69d4e8e452294a838adf848d32d57621350a7791d8ac8e1e72f8336
-dist/2026-08-30/rust-std-beta-wasm32-unknown-emscripten.tar.xz=5bd2be0368720436ace1cf02569ca50fa222f936bdda7761954108756151b3bb
-dist/2026-08-30/rust-std-beta-wasm32-unknown-unknown.tar.gz=fbdcf8103c16966255aa5a1a65ed02fe6e39862ef2b6e6eade8af07d51654392
-dist/2026-08-30/rust-std-beta-wasm32-unknown-unknown.tar.xz=5c4f71b3be2808511727536c13b6af98fb61661c092031df3f24c568f8bd31d2
-dist/2026-08-30/rust-std-beta-wasm32-wasip1.tar.gz=254037cb663a97b20471a3c87f95d62d1be7b2810a35e53acb219a552e8b58fc
-dist/2026-08-30/rust-std-beta-wasm32-wasip1.tar.xz=5f651662f78216db6d2db5a8ac7f8ed04349a82530c08aab2fe3b43b8ea8bf8a
-dist/2026-08-30/rust-std-beta-wasm32-wasip1-threads.tar.gz=6093fe10ebfc96c45909e85ae72f98e4f8093cdf2ce9bd720ac1a1aabddbd60c
-dist/2026-08-30/rust-std-beta-wasm32-wasip1-threads.tar.xz=175403a655dc2afa2f7b41bdaaac4cb371a6c5cd99a043178fa93f97ab02f604
-dist/2026-08-30/rust-std-beta-wasm32-wasip2.tar.gz=5248648157e3ec5c37d12a40caae0adac59aaae47438585e79a7fc91c294ddf3
-dist/2026-08-30/rust-std-beta-wasm32-wasip2.tar.xz=46705306104b7c5d25a15c0f3cc94f5e208d4da2b07eb516d63533194e901b5c
-dist/2026-08-30/rust-std-beta-wasm32v1-none.tar.gz=746d7fa3e93d255a395baaf67d3d318e6419732698ab0089692bdbed5ec4a13b
-dist/2026-08-30/rust-std-beta-wasm32v1-none.tar.xz=97d8daf857aa2da8f8daff5f7137c4cf442f3cf05a019b5608a20a4cf5e5d291
-dist/2026-08-30/rust-std-beta-x86_64-apple-darwin.tar.gz=8a5ca2b36f9f4b2ba1dfde1539e95c30a20173137b9822e7d0ec5b2c12aa89ec
-dist/2026-08-30/rust-std-beta-x86_64-apple-darwin.tar.xz=2daa0aa9b738f036815b667c664e152750acbb9d14ab41e4ea994000867caae6
-dist/2026-08-30/rust-std-beta-x86_64-apple-ios.tar.gz=4eb04a86e00e50becf154d88eac41feeda32c76730297fd05178a1e941dce0ec
-dist/2026-08-30/rust-std-beta-x86_64-apple-ios.tar.xz=80dd8be8e4c1a83b66a0cce6cb5bdea61640e471e755c314a549b56dad10d2d6
-dist/2026-08-30/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=5080a59c173281ec57ff14c32401cb769b1a577ae7710cc54c820120b35c5564
-dist/2026-08-30/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=fae0fb63364548777b9e644e83e3c6d7aeab37953efea5ac27cd2558c828a551
-dist/2026-08-30/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=fdc91ac8f59e98eac84f79059a486c2ada66890f22b7e66ef7e0b899f65b36e9
-dist/2026-08-30/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=9ead7033def70e9f455e4079d8a8b1c870f8871b80ae721a41f11e53106a6b64
-dist/2026-08-30/rust-std-beta-x86_64-linux-android.tar.gz=c143b388083353883d88d109db9131c1196d2874a0195b66aaa4427365bd4563
-dist/2026-08-30/rust-std-beta-x86_64-linux-android.tar.xz=f877fbc3b099bccfc531661cf4a5d67a69c0cf426b7d6d3269b4aefb85304f9e
-dist/2026-08-30/rust-std-beta-x86_64-pc-solaris.tar.gz=719cb1ac855967c03120c7408d05d88ff101e34de40a65f2d37828f496a84eb6
-dist/2026-08-30/rust-std-beta-x86_64-pc-solaris.tar.xz=647430147f7b7903111ef24a90d2f326198ca70bfa0bb0ee5b1e76d297e9a81e
-dist/2026-08-30/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=520d157e438e557e8f37792b9c59c913a732c77149b534a1c7d2769b52e932dd
-dist/2026-08-30/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=830bf07e7f1b80e535ddfc2c269c8bd4ca3c63853faa6ba39c7360b0fad976d6
-dist/2026-08-30/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=74c1ea656656a624eb84650a833f6d4d3428230435c67ce0a92798a524c55124
-dist/2026-08-30/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=8866757f9e3508bd74c724c754511413697229daf50da755411ddc8f9de78fbc
-dist/2026-08-30/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=8b3ed1fbdf18c25a2900568f9c974154750a187d5385e06537fc54c607e8e305
-dist/2026-08-30/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=f5250ac89f4ee3b68b86e125e64b2209360040189b39e34671aee03b9de3abad
-dist/2026-08-30/rust-std-beta-x86_64-unknown-freebsd.tar.gz=711017150d461a85f3dcf28a37c7fa354ae08dbfa9ffa049576e71b224d7c189
-dist/2026-08-30/rust-std-beta-x86_64-unknown-freebsd.tar.xz=5f8a081aa1b6e7ab3bf88b6548ed55a0c1021b26060ee2655da38556b54a0e06
-dist/2026-08-30/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=40d0e66f5b6c1831684ec5c6946e2467e9c81c38d5a7ceffbdc9441397d6c214
-dist/2026-08-30/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=2632a2393f2f51884db1c07a3f193f19942bd20ab7a3bce6f654444028188aab
-dist/2026-08-30/rust-std-beta-x86_64-unknown-illumos.tar.gz=bfe5417f3575d1fd0302e6caef380e33c71fc07ab1b9a98fc80d66cf8997006f
-dist/2026-08-30/rust-std-beta-x86_64-unknown-illumos.tar.xz=bff9b2786581d340b0e801b085bdfb40d19309e07a99a97f92cf2016d77db81f
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=76d75f97d7b0f3421029d078473529de626d1413d5ac8c0473325c15f2765573
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=1ec3eb585a38de48d12e05f78c82394493c9c640f8c6fdf487cc8c29ca88742d
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.gz=7d12531568c430c670d4933955b767985504a88c3da513b832b857f28e59fbf2
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.xz=ade92cb3f5ca0088d93eeac74ec29b8532d285a730eb87350086e9cda4f7d60b
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.gz=6280a11a0e153f98dfbd4892a90ee60f086c812ded8177e21e6fa3fd9f733441
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.xz=51792543085e26437577f4c3cabd226571c9f9d5b85d142a4d7ec19b992c4bf2
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.gz=85bdd806ddf39fe35df389895b3c531df21b26dd60945f2b92a3f7f7627dfe77
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.xz=076be1c27da9f50254ed8ae748c0ebe01a21af0c47920e035ee25121327cc607
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=e0c5acc46aac350663adc8b6b73e097299a94574785baf5487181b321979b34a
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=f9470afacdce7db3d057bf13af6b6e45574b4c6cd8a1c75adbce2732ab61515e
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=f207346769473385b1efd771abcc0e2a95d73dc93e5039a0ce4cc329daf1e83b
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=25d752aed1d312ab614cd065826c688440aaca70cc7e67c4578ca82398f951f6
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=fc511b73ed5c0da3303efb8b5e01d6e4465cf028543a9ebcd5b1ba273e3e5104
-dist/2026-08-30/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=9ada977527a2fb632cfecd9414226664b47514adc988fbb0e3cb86cf1f81f81b
-dist/2026-08-30/rust-std-beta-x86_64-unknown-netbsd.tar.gz=9268af9ae7ed919e0955a1162376ed84c65906304f3dcc64762a6f8dc764031c
-dist/2026-08-30/rust-std-beta-x86_64-unknown-netbsd.tar.xz=49f7e2808660320fcde2f1ffe23d4e5d44f26c9d08124a97ffbd715d24c0d21e
-dist/2026-08-30/rust-std-beta-x86_64-unknown-none.tar.gz=7f2dea659c4d5ff038118307cd2fc6286a95a6dc12a85686bd958806e3d49647
-dist/2026-08-30/rust-std-beta-x86_64-unknown-none.tar.xz=e96d78c8025876bdb25613fb81cf27b54803ab0a809d761909fc56e626153e1c
-dist/2026-08-30/rust-std-beta-x86_64-unknown-redox.tar.gz=7874b37200d60c3986588f6178a623817acbcb66bbbfb9b81c9e4ae348cbc0bf
-dist/2026-08-30/rust-std-beta-x86_64-unknown-redox.tar.xz=a6d454739b2fcd6728a7c19afc6e95e6ce2dfb02a569619a071b02b3fb7a6e33
-dist/2026-08-30/rust-std-beta-x86_64-unknown-uefi.tar.gz=6b4c4371089aa7d2be7dea927dfc623c9958998cf02952b8455dc4f05c466ba4
-dist/2026-08-30/rust-std-beta-x86_64-unknown-uefi.tar.xz=1dd395befcbdd4f379a2f78e498c15113e07934b46dfede8dc1075276d7c7cf2
-dist/2026-08-30/cargo-beta-aarch64-apple-darwin.tar.gz=9e761054280cc664f95355b3ff7c9828d6b98fcb63c6cc65b3ef07f78fa98a2c
-dist/2026-08-30/cargo-beta-aarch64-apple-darwin.tar.xz=473eed6c6004b83a306c4fcf34002560c292050a6c25247a8c1cbe3ad05b93b4
-dist/2026-08-30/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=079698fcd5ee509d6b733e7119a8023d9b5e538ea526b64fb286cfdbb85fe16d
-dist/2026-08-30/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=86018bbd5e4ce4a2ed6fe33c520fbdaa1e1cb93a86cc47f8fb8a84f139fbf77b
-dist/2026-08-30/cargo-beta-aarch64-pc-windows-msvc.tar.gz=136513f5d9caa1d9a982c5731f07c52ed33ffcca18cf8c76f65b15193788f4df
-dist/2026-08-30/cargo-beta-aarch64-pc-windows-msvc.tar.xz=faaa5028d993cfe8ad0c86b03e8ce2718bf20e8cee68d8185ecfa39cfa3870ad
-dist/2026-08-30/cargo-beta-aarch64-unknown-freebsd.tar.gz=f9c7edc721b9e36377248325ec7944df39cf2ca005fb02a91a4994d717ad4783
-dist/2026-08-30/cargo-beta-aarch64-unknown-freebsd.tar.xz=581acbb17a497d6b76b99cc94833a33d72e104f2efff7d408d69550f912da462
-dist/2026-08-30/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=33647f90516de973cbfda8c553497ae5721e4412c4aecbdba1af4ff414093ca6
-dist/2026-08-30/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=9741da1d26464d27e5566220ac240ece0c94d95e0458e8e945c1d29cc198746b
-dist/2026-08-30/cargo-beta-aarch64-unknown-linux-musl.tar.gz=92e567bb8a7eeee6e001bd47b39263473d69a6591a9e64f9f48736a3ee631669
-dist/2026-08-30/cargo-beta-aarch64-unknown-linux-musl.tar.xz=69bd4e038b62ca7a94d85b3673286fe9a2ff57d4fd750e35cc0f4edf2e74b701
-dist/2026-08-30/cargo-beta-aarch64-unknown-linux-ohos.tar.gz=58627d33a59fcd84a33e71e121f267e675d78a181fdabd8bfd645b0c21e36c33
-dist/2026-08-30/cargo-beta-aarch64-unknown-linux-ohos.tar.xz=4dd725fb1d9eb9f7f1434edf563642dd4357b4622b7990ca835c62db9b26bf55
-dist/2026-08-30/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=86ca22788c633215cdd0ca96986136504dc7525c1d6d12da5d2d37944986ea21
-dist/2026-08-30/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=99f26d926f354f3a72fb422bcd8a2f0b8379ac727d5c3f16b57b433fe9f5d656
-dist/2026-08-30/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=681839287ba9bcccbff125e21f9b1381915ebf1e2748d558cf4ff1dcace861fe
-dist/2026-08-30/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=cf1e4cb9ebb5c86ad2090a9f08862fc85ee00f0c0a4dce50df4e688112e2b3d7
-dist/2026-08-30/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=9cd65395b781a22ec66e2e49e78d5a972360c93b5da7ed22b837635c68899a0f
-dist/2026-08-30/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=b3c6b3a99f537303f2419cf7379cbdbacb899a956ad0653b0726d558f893f481
-dist/2026-08-30/cargo-beta-i686-pc-windows-gnu.tar.gz=055b916329d7848a521f63cbe6c373a4ad94a36e9c2cefe155283bb67b2c655a
-dist/2026-08-30/cargo-beta-i686-pc-windows-gnu.tar.xz=728142c61e80ed2884a41446fb5ef9784ae66c6a5ae01d34548ad3722bf17547
-dist/2026-08-30/cargo-beta-i686-pc-windows-msvc.tar.gz=902d87163289b5f7c8876d79b4bcf6a524f445007afb41478c3d446c47e8efd9
-dist/2026-08-30/cargo-beta-i686-pc-windows-msvc.tar.xz=f8c2377f283109ba8db1d15925ebf549a0297d33245d67efc2f178fbbc13a766
-dist/2026-08-30/cargo-beta-i686-unknown-linux-gnu.tar.gz=acb2edc9a1e93476848d22725017ca6c80906875cb3c3cd5f23972a9a96c109d
-dist/2026-08-30/cargo-beta-i686-unknown-linux-gnu.tar.xz=6600fd8770b01333c808210c5fe794cac10f302e4d256d1c76d1ad3b86b2c63c
-dist/2026-08-30/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=98b4d2d3c9684c4477cbab01edad84970f9bbef0032249800f48cb4aa6259eae
-dist/2026-08-30/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=3ab812af126bc73f9da76ed94436b856b3a5b778a0594773217ede933c136e89
-dist/2026-08-30/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=d5058dc322f0f947bd5b8ac8644df85ff760797283d4cd62a08c6137fb1b31b8
-dist/2026-08-30/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=34dfe36b152df195bf161ebf151e7166096b8cf9581b8972b49b17cd9be6f101
-dist/2026-08-30/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=7402338613366b038279a45a2390a403fd7479cca7e38fae1614e3356b1ed17b
-dist/2026-08-30/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=6637409067ce9667b02142a3866bacac5b378a7d3f4c1198ad63b8dd44e13683
-dist/2026-08-30/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=bef6d62721d7cb4a5e8d16b4ce8dd0b64100991ff86e4228ccfd2baef6bc1d13
-dist/2026-08-30/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=ab6ebfc224a8b5732b009ea5fcd082f6765ba92c1912b4507ad6b7020d366f31
-dist/2026-08-30/cargo-beta-powerpc64-unknown-linux-musl.tar.gz=07db627041a31120cb4c416ba8d8cd9497e496830568f06770aaf3bd2388cf89
-dist/2026-08-30/cargo-beta-powerpc64-unknown-linux-musl.tar.xz=c5438cb0e1df9c6dbfcb31d9b578d8421dffea54ce84fbb16619b57eaac22fac
-dist/2026-08-30/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=9ec047abc63b03ade31cad80b0e3c247855ebbdeb42081f0e7d1cd0fa2d6a591
-dist/2026-08-30/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=59850205528f58ec1df682519b33d149dacfd34c6820188344166be741b6496a
-dist/2026-08-30/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=b51d3d280d5c7db88697f5cf62a16bdf87debc3a36e169e1613b19c787684460
-dist/2026-08-30/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=42fed8ea76cdef7ef55cea3f5afa7b65bbbd0f64a7dd91c5128b4d0a459a1d61
-dist/2026-08-30/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=674a081bb7e9264aadd9877cd56e354023bacbd3d7645f47b5e56fd929b2893c
-dist/2026-08-30/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=cad87b60d098bdc83f26039d2a7b01cecd72b454414423786e69d7830fbc2f11
-dist/2026-08-30/cargo-beta-riscv64gc-unknown-linux-musl.tar.gz=0020a7c5575ac0aed412219257ac4ed7af155ce4696382ee4a5b20113331b8e5
-dist/2026-08-30/cargo-beta-riscv64gc-unknown-linux-musl.tar.xz=ceb3b28ee22ad4b7e893583774680f5be45be9376fb56d23d48ac6201bc972e8
-dist/2026-08-30/cargo-beta-s390x-unknown-linux-gnu.tar.gz=59836d761c03a77477236199be5b0bd06d2ba5ab1d0f39176e1d7c8434eb45e2
-dist/2026-08-30/cargo-beta-s390x-unknown-linux-gnu.tar.xz=38dd22d489aecdf755bb667b4e79d2cb2ec8b6c2710d01686d600f1273e8d59e
-dist/2026-08-30/cargo-beta-sparcv9-sun-solaris.tar.gz=c9df6b1cf54638837c2ab060d81241b1cc9c0fe415927c3df281a6c27a46fa5b
-dist/2026-08-30/cargo-beta-sparcv9-sun-solaris.tar.xz=e1da5f2fc4dfa042c2819cc20ec8a7fe223aec9a3632899d83965b69c0742048
-dist/2026-08-30/cargo-beta-x86_64-apple-darwin.tar.gz=466f22d638541dfd8a067ae8b01d1d5ba3fe53e77191da3f3f676d4a90d88cca
-dist/2026-08-30/cargo-beta-x86_64-apple-darwin.tar.xz=239a1222ddc7c24648f902799dfd258ae334a37f3f58675e94a62879fa51d302
-dist/2026-08-30/cargo-beta-x86_64-pc-solaris.tar.gz=7623f134d775dc42c669f1f23dbd22415036927efe13b183edfc303003d714e1
-dist/2026-08-30/cargo-beta-x86_64-pc-solaris.tar.xz=126bd01ff0c9bb942e211a8fdf6712199979c35d1b6b2b19bbd2a21fbbea966d
-dist/2026-08-30/cargo-beta-x86_64-pc-windows-gnu.tar.gz=bfb4fedc712bceeaf74cf23245fd3efdd68728d77db8e04a32ddc329995bdd97
-dist/2026-08-30/cargo-beta-x86_64-pc-windows-gnu.tar.xz=b703ae1050c9a7ebb6b6ddb0523c59b2e5b38466716346e85e7c63c26588927b
-dist/2026-08-30/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=562f4d368d2d854ac580e07738411afb563373e247514e944bcd98f9967319ae
-dist/2026-08-30/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=f165e4bfef2e6bafeb4825961c0fc41ac7ac23d7457feb444dfb8c1e1e0d012c
-dist/2026-08-30/cargo-beta-x86_64-pc-windows-msvc.tar.gz=9a3c7ad87e5f3b98d02167c449437c0aba21d174a6ecfa2f0e4817b8c93ad91c
-dist/2026-08-30/cargo-beta-x86_64-pc-windows-msvc.tar.xz=831c421d5c5d187047920ccf7ce76300f4d9e3a36960e347d179f31b08f9b49f
-dist/2026-08-30/cargo-beta-x86_64-unknown-freebsd.tar.gz=3dd99be35b587a0334d71bc92dfe15e06ff0a052d66782a2425895684dcfe669
-dist/2026-08-30/cargo-beta-x86_64-unknown-freebsd.tar.xz=e4220bc3ccfb034fb1b40d506c9a9637153c943e0a0f9dea4bd56065df2698cd
-dist/2026-08-30/cargo-beta-x86_64-unknown-illumos.tar.gz=98de23e890441294de89857063f2810f81df29c02cb9da755793f78eaa8ca8fd
-dist/2026-08-30/cargo-beta-x86_64-unknown-illumos.tar.xz=9dbc424c16bed26b8d2ea662c41f156ef14636cbc2006c36af151ea68c932551
-dist/2026-08-30/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=2d2cdc1af3afe2816da895ed1ef0f27a31ee31f938a9385864c0c8e1385a2ec9
-dist/2026-08-30/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=62bcbf31738317455017be5dadb592ce9a6b937bf61303c30c56d4f6d8f1ac3c
-dist/2026-08-30/cargo-beta-x86_64-unknown-linux-musl.tar.gz=32247e6fb942d39444cab2b35ce2b64a44c84b2fa934acb781ea9c682f60f14b
-dist/2026-08-30/cargo-beta-x86_64-unknown-linux-musl.tar.xz=8c155d690af2600d9a4dcf00d62b6a5f52524e999d25d02eb873a6ab28f373e5
-dist/2026-08-30/cargo-beta-x86_64-unknown-netbsd.tar.gz=c588c5407c06a36da78587b6ee7baddc72b45ecb6fac9290e333fd0eadab1152
-dist/2026-08-30/cargo-beta-x86_64-unknown-netbsd.tar.xz=09c84a0118c5d533b442f39c33265a04abb72133c94f662654095f984f0e85e8
-dist/2026-08-30/clippy-beta-aarch64-apple-darwin.tar.gz=cc03b3970d8e2f5b055fab29f46e9120fdd520f6db45a6213a699a9a4367997e
-dist/2026-08-30/clippy-beta-aarch64-apple-darwin.tar.xz=7c6c789f64225fdc45aad2c8eb596aa679e855abb5c4d79573a458f2da7309ac
-dist/2026-08-30/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=b404caee9abf7e945985ccd5379f0e2f41c3b7dbe6e999d722b55fdf9d08c6ac
-dist/2026-08-30/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=36c9f84de6b071aa5f1c0bae438ae3ef132c4add9d35ee5a69e8a754501b568e
-dist/2026-08-30/clippy-beta-aarch64-pc-windows-msvc.tar.gz=bebf9f956d1974779ab06d7bdd25a7ea053811523ba2ff4ae18267bad7c80494
-dist/2026-08-30/clippy-beta-aarch64-pc-windows-msvc.tar.xz=fb4274e7618fe49031cb6f4021a0e7dc4bf1ee8900eb45cef118600c8137ad4f
-dist/2026-08-30/clippy-beta-aarch64-unknown-freebsd.tar.gz=79e922d0c5bbd69c86d7a459552e47511481eb5faee8a7a2eb893ccc5f7b6788
-dist/2026-08-30/clippy-beta-aarch64-unknown-freebsd.tar.xz=ed65f1ac492dafebfae2ee367135e1f56f57af9b2d284739fa57b18793e7386a
-dist/2026-08-30/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=d4aa6c22318d181ff4ef17f0ef2b8aea6641efac232f8a074cf4948e76c68802
-dist/2026-08-30/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=1d679549e6cb70f5acac81d255aabfbb6afef0c94973747e791f27e1097dfb8a
-dist/2026-08-30/clippy-beta-aarch64-unknown-linux-musl.tar.gz=0fecf358ff0e7725ec6df42b194a1912b91b358aad683fc48d36b1768c88042f
-dist/2026-08-30/clippy-beta-aarch64-unknown-linux-musl.tar.xz=443cb8a078231aa3bba0b8082cd5f20ce36caee120d1060e8f3cf73fd05d8907
-dist/2026-08-30/clippy-beta-aarch64-unknown-linux-ohos.tar.gz=f8b624585864c6bd679db4d505b8c84d46682b8cccb29fcd5bc5fcc74c7a79e7
-dist/2026-08-30/clippy-beta-aarch64-unknown-linux-ohos.tar.xz=8e09d294c73ff186be62d2db49a06240b6d66c674c81c2471646222a5d607e01
-dist/2026-08-30/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=106efc64c2e21abc149264e3a98c4b836c1430d0240f3489d5605a2cc17760fb
-dist/2026-08-30/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=b45eaa6f6586aca7e622c5ad60ae9ec92ddd935dff5d6c94ba3a78e0dc6dc304
-dist/2026-08-30/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=8bb3d211d9d17c5acb2867cd154f3dcecdbfb36d723c05f35d91f2e33ea00067
-dist/2026-08-30/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=08c78ecc4b5489c5480fe6d3832298686f782f9e45bb265946b9bb1176733f54
-dist/2026-08-30/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=1875b1f3c267c634cd48933c98891a53b350f7142462cb56bfc6513326024c89
-dist/2026-08-30/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=a647ca6600707b40a1e97f7fd0e39bf43c863ea60224eb28beee0622f74253e3
-dist/2026-08-30/clippy-beta-i686-pc-windows-gnu.tar.gz=772d98712f108d6d7eb7730e26ec04e66a972daf3ac5352c30160e20c1861ba6
-dist/2026-08-30/clippy-beta-i686-pc-windows-gnu.tar.xz=d75cdb626c3104552b122e79d2ed07bad9ec04f084f58bde332d029feb3ae90d
-dist/2026-08-30/clippy-beta-i686-pc-windows-msvc.tar.gz=e7ecdd93739741d769a1fb4ea33b9dd3c935008d7ad5e773d3673d5ea7dbd6d6
-dist/2026-08-30/clippy-beta-i686-pc-windows-msvc.tar.xz=8b1223c943d378e201e83d61298527e2d7307f96ce609c6e1a5483f086490bec
-dist/2026-08-30/clippy-beta-i686-unknown-linux-gnu.tar.gz=f326afa8e228964581df0c4a0096eb33fc132df0254b2648f43f6589466e72bd
-dist/2026-08-30/clippy-beta-i686-unknown-linux-gnu.tar.xz=7e868c12873c5e451ebdfe67e4474538a9d3f46d5dde8ad4139c8f5056a44685
-dist/2026-08-30/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=e185f345c34e54bc100b1df955c047b53db30b9b3b054a2cf5a264f0e3ae2405
-dist/2026-08-30/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=270c4f7d7763180bfb8a7dea1d97259398c9b7c6560fdd3b58192748ffb40cf2
-dist/2026-08-30/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=22d484c3ae2ade651e12ce943780b51da3b0dd6bf04c6f8403540cc7f382ced0
-dist/2026-08-30/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=a669d05d6efc4e77f05b417d00272f2a0221e05b37f921b9e0f9769a8b48830e
-dist/2026-08-30/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=3d782e904a64856dcae5de5d2be509f2ccc3109e9067ddd540bc8e1049ea3ceb
-dist/2026-08-30/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=dd867a9fca45df5ee0d3ef602802f8accaf9fcc1ab1fe52b74ea72e03b91d67f
-dist/2026-08-30/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=a890aa398977d62b10513350e2c918fb41ffa76a2733b2f08ec829f15b8dfd0d
-dist/2026-08-30/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=c8ae48e109ae2f4daf3c878056641acacc457618afe42c9af53eaa4bf9a4faff
-dist/2026-08-30/clippy-beta-powerpc64-unknown-linux-musl.tar.gz=010d6114089273e267645340437d74b962c7f16ad21914b689100241e1e5879d
-dist/2026-08-30/clippy-beta-powerpc64-unknown-linux-musl.tar.xz=1ff705f8d502081d85e8f85a177b4d00a3f102475c6148f7609040efe8f95cf0
-dist/2026-08-30/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=226cdb2a14e6f7ac8962326d6f0a4459a99d5f43ed6516f296da74a4c96504e5
-dist/2026-08-30/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=6f0d5341554b0b12be7138962ad1f02cf534b197923f791e8489e09c2ec0fa31
-dist/2026-08-30/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=aa41e1b12199dbe2597c1614908911bc936b77e4697d6f47a73e99b3fc6d3cbb
-dist/2026-08-30/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=f0084a572996014050b886ea7defe6c6f3dbb8055c840c9f3e0f09474f1cd87e
-dist/2026-08-30/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=35d0c03ff88bbc60059f1014c65f8803a5e649fcef0ffecf90c73db0b5e29d04
-dist/2026-08-30/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=f2233e50c2c976941b30f41859494c3b47a4a92022b50f924eb3aafbb10ad1c6
-dist/2026-08-30/clippy-beta-riscv64gc-unknown-linux-musl.tar.gz=8f34275dea87439be7c820cf5c239168c5641711e439afe873615ebc26e92f20
-dist/2026-08-30/clippy-beta-riscv64gc-unknown-linux-musl.tar.xz=7346c56c1ff8cadbb633d0890dfea12918344f035075a5ade3fb44869da7ce26
-dist/2026-08-30/clippy-beta-s390x-unknown-linux-gnu.tar.gz=064c99e94f0dd2da50e8445cba0f6bd3b6de9a78f860fde838097f26f93c0a86
-dist/2026-08-30/clippy-beta-s390x-unknown-linux-gnu.tar.xz=b5237ae854270214b81270f1a6dcd26fab19470b98450b8503a1647d83f19d66
-dist/2026-08-30/clippy-beta-sparcv9-sun-solaris.tar.gz=e8cb900135fcaecc87565e6279f3b50db957370b73f7bdaee39401bb2236ec93
-dist/2026-08-30/clippy-beta-sparcv9-sun-solaris.tar.xz=a1315c1d6b3ab19a6351527f07d62bc375d937571af49f1130b030440f96ad74
-dist/2026-08-30/clippy-beta-x86_64-apple-darwin.tar.gz=4adb22b7d502339fa505fe7ecf18167fd7a054e15211d28f78d7f27c05fcfb4c
-dist/2026-08-30/clippy-beta-x86_64-apple-darwin.tar.xz=0e9c5bd310a8c6d797cc741a3368c4e18ebdd138fb0035bcec94ca3563fee966
-dist/2026-08-30/clippy-beta-x86_64-pc-solaris.tar.gz=ec8ea5558cd47e0324ab46fc8d7f06b55e3a5b015e1b06f7d8372ef63846e2e5
-dist/2026-08-30/clippy-beta-x86_64-pc-solaris.tar.xz=2ce6978bb89c20fd4d92d9a513c60ed8a4ecf243d68e9ed5e76a06f46374725c
-dist/2026-08-30/clippy-beta-x86_64-pc-windows-gnu.tar.gz=269d4722bf8604755727de19c3e92932976797ee07a382a4241d598e11f1dcc3
-dist/2026-08-30/clippy-beta-x86_64-pc-windows-gnu.tar.xz=bd37185b9ea6c75df3fa873bb7bb961ea48cd7eb2e1e537df78fa23560a4e542
-dist/2026-08-30/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=7a84636be94207fe6bad2a162bb9f412944f07d87e65aaea8defa01500be420d
-dist/2026-08-30/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=6f3cd9590fde49d3d32473d7363b8bd9e1298adb87dbef2fc8ba2aa6565cf7f8
-dist/2026-08-30/clippy-beta-x86_64-pc-windows-msvc.tar.gz=9d33b21d67155a006f8ba2de17892812519ce9ddbb6531656b314c710363f7d1
-dist/2026-08-30/clippy-beta-x86_64-pc-windows-msvc.tar.xz=a6805eaf9f9d0d5d9f98d6fafb4b4e96accfb2676acca907ee704f84745c5768
-dist/2026-08-30/clippy-beta-x86_64-unknown-freebsd.tar.gz=b8e66bc833089b1b23cd0e73c2e1b3409864d2b00c7ba533378b45eba07a8dc9
-dist/2026-08-30/clippy-beta-x86_64-unknown-freebsd.tar.xz=593633c48f833329e86613601cbb4db25071eb19b33a4561f7104c0cba86f03a
-dist/2026-08-30/clippy-beta-x86_64-unknown-illumos.tar.gz=dbfa333d2cf958b0d39983bdf3fd2d55623903d82f34d70d06ad31561f51cf97
-dist/2026-08-30/clippy-beta-x86_64-unknown-illumos.tar.xz=53a0ec434ba0664dcd967d02a13daab11c23eb294b3e80befb80667f8983c586
-dist/2026-08-30/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=17a88086e382454d70bf08e33149b8e0ba97a34500b9f56dbbfd9ff4c3fc535d
-dist/2026-08-30/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=b0237d0782a9b8938769e85dbbcf1a6eec91554f665b90acf00a60f4dd0714bf
-dist/2026-08-30/clippy-beta-x86_64-unknown-linux-musl.tar.gz=2d7ff9aa37dbcfdec585dea69555c973430b7e6f4f6b55e450cb34c05b59baef
-dist/2026-08-30/clippy-beta-x86_64-unknown-linux-musl.tar.xz=9ae39943b49d89ef53153b2921fe7dd6ed244acd5e39297ba7cf108c38ec644b
-dist/2026-08-30/clippy-beta-x86_64-unknown-netbsd.tar.gz=7c8c9387e3f75a917dd721cf96a118cd8924baae1b476e9da545aa6c4cf06609
-dist/2026-08-30/clippy-beta-x86_64-unknown-netbsd.tar.xz=0d85f1338a69ad620c923bec29c3fcad6225f957578f0a41a11568c154e091aa
-dist/2026-08-30/rust-beta-aarch64-pc-windows-gnullvm.msi=99a2ea82e19f436cdf4dec0f0aaf315c16a3229fb6d9b103ee9d1a2c06b74090
-dist/2026-08-30/rust-beta-aarch64-pc-windows-msvc.msi=c0a27c16075e29239e68b31d76946a41a452acce1140c1e509a189c2e3f56eff
-dist/2026-08-30/rust-beta-i686-pc-windows-gnu.msi=8f742fd4920a3fcf5d41dc113f885e441f8681d83a745a5b12195c2782a4c93b
-dist/2026-08-30/rust-beta-i686-pc-windows-msvc.msi=513fb7fe5d4289ddbb58260863ba3821d2cb2a3baabc0bea1a65ef2885c413ec
-dist/2026-08-30/rust-beta-x86_64-pc-windows-gnu.msi=2d9f279983d1a50913e7777de880899143190413292801266b95ac2ed69a4e4e
-dist/2026-08-30/rust-beta-x86_64-pc-windows-gnullvm.msi=5bf8e7568a27395a4b879dd6534c141a92cdf12536d1201a175d84453963699b
-dist/2026-08-30/rust-beta-x86_64-pc-windows-msvc.msi=23463fbf570caf314427b3ff8e666a2d9b3cfdf7947aced459187eb59c645e48
-dist/2026-08-30/rust-beta-aarch64-apple-darwin.pkg=e933472ceac42d94982728bedda2976bc77da11805a236cd93cab0c159dafe5e
-dist/2026-08-30/rust-beta-x86_64-apple-darwin.pkg=bb9d97c74eb28bae220ed548e46b91c478d66301801c51d4d170d45989d24cc1
-dist/2026-08-30/rustc-beta-src.tar.gz=baa6964c75882e0393efbed2f19e8303b46101336adfdf44bede282dae15ef0d
-dist/2026-08-30/rustc-beta-src.tar.xz=f835b92620f3802afdaa41fa49de6e253c9db0de0234070833011ce65c14d0e2
-dist/2026-08-30/rustfmt-nightly-aarch64-apple-darwin.tar.gz=22d6733e4325fe6fa25399b651e77cd5ed1a7f370f7558aaa08e8b6447f55264
-dist/2026-08-30/rustfmt-nightly-aarch64-apple-darwin.tar.xz=fcc49f0698c09f8ff89ca044d0426dad2399da253d287c3aaabebf103b4a2820
-dist/2026-08-30/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=34a0e1f6d068d30cca9099c44736657de307ea3041970fde751aeda3781d02f7
-dist/2026-08-30/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=8f7955c05e2a5324fba961df617ca2d70d473565cd3389fcd52814e9cd5c4f65
-dist/2026-08-30/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=7df7e3f128e4d4f88a5777e9e736fce117f5f47ef8cb505713aba9db09b8cecc
-dist/2026-08-30/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=094323c8a19c6840d13d9e3a1668c94dc249ff0c720634da1fef8cf844cded71
-dist/2026-08-30/rustfmt-nightly-aarch64-unknown-freebsd.tar.gz=bd932f456a46de862f1aa3fc5b936a5e364a714a6cb8b71c7cf3920f180177a0
-dist/2026-08-30/rustfmt-nightly-aarch64-unknown-freebsd.tar.xz=4c14e353f8f5982ba3b3828578e412f433ca3f16e94c9aa0f6efdf2949b53215
-dist/2026-08-30/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=efb14d13c092a4dfd1d2229aaf850cb2e6c56bac9c31ec322e22f515050567da
-dist/2026-08-30/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=7df63718528c050a0e306ab08979ca787b6f0522a442d34355cf683f3bb259f0
-dist/2026-08-30/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=b0a231d0eb6bb006bfc144a954be07ed9886202967843b0e8475b19429902884
-dist/2026-08-30/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=b98a8ba107231b4d8832d6f1cb679661e9ee0faf13c81dc3eaa576853580582c
-dist/2026-08-30/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.gz=dec01a69341b8d512eb17ec28687b4ee43174de63e31a90b91e99b9eaf17e345
-dist/2026-08-30/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.xz=e598a9559c169794bec2443e7842e62728e09fcaa6614b1a3f5ebd6803f0ef6a
-dist/2026-08-30/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=18a5a8ca79e449f7daf52f534cd2ab137e33204280ac7da35e0bd31f6ba2674e
-dist/2026-08-30/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=00e6e3d4d555ee786545b5f0a542d7b5bb9260781a80e4598d50bdf856457a4a
-dist/2026-08-30/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=421735da37fcf7a85c2bccb27b13c15105f98a95333734c1d383e18b7a01842c
-dist/2026-08-30/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=a3936b0c6a67da7180c10554dbe6427beaf05480c40b3a57cc07082085987cc1
-dist/2026-08-30/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=817768d8aae4d3d09b952631982051eba84b889e87367c2d740a14e35261fb4f
-dist/2026-08-30/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=5d905fdbcc0d3d2f5949c0e32980172fa8216a51974945248e293f8c81b58203
-dist/2026-08-30/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=e2cae9d3e6b6c6cf72bf0e12510358984adb5f5279f49af8f4a29869614f0a84
-dist/2026-08-30/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=bfb5472037dd5d1031384c70d58bf841ff4a9e33716b55d8384c47d27a31ac04
-dist/2026-08-30/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=b18fa3d4a5469b7736655c842af84ad44a07fbd6146669c6f2b5f5c3f26a4e33
-dist/2026-08-30/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=c7978ac60291efc21bc77c2aed4d14c0bbfd6dbccb461f0499202fe8b8dd0818
-dist/2026-08-30/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=e1e69785fadaa294f92d7f5e42b046a47c4b508a806804048c3c2b1cfcda25d1
-dist/2026-08-30/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=c6371931d1bbc56f94f17d55ef0e8a756388606599a6f8828b1269504b57f0ac
-dist/2026-08-30/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=e2763a910eb0305fbad6200fdb70e21c80f6ce61a29c9ef6cfdd134e54fa149e
-dist/2026-08-30/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=b8ff26519a2b6087969497e02e1a958b283b2dbd5741c5f9a531bfadb7f55b4e
-dist/2026-08-30/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=f83eba99f2c4ca3c8e72debd3abfc81c4e8e12b78f33030a2ec0bca467ff1026
-dist/2026-08-30/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=9da6df6e5b98e59dad134fa7eb6fc74cdd7590799e5d77b885675d3301cb5ae5
-dist/2026-08-30/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=ab48c3b5e6a1c920d2776ada7f2c7a262c6456c70c4051c55f24067768f36011
-dist/2026-08-30/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=d6a6ff842d3004c14a39349c62453b5279085bcf44f2c3f101bba074249b6393
-dist/2026-08-30/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.gz=7790a116d7598a29c083e8defa140b3c69dff2fa8632abe16c0814e3fdceb771
-dist/2026-08-30/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.xz=090ff92dbd36a9d051e48545672099c40917f5cc781fad0075d1db73bacc9b6b
-dist/2026-08-30/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=6a448b720e8b8904a7f6b160891dc711165b043aa2f2700f1001220841da7383
-dist/2026-08-30/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=47850b2456b8f28493268987e10ee2197f6bc49517b9338c469346e42c4ea524
-dist/2026-08-30/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=51fa8c6d2e9144b5086ebcd91580a7b2338e42294a0db614c2a5b40c2817f074
-dist/2026-08-30/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=09af68ab10528ac45be29d2d7671a5cbbd0c508d842c811448d1b1a0818e4ebe
-dist/2026-08-30/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=4ba0481a7d6111f1197c44f9475ccfe814a32cd13ff218b7a6f96fa6b188dc07
-dist/2026-08-30/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=cb078f0a92905a6ce410866e2c0f93ecdc12fc2b17716e8ab503531b72cd2f41
-dist/2026-08-30/rustfmt-nightly-riscv64gc-unknown-linux-musl.tar.gz=5c8f989fc890a8d40b88d03002819dba392def655ff4a297eae83e24635599be
-dist/2026-08-30/rustfmt-nightly-riscv64gc-unknown-linux-musl.tar.xz=ac6a2d15f43100e71a401f334eadc59d76e554fc7e2e4c67870c24f05c7ac682
-dist/2026-08-30/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=78f43dc32a140e6b84c5b50e319b5d779d8d3a6a63172df5b0a7df984cda2919
-dist/2026-08-30/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=cdc738d4e7db3489ec4be89db19fb6beeefedc09f0f99bfc3f4177e5a0e29e39
-dist/2026-08-30/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=8b04309e8d8ed92f52ee9656b0c3b694681c9c867bbadb781c14df8d2f25a189
-dist/2026-08-30/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=fa880983d380d71b52468551aeea00502c04a1c84c1976b82ad137031b63e61e
-dist/2026-08-30/rustfmt-nightly-x86_64-apple-darwin.tar.gz=0faa8f222a300d58a8d815a49625202da2c93b89d655de9f8105fac8fa3b49c2
-dist/2026-08-30/rustfmt-nightly-x86_64-apple-darwin.tar.xz=860418646c51c8a4309b5f64700e9cddbaad55edd33776bce10341d069a4842b
-dist/2026-08-30/rustfmt-nightly-x86_64-pc-solaris.tar.gz=70dd11166440c56c5d39ad393f22904b0d043c4e128ceed9b35276b1f7c88814
-dist/2026-08-30/rustfmt-nightly-x86_64-pc-solaris.tar.xz=0c0224c46c41018eee3fd6373a3a50869faca604acf5985627a43d381bd023bc
-dist/2026-08-30/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=e3ae658cd8daf76fba66422c5b63d335a73c6d1abd0b0f6b88c385467779f876
-dist/2026-08-30/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=372750b8dca20904cc7716f6c999a581ecbf67537bbc1a340226cc4d1cf5f01f
-dist/2026-08-30/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=3edebbe5ca7cc0e9cdac3dbd715caea022c890f2e16dc0798f8517c324dccc8b
-dist/2026-08-30/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=bb6cb837ef4e0355b946a9e8af2d8a4e9a89e06f68f6a0f92adfdf56eef1d583
-dist/2026-08-30/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=7b5a4c70a3223e4987e216f9853833c87d347c5e4daf6328eda4f2e434e3dcc8
-dist/2026-08-30/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=4040814b80224dd9ee4ad051a491c5c7cb345ed41c2bce1070c13faf785cffb9
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=529dcbadb35869dd2dd39e4b81929dcd5fc74d983e5544b61e66a663dfc40fda
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=20c86d4a327b5b227dddd1d9a900f5314f25728b5f1cbbf970d7a8bf2c8b039c
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=b6951008db1f2b95e35dd207bdf95040bb0bc6875a710a744d81a9769e24f91d
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=c502feb9fb19f971450201f5d396d9e622169884ab2fa42b14ca4685e2ec485e
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=76acd957f09291ee38b993aea1511d7ed4247fedeed07b90368efdd4cd216e3a
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=5a9b8925bfbe5c244e6f1c84ca821bad2227ec374db11f0d593830f2419742c8
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=da93547e78b5b8d587e35d15df2eb789ad4f075bb82d4605b5f4abe49b7fe49d
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=688e31843695905b5e67b2a186fa4e509c860befc70ee533195710f784787b64
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=229cd762e308882adbfaee3c50e1a32bf88a3e1c488ab9998558a90716340a45
-dist/2026-08-30/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=47e7a7cf0eebb9c62185e5506ff1aef012709b36c7433181d774b8cd1a75567c
-dist/2026-08-30/rustc-nightly-aarch64-apple-darwin.tar.gz=25ffe92502f44e574a72b9493ee0b1a4e0e873c1c931f1a07aa0e478ceb170e1
-dist/2026-08-30/rustc-nightly-aarch64-apple-darwin.tar.xz=9d494a6b72761dee6ec3c0ec085d5b29838565ef45bbb67b097caf0aa4750304
-dist/2026-08-30/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=576b8ba2a8aab889df0e673d434402c38d22efcaa4a8cd2f005c01063cd80601
-dist/2026-08-30/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=dbd428ee786b17c9a91039a2274e01d1adf14d6af747f78c32d68a62a5752e35
-dist/2026-08-30/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=395f1fd4b0286f70d4d48d5b1aae4a8f7ceb0e0a916fdfb69cbe2c00a1cd31c6
-dist/2026-08-30/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=33fbd7251609d17dcedff1de1d6b34e5aa257411229e9e7c0066d51b3b22d23c
-dist/2026-08-30/rustc-nightly-aarch64-unknown-freebsd.tar.gz=954f471480070c222a6316e1646770b6472c007b89f68ea61a713b153210b960
-dist/2026-08-30/rustc-nightly-aarch64-unknown-freebsd.tar.xz=9f19a67717d4710b3e445fbe84591da5fc5be7b6c6f07e5e5bbcf978243c4070
-dist/2026-08-30/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=d1cdfc3cbcb3f131b4307b83389da6c0385f733ef6c68e569f280c1d10bc6a18
-dist/2026-08-30/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=c967d3a8cf286f5197759160f90f823eb82c0dcfbdae4e43580c4e4336fee294
-dist/2026-08-30/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=667e1683c157443a221f00467c927651756a593f5bec5f438b55aaadd740dd27
-dist/2026-08-30/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=e4680cff6ef155809ede44b4c4a5f23ade8f920fd54e877ed93b6166010930cb
-dist/2026-08-30/rustc-nightly-aarch64-unknown-linux-ohos.tar.gz=fd6c0c4450fe0b8f586452046c80b424935c1fa83181358c70c19b25ddb0dbed
-dist/2026-08-30/rustc-nightly-aarch64-unknown-linux-ohos.tar.xz=b2c7e0cf7f1b71e141b248e62b7d10f0999f48fffcd6dc07318c3205c79ca505
-dist/2026-08-30/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=df20767bfd43a0fd4c5665ab4c0d0f0511b3356918f54b7c3074f6a1b7298aad
-dist/2026-08-30/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=c43366c230813ae776aa094e3422a445b4a3d513f98ba6d7b78cb5ad2d0a2a8e
-dist/2026-08-30/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=0c0c872b14aa8dc461989326b53c2692b46bc24bb8125d4f90e5b977f5db3bcc
-dist/2026-08-30/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=82e0eceb946f0a69f2d766c3fe2a5467852caddff960a66c5fcf9d14fa6daf92
-dist/2026-08-30/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=4783a2cc2a99596fd187bad7f486f97018ffce918c34b4b022fd88f27053c967
-dist/2026-08-30/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=c078badef6ab76e69f0fcbe6ca76f1037cb64d67e5a1feecee898ef6aca91521
-dist/2026-08-30/rustc-nightly-i686-pc-windows-msvc.tar.gz=340b68ba0802676c99da1784b0f03eb9e3cd7f78cf40fa579f97601c07dacb24
-dist/2026-08-30/rustc-nightly-i686-pc-windows-msvc.tar.xz=ac4c0562021b4f3076b39856eb16ab288f3d16d25c557cf954ce66f389449f9e
-dist/2026-08-30/rustc-nightly-i686-unknown-linux-gnu.tar.gz=5ac857921af0b1b8d290a059eeb1d510ad4cc5f450b513b26a11be67885558ee
-dist/2026-08-30/rustc-nightly-i686-unknown-linux-gnu.tar.xz=a01fb1c1721998e3bffe377a15663e911bcaaf497fc2a7f1dbef06125466febd
-dist/2026-08-30/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=46d1aa393ee0f736bf46cb6d8e975e66774a797a78918fc106cb1baf2115c1ee
-dist/2026-08-30/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=66ea19498d78291393f20ad6313fdb2359b7a685bb358d28c498042f957b7ce9
-dist/2026-08-30/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=27e138e7e0ecff208f09780f6cb51d4447fb75b5891c2e961c3b380670bf43e2
-dist/2026-08-30/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=16bade7c4f0644f4474622591f1ae83be1c7d6ad86aa23f1cd0bc29959e41555
-dist/2026-08-30/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=44207e156b7d05f8ffd05394cd0a5f2c4cf290e8a7d4be07a95e6242be738f85
-dist/2026-08-30/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=98c9309ccd0bc473ab1c373232c0ad483ce959a9b7b31cfc0b948c0dcff4ae55
-dist/2026-08-30/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=bcaf935990ad326f9469b18514330bb219fac62773b1ca44cfd9f2639e22442e
-dist/2026-08-30/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=68242588d61346c4001c4bade2daec0611f3f079fe1d1e5debf08746d8ca2217
-dist/2026-08-30/rustc-nightly-powerpc64-unknown-linux-musl.tar.gz=34e4d626d1e484c3d8bbe2be39a6324b0a02cfc60b7bf13c561e6c41eb6b3917
-dist/2026-08-30/rustc-nightly-powerpc64-unknown-linux-musl.tar.xz=8b35dd518df6b7225dc7b8da30ef9fce97181bf3781e69fbd5fca67833c54457
-dist/2026-08-30/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=66aca4805b3450a90bde12ddf6f2b9139fcab333bf4a33825d9bedf3842fccaa
-dist/2026-08-30/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=6861be8d2ca2fe398e461ec1d68eb4b6e5a589b5eb39b60ca4083579a54ccc07
-dist/2026-08-30/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=7644e739c1afbe9a7be15878444e56340dbadea64f06799066e8d14c1e736ebf
-dist/2026-08-30/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=fe4e05894da7fb3bff0d4cc725e0e80dc78fa55d97bbb0588ce5383fdec72407
-dist/2026-08-30/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=e59bb87d54ca41779b984fad84ad20144e4bb224ca187ca6a51ee1d15ec5bff4
-dist/2026-08-30/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=d997aa633692996dac26f68a246b3dff4a597595a08808dd965e01f05bc502b6
-dist/2026-08-30/rustc-nightly-riscv64gc-unknown-linux-musl.tar.gz=3d5692e095f9b23a05aa57b1de83fee4a6ab9ba1ba85f0d6a7a59997814f762c
-dist/2026-08-30/rustc-nightly-riscv64gc-unknown-linux-musl.tar.xz=85b6a0d7e0405537ef929819b957a37723010e8cefa82c558a7d0c42e645fa59
-dist/2026-08-30/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=668c203cfeed5b0286a5928d9b98e289f0ec32fbaf21fe61534ac9bb5c9236fb
-dist/2026-08-30/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=8fd2005a2f7233db1399af86d9c8b48b959b3627faa5c8a3dde1d6db67f72562
-dist/2026-08-30/rustc-nightly-sparcv9-sun-solaris.tar.gz=d8767b7abc10f45dcc53258adf4ca2c062d3f063f830791b6c475537a7009704
-dist/2026-08-30/rustc-nightly-sparcv9-sun-solaris.tar.xz=58ed2a29ed983d6dc632ea7dd68532fef902dbc44a68e2cd668323fa9676438d
-dist/2026-08-30/rustc-nightly-x86_64-apple-darwin.tar.gz=27bd68fc60a35b8f56b538cfe9d3cafe156dba2b8cb25bc04d488505882157b6
-dist/2026-08-30/rustc-nightly-x86_64-apple-darwin.tar.xz=a452c953f1641c6d2ffaf59d129f38b7fa2c6f8c29882c3d82408b50e4c4c95e
-dist/2026-08-30/rustc-nightly-x86_64-pc-solaris.tar.gz=c12868cc994812742945591b906f761f9a5ca0d09a809da69f3b0f7de731a707
-dist/2026-08-30/rustc-nightly-x86_64-pc-solaris.tar.xz=9974a6f3bf2b784771114ae846f7fb54746525e5dd921f4832410e40a00502b3
-dist/2026-08-30/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=6ce5a31fd706d532679c5db6bfca375fb21f34df077bd7e182f6e38cfb852561
-dist/2026-08-30/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=72cb129e77c6c8f48e82a82d894a5fdced57d74c8a7ade88589c3baf1385ef26
-dist/2026-08-30/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=e896320dd35b2b43943a29491bacfc696d5e68c3c9a7c0a4fbab6cc57ca5afe7
-dist/2026-08-30/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=93b8fcf4ed8aaa3a9ad1ed14086ed4bf44cc38db920f86eef0c1f42da37c9665
-dist/2026-08-30/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=5368d930648a6f04b20967d6183e53925bb930d047271b3683cf3d663d893f23
-dist/2026-08-30/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=e696551fc4f4b0573c60750826ee93113a95a4ee7361af3752e49c5a386abf69
-dist/2026-08-30/rustc-nightly-x86_64-unknown-freebsd.tar.gz=c2ef207e1ebd2c408c91a63cffd5986ae01cf265e535947d12bc43a2015eae5f
-dist/2026-08-30/rustc-nightly-x86_64-unknown-freebsd.tar.xz=5025d42e80e6d377a9dba466ef3e81ab817ff6e098c2bbde4923afedf0fd7893
-dist/2026-08-30/rustc-nightly-x86_64-unknown-illumos.tar.gz=876fbafdf17e645e870d4b6afcd5465ee155e910309cc91bad10dc885d178b0a
-dist/2026-08-30/rustc-nightly-x86_64-unknown-illumos.tar.xz=f380f5b0a7ec8c537b8bd53528b3a407cd69449baf0d6c513f03c2de047ba3fd
-dist/2026-08-30/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=4e010b6ff2f3923b31c44cfcd74d33389dd2de01521e4f22b90c58294fa490fa
-dist/2026-08-30/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=d87f9b9bc000e028ce81b49d64352c59eccc99cbf282c9c3bc834a72d9aeaff1
-dist/2026-08-30/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=2332302e83712fa814b119bea274fdb1f70494fc7e8ea6a23c88f20bac3ac6fe
-dist/2026-08-30/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=2a43c8666489856bf8ce91729c2eeceb88a3d38bc6cacccc8c598373afad1247
-dist/2026-08-30/rustc-nightly-x86_64-unknown-netbsd.tar.gz=094c2005eef2f8ca0e466da77af70f7b1cc6c837e8b2e933c26d66b8bee3e06d
-dist/2026-08-30/rustc-nightly-x86_64-unknown-netbsd.tar.xz=a68f04797c3ae9db0e31d9670fa9ce17efd5ca3054bdc4de06ca97b143cb59f3
-dist/2026-08-30/rust-nightly-aarch64-pc-windows-gnullvm.msi=4334c750cc57337150cf11dad2b10c5d65f1866e7f672093550322fa696d888f
-dist/2026-08-30/rust-nightly-aarch64-pc-windows-msvc.msi=b2c56f022de67eb6045b1137709a5055c139d88e9fae8175b932a7da1f2fc1d7
-dist/2026-08-30/rust-nightly-i686-pc-windows-msvc.msi=bb18feb2dfdd9495289b70a6bb41584489dfe14de19961fe32fe6d249ff60c7a
-dist/2026-08-30/rust-nightly-x86_64-pc-windows-gnu.msi=18d50140987657604cbf1a980b2249243afc6a734f725475a25a3f96c0edf72c
-dist/2026-08-30/rust-nightly-x86_64-pc-windows-gnullvm.msi=83cb268a0ee1c120357082f9711d2a5eb05e58d433bd52dabfabfcbb31df6200
-dist/2026-08-30/rust-nightly-x86_64-pc-windows-msvc.msi=b19b6e4ef4b022f183c45ebba60ea8b6bcbcb06c60345231fc602dc1aae0ba5a
-dist/2026-08-30/rust-nightly-aarch64-apple-darwin.pkg=2fa1f66fd223a57405047c498614d71fd3bf087a98063e2f652c9899d2a5960a
-dist/2026-08-30/rust-nightly-x86_64-apple-darwin.pkg=20a2d983a8ef414f2c61773f056bed1d300c24e5f65252c1a0b01fc230030e28
-dist/2026-08-30/rustc-nightly-src.tar.gz=a1768b2d3627caf5f7fbdf5918fc1586180a7a2f2076403d1cb4ab11ea3eaec6
-dist/2026-08-30/rustc-nightly-src.tar.xz=b03a014a5a4f8bb1d0fb14d9f01e3a5cb9df64c4d4208463f4a6b977d2287d9e
+dist/2026-09-29/rustc-beta-aarch64-apple-darwin.tar.gz=08cb5170859d6ebf335c279df46cd8421e6478a0199d0cd2709c0afbe8a92dc2
+dist/2026-09-29/rustc-beta-aarch64-apple-darwin.tar.xz=5ec30352066404071c4c9a077e19b211e1e2865babec422c1b5305882fccb2f8
+dist/2026-09-29/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=24630c62a81890608c84b0c5d1ccba809c7414c9cfa6737b092bdcb3defb6797
+dist/2026-09-29/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=b9db7c497276274a7e5af4ae6666d4d77bb9ebe8a389513c1628488f4f86b950
+dist/2026-09-29/rustc-beta-aarch64-pc-windows-msvc.tar.gz=75b429e1d1f34317877ce3838e4e5c79ea579a051314fce9755ecd92782031e4
+dist/2026-09-29/rustc-beta-aarch64-pc-windows-msvc.tar.xz=04fb7d879ff7b00ed5cc3a054bfd8f4dfcbcc039c1000334db34284b6b7d0d27
+dist/2026-09-29/rustc-beta-aarch64-unknown-freebsd.tar.gz=4a4ece6cb6b686d844d3d93c6b5cc50dcc6fd1a2aac17d7ff7606cc3fe103980
+dist/2026-09-29/rustc-beta-aarch64-unknown-freebsd.tar.xz=2bfd413768c42feade1655007488e4cb913fc5b295763dd7835224e5a57ab198
+dist/2026-09-29/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=c60b31aec10e123a0c461b6f86b0f7d18dd22e706abe76ed4d9ea010c76e1fc1
+dist/2026-09-29/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=ecc23a873a11fcbe2b81e47763204f93a1f91e551c0fa8766262ffa2cc3d0538
+dist/2026-09-29/rustc-beta-aarch64-unknown-linux-musl.tar.gz=1634c9acebc04a266987633062e0db4d4b5a92a568ae55cb146cffba8108038d
+dist/2026-09-29/rustc-beta-aarch64-unknown-linux-musl.tar.xz=4361c19fcc2cf8e26bb52489e7dd3e96500c6e6d54bbeaa1493d0b8c8d6a066e
+dist/2026-09-29/rustc-beta-aarch64-unknown-linux-ohos.tar.gz=318e6fae90b8da5cad5eea22d358b848746a8f4fcf60d164a2d630f03d12facf
+dist/2026-09-29/rustc-beta-aarch64-unknown-linux-ohos.tar.xz=7d80d8a51de0f9a8f0af2ac170e5156a14dba2f3952946a845917f772e9c7dbb
+dist/2026-09-29/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=7dc6dcfa998512791269d52f9ee0097bfea867c3a02a54c676c88a69a40f8a23
+dist/2026-09-29/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=b791b3ed832746088ed4ec8378f9b226a7900c4fd4cbe6436f7425191ef1013f
+dist/2026-09-29/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=0a1bab07aafcc98cbb130b81b3ad9eceff1194037110fc8ed7fa6650a572ab07
+dist/2026-09-29/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=677ee4e95a57d1e498ac4bd9ac05084675c03c58de6e85320d7d6d0c725e6ebc
+dist/2026-09-29/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=e7de0b8ec0715ee54866b533f22ffe23b560e58884228f145e0458a3dfb0450b
+dist/2026-09-29/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=6316b4bc4931c2811c90d7dff9df5bf7875531c6cf985c065f78b8a0577e370f
+dist/2026-09-29/rustc-beta-i686-unknown-linux-gnu.tar.gz=8229d9b5bb6497abdedf15731c15c2ae85c8050bf0995a576685716e9d929ac8
+dist/2026-09-29/rustc-beta-i686-unknown-linux-gnu.tar.xz=428ba34f2281ddbb794a2062e446ca6e5b0cd90a84829186f769bb8d2190a28c
+dist/2026-09-29/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=04ab37c4e7e9dde5a2332975b6f7cfe6c02319e89f9bab2128945656ec81110a
+dist/2026-09-29/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=50d6c00c82dfb7f10bd2c49057822e082c3bc1f6cb7a08e06ac2a5a350e1d1eb
+dist/2026-09-29/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=9fc8d551462b4a845c18f163c2787e256d00d4edcaca0721da63ab57002f418c
+dist/2026-09-29/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=ce74c12908e44b8b87fdb371533b6a81b5cbc8967e04209b833c87940f4a1420
+dist/2026-09-29/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=e7417324e10e59b5768daa4b5cd01fe92a624739a9b450693fbd5902227a3561
+dist/2026-09-29/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=68dbbc9c7f6c1f2725140c0edd58e3607cd31d4406e7514cb32b9a894f3af39e
+dist/2026-09-29/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=93b02c260b6ace5ea43fd716a100abfb2ed3de24a53e3032794c35858fb0f618
+dist/2026-09-29/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=e78037526d62c567cb2aa1336c0ed2bfde01e2948833c10a3585040dcf26f343
+dist/2026-09-29/rustc-beta-powerpc64-unknown-linux-musl.tar.gz=3ee5c15579228dc36bef6b254fc235ff57426be8dba7bb358beaed0f1791afc0
+dist/2026-09-29/rustc-beta-powerpc64-unknown-linux-musl.tar.xz=053fbdbfdce20029dedadf7218daabee5b181a69c20b46c2849970f9fa91a7a2
+dist/2026-09-29/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=a0d9ad02f3f031d54080f3a64f97d099f38de9b324e3906ecd9f873f8353167f
+dist/2026-09-29/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=8a81d01e78892fbfadfb22b59c6264bcaf4343e36afa806d94b2c6f51eedde43
+dist/2026-09-29/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=5780592d8b617c2a2b3c1a0c142e71ba589ce5a6ca8d05840668ed9b0217e807
+dist/2026-09-29/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=e71f58d7383c5ce823ede7d7d032349a3616ec3c3fcae212786b24ec4e427fcd
+dist/2026-09-29/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=3f113901c2996c2bc39891cc6146fa4c2d8800029258186805b20a34dac0ab13
+dist/2026-09-29/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=2b7bfe0f71378a76c4b5bc04224f728c02b0cf21d66999d86a33b754ff80b52a
+dist/2026-09-29/rustc-beta-riscv64gc-unknown-linux-musl.tar.gz=b4e6d98741d7293f16ab9218e5492664765f43cbc7f8537b45ef6815ca83b0bb
+dist/2026-09-29/rustc-beta-riscv64gc-unknown-linux-musl.tar.xz=98141ecd5a1426d8b168e5f181bacf083150895e446840d2243747159bdc3773
+dist/2026-09-29/rustc-beta-s390x-unknown-linux-gnu.tar.gz=5b821594334d8f9b1d07264df899f22fe7a041d7417618b8e7809973fd45ae22
+dist/2026-09-29/rustc-beta-s390x-unknown-linux-gnu.tar.xz=5c52006d530dbd13711e01402dc533c1d664f77e4f1c997179b900ce29ccc617
+dist/2026-09-29/rustc-beta-sparcv9-sun-solaris.tar.gz=7db0a06f0450e2f47ebae3912fff144d416cfe58877ff8996d1335af634bc7db
+dist/2026-09-29/rustc-beta-sparcv9-sun-solaris.tar.xz=3d8c85b04fa3d1947840867c5ffb750ae341ad17982aca302abc754e43e1ff42
+dist/2026-09-29/rustc-beta-x86_64-apple-darwin.tar.gz=2bf2b522df594f578642b9c1670b265a02b937b48b5b47ace32a53ad7b569200
+dist/2026-09-29/rustc-beta-x86_64-apple-darwin.tar.xz=ed18e8348eba7bbc6adfd6b95292d802834022a243bd9739cfdbc5d69d8e7e2f
+dist/2026-09-29/rustc-beta-x86_64-pc-solaris.tar.gz=cce6ce17920028ed75d83134bae4e02704bf497002b654ff629dedd8294a8335
+dist/2026-09-29/rustc-beta-x86_64-pc-solaris.tar.xz=6d5cb6a91f23044f79c73954bf392989d031412e4d6b43e18d4256d7a3c1fb0c
+dist/2026-09-29/rustc-beta-x86_64-pc-windows-gnu.tar.gz=efea45514b6313626db60fa3e922fbd812454004c34c79e3770050826da93022
+dist/2026-09-29/rustc-beta-x86_64-pc-windows-gnu.tar.xz=5a32405ad9ffe040516efd73d961ca53f89c1cd8b4bd8eadb900caef8303e0c3
+dist/2026-09-29/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=6e911af2547846c6baa414b7d85288d954293df34b5cc87805aa6bb06570dc48
+dist/2026-09-29/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=e1ad982eccf000e89da01d6910cf918d2231e3cdcc3738f6696d3d57dfa5f353
+dist/2026-09-29/rustc-beta-x86_64-pc-windows-msvc.tar.gz=fd2d7a0809aa431f3f2365f6a98901f359514d47967067c936ba68bc47437d5c
+dist/2026-09-29/rustc-beta-x86_64-pc-windows-msvc.tar.xz=ea968def39864e80a462e6be752a7fab2a8c9da7f14799b138ddf0e9bc1f534d
+dist/2026-09-29/rustc-beta-x86_64-unknown-freebsd.tar.gz=87deb753d7a5af1afc02cc988d23ea0d42a9573b5e9abbed23ff8f345a91056e
+dist/2026-09-29/rustc-beta-x86_64-unknown-freebsd.tar.xz=2dbaa50d6542748cd31dc9f13d4fb82874825634f027317b830121937b583d76
+dist/2026-09-29/rustc-beta-x86_64-unknown-illumos.tar.gz=f682c3ad10ae60d43e2a54a3f624782c9ef0ae61fb0e9ed95a867794e0bff256
+dist/2026-09-29/rustc-beta-x86_64-unknown-illumos.tar.xz=0ad43335ebc8b0d1dbdaa34aa53fbc0cba9a8186b5edac080f5a7bf7ed7cde7d
+dist/2026-09-29/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=c567617a07be89de49b009162604ef9bfe4bc542419d405c444e39714591f4de
+dist/2026-09-29/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=e562beb9a7ccda3e99c79b2f37149fe5dacdb1f3bb7bdb77ec94b1a947daf009
+dist/2026-09-29/rustc-beta-x86_64-unknown-linux-musl.tar.gz=cea2a33fbacd6b80a7e19592a2ca8f58eb1613589dbd8c906ae78b5723cebe6e
+dist/2026-09-29/rustc-beta-x86_64-unknown-linux-musl.tar.xz=e0a1889de08bc4c91006e1d335ed7215257de80bbf6bae375906021ada6dd95b
+dist/2026-09-29/rustc-beta-x86_64-unknown-netbsd.tar.gz=262db7c3e54259876fa7f03775b73a5f190cd4812060feac04c13a03db1c5343
+dist/2026-09-29/rustc-beta-x86_64-unknown-netbsd.tar.xz=547adcdda9c63d0f63f8351dee197ca843628bfb1f965e8305f947ca128a2f69
+dist/2026-09-29/rust-std-beta-aarch64-apple-darwin.tar.gz=12a712c301ab944900438c0da63b45ec133efea74b398e708faed172e2960042
+dist/2026-09-29/rust-std-beta-aarch64-apple-darwin.tar.xz=d9705141deb514ad2d721ae34174c33ab5b64ab7181294886cbbfdc3f9b999ae
+dist/2026-09-29/rust-std-beta-aarch64-apple-ios.tar.gz=3a65781d05da1559788ea8bc2df4d84f12fdc4194cfcece0863ce786ead5ec13
+dist/2026-09-29/rust-std-beta-aarch64-apple-ios.tar.xz=728a2be2bbbacf3866e007d92b9f0857a9b7da0d0c47c16e296fba25839afbf4
+dist/2026-09-29/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=b445edeeddab84fac96c089d73f3a87e485415583ddbff217092058c14c79c9b
+dist/2026-09-29/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=db73dd68d6a0458b7ab9e49f2e331a460f14eb4598af19f2a6f642b85db3c947
+dist/2026-09-29/rust-std-beta-aarch64-apple-ios-sim.tar.gz=09d2bbd7f44f6245ff9e7ffdccec0a491e9195075232cfca2f247329b0371aa8
+dist/2026-09-29/rust-std-beta-aarch64-apple-ios-sim.tar.xz=1faee83ec196e8a2876c06dd5377a542aac1aa32c7d3b00ecf31a3713b50555c
+dist/2026-09-29/rust-std-beta-aarch64-apple-tvos.tar.gz=e8d1cd23d78eacb8a4be5cb465b94902b5351573b4c0a47073205ec4c8028397
+dist/2026-09-29/rust-std-beta-aarch64-apple-tvos.tar.xz=42f013a0c3ad79263d651b194dab7b08734f6a96dd5943535706f4a8990ca819
+dist/2026-09-29/rust-std-beta-aarch64-apple-tvos-sim.tar.gz=a5381d8ed927c6e1c720833462898ca6c4bdae6702e308352f0dc5698e3fb93f
+dist/2026-09-29/rust-std-beta-aarch64-apple-tvos-sim.tar.xz=6ffd6d6d7bc230e28a78f7230b0b91fc71dda6af018feae186b0eb48910234c6
+dist/2026-09-29/rust-std-beta-aarch64-apple-visionos.tar.gz=90a82a478d671ed7269f7cfb5eeaa70cb914d9424dd741c7a2ad2b4a26840b6b
+dist/2026-09-29/rust-std-beta-aarch64-apple-visionos.tar.xz=1c700b45a80f7304fe00977cb2fe46975ce16ac31494f2e5afc825465b475d02
+dist/2026-09-29/rust-std-beta-aarch64-apple-visionos-sim.tar.gz=50113f0e4b4cbd8c528978a6ead8fc3fcf15dc6b1c4bf97488a61da8d9245dfe
+dist/2026-09-29/rust-std-beta-aarch64-apple-visionos-sim.tar.xz=fbd9564bbdd9d0d43fb00fe67a83fad16a58d4545982344bdbacad93dd53b110
+dist/2026-09-29/rust-std-beta-aarch64-apple-watchos.tar.gz=6ba080aa355f112b74c180ee6ef1ed182bad260f35e4816bf22f758af1782286
+dist/2026-09-29/rust-std-beta-aarch64-apple-watchos.tar.xz=979686c0acca1dfe4bbc1906bbb7dd268b90b9aac3dd97a06f105fbc3260f78d
+dist/2026-09-29/rust-std-beta-aarch64-apple-watchos-sim.tar.gz=4d3459fa110abab0d95e1748f5426f162d746635529839d88360dd7c186a9a0b
+dist/2026-09-29/rust-std-beta-aarch64-apple-watchos-sim.tar.xz=303623e7c027952c164dae9e8662c1141914a35c7af148de8e7b0cd813594384
+dist/2026-09-29/rust-std-beta-aarch64-linux-android.tar.gz=cf7c1de2dbdfd3ac05131e63cc6285c5d76e8ae85c186350a164ce1017a6a1c9
+dist/2026-09-29/rust-std-beta-aarch64-linux-android.tar.xz=790d34c2a756240cad1da2662132eb11ffa2b3e844ba639c3561aa5ba0d3ae97
+dist/2026-09-29/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=dde06b88182f2f6bad4d7b2cfd40a99ecccac1fdc2dee3ef5e65f425e706484f
+dist/2026-09-29/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=f901b2689461d3b38b5f2eec0a6f5c6795ee3638da97a433c1fa84ecff11a082
+dist/2026-09-29/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=943394d1133a8c82da94d97ae738472666a9ae4f2d04c504171d8bae34a13f21
+dist/2026-09-29/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=6777866c103e45b453d7ad36d3addc3bfa09684b6e6e4abe18ea5ef782ade595
+dist/2026-09-29/rust-std-beta-aarch64-unknown-freebsd.tar.gz=5b2e8bf0dfa7a5be26a3d969c708e5181149982877a3d571d75ad2c118b56ef8
+dist/2026-09-29/rust-std-beta-aarch64-unknown-freebsd.tar.xz=b5146618aee2bdeea3f3da4c6afe4b07d6b8af0440f6d954985973d12dc7ec9e
+dist/2026-09-29/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=e92c49005a09ba23a21cc74364f30769997f7b6b81c2205ee7e9d9413fb38fb7
+dist/2026-09-29/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=fca1e29e1856abe923cccef58d560074d2d5adac5211007c00e0657677ea7f57
+dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=9d02af2c761d752a1371e301753a432031984cfaf53d9812c8ce540bfbf6d716
+dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=e991bfc2818af00b53cfac0535d094135712339b8f1289186a6d0f8d209ff351
+dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=405f757b12a00629b2f2dfd0ebf3c372d257047fd8ddf348088ed78235fc0e7b
+dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=c8dd6d868b2f6b316433bb1849a809450bae0fab9305c60b2123816066e69d71
+dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=4fb73dd34675a6f27b6426f58ad7be879ff49ab8e98c3ce003e49651bbacee4a
+dist/2026-09-29/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=a89e58073a28be60905bb7647f0e60b4520639f5460cfc3c6f1e25c581939864
+dist/2026-09-29/rust-std-beta-aarch64-unknown-none.tar.gz=b7bb5e2d07dfb49786bc1f9de858c3a41a6c4723df4e48152905616867389617
+dist/2026-09-29/rust-std-beta-aarch64-unknown-none.tar.xz=0c0fc594ad1d67be737ec709d3e10ed319d3e5a4263d1951a9bfe664bd2504b3
+dist/2026-09-29/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=25ac7161cf32dad13f4bcefc64cedb25963f4f61995e9531650c8a2636536263
+dist/2026-09-29/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=440165cb33ab38c651e798c0ddca0195f36f7ab6de981c37b4f41c98c2cd6f38
+dist/2026-09-29/rust-std-beta-aarch64-unknown-uefi.tar.gz=b5ba39fce8b242d9f77fff252e0da2b4a8d455929d247ffeb522d063eccc3253
+dist/2026-09-29/rust-std-beta-aarch64-unknown-uefi.tar.xz=16915d999525cd8e1488d6378ded9c11f58b0390e2a03f0dfb89d32b3d2339c6
+dist/2026-09-29/rust-std-beta-arm-linux-androideabi.tar.gz=e1d3999e6ba68470df99c7836ce8c51232fb62785ea7c96c6b2a456d468655f2
+dist/2026-09-29/rust-std-beta-arm-linux-androideabi.tar.xz=c23e03c5eea7fc437413e6d539ffdf43bfaf2f00d9f13db2e4d789e3edb31527
+dist/2026-09-29/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=db082f4b98dd53be4f32b618d5494ec2fc2af75ac571d7aa1e93edba18ecf30c
+dist/2026-09-29/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=cdd51373266d628735f876c8acab3d658f1ec54fca4ef76511c45d7d555d598e
+dist/2026-09-29/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=62de66b7ac14a2d8b725be25b5f6af6246973ec5557ac631cff594177b1db726
+dist/2026-09-29/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=fb86b6e2e3b556a63144c0cef982c200e2bca8d2d0a1db4b1374d0c7724107bd
+dist/2026-09-29/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=0f64d408c08361269324e8cea25053c5f542bda8b7afc5393a497808993254ea
+dist/2026-09-29/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=b05ec5e82bd8c93ceabbe2578dda16076e4b87daf315dc5baa54c8abd4e52ebf
+dist/2026-09-29/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=2effbb32422491890eb626dcf181cfb30499ba26c4f64d4a96c9e304c22dcde4
+dist/2026-09-29/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=24bb014666bfadb3256c390b36c2369a324077036eb2cc1c6e2be825d6e8d278
+dist/2026-09-29/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=932df0b6c8289fb46a9f056b70921a4b1b9400c136dd45c0561f190802d10c1b
+dist/2026-09-29/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=fcf67570a855d2e396f0019492767c8fabf00b20ba614c8e00ee9c987fb06b31
+dist/2026-09-29/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=4805f236f0122d3a67e736031b2b530e9c1c4d7a1cf65039d7118d50985fe033
+dist/2026-09-29/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=3ae97148bbabfee58ecd7db754eef720a084685d6df918713ee9103126f8b96b
+dist/2026-09-29/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=d5bc909741d6dabf577c4d26e9570e66a4fe0f7a253c61364f57bd3adf11c4d8
+dist/2026-09-29/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=6bb41498459ce565e0c91228c41c23ba326cd4d964bb5554866cc350d30d2381
+dist/2026-09-29/rust-std-beta-armv7-linux-androideabi.tar.gz=04be64de9a88dc5fad743c7c9e3ece7ffa88fc8f6741bc7097011dafc3af867c
+dist/2026-09-29/rust-std-beta-armv7-linux-androideabi.tar.xz=87450f7a9e275eb7dfd67e78eca210d867ce06e338b8a53eda0e5eebb2930b85
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=9d2c987cf665bd8490e43e66611cfae292c5bb74aacf7d36129cd71cadfe06dc
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=0533fdb36d2e8ee0b1bf5274e000f7876ade0f6c6a289a4014b97bc41eb4b88d
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=f6d92ec41459b974d5a1058b079560737261d263f218fa74982fb3d143117e02
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=b7ea4246a4a35d36596edba6f808b351abf99e0c861abfc5623d7a7cf2a125e9
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=004e933e4e1cf4c3bde0cb189b22c71bb58e84e9f9d0cab9288d46744c529b7d
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=ceed6092180912b2e6bfa95cd7345d2a0da20aced84ef1626ee9945fa109b950
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=4acecafc1bec8a97b67206557e340d6de7fa3f6a39baef49e704e203798f12b0
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=b79c57d00374db2f33708752d0c0c1ded34c9282c1a14b7a155f5c8ef49b96fd
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=2fd30887db6155ef25f02781322e79b6b69113f282e89b68e119677a3cf6c526
+dist/2026-09-29/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=9d65af3b8227e2096f3f78cfa2207241d226ceacd6c5559d2ad682ab156c6842
+dist/2026-09-29/rust-std-beta-armv7a-none-eabi.tar.gz=141612e58714918c93ba2769723712e577c99e19b6d858e77d8677850e2dcf85
+dist/2026-09-29/rust-std-beta-armv7a-none-eabi.tar.xz=2bfe5040c6c62fec4e863428288baa735fc581ac2d7ff4a180b51e169db0f291
+dist/2026-09-29/rust-std-beta-armv7a-none-eabihf.tar.gz=5014575869a7ecf9c6a6c91cb69b97f6fb798d3836f0c1851a5a9128d380fc42
+dist/2026-09-29/rust-std-beta-armv7a-none-eabihf.tar.xz=84dd449ba61513a783e10ccdc4b40ebf02db42a435f306690f945b59a9b38274
+dist/2026-09-29/rust-std-beta-armv7r-none-eabi.tar.gz=bcb61efdf77fc8a3ac756a2989cb29e57519cbba6cd86eac5eed42799e6dab98
+dist/2026-09-29/rust-std-beta-armv7r-none-eabi.tar.xz=0cbdb7ea8c7c9505a3b8a9d055704d736ea9be344862ef3f335d4abc27bf9d21
+dist/2026-09-29/rust-std-beta-armv7r-none-eabihf.tar.gz=422ff4501a710a25cdc6569428320beff61c2840872af2d63dde98543cd795f6
+dist/2026-09-29/rust-std-beta-armv7r-none-eabihf.tar.xz=c26f216ca75b5ab3c9e837a55c6a0faa7ffc3a348125e6dc545def1ad92582b3
+dist/2026-09-29/rust-std-beta-armv8r-none-eabihf.tar.gz=44b08082e62a1469c30956d9b3c82053bf341cd15b36a9ad634d0b9061cb2702
+dist/2026-09-29/rust-std-beta-armv8r-none-eabihf.tar.xz=57eccc6e20abd4d9a95bbe0095401d8b64fca6829e11a0f4f0b4977bd5466b8e
+dist/2026-09-29/rust-std-beta-i586-unknown-linux-gnu.tar.gz=c98675485760784593bfcc1c1239ace93b05a90649a37cf40c78ec76f54c9b6c
+dist/2026-09-29/rust-std-beta-i586-unknown-linux-gnu.tar.xz=25c25743a6bcbdcf35b6a055b5bb4a7c3af73074bca1923d3b97dfb5b87d51a4
+dist/2026-09-29/rust-std-beta-i586-unknown-linux-musl.tar.gz=5f0a8c43f055eaffe5efe71b62f0ba276bed1afc158efd29f10b5ea064fcd881
+dist/2026-09-29/rust-std-beta-i586-unknown-linux-musl.tar.xz=5d73bfd5f7115ec5e67b07c0e978f4aab9e8f79adee879e917b29e01fb78ca76
+dist/2026-09-29/rust-std-beta-i686-linux-android.tar.gz=7cdb05e049ea8e32fad2cea069fa98181d5289dcb2d6322e5dc80d151ef31b66
+dist/2026-09-29/rust-std-beta-i686-linux-android.tar.xz=e127f07fd97a7fada184bdee50aa83002c7764d6a0b320aa10d6b2bd400b2786
+dist/2026-09-29/rust-std-beta-i686-pc-windows-gnu.tar.gz=3f9713c9e37aafd3ce7c825ccd9a145dd9c975841da6de6f0ce340ae2381ad24
+dist/2026-09-29/rust-std-beta-i686-pc-windows-gnu.tar.xz=ec6e784cd6d3dc3e76857654621a4072193945668287b9d7665eb5105878bf0b
+dist/2026-09-29/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=c174dc7ec2ef614eb6323f06e655eb86266c0b81e1d644e5e093d58af7806f5d
+dist/2026-09-29/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=ac9f8789b013c8ece9ba57a56bd05047b8b7134c7f3f13e616bca2b592ca5ab8
+dist/2026-09-29/rust-std-beta-i686-pc-windows-msvc.tar.gz=a4b5db143623d75352bab8f5154583b0ee8f3a4886062e9bd79675e956e528d7
+dist/2026-09-29/rust-std-beta-i686-pc-windows-msvc.tar.xz=cfde62235d503f2906d0aeb21a07b479d3765a4d6bff10c1e54fbd557937e089
+dist/2026-09-29/rust-std-beta-i686-unknown-freebsd.tar.gz=d7bbff8b33fd5d247a8bae9a3c83f879777c65651babd1cc7515c52668b0f43a
+dist/2026-09-29/rust-std-beta-i686-unknown-freebsd.tar.xz=a22f726246f417641f5feda6ed2622749e375d03d11bb1be57072d74e286ff68
+dist/2026-09-29/rust-std-beta-i686-unknown-linux-gnu.tar.gz=0d90d3e128d0f378c4b8d948fa65e6d3f42c9eda9da023e9218b6d62cb3442d6
+dist/2026-09-29/rust-std-beta-i686-unknown-linux-gnu.tar.xz=5e78729655a70c60fe5c49a32a7f09418a720f7623d512dd260d04ad52645b8f
+dist/2026-09-29/rust-std-beta-i686-unknown-linux-musl.tar.gz=1e10e1e648b38e1e5d102ba87c374937ee1eca7abf53d4abf4421c74e2583283
+dist/2026-09-29/rust-std-beta-i686-unknown-linux-musl.tar.xz=a716466a78991384a45d0f27c73a3268e4f1f709d27ea32474100a8cc9ac5736
+dist/2026-09-29/rust-std-beta-i686-unknown-uefi.tar.gz=f5168879aa790d8a823d98865b2abed8683ad998bc46cab8f92b3cb046c0b442
+dist/2026-09-29/rust-std-beta-i686-unknown-uefi.tar.xz=414e0fc0ff74ba42765954390114a14cdfb261dbcf82ffee03509421ac8b13f3
+dist/2026-09-29/rust-std-beta-loongarch32-unknown-none.tar.gz=f651fea2e64f49fb75f74e7b4a350fde8391808ddad903dea20f8af4e4f848b4
+dist/2026-09-29/rust-std-beta-loongarch32-unknown-none.tar.xz=cef214987ba5cff11f8a5c75b11a2bc4fd3be236e23ca98308addbdf83529232
+dist/2026-09-29/rust-std-beta-loongarch32-unknown-none-softfloat.tar.gz=1a2f03ff61944e81dfe485129f96084a8f0843da76ce62287bf6a70500f5644b
+dist/2026-09-29/rust-std-beta-loongarch32-unknown-none-softfloat.tar.xz=39f6bd3be80e0ead123e2ac706d5da15e2c76a7fa1994de40817692d82bb7714
+dist/2026-09-29/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=5012a90d4f9fcacbdf003f151cd6f3316defcd2283514526102834bbd74a8c8d
+dist/2026-09-29/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=b8d1bfd9c839ebc6b7c90b98b0be907f6246e69fc92eb48e85db4ed6c7dcbe0b
+dist/2026-09-29/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=6569ec56c5f6fa26aff9883603cb9453504854fee82878b25b1b0d2cc9935e6b
+dist/2026-09-29/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=2b087399ddcface9b4466a915bf99077adbd8849846498016d57a61c48236d5e
+dist/2026-09-29/rust-std-beta-loongarch64-unknown-none.tar.gz=064352424fbc4bfb9637b2a5e45c7ac39d4c2acf937a48f5c8b71cc3b24cb615
+dist/2026-09-29/rust-std-beta-loongarch64-unknown-none.tar.xz=1f3bd23cb2fd4444efdbc15637a05ca8adeb18b2dfecdc5281ca92fdab40f6a1
+dist/2026-09-29/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=cacb51b0256f0f30722f8b69c4cafaf79dc2e9d561ca4990e00ea450a49626d1
+dist/2026-09-29/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=a6c1b71975918d172cf47017a2636a29814297ae79f80d223a83ac0cf17770d7
+dist/2026-09-29/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=e8f0efcb638b971d12ff73cc32422ce944cb2816022dca9d875f1eae938319ca
+dist/2026-09-29/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=b40bcea95f0c915cf154ffdcbd1388156c2d3c1734b4b00e192869422dbe170c
+dist/2026-09-29/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=efffecff9289cb117cdf4e3fed6126b45a3a82040e0d5f44101ed52f0b38f274
+dist/2026-09-29/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=e12f25ed25788772becf9f44bca4e88eda5a1f21cf17f08b09cdfa728f90a764
+dist/2026-09-29/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=e032b20d3f989cc8c74478871e6dceed4ce3fe3d0a7d232c15b8976e679f870c
+dist/2026-09-29/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=82e13804fce4dc6a36832873db80d5a4a43d9d8aee44c40c33c30a88227d5d44
+dist/2026-09-29/rust-std-beta-powerpc64-unknown-linux-musl.tar.gz=20a1312d8c162e7cb26ffe9ba89fa50cc92f4ca4bfa862e3bf2a540d3718a3d6
+dist/2026-09-29/rust-std-beta-powerpc64-unknown-linux-musl.tar.xz=6c2b3f2b17804994388a18f443470049bb63a785852456b27eac2a3320c03b31
+dist/2026-09-29/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=b02de7909bdcfb397a6714fee31031f7039c129fcbf831816d12957217fc9c7a
+dist/2026-09-29/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=a8d21a1e9f410be453757ca441d1872cec6a4c92aef1ea2111b4ee4a126a3db3
+dist/2026-09-29/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=44be1a79c527831221deedfcfb0e0afd0d8c772102b90286dd9180c6f102dff9
+dist/2026-09-29/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=d2305657826fd51a2c6480d8aa3d5fdf92d0f665770a83ee4c0f7f9ed0f0de65
+dist/2026-09-29/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=f1c9e1c8dc22a6f1d784aec5b24922976972c1eeb56e7d587650e22d4eb0d601
+dist/2026-09-29/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=7aaa2bde1cd84c38b13d24dafa47ab9083339795cac996437f41c7510426a562
+dist/2026-09-29/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=f04d393d79727af08de12ca7d13fd41ec78120e3bcc30008f684508edff0f2af
+dist/2026-09-29/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=04c8d324b52253354cd7907693bce663b300c075f10a9a0668c29956a8cf8a24
+dist/2026-09-29/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=2a8d5ffd86d7cf52d942933725653c6147ececd7f19a5d1ffee654a2cd1b8bdc
+dist/2026-09-29/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=5399870b58683f7d4d35b80c7079e959a092ced21e6b56969a9e9c67e82acfde
+dist/2026-09-29/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=6693b6d5032b92eb844e4c7dfbd7f251dae9a13c8af74aaff015c9258367c292
+dist/2026-09-29/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=cd1f07d5a147eb17ff4b6d77a9a9fc567d46a47ec00a1ae15d8ca0d48f12e5bb
+dist/2026-09-29/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=e783e12d4436d0976053f3c559096b4baf6f5a02d222c45f3cb40f59fbb91f53
+dist/2026-09-29/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=00564a08fd47392352f40d4b375a7ca565c8fee14f553bd526dbd88f049ad9a3
+dist/2026-09-29/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.gz=731b85413ebe28cad585e028bc77b78869e80ee0714f01b5e6a913d452ab6cb9
+dist/2026-09-29/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.xz=25902d5d514f10984a67301e6281b7e7fae38af2d95879c1ae730485068e3d67
+dist/2026-09-29/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=a776dd47f9381e67c9fee75db18df84cc2faf51d8691d23c393ea1514f257bbf
+dist/2026-09-29/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=9acd29f728562348bc380cc112cf56709ffd62e499d52e5ac9c0446a8c1731d2
+dist/2026-09-29/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=549702f03471fa57abd4b2d990b716fbc87274c8d0386afdc4ccadc7bc4dceff
+dist/2026-09-29/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=574bd2d37d0c13be91082d9633af161ee3eb7572fd72c8959cc744672723cd1b
+dist/2026-09-29/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=1c52932e910cada292e4561fb2d469d75e48369292475a67221a49e80b06e0f4
+dist/2026-09-29/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=18c6df09267c26b5f5c3d55b0ca108aeb1c6cc4e286461baef7ad126f5ca208e
+dist/2026-09-29/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=3f42e1e761b319b3e348396c87c3b79f67783081b2ee0acbfcf72c29a5409fc1
+dist/2026-09-29/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=f5fe44aeb22ad3c00eef4f4a1bac56436ba59bc9336b901d88c0f781032dc954
+dist/2026-09-29/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=88b170bcd8d3e26d422bc8ae7a525d8969878434acdb60c4d8f75ad4a6f5fb10
+dist/2026-09-29/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=5cbcf61ee88f021d7570f360971a4781a48ace118b6c2047a6d71b6928ec874d
+dist/2026-09-29/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=5772cb9750380f03ef47f1502e82ac790237967d7dd2e3de2eaf6fb0fb723df8
+dist/2026-09-29/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=5f2fcaf8b81c370443b53989dd12f3885c299fd8009aaeefeafb63ffa8c2dc40
+dist/2026-09-29/rust-std-beta-sparcv9-sun-solaris.tar.gz=4bcae41b9149b8d7d3a968b7924fa60ca15ff014c997dffddf1073e3c756a48e
+dist/2026-09-29/rust-std-beta-sparcv9-sun-solaris.tar.xz=1bcaae45605a3b9bc05265d48e4bf46bdae9d3a45c6e4cbab4de7df0ec76b73d
+dist/2026-09-29/rust-std-beta-thumbv6m-none-eabi.tar.gz=c8668ef20b4a6bdf393082067ec753b9e7e7fdcb4215bfa159a8394e70ac62bf
+dist/2026-09-29/rust-std-beta-thumbv6m-none-eabi.tar.xz=6aa054160722c4f887cd335f5e5549afe289f04e7abc5d6df95769a83be453d4
+dist/2026-09-29/rust-std-beta-thumbv7a-none-eabi.tar.gz=b28bd0f5ffebe62f944a3c5f17a9a73eab5c990201ea6961d530b769a69f8d3c
+dist/2026-09-29/rust-std-beta-thumbv7a-none-eabi.tar.xz=ce529ebc58e8a757bdab3aee87d34a0c06dd59feca3b708aa97a97b79ca176b4
+dist/2026-09-29/rust-std-beta-thumbv7a-none-eabihf.tar.gz=bc94dbbfe23cf6adf1d34a8a6421480854eab76009a0d327d597f84c83c597d6
+dist/2026-09-29/rust-std-beta-thumbv7a-none-eabihf.tar.xz=96bb2b46a7b11d85ef347e2561730fabd1f56cbb334b5b4ebe8fd0a60fc980ec
+dist/2026-09-29/rust-std-beta-thumbv7em-none-eabi.tar.gz=988b9a2c797874a96a155b152d2704624eea46e3ff76c9ee31081708661ee390
+dist/2026-09-29/rust-std-beta-thumbv7em-none-eabi.tar.xz=8c64f7dc6ac9d4b35a5683f6324cff0e1bf136b63dc7b0341f5b15570cd6ff37
+dist/2026-09-29/rust-std-beta-thumbv7em-none-eabihf.tar.gz=35fe10b86edb438efac8d9bb37992dc42758f84b82945fc5c115294c1645e997
+dist/2026-09-29/rust-std-beta-thumbv7em-none-eabihf.tar.xz=9ce5331218676dfe1cee5e975a7e9c56c30e051e4999cf4d7bcc89664aefbb60
+dist/2026-09-29/rust-std-beta-thumbv7m-none-eabi.tar.gz=d268977a2462bc3f8ee3a113965417313c8ce91de44700701bf89a1f485c1261
+dist/2026-09-29/rust-std-beta-thumbv7m-none-eabi.tar.xz=02cc4d5a04d190245b154769f6bf691ad82b2a37d5b6dcff98d25218f4da6508
+dist/2026-09-29/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=6b5025117edb1c0f6e2a519d7a827c257371bcbfe8c1cd2cf194fd8e808fab18
+dist/2026-09-29/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=f6ee4b5ee7439a71c1ac02c428ccafd739fb59e4d7743c73218472c99d54747e
+dist/2026-09-29/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=a1a6e10b069cc010dc0d25d33e39bf09d2e902ba824951571b1ff6272c406a30
+dist/2026-09-29/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=1e5f603944d9a1565d7ec648298e126a8d039ca8112bc9f5f8c4e6b2bfbe6f40
+dist/2026-09-29/rust-std-beta-thumbv7r-none-eabi.tar.gz=36c4b0a0bfe975883763666d3cc6562ca9f98e1b8623dc6fb1d341390669b511
+dist/2026-09-29/rust-std-beta-thumbv7r-none-eabi.tar.xz=d087749ff3a16e4577ae93afac8635ce614cfd56c68d2f01e939a33ee07ee5c8
+dist/2026-09-29/rust-std-beta-thumbv7r-none-eabihf.tar.gz=fff03b17250ffc7c328b68b542d293da4d81ae16fda76b53ca87d2dbe03a9fd4
+dist/2026-09-29/rust-std-beta-thumbv7r-none-eabihf.tar.xz=e47e298a4f5583c447056566b2c559af073387024d74822d4f7d657396cbb842
+dist/2026-09-29/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=6245b71146c9bf6892f87d36505f8f8b019f925a93e9e7382fb4c11ed7b92921
+dist/2026-09-29/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=1190208ca7e613923db504b2f452c87f631934a9ff69c212824ec15e03a45a58
+dist/2026-09-29/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=e2ae5641572df4bb08906d2b6e7f739eea79278333eb0c5547c49b0727c56dcb
+dist/2026-09-29/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=fe005ce3e6d13722a8a20e3ab668d44848ec97a3d7e275b74d60a84d8e421ee9
+dist/2026-09-29/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=a53f0858a9105a0e1c675d7662838fa849266d19ce5e0f6a35f72e1d3c6d4294
+dist/2026-09-29/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=f229db4fd00f6995049a9e6e3cec6763dee8ce10daac63bc522013b121bc4973
+dist/2026-09-29/rust-std-beta-thumbv8r-none-eabihf.tar.gz=341a7f6420319fb33970a0904144734539e605a2323dfbf2b91169e53aafdcc8
+dist/2026-09-29/rust-std-beta-thumbv8r-none-eabihf.tar.xz=2f3cebd916bff44147582514eeabe207c693cdd5e058febe7d86e8c5c87ec598
+dist/2026-09-29/rust-std-beta-wasm32-unknown-emscripten.tar.gz=e8b45a1e9bc3b54f1047a1cdaf9f6b8af3a6750413e4da81d69f0590a6137348
+dist/2026-09-29/rust-std-beta-wasm32-unknown-emscripten.tar.xz=5c20fdc9b9429f2cf72b11e31fc401d81a5deed37f7bd15627d81db5f834b57b
+dist/2026-09-29/rust-std-beta-wasm32-unknown-unknown.tar.gz=0796808b38d7517a28cfe7ba3eba5ecb037242a9abcc26390e1f1825467c7977
+dist/2026-09-29/rust-std-beta-wasm32-unknown-unknown.tar.xz=44dbce1c52229c875f22d98de17a78260892e4759b996e989d96ca58f22ea89c
+dist/2026-09-29/rust-std-beta-wasm32-wasip1.tar.gz=79a9003e337d684054d8c6859c2118da6992f4ac7eeb8bebb790b763294902c0
+dist/2026-09-29/rust-std-beta-wasm32-wasip1.tar.xz=7d0bdf81bdfea1bb40a17055aa3077b0b7afb214a6826a92a462ac9006b6aafa
+dist/2026-09-29/rust-std-beta-wasm32-wasip1-threads.tar.gz=1721f8d930563486f9f90572797b910643b4b0d62f1d89f90114568401d3da68
+dist/2026-09-29/rust-std-beta-wasm32-wasip1-threads.tar.xz=dc0968859fba0cf6ac6e2b50cb53b7790529e23e008a8407aeeb72b9939fa2e6
+dist/2026-09-29/rust-std-beta-wasm32-wasip2.tar.gz=f57b56c42f272d0daa2a8dfe5e0dc16d2ec696a820037bffece1cacdb664232a
+dist/2026-09-29/rust-std-beta-wasm32-wasip2.tar.xz=e82fa595d0ee89331a1f862efd487beac1d29895f8eb061ad6b6d04049ebdb9c
+dist/2026-09-29/rust-std-beta-wasm32-wasip3.tar.gz=6abca32199fc1bd072ef19d69c9884efe3dcb07c81d0260faa0ebb17e94617cf
+dist/2026-09-29/rust-std-beta-wasm32-wasip3.tar.xz=f019b8b140d81aa18a01dff20170f07a381908196828870d3b4dfcbe915f9d34
+dist/2026-09-29/rust-std-beta-wasm32v1-none.tar.gz=777b38934c1f0e70e39e2fb55f3424f8dd77c54ad49c72340ba20cd4307d49c4
+dist/2026-09-29/rust-std-beta-wasm32v1-none.tar.xz=4c78b7da12168bb42a4df10aa269b7a5218eb086ad203e093a87c84f64b2756f
+dist/2026-09-29/rust-std-beta-x86_64-apple-darwin.tar.gz=232d6824004015f32bbbb285c872030bdaf8bbf36cd259494f24f2802cac399a
+dist/2026-09-29/rust-std-beta-x86_64-apple-darwin.tar.xz=63bf0f85ed80e97cac13f2edc54826829867b62b1758565c580a0680bf370bff
+dist/2026-09-29/rust-std-beta-x86_64-apple-ios.tar.gz=23e8e77b11c0870bb486fcd76cee15db11587d3f47df20f220d69a46640ddd8f
+dist/2026-09-29/rust-std-beta-x86_64-apple-ios.tar.xz=9f556cc01cd4abf0949c23f1ddc4209d7b92cdc1d521cb22403a4258eac0fdb0
+dist/2026-09-29/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=d5e6bd07a5aa5346c1294d851466579d567ce1d1db16f6b9a40c20619958c8d5
+dist/2026-09-29/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=c3d8808f3b17c81d6de7a8ee2486b5a837f67069e51ad29b0a3c2fa4ebaf4f0d
+dist/2026-09-29/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=72d8b973a20da182acb65479a067be9b4e8fc4e7f7eed41deeac27f8e2401737
+dist/2026-09-29/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=ec661a7156e6baab75839b55377d270a1151e6c432420683ad5a082571f37a77
+dist/2026-09-29/rust-std-beta-x86_64-linux-android.tar.gz=06c09a6a5e54e4da413cedcf0a178107f2d6cfc8082903b262a5db6c807b4a44
+dist/2026-09-29/rust-std-beta-x86_64-linux-android.tar.xz=d36c4d48fa72b2313ba29fc757c505e8a11c712cc779eda7ffa5062b2646907e
+dist/2026-09-29/rust-std-beta-x86_64-pc-solaris.tar.gz=ca8ce15a7ae374cc46fde55808a54f94c197bcc9bb40448df06e09cef1257dae
+dist/2026-09-29/rust-std-beta-x86_64-pc-solaris.tar.xz=f7c2208dec2c25805546258a81d361f250672ea51e0891254bee9f3c3f4e95ff
+dist/2026-09-29/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=b8632646f82535baf39460a3a6ed6a6a92e33f31787efaaf4e6d655225c4f5a8
+dist/2026-09-29/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=ab6729530be4e5fbfa51e76f53f4dcf9c974e0ce6ed11556e8aeb831b1aecdc6
+dist/2026-09-29/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=c76571599f894548491d95639bd75f551a3c614e8dfcf34dc6b38e1d3bf28474
+dist/2026-09-29/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=52dcb526a8ddeaa6081809401ff94a733128a5e4adf9feb1671744ca1134d817
+dist/2026-09-29/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=84c55c99e3a783136cd334db0fcd6cb6e6cc6d3fa997fedc87dd7620e094ca5d
+dist/2026-09-29/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=d7c46a39c354ca67f2197be455db7f3817cf35f476b8fac5c85e16c911cd291c
+dist/2026-09-29/rust-std-beta-x86_64-unknown-freebsd.tar.gz=46331daca0d7bc83edd687190817d7b7b62f14fa037d9dd56c32314d10e1df29
+dist/2026-09-29/rust-std-beta-x86_64-unknown-freebsd.tar.xz=ac315cd71f957e6b555f98e7744bedf32ae06cecf8a688594d16dc11b0409e14
+dist/2026-09-29/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=5ac6db26e1298837d5d660ca24be108c9fe569784ddb2061dd8b7afca06c4a1a
+dist/2026-09-29/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=0ccc6aa8a3746d143515882a33254fa67cead1e58fc3dbce191769f59fccb635
+dist/2026-09-29/rust-std-beta-x86_64-unknown-illumos.tar.gz=9547382b596806f8460bffd1fba4b21c87a809744b678d1379c821288256bfb7
+dist/2026-09-29/rust-std-beta-x86_64-unknown-illumos.tar.xz=a52fa0165572f08d7c0807b618b8841c9220065ff188095bdbf4bd4e9bb11771
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=b8eaac057b7b4197941904f539ef4e01eb93daeaedd8b158b5a0a2d8e370ea26
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=9095fa52e354f1441568af9e3a9839b16268f7ae7707fd4bc48b2a2bcd1d547f
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.gz=956b82298d2f2c7e34e28d157ba41945d39865a23b9bbe20678d7ae31aa825b2
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.xz=3ecf190a1c53ee9aea39f643ac62923835379f08f6503f4134459ebc5f610a08
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.gz=10576f120a98f153c7a68e62a565a92424917a36fe3cb017f4a657e236b3ff88
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.xz=a009b119cc0d811e070dc329cf241b8b509d9a297faa68c5d2216b4e21f5ac50
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.gz=8d9aab19bea2b6b07f11e9a2bdc0058441e6f80f4d6e778c03cb5b52854c7aca
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.xz=3507d9b8563db110eaae0253c5c041b62d42508696f1526b94b92fd28e200b14
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=7dc3b370335b15345dc9f508c4f132d00a69fdf0feacbaaaaa2f93bd7cbf9ce7
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=b8b24db68ff29f15c52fc70ee12cc6d10bcd65259c521876fb08892c8f67b980
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=13da2b408f85665b37c6ba519cc4fbf8eeacae1dd6835f22edd800fa229d6f56
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=61f986574cf89a091fc6563c0cef458e1c5618444364eb36751194b2da7f8da9
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=48d5e6ffa8dc7319809a13ed109a8c5e43e9b17d5e6c9e88a57ec160068caae5
+dist/2026-09-29/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=962cc03687830996b02c8419b4f948b94b7f9b6c40a918212bfa9ba8a3186aea
+dist/2026-09-29/rust-std-beta-x86_64-unknown-netbsd.tar.gz=93c518fd23ffc00d69f37e38b90033d76091b3946ee7ec82d906b78a4f7130e9
+dist/2026-09-29/rust-std-beta-x86_64-unknown-netbsd.tar.xz=a8922fe96c323e6ccf587a70841651143065e25d2ce465dea5e2d9ffb52fd42c
+dist/2026-09-29/rust-std-beta-x86_64-unknown-none.tar.gz=4df5d869a75e754e1952b73fa78a4722fca53038325dd0e541887e8d0c8a7620
+dist/2026-09-29/rust-std-beta-x86_64-unknown-none.tar.xz=c37467acf1d25eaba261edff55a410a0104dd31b90f8158b10b6f2e369a6d9eb
+dist/2026-09-29/rust-std-beta-x86_64-unknown-redox.tar.gz=8d245bade3f0fd036e16314190cf3a0ca535c75a4c97277e24135a9e76815156
+dist/2026-09-29/rust-std-beta-x86_64-unknown-redox.tar.xz=76392bc2afdd60a591b3114fb191deacf59388c21fb1d7ec1733f2f561778648
+dist/2026-09-29/rust-std-beta-x86_64-unknown-uefi.tar.gz=b17e48ee19a86057a7ebaeadd697a4dc86853cf9e66c4981e5043de9e3ce1c00
+dist/2026-09-29/rust-std-beta-x86_64-unknown-uefi.tar.xz=1cd2a4b32284ffb4d11bcd3fb561578f3d00c763c704a177e113af6899c22d0d
+dist/2026-09-29/cargo-beta-aarch64-apple-darwin.tar.gz=f3066c859807c0ab69429ea69362654e18c21d26b2c482be436280bfad4b49e2
+dist/2026-09-29/cargo-beta-aarch64-apple-darwin.tar.xz=0bdc913f85f762ca2af5c9bd2d72a31865c102bc66bcc43250a7eae06208de49
+dist/2026-09-29/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=e2bde3311142eee8c4d822ff838778cbd2ef7d7f496f4dd4a0237756fd16964e
+dist/2026-09-29/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=1c26e80d1529c17cf4ef6025ceb63490cd862ca9eb7c21fa043fa89d2ee1f0ff
+dist/2026-09-29/cargo-beta-aarch64-pc-windows-msvc.tar.gz=2b71fb86fb57894c2fa83ae53522783fd9b5b654332ae7623eca3b153f4136e8
+dist/2026-09-29/cargo-beta-aarch64-pc-windows-msvc.tar.xz=5a8b4e3db041cafd58e59333f872cb1020f385d54269ea02ca7ca8a4ce45796a
+dist/2026-09-29/cargo-beta-aarch64-unknown-freebsd.tar.gz=12d98333d9d48a97a6cf0bbb9b01cd4a215a51feaf81c5ddb4ac54ce3644814b
+dist/2026-09-29/cargo-beta-aarch64-unknown-freebsd.tar.xz=89fc6ebdf93d553fc957a1adac94f9d83feabd5c84c364aa875f36a4d274e31d
+dist/2026-09-29/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=173043d8b96bbd8149de521da3271123895af497379a278a87039cef644f5245
+dist/2026-09-29/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=69eae56c755c9d90a1e35d38e22d43b46e204913d237c5c2ea9001906a273db5
+dist/2026-09-29/cargo-beta-aarch64-unknown-linux-musl.tar.gz=2590e51b526f771cc486a2ca15f89c7ccdf878bce18c7e03cf32b6116ab5483c
+dist/2026-09-29/cargo-beta-aarch64-unknown-linux-musl.tar.xz=8d1325965495214ac2894aa9062255e519397eded66a32e71b871eeea81dd930
+dist/2026-09-29/cargo-beta-aarch64-unknown-linux-ohos.tar.gz=e18bfa187c668f15f48aa36fcb29d71791577132e829334dd3ac05d5b7cdd7f4
+dist/2026-09-29/cargo-beta-aarch64-unknown-linux-ohos.tar.xz=fc3d7339b87792efe262f8f0685bc97c42bda4ee21541d4d0719e1ba1fdba4a5
+dist/2026-09-29/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=25a23eaf8af21d465d2b0ca6461281702c10339d968ff226e0c63dc6bf9950ae
+dist/2026-09-29/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=7544dd758d44668e985e93eb777bccead5f63bf98326ed7e003d2a68a59d4c4f
+dist/2026-09-29/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=016d2a04723930c835f7564bbf460978ec2ba9f497c5b94c6665ece36989aefd
+dist/2026-09-29/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=4a40079a253cb349e41148b919b7e460e5eb6c659089dc4366c32cb343dab5c8
+dist/2026-09-29/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=36b8677ec6fc857af1777e2f4a68c2cbe90a72b21f9afe2b4221593a76cd3748
+dist/2026-09-29/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=816e1c6b3bdaf08b24514331b972d864a6b7bd8d63479fd154dd1608ac66f26e
+dist/2026-09-29/cargo-beta-i686-unknown-linux-gnu.tar.gz=f374e9858d5d4294e9007986d4df7af0d15a57bef5862c289b818c3bf7bc8299
+dist/2026-09-29/cargo-beta-i686-unknown-linux-gnu.tar.xz=ebaa11b6203e20cb0a612c53aaa9a0ae5c275795c1737c4bebebb679cdabb485
+dist/2026-09-29/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=e6816ee73290cf376b402ad6470eb2b68004a883b1b4294393a8966d7bdf1aa0
+dist/2026-09-29/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=b476bcd327cd838606b8482381c6fabf0ce97f518e3ab11b35a50827f2b18b51
+dist/2026-09-29/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=b83080fee58cb9e72db9c8ac994724ff3a5bd2b7039eabbfa0cd9bc77d2d4532
+dist/2026-09-29/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=889717547ec4cbb80d7f2d2e35b1b2b512c3e450ffa56a1bc27289fe285898d6
+dist/2026-09-29/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=340d7ff13760dbb32148c8616dd7c7246870a7f091bda102902589a20dc8c2f0
+dist/2026-09-29/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=29c10897c335e4bd2dde7848bf67bcc93b96e5911888524d0abb8704fb88a629
+dist/2026-09-29/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=62fe339183294cdd58c5c90a6a1dff3a388dc2b054f2ef46babc127cb1dcaf11
+dist/2026-09-29/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=18ce8044103b232c245c8ad3ab92073a473740a897506c69f79c406b611263d1
+dist/2026-09-29/cargo-beta-powerpc64-unknown-linux-musl.tar.gz=fa3e4a74e3bcb12816049d51dcbd9103fd2136679c509b47b4a64f38686c46d9
+dist/2026-09-29/cargo-beta-powerpc64-unknown-linux-musl.tar.xz=d5efafc560f206af8e32d6a720c923e74443af1e5e30e8e9a5a06a38b2955534
+dist/2026-09-29/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=07a1eb729d565b322c3f65d925cb98f125d8c031ea390e5537208fc831cdb627
+dist/2026-09-29/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=fae744722b6f92d00dcf4325d1f5c7a59dbf3563f53318e772ac48ec330c7d2c
+dist/2026-09-29/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=95e91adc5af521f58650ab88707c870952be0492e913c96df8dd3a816449f242
+dist/2026-09-29/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=d46a64931a0ff96ba7c80f3fb3edceee803d86458c72255b5037857e0ff86de5
+dist/2026-09-29/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=05a6b30d13367ee0f13295ebad1ab19c41d6ef7e0658971b4857e2b423d04ac2
+dist/2026-09-29/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=d64db7e154194aab5d689236a545e3a2f657a67339c0eff77581be6f1808e6f1
+dist/2026-09-29/cargo-beta-riscv64gc-unknown-linux-musl.tar.gz=88adb1c494bc36bc577bb13bae1efa5051481cfce96249c4d340ab7eca017c17
+dist/2026-09-29/cargo-beta-riscv64gc-unknown-linux-musl.tar.xz=8347b2a940db92e3af2c11208ad77c337f5dc856960656c179e19c2b17a161b5
+dist/2026-09-29/cargo-beta-s390x-unknown-linux-gnu.tar.gz=79070ab2fd6d93d37a1cdd11d24a1de15a887d5503086f1e64766a99796decb3
+dist/2026-09-29/cargo-beta-s390x-unknown-linux-gnu.tar.xz=b64e4cca016d3ffce2b1e6944cd249d4e93eab689c0d9cced01a798bc7e183e9
+dist/2026-09-29/cargo-beta-sparcv9-sun-solaris.tar.gz=fc1bfe106843c3b7f0affa77de936dfdb8b9f5a438176d9037aa0533e9b9c8ee
+dist/2026-09-29/cargo-beta-sparcv9-sun-solaris.tar.xz=9e12971574167eff3830526f10db3e21cb817f4b28acdb10c42c7689cc2f9656
+dist/2026-09-29/cargo-beta-x86_64-apple-darwin.tar.gz=97072e5a8006d0a8932983a44b1dc0a7b56d46efc76fac6378315f43cfb2c556
+dist/2026-09-29/cargo-beta-x86_64-apple-darwin.tar.xz=d296336efa8cee66a03655cbd66e64709866fe98bc2aeabfdff88039b74eb800
+dist/2026-09-29/cargo-beta-x86_64-pc-solaris.tar.gz=96832f53757943d1c752dadb11fc122af8085317017d7263b73d413029ce9b1f
+dist/2026-09-29/cargo-beta-x86_64-pc-solaris.tar.xz=091cd84168e3c9dd860bc0df58d07def0318e470c3459cd431fed713c0ab2616
+dist/2026-09-29/cargo-beta-x86_64-pc-windows-gnu.tar.gz=f99a145aa7938be5baae99302858b680e2c2ae3dd84e8434cc38de374967deaf
+dist/2026-09-29/cargo-beta-x86_64-pc-windows-gnu.tar.xz=5bd7758064d9500c68fcfdd5a3a851d4dda40d3c870a83b9a70c93b46a8c8823
+dist/2026-09-29/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=06494aceb50c8bf0131639c52c62746b07ff2143b04d383be6f137277397a0ae
+dist/2026-09-29/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=5923b97ac130c29f6f0ba96fdbf4b034a452a9d03ae78d8bd812e9d3eb304a80
+dist/2026-09-29/cargo-beta-x86_64-pc-windows-msvc.tar.gz=26736efdd0b4e09dd8e7ed421881fcd39e588b31c45129c011bd78d83e42c153
+dist/2026-09-29/cargo-beta-x86_64-pc-windows-msvc.tar.xz=9e72a3172d9638143bbb51c9cecfce7dfbe463644ca3e90cfbfb04a30561ed93
+dist/2026-09-29/cargo-beta-x86_64-unknown-freebsd.tar.gz=e9b9ecfda5fa944168f81c12ebbe2c127ab245f867d61d47197ae23ca8eb9c86
+dist/2026-09-29/cargo-beta-x86_64-unknown-freebsd.tar.xz=e7359e4d2a6e0ff4ac99fa49346f1e2ee4c64487bb2f35ef0b75fc497bb676bf
+dist/2026-09-29/cargo-beta-x86_64-unknown-illumos.tar.gz=bc5382bc1853388dc1573f464bfc3393f41293b159826488b0096ce1dd87582a
+dist/2026-09-29/cargo-beta-x86_64-unknown-illumos.tar.xz=46867f0df7b6b95f13598267c5e17a96aff1de929ea2b23fbedb30e7b24324da
+dist/2026-09-29/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=dc8dcdee80d7034b0ceadb64fb15608c7617022f4c0be595bffed3326f1bc7a8
+dist/2026-09-29/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=6ed534d029be58d7c0fcebaba581166fee81167de58806540d9d6ffb0f68836d
+dist/2026-09-29/cargo-beta-x86_64-unknown-linux-musl.tar.gz=ccace12c5ac38d428e107faf94c7945eeff7f72058910fe93f6514234feb0aef
+dist/2026-09-29/cargo-beta-x86_64-unknown-linux-musl.tar.xz=03501cfc18b5dd937612ee76fbd57ded962da245f87aefe3bfa4f332afd9812f
+dist/2026-09-29/cargo-beta-x86_64-unknown-netbsd.tar.gz=384f90d70932ba9babe4f9baae008cdf52ef7815a0052b7b6c73bece3f024aa6
+dist/2026-09-29/cargo-beta-x86_64-unknown-netbsd.tar.xz=3c4e43e90a741f1e10409b3cbe426ebe3d3506ad7196eb291c55c4ee060d9e19
+dist/2026-09-29/clippy-beta-aarch64-apple-darwin.tar.gz=aa278ec430f7939b2eb5da177a7e3229b92105ee9e7ad71d8ba7f04cf6f41a4a
+dist/2026-09-29/clippy-beta-aarch64-apple-darwin.tar.xz=3929ed842657b6792f95b987e0deb630d96aeb98db9700493be148999390c5e7
+dist/2026-09-29/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=1272823dc9eeb737f03ec09313c09953d75fea3a848e695c8bc434c2ab53e062
+dist/2026-09-29/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=76155e48b475fc40bb31ad136725f00875385db2bf179fdb3979065c7a65282f
+dist/2026-09-29/clippy-beta-aarch64-pc-windows-msvc.tar.gz=f79d2073573010aa0f1ee4a8579b17f3a1997dc96fc6652a8c8c19a566231eb0
+dist/2026-09-29/clippy-beta-aarch64-pc-windows-msvc.tar.xz=4b8303804318d731b61159959c93782f205a95d8a3aa14e1643b319b6fe9558e
+dist/2026-09-29/clippy-beta-aarch64-unknown-freebsd.tar.gz=1028922c743c9170603eb76731be0d3d994873a2b5a47f6a46480eb339a14554
+dist/2026-09-29/clippy-beta-aarch64-unknown-freebsd.tar.xz=ac262e022b7b09669051a325e02eef2cb83087c25ffdee6f059e2069ef430e3f
+dist/2026-09-29/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=bb1376c0de000c1e0efdaf8ecb9fa11b14a64a6fe99000ac391f828376ce2c12
+dist/2026-09-29/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=90d1d3895d777b2a473f8035d3264f374c9ca91fdeec32d78899ae0a5f33f0ad
+dist/2026-09-29/clippy-beta-aarch64-unknown-linux-musl.tar.gz=5a4cd4fa995f9ba8ef4f87001a87595c4a144f1af62b6a61ff2c5d4e2d90f7aa
+dist/2026-09-29/clippy-beta-aarch64-unknown-linux-musl.tar.xz=3775b95f01258fb108f323d031ba8920993d23746f62a6fe5b14add176833b05
+dist/2026-09-29/clippy-beta-aarch64-unknown-linux-ohos.tar.gz=7759e690dcf0984c274dadb14d5601f64cecd21c833b44c93b24c509234bd697
+dist/2026-09-29/clippy-beta-aarch64-unknown-linux-ohos.tar.xz=21598de0d56cb2c0a259cec74bf4b45b1ae350a9d62296289e85f6648fff0427
+dist/2026-09-29/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=a8db1b3308fd0764012d3e76bdf92a076749a04af6f3f139288a1b5f7aea6d3a
+dist/2026-09-29/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=746e5b548d3c57a9c42da80a02a5c2df0c2e025b2a8becf17ca1aab937d0bf27
+dist/2026-09-29/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=6100df771233dbe2d31b9ca7ac202ecdefddb964687b9ea2b97799c58f2df8b1
+dist/2026-09-29/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=601693ede0315db0d92c6bc9c53f1f4d829d1a506001cd291fcb61c12c91ca09
+dist/2026-09-29/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=a7cf7145fc885a7d0359e6f32f8d9a46bf2adbdf268823f1202647bc2a131fdc
+dist/2026-09-29/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=4b26189ee6eb3d78cce60be7a54d0d64f1a5bfb18dbabf30e829296ee09065a6
+dist/2026-09-29/clippy-beta-i686-unknown-linux-gnu.tar.gz=b73fe9b224653599b38a0a68cada53106276e749f5350871a1d549be5c147487
+dist/2026-09-29/clippy-beta-i686-unknown-linux-gnu.tar.xz=60fa35754a88f0f97e538b639c24237d651c11e1edb16c653536111e1a7f123b
+dist/2026-09-29/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=8a59dd0ce10cde5e714d3f8989fb1ebde1ac51d746e96a72d6239feae81d1568
+dist/2026-09-29/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=3e7d0761021dc58612054a575e202224645665f90fec0bf805998694a71c8fb9
+dist/2026-09-29/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=f220e05c95906dfe8247ab7a3fb732a5444cba27facad044f50db4c04b62bff4
+dist/2026-09-29/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=d9a7343dd0ee670a086a565a1013f647b3fd8061d4594d42cd2724d3cd52bb78
+dist/2026-09-29/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=e025c6f5c822b45ddf5387dc9a42dcdca9f69be2546a020b2d4de2c07590b8c4
+dist/2026-09-29/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=90d7b50a45274903c43d4d1c57c9ed5b4213c07563feed70caec38723df02bbf
+dist/2026-09-29/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=31aa57d681a3215023de663aafeea01e476be4e2a1f89345602e89eb3b1b5c03
+dist/2026-09-29/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=fc5dd5800afb155af741770c6111262e9a2b5817bbd8bc2ba06ba2daeb72c822
+dist/2026-09-29/clippy-beta-powerpc64-unknown-linux-musl.tar.gz=ab5edc689617c105a00941d3870b6490c62209d235d09b7f2d48b8ca460b62a5
+dist/2026-09-29/clippy-beta-powerpc64-unknown-linux-musl.tar.xz=77b9759b82d634222650a2ccf9160b654fc636be0b7fd4fac822728eaf1f7317
+dist/2026-09-29/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=04f40458440c4222e49df829159f51fc667c10b0762181a535ff61cf120352be
+dist/2026-09-29/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=ebc8495543e025b2c6db795f665725ad62a2ddd17094f6725bf4e00cbbf25331
+dist/2026-09-29/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=ba6653802d14bd1586819ae5f9510b9a97e0ba6ebc062942264b52fc297fcff8
+dist/2026-09-29/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=7c3f65a1938dea882cfee18992a10cb23b58de801a191d0cbbf8c6cc6f9cd900
+dist/2026-09-29/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=ad43d2a294308b1509151379c5a9bb40b064e13a841c2d34ed31537bd9eda3a0
+dist/2026-09-29/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=d7f118d124d772ebe763780f8ab1cd0295562eccae944c5507500971eebc5352
+dist/2026-09-29/clippy-beta-riscv64gc-unknown-linux-musl.tar.gz=9bb458f695227868c03d21e15177210b067c7fea223c1ba877f3908cff85e673
+dist/2026-09-29/clippy-beta-riscv64gc-unknown-linux-musl.tar.xz=80de4f209ad908cb28921bedd07cbb1444cd7f25179a851c6a2285bfcb13e13e
+dist/2026-09-29/clippy-beta-s390x-unknown-linux-gnu.tar.gz=1f3e61cac84317586d80f816465800299920d032548dc82ac6fdd554503d9f86
+dist/2026-09-29/clippy-beta-s390x-unknown-linux-gnu.tar.xz=98f16b6b0a8a6a4542a07d0ec06ae1a05cefdeacfe7398363c61af5b5ea0e3dd
+dist/2026-09-29/clippy-beta-sparcv9-sun-solaris.tar.gz=d5876205c3b704883a464354e287ad485dd0677261d36c7adb3beb97509bf907
+dist/2026-09-29/clippy-beta-sparcv9-sun-solaris.tar.xz=b036fc21fa47b8bce0113a1ef74ff869a54ea06d8f3bc0058f4551c3daa1f089
+dist/2026-09-29/clippy-beta-x86_64-apple-darwin.tar.gz=d9f9860fa397ae78d9e6612240a05eedb917cf536ebdef03bfd4bee110feff58
+dist/2026-09-29/clippy-beta-x86_64-apple-darwin.tar.xz=b054e2bba8ea8b3994e48aa1ef9b121eb1760f1c9468da3dcd9ca8cbe05728b9
+dist/2026-09-29/clippy-beta-x86_64-pc-solaris.tar.gz=ab47ad303b93eae7fd933333a94e7b4f65f0119735b83b8eca83691e24f982bf
+dist/2026-09-29/clippy-beta-x86_64-pc-solaris.tar.xz=2187367acea68f7bf09932f0cdb237e30e57a57aadcc388219f60aaf28ec4ea1
+dist/2026-09-29/clippy-beta-x86_64-pc-windows-gnu.tar.gz=97af8a6c3356b4d65d1f96f893e57100969ecfbb2e6c364a2380b07d154677ec
+dist/2026-09-29/clippy-beta-x86_64-pc-windows-gnu.tar.xz=af7f0a59d0ae24d0dc8ab6424a781a65d5d0cb8b3253786daa908e1d43efa7eb
+dist/2026-09-29/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=683647b7e096c4085162b0936c614e7151bd6e9e6c5da902a80e68b91d54f47a
+dist/2026-09-29/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=9a3b7efc7dd8c84f8351f117bcad61423c2f2cae6c1782fd28361a6865d31abf
+dist/2026-09-29/clippy-beta-x86_64-pc-windows-msvc.tar.gz=b487c66b5091b4a7446f70d9fe138b62a253aac4a8a7745151f8a2e0f0af2c77
+dist/2026-09-29/clippy-beta-x86_64-pc-windows-msvc.tar.xz=53c63e23c797c931401bfc23053b336ebb0e0e26d603cd817770daff8aa8fb8e
+dist/2026-09-29/clippy-beta-x86_64-unknown-freebsd.tar.gz=1174a56bb2aab0c5f88b963a8d2d26fbb5d29ff3f3dab449c6848711641060c8
+dist/2026-09-29/clippy-beta-x86_64-unknown-freebsd.tar.xz=adbb076f2efe0532c7e6997ceab6c08e8e5c228774b0e9f844bc238c14663f90
+dist/2026-09-29/clippy-beta-x86_64-unknown-illumos.tar.gz=07047d9cf9e20e6cdf12f1a24706eaf6791d921df97430aea8a1fe37f6cfd6f1
+dist/2026-09-29/clippy-beta-x86_64-unknown-illumos.tar.xz=7720a8410c6c1814a60c9c1432190179aff2bcdba720cc1fe7863cfe9c4ef7e2
+dist/2026-09-29/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=9a47312d7f06050e2a35f884a0fadb63994d9ce4c988db7055df9c3a18826db5
+dist/2026-09-29/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=dc6cafdb56fa4c08d69fabb0fe55c2bfbd13f5452676b7ca7ea80b0feb0636b7
+dist/2026-09-29/clippy-beta-x86_64-unknown-linux-musl.tar.gz=681bc45997f340b2767e1fcdb98d77cd6331b435c0b9b94d3dae0d68d2afe628
+dist/2026-09-29/clippy-beta-x86_64-unknown-linux-musl.tar.xz=09933240e021562422512f9a01364a681fa5fbdc0518d53b2c84159cc160f64b
+dist/2026-09-29/clippy-beta-x86_64-unknown-netbsd.tar.gz=7f09a6e7d2a3ca645d600f7b2836854240927b9b22ed5b90c2e19b18602f1bf9
+dist/2026-09-29/clippy-beta-x86_64-unknown-netbsd.tar.xz=6f55faa86ce658f28036f4828d00d9f3554a16bc4c08d338f90e46cc0b8290a8
+dist/2026-09-29/rust-beta-aarch64-pc-windows-gnullvm.msi=110b7787e72503c3d8f00bb83b4844ee5d86282006535978fabaeccd570b9446
+dist/2026-09-29/rust-beta-aarch64-pc-windows-msvc.msi=52095c3b2bb30c4444514adb315c441ae99a908fcd6dabf84df86e9fa547fdf2
+dist/2026-09-29/rust-beta-x86_64-pc-windows-gnu.msi=0dbeb0a4874799e29f61078c2ee7b52aa09f3892da449949562f7b834213d2af
+dist/2026-09-29/rust-beta-x86_64-pc-windows-gnullvm.msi=67bb2a3bdf0efa223c1ec3961ca8bb3becd0dfec3dbba6c1664f3800c13f96c9
+dist/2026-09-29/rust-beta-x86_64-pc-windows-msvc.msi=f3832ded2d7dc6b8e344a8a05a58145753b7206409ab7989e4e175b000891bb5
+dist/2026-09-29/rust-beta-aarch64-apple-darwin.pkg=ba8205d70d4e7d9dac9fcbbb50e26a1c48d95f6d53115cd4f31b4894fb770f86
+dist/2026-09-29/rust-beta-x86_64-apple-darwin.pkg=821a0c24ed40c517f6b3cadc591a41e12f3dc17ee177d304d91adcc4d00d1557
+dist/2026-09-29/rustc-beta-src.tar.gz=1e970d860c77112674c08a4f6fe27c7f5f3eabdbaaabae7924872f37b0a6bc9f
+dist/2026-09-29/rustc-beta-src.tar.xz=8c8dd7643b15e160e0ee62ce2ea2804c1c463954a983527335c9ad05e2d7a282
+dist/2026-09-29/rustfmt-nightly-aarch64-apple-darwin.tar.gz=3bd82067ee57ab38a80d21b212397e600b1cdfac4ffe67e064a0d4fc72696579
+dist/2026-09-29/rustfmt-nightly-aarch64-apple-darwin.tar.xz=105657de7a7e2989d0e1aa27655bad89689dfa702e6208072c04a5dc1f116dca
+dist/2026-09-29/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=e9ac24651a2dcd1b92c85ce3ca537ca4004d077d13d81a76c30543a2ff537ce8
+dist/2026-09-29/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=12d0fed0b8caaea2fb0b63590a4dc2f96af71a54eb3ca113e09601a5e603fa7e
+dist/2026-09-29/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=2e4a7ba18c433714efdcce7b1b858a3128b10918f0b6c081225b5699ce095b4c
+dist/2026-09-29/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=da5ef1e3577b7c7817509115086de5f3b32d943b76ee3e5d3d555f88bc02b28e
+dist/2026-09-29/rustfmt-nightly-aarch64-unknown-freebsd.tar.gz=44446b6fae2d871a1b6af2100f4c0783b3f000b348a1536c5c4f23b82c8107ec
+dist/2026-09-29/rustfmt-nightly-aarch64-unknown-freebsd.tar.xz=7d37bb9b45eac9c1e2bbcc623da6dde1d653527d408292e913b4347f3622accb
+dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=997a0e463191defc94ffa9405ba11a4a2bba1b220b40cef415a1a8d21e2e88f1
+dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=2050f09bd2dffd324c3b949626c35830d16f2e92a680a8c7001a19287d3d1b54
+dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=479090aac278503503b41acf936c774c645343a33193e5c149f9db28a301edc9
+dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=87b3f386c5372dca8676065403c0123935c7a47c5e69579beecc040a0b67ba15
+dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.gz=10da9a954bd0b76aab56c09ba01262eb87069ba18d67c36b982f3a5ca0ca3555
+dist/2026-09-29/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.xz=f3db934402e31236c41188b5f85eab229e4cc8d108c9c33375e03bdd3b72bde3
+dist/2026-09-29/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=9891c54c4cc027cb0e0edbf6c7b2d85a80287ff486074d8334cc0eea662fce48
+dist/2026-09-29/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=8ef63b3fbace26c9ae4045bf08d8bc2c60fc6fcac095bab34f0743f82729a15b
+dist/2026-09-29/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=fabf81e854b1e1220756f2cc04cb911bff886af1a84f306bd38eaf3d7bf6e0bf
+dist/2026-09-29/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=f47aac3590c165cd800be1526278bc06538fddfbadc2f2ea0288a16274a3b04f
+dist/2026-09-29/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=fe5a0792b5f3f34e4854e257f3edf27e30c90938568e4ff576d374e5a4800cfd
+dist/2026-09-29/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=3ed3e957bbb5aeb4895cb5ddfcb93abd32a5c10982adb0724a3b91a578c9d5a5
+dist/2026-09-29/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=d1e17fb001c32efa0455ce814ba35276e02de4fa41f858a1573f407ebfb79b21
+dist/2026-09-29/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=d673931f677d95884fcbdb9dd1d971588ad8209b12b9ec10338f2c9e1516479e
+dist/2026-09-29/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=96cf73ca815b8b5c912cb82e2ee2d75d1d60a11bda9fe242173b8a74335441b1
+dist/2026-09-29/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=a1af935bc9d319a962f388cb9d52981ccc1adae9e79ad561c520f92994b5b4de
+dist/2026-09-29/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=a614c7570d2f7370761938d62a93cf231d6673f4cf51be1ec13a86d7857d8a26
+dist/2026-09-29/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=c7033f3846f19329e2d0c177cdc328387e9fd1d6738f44f3134fd73993e810e7
+dist/2026-09-29/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=5a5c754617ff1d20b76c4f6a651bfbeb3446d133e2d7d1d151195d9c9709ba37
+dist/2026-09-29/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=efba88f943670d427859c411c71090e3c9c503400c527432bf0f4e45aa9a640d
+dist/2026-09-29/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=bdfd3bd37453fd6c8cf965b2ccc56d0db4131dcb232843ff8ccb744126d07581
+dist/2026-09-29/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=36fb9e8d537d9439391b2eac5357bc93d422be396fe226c4e7ada987ae1cd0fd
+dist/2026-09-29/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.gz=613aaa4c896802ad5065a846a0412e708ba4ec8d4cbb8c4cc268924edf50866d
+dist/2026-09-29/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.xz=d11268b84e0ad465d055208171268a63340724909916c9c4c8f2db7f77930406
+dist/2026-09-29/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=3635e8a286ebf903e86b13e71a0c9da91b1cf08acd15fb529990e1bb01938994
+dist/2026-09-29/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=7ba06366c9cb6641d177d1fea1efc74b4a70145f4947aea57dc3161d21e3b53b
+dist/2026-09-29/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=64fa9295cd882e817a913046856e11e3980740efedbc9dce3c9154e38c9a1088
+dist/2026-09-29/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=190e0db21d5bfb1e47a6448566b42429a386e8ced68eccf29c575e8a17774aa2
+dist/2026-09-29/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=780db7ef6ffc4d4e3bf37588d111b2733b2f30b22d1247111a7b6d290ed7882a
+dist/2026-09-29/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=0c55a5f391d9e032ec946bf2ea977b80514239c54109438e4ef17257bbae05e6
+dist/2026-09-29/rustfmt-nightly-riscv64gc-unknown-linux-musl.tar.gz=e9f3036825eae095bc415b485ad9397c96edc3481a258865db9d4b54e7cc9134
+dist/2026-09-29/rustfmt-nightly-riscv64gc-unknown-linux-musl.tar.xz=e4b3cac7c35db29013a22fa6e374011dea824909e3411ce4dabdb197344e0a9d
+dist/2026-09-29/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=c989d87883a750ae2e3d92366f22c0a55858dab9402260af5b2272b8b3eb10c2
+dist/2026-09-29/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=e9cbc14a8c2a85229bd523a46982aaf50e242a810708f3ebb3eff2b89c8d1ddd
+dist/2026-09-29/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=9bcbe9b3c071008b490ecfc47e0b6007ef0577a488b71ffe829cac10c3f7b467
+dist/2026-09-29/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=319876228cd9ba5319749c819fd127ff7fd9fb87e2886aa4eb97f14e13e95cf3
+dist/2026-09-29/rustfmt-nightly-x86_64-apple-darwin.tar.gz=a71ddea3e092dcd35a2b18c2538a7fc7df24b7fbde464e5b2a8014f86b24b843
+dist/2026-09-29/rustfmt-nightly-x86_64-apple-darwin.tar.xz=5b0ccd75907f3dc4a603cd60bbe87a11c3d75dc793adbdeb453fd385ef91df1f
+dist/2026-09-29/rustfmt-nightly-x86_64-pc-solaris.tar.gz=26149456d7e5823901a3df9e5b4e49a93a04e02a536b324bfe2aa16dc5a5f4b6
+dist/2026-09-29/rustfmt-nightly-x86_64-pc-solaris.tar.xz=874f59be83371e0371bd30ccd4abcfe038377c2544ee2c3c577b8a8882a28ee5
+dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=bc002bd19c2d5c13692d8571c6a82cca5213dd5454e8f1d17215452683b612c3
+dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=09c04f5a4a7bf944b58b1b3a0a3142ac8450d7db5277028b881d7ab96242a0b9
+dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=4af726ea96c30759085ad6886d3d0b0c429abb6ca68990c382f2490ec44cb022
+dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=77e0d096d1d241c238dd84266a0d32500f3dc0acf142a644012a99eb50fb00f7
+dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=294cf327a6af4a8a88ddd6c3bd74a9877afe0940b6a451675f67b10c20588c1d
+dist/2026-09-29/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=8d2be13b650f7ce0eea90ad26f7b8f5b02771d140ef4b13d3b50ca0a7fe53e21
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=bb8a080ab727bf0503740763ce1eaadcedfd5f592b5462140d1038d397a973b7
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=35dc1d5b43934cb35f390491d62c5ebb570005f64edc0baab6456bf2421a71d2
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=7af5c6a369e6bee9a0239a5c2ebb901dbec8a5b4ed7dbefcd54b84d72cdcf2e1
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=633ea7cccf1ff5d0999efcb16a35da4e47911ec276b03bf62db5e87b38e82e88
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=cb4dc1c222f7cc67bb2a97418347fce26bdcec945567afc4867549901c9248ad
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=243f7fd02c5e75bdbd2e35b0ff0ad916de1fe812bf05ae92e51e73f085ebf3bf
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=864f2b4694d45c087f28a54096c5419970a8b7f21e8d60bcd34eef10c6505ab3
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=a461bbc1b5162ae9c7f0c6d96025b6eecf35f4f0bd472715a52937934049bd52
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=11653a0860011db783741465f11dd6833325d1396a82518acb4024d9f65cc545
+dist/2026-09-29/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=ba8ac6446ce72fc0bad895759fe9fa281acabbf06ed676908b07a303849f1139
+dist/2026-09-29/rustc-nightly-aarch64-apple-darwin.tar.gz=f8bd07a928a00f5a58ecb90eaa3f5383deeca284ecd269c259dce96229c8dd9f
+dist/2026-09-29/rustc-nightly-aarch64-apple-darwin.tar.xz=e76cb7ea5f41feb883ee7ed89bd71f48ec029eca9605d3aa757d952bd6a153be
+dist/2026-09-29/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=0c6136923cf94fa3910caa5440e2e68a4c517366154a57824a1e96f30da4fc81
+dist/2026-09-29/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=bc94e0fe4523abe8ae134c068651b571e24ddb44a2ed7bbf40feff344d1668f0
+dist/2026-09-29/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=1d0196716ec66f3a08092736407bcff0b5eeeb0ed9e700467f16959ca8167594
+dist/2026-09-29/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=c08b4c0f3f5df85fb2a39a9e7748be6ce73bb4c17aa00549d3098a4e30738336
+dist/2026-09-29/rustc-nightly-aarch64-unknown-freebsd.tar.gz=3a513dd49f1fd8c80c8a9b51d68bf40a01a4fe6cf0c98a12420dc130e28c3a0d
+dist/2026-09-29/rustc-nightly-aarch64-unknown-freebsd.tar.xz=3553abe463701c7b10bc853849e4273eb1f3a0d1d3c6e3d5dda106a41729e2ad
+dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=23732a3568613f3a0b2b06ab28e1732282297399ddfa07baccaa67c12f50ebdf
+dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=651734f660be3f83022f4a627c920753e19e79a7e6c0ee1e6c41f4f78c59767d
+dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=fa01fe14d03160af899bf60866613826f83a180a6b9eafacb0cf97380059ebf8
+dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=3a67ebd7e6083ba65598070c2097e322eab032d4a5084bb6a829a51d4923e6b8
+dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-ohos.tar.gz=444251d96d77b80d3b8252ab13108ef053c9482340fbed582b1bef245c258b32
+dist/2026-09-29/rustc-nightly-aarch64-unknown-linux-ohos.tar.xz=1df09853d89ca89950dcf058933dd4d760d1aad172a67b9f60c5b25522f0fe40
+dist/2026-09-29/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=61f9a4ade7f6daf6b5dfab631321b99625533bab506020594fbc9b6b7c1065c5
+dist/2026-09-29/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=21ccf42a6618c0b7c1db874566d1e1abe48556c6d8b45139f7c858583debdafa
+dist/2026-09-29/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=296d9251257c6b8a1225cc6cf5c422a790df5b9ccd2fb84d269bff701ee71928
+dist/2026-09-29/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=d732c98eeefb447784ef6cb61c59fc919c3e48d4c291efff524cd9492a44e8ae
+dist/2026-09-29/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=5f50621c4463f2cd439922c2bb3b9d2e6af145bfe63aae0a2edec7073af7c758
+dist/2026-09-29/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=52af25e8af238a3fe660f984c1c1cd28f90355cb78d5ba6a967bba94377572ef
+dist/2026-09-29/rustc-nightly-i686-unknown-linux-gnu.tar.gz=55f65a08943922d590639588d8c29a6fba4049b33f20332195d72a71a7af7d2e
+dist/2026-09-29/rustc-nightly-i686-unknown-linux-gnu.tar.xz=e234eb2638f14654677955ecdf87fe369d439da77cd466e0154f673898bee09b
+dist/2026-09-29/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=70772d9f7de70d4f0ac082e266bfe582a9c20969be33482f3f3244aeca11ee57
+dist/2026-09-29/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=4f021e104f149d5c128b646bfd7a889c3bef37322ace9a5759075b42cde2c193
+dist/2026-09-29/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=b771b86f7af7055f876cd842f70288d26f34c9fb594b7930a43d94d22e07e6f5
+dist/2026-09-29/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=bfa7b382ac38053d6cd2a5fbda87494168ce54bfad95b161c0bc3790e94d99bf
+dist/2026-09-29/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=576a6faa602ebc4eec32cc06209fe958f98ae584db2c8ba52c7d55bca258c16a
+dist/2026-09-29/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=7a9563061646816f62ed10d8470ddc931d1df850342bca8a5e109dca445a487e
+dist/2026-09-29/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=d94deb2c8476421c2a223af821d7bda039ab853954e6e7eec3dc4235a4bd1de2
+dist/2026-09-29/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=9d21d197013585e2cba456b76885c41e3b43a30c4004845fdc313eb33a38afcd
+dist/2026-09-29/rustc-nightly-powerpc64-unknown-linux-musl.tar.gz=bab32e4293dd8052aa081aaa6643303d7b0aa4fbe3acbfd91c717a0bea776a5f
+dist/2026-09-29/rustc-nightly-powerpc64-unknown-linux-musl.tar.xz=445b9ff411c8dc74cbc337b1b353c72dc75bc431eb997a36436e6b80987059ec
+dist/2026-09-29/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=c8ef38bc477c70fa0e7131c4971b52ae728524e80e29a2570dd5354d5dbe48f2
+dist/2026-09-29/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=afb3c35107b8e4cb6edb48cfa71113084d6fa5360b28127a0e8e1948fa2abc7e
+dist/2026-09-29/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=9ce50d28b324c020b5fdb37db1a5522ed5a59815a14cfc117177a6c0d98a0d73
+dist/2026-09-29/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=9bed9c6990d3ae6b33e60ffa7b60d0e9f6020b24c2c8b5cf7fff61474c87c987
+dist/2026-09-29/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=5ae5f61985ed5dae8cd9f6d7638afe4957ef1d860a8e819249fdac1d58750e93
+dist/2026-09-29/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=445bef041d5e64fdbd50ad4e883c6b831c4df8bc170f04f779fdccd5db553f02
+dist/2026-09-29/rustc-nightly-riscv64gc-unknown-linux-musl.tar.gz=57f862b615abeef4aa0988e9b023468230757454c30ff8af847a87f884e43f41
+dist/2026-09-29/rustc-nightly-riscv64gc-unknown-linux-musl.tar.xz=eaa6fd5bbb2a8e256e8f0a335f9b7ef33c60a40f0d4bae7a72ad1341809dc8aa
+dist/2026-09-29/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=1d2eb7ede0ef321f5a5eed1f19ff30c645048cad2dce1ee32a01fd473d07d529
+dist/2026-09-29/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=892a029d3c60c9b037c073a02cad2c22247bfdf6c21ef94891eb5709ac85b3aa
+dist/2026-09-29/rustc-nightly-sparcv9-sun-solaris.tar.gz=75ebd4fd6a89b3fa3529fecc6ab418a88aaea6f2085d2041bf7aa65cab57d1e7
+dist/2026-09-29/rustc-nightly-sparcv9-sun-solaris.tar.xz=56b8da62b8a49658c8a9a575bee49c28eaf955d21442e77c1740935f94d4b0bc
+dist/2026-09-29/rustc-nightly-x86_64-apple-darwin.tar.gz=a1063ef2cf262f973c63358955bb1381fb37e73f154b44828b77091d3156a450
+dist/2026-09-29/rustc-nightly-x86_64-apple-darwin.tar.xz=99773bfc304755bc642fbc3617989bc62ee79f2265008c64d6ac15c514673f10
+dist/2026-09-29/rustc-nightly-x86_64-pc-solaris.tar.gz=b9c97ef49440e32d0f62012b1614b8e5cb9773efafeeec5517f82f6ef4f21623
+dist/2026-09-29/rustc-nightly-x86_64-pc-solaris.tar.xz=a286922465f006f15c802a8c1dce3c12ea73846a89006a917c86ebe20e605d7b
+dist/2026-09-29/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=ad9a406b01931b98be6021e991899cc1fb028a121b35ffd0a30d8b9359e3b940
+dist/2026-09-29/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=8de44d3694475f3d7579f24d9d8c0dc66f927cd816db4cb572f81eb1e3eb5656
+dist/2026-09-29/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=404c667f59d56ac591e9d043ec0427ac2a676fd2a1825442efc3465fe48719f6
+dist/2026-09-29/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=f581783eb350436723bb5b4f12257dec703651b055998e3490f7af616e987479
+dist/2026-09-29/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=530917988010ccbe9a6449f5136ba01958d5f94e282a41834b10e7017da11b20
+dist/2026-09-29/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=8ad2b5afbc056d7515626ac2aef4b81d992469f70ebf41701222cca1bc2bcd3b
+dist/2026-09-29/rustc-nightly-x86_64-unknown-freebsd.tar.gz=b693055d8cd4da607549da8ed0a186876a3db81f3a27deba1872439d68748014
+dist/2026-09-29/rustc-nightly-x86_64-unknown-freebsd.tar.xz=b55c0de331ce5601970e8227a34ada46ec394a18a86b89700b50d369b6dd59d7
+dist/2026-09-29/rustc-nightly-x86_64-unknown-illumos.tar.gz=54a37b89c59f32e12225f183cb4b0cf2c79721fe5dc15f5801c9527d426b2df7
+dist/2026-09-29/rustc-nightly-x86_64-unknown-illumos.tar.xz=0cff97495e37bdb45230d2ce7d57ccf06b767f6fbbb7cf69df57ae1595b8511e
+dist/2026-09-29/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=ee5cf66faf459f360fb13c9898c2f588f5e04525ce29539c81147b3d0daaa3e8
+dist/2026-09-29/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=dba6569dd43bf3566bea07621fd270baac5ee75ca70a729c45bcef46f2725b9f
+dist/2026-09-29/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=ce2f90940e5911e475f10dc25f7f49a32a971b375bc5d990de4c729f3efde5e0
+dist/2026-09-29/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=7a3b06231fb1604c465c241951cb6c2286d841bb175da13d933c24bc5822a2f5
+dist/2026-09-29/rustc-nightly-x86_64-unknown-netbsd.tar.gz=ce146f46f22b2cb210fbd5a2ce33511b309101f2e1e290db4319e8ed14894bf9
+dist/2026-09-29/rustc-nightly-x86_64-unknown-netbsd.tar.xz=9c787a33d96d02b05e1ad8eb0ce6da8de1f531a05e05199ac4ed8dff051314cb
+dist/2026-09-29/rust-nightly-aarch64-pc-windows-gnullvm.msi=a4c6d25c32b5a0a751b53568185e1bb29b6701e9c78a3c964c99de435d5df5d2
+dist/2026-09-29/rust-nightly-aarch64-pc-windows-msvc.msi=1bcc25f2c3c3d154578d314d51488de9a5db11759a38703a6ecf8bb5a5d6d6a3
+dist/2026-09-29/rust-nightly-x86_64-pc-windows-gnu.msi=3f8abd777867a484177ebce45009325559fd89f56065c257cc12e05b679b1658
+dist/2026-09-29/rust-nightly-x86_64-pc-windows-gnullvm.msi=be77343c9728e594b2f355f0d1c03a42ecde8757b2ff4ce4cd6da95a4dbd3e34
+dist/2026-09-29/rust-nightly-x86_64-pc-windows-msvc.msi=a080cc47533ac72c19cbd2b309fab14f33ae11f7aca18feb7a1c955883df37e6
+dist/2026-09-29/rust-nightly-aarch64-apple-darwin.pkg=1485843b8c0f53e3b50dd277aef08d2669a01ce6485bacf202c8f24fbebaf623
+dist/2026-09-29/rust-nightly-x86_64-apple-darwin.pkg=62ef2681dc83414c208c981949efbfc007b9b9ac8ab1bee776b3ed42130f2fe5
+dist/2026-09-29/rustc-nightly-src.tar.gz=54f78062b491bb27ba1eeedcf59fe8f0ce7c4e30189613af34b711feb4839ff8
+dist/2026-09-29/rustc-nightly-src.tar.xz=5d38310ee84c42e638094781bf1ec5456977fdc64021a83c8e0779d04371159a
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
index 87bb44875aee9..0544f1bcac20f 100644
--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -7,7 +7,6 @@
 #![feature(iter_partition_in_place)]
 #![feature(macro_metavar_expr)]
 #![feature(macro_metavar_expr_concat)]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![cfg_attr(bootstrap, feature(unwrap_infallible))]
 #![feature(rustc_private)]
 #![feature(stmt_expr_attributes)]
diff --git a/src/tools/clippy/clippy_test_deps/Cargo.toml b/src/tools/clippy/clippy_test_deps/Cargo.toml
index 880df6599c1e4..c3d236a17e1bb 100644
--- a/src/tools/clippy/clippy_test_deps/Cargo.toml
+++ b/src/tools/clippy/clippy_test_deps/Cargo.toml
@@ -18,3 +18,7 @@ itertools = "0.15"
 
 # Make sure we are not part of the rustc workspace.
 [workspace]
+
+[lints.cargo]
+# Not all tests use all of the above dependencies
+unused_dependencies = "allow"
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index d1b3e1a1cf1f6..14684a5dcef84 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -14,7 +14,6 @@
 #![feature(float_gamma)]
 #![feature(float_erf)]
 #![feature(map_try_insert)]
-#![cfg_attr(bootstrap, feature(never_type))]
 #![feature(try_blocks)]
 #![feature(io_error_more)]
 #![feature(io_error_inprogress)]
diff --git a/src/tools/miri/tests/deps/Cargo.toml b/src/tools/miri/tests/deps/Cargo.toml
index a377141f98aaf..6b6d4a9e2f443 100644
--- a/src/tools/miri/tests/deps/Cargo.toml
+++ b/src/tools/miri/tests/deps/Cargo.toml
@@ -37,3 +37,7 @@ windows-sys = { version = "0.61", features = [
 # Make sure we are not part of the rustc workspace.
 [workspace]
 members = ["cross-crate-items"]
+
+[lints.cargo]
+# Not all tests use all of the above dependencies
+unused_dependencies = "allow"
diff --git a/src/tools/miri/tests/deps/cross-crate-items/Cargo.toml b/src/tools/miri/tests/deps/cross-crate-items/Cargo.toml
index 1f9fc93cd5237..ca6818dc0fe25 100644
--- a/src/tools/miri/tests/deps/cross-crate-items/Cargo.toml
+++ b/src/tools/miri/tests/deps/cross-crate-items/Cargo.toml
@@ -5,3 +5,7 @@ edition = "2021"
 
 [dependencies]
 futures = { version = "0.3.0", default-features = false, features = ["alloc", "async-await"] }
+
+[lints.cargo]
+# panic_abort is not directly used but must be linked in
+unused_dependencies = "allow"
diff --git a/src/tools/rust-analyzer/Cargo.toml b/src/tools/rust-analyzer/Cargo.toml
index d77e89df45e44..54e82148665b6 100644
--- a/src/tools/rust-analyzer/Cargo.toml
+++ b/src/tools/rust-analyzer/Cargo.toml
@@ -68,10 +68,8 @@ parser = { path = "./crates/parser", version = "0.0.0" }
 paths = { path = "./crates/paths", version = "0.0.0" }
 proc-macro-api = { path = "./crates/proc-macro-api", version = "0.0.0" }
 proc-macro-srv = { path = "./crates/proc-macro-srv", version = "0.0.0" }
-proc-macro-srv-cli = { path = "./crates/proc-macro-srv-cli", version = "0.0.0" }
 profile = { path = "./crates/profile", version = "0.0.0" }
 project-model = { path = "./crates/project-model", version = "0.0.0" }
-query-group = { package = "query-group-macro", path = "./crates/query-group-macro", version = "0.0.0" }
 span = { path = "./crates/span", version = "0.0.0" }
 stdx = { path = "./crates/stdx", version = "0.0.0" }
 syntax = { path = "./crates/syntax", version = "0.0.0" }
@@ -167,6 +165,9 @@ hashbrown = { version = "0.17.0", features = [
 # We need to freeze the version of the crate, as the raw-api feature is considered unstable
 dashmap = { version = "=6.2.1", features = ["raw-api", "inline"] }
 
+[workspace.lints.cargo]
+unused_dependencies = "allow"
+
 [workspace.lints.rust]
 # remember to update RUSTFLAGS in ci.yml if you add something here
 
diff --git a/src/tools/rust-analyzer/crates/macros/Cargo.toml b/src/tools/rust-analyzer/crates/macros/Cargo.toml
index 8184cc6d1c03d..b0d0000268588 100644
--- a/src/tools/rust-analyzer/crates/macros/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/macros/Cargo.toml
@@ -17,3 +17,6 @@ proc-macro2 = "1"
 quote = "1"
 syn = "2.0.9"
 synstructure = "0.13.0"
+
+[lints]
+workspace = true
diff --git a/src/tools/rust-analyzer/crates/proc-macro-srv/proc-macro-test/Cargo.toml b/src/tools/rust-analyzer/crates/proc-macro-srv/proc-macro-test/Cargo.toml
index 78630ddb4d7d8..668188340e5c8 100644
--- a/src/tools/rust-analyzer/crates/proc-macro-srv/proc-macro-test/Cargo.toml
+++ b/src/tools/rust-analyzer/crates/proc-macro-srv/proc-macro-test/Cargo.toml
@@ -11,3 +11,6 @@ doctest = false
 
 [build-dependencies]
 cargo_metadata = "0.23.0"
+
+[lints]
+workspace = true
diff --git a/src/tools/rust-analyzer/lib/ungrammar/ungrammar2json/Cargo.toml b/src/tools/rust-analyzer/lib/ungrammar/ungrammar2json/Cargo.toml
index 0fa08bbbd0485..f17587e3f556c 100644
--- a/src/tools/rust-analyzer/lib/ungrammar/ungrammar2json/Cargo.toml
+++ b/src/tools/rust-analyzer/lib/ungrammar/ungrammar2json/Cargo.toml
@@ -10,3 +10,6 @@ edition = "2024"
 [dependencies]
 write-json = "0.1.1"
 ungrammar = { path = "../", version = "1.1.0" }
+
+[lints]
+workspace = true
diff --git a/tests/codegen-llvm/direct-access-external-data.rs b/tests/codegen-llvm/direct-access-external-data.rs
index a151bb6012e1e..43ee290d3a058 100644
--- a/tests/codegen-llvm/direct-access-external-data.rs
+++ b/tests/codegen-llvm/direct-access-external-data.rs
@@ -22,15 +22,6 @@ unsafe extern "C" {
 
     // When "linkage" is used, we generate an indirection global.
     // Check dso_local is still applied to the actual global.
-    // CHECK: @EXTERNAL = external
-    // DEFAULT-SAME: dso_local
-    // PIE-NOT: dso_local
-    // DIRECT-SAME: dso_local
-    // INDIRECT-NOT: dso_local
-    // CHECK-SAME: global i8
-    #[linkage = "external"]
-    safe static EXTERNAL: *const u32;
-
     // CHECK: @WEAK = extern_weak
     // DEFAULT-SAME: dso_local
     // PIE-NOT: dso_local
@@ -44,6 +35,5 @@ unsafe extern "C" {
 #[no_mangle]
 pub fn refer() {
     core::hint::black_box(VAR);
-    core::hint::black_box(EXTERNAL);
     core::hint::black_box(WEAK);
 }
diff --git a/tests/codegen-llvm/loongarch/direct-access-external-data.rs b/tests/codegen-llvm/loongarch/direct-access-external-data.rs
index de495d7fe9a72..e5b7124a722e2 100644
--- a/tests/codegen-llvm/loongarch/direct-access-external-data.rs
+++ b/tests/codegen-llvm/loongarch/direct-access-external-data.rs
@@ -20,15 +20,6 @@ unsafe extern "C" {
 
     // When "linkage" is used, we generate an indirection global.
     // Check dso_local is still applied to the actual global.
-    // CHECK: @EXTERNAL = external
-    // DEFAULT-NOT: dso_local
-    // PIE-NOT: dso_local
-    // DIRECT-SAME: dso_local
-    // INDIRECT-NOT: dso_local
-    // CHECK-SAME: global i8
-    #[linkage = "external"]
-    safe static EXTERNAL: *const u32;
-
     // CHECK: @WEAK = extern_weak
     // DEFAULT-NOT: dso_local
     // PIE-NOT: dso_local
@@ -42,6 +33,5 @@ unsafe extern "C" {
 #[no_mangle]
 pub fn refer() {
     core::hint::black_box(VAR);
-    core::hint::black_box(EXTERNAL);
     core::hint::black_box(WEAK);
 }
diff --git a/tests/run-make/linkage-attr-on-static/bar.rs b/tests/run-make/linkage-attr-on-static/bar.rs
index 68607cbb65721..cbab76ba6f403 100644
--- a/tests/run-make/linkage-attr-on-static/bar.rs
+++ b/tests/run-make/linkage-attr-on-static/bar.rs
@@ -1,7 +1,7 @@
 #![feature(linkage)]
 
 #[no_mangle]
-#[linkage = "external"]
+#[linkage = "weak"]
 static BAZ: i32 = 21;
 
 #[link(name = "foo", kind = "static")]
diff --git a/tests/run-make/linkage-attr-on-static/rmake.rs b/tests/run-make/linkage-attr-on-static/rmake.rs
index cd85542e9587d..f1cf80a2b0c5a 100644
--- a/tests/run-make/linkage-attr-on-static/rmake.rs
+++ b/tests/run-make/linkage-attr-on-static/rmake.rs
@@ -5,6 +5,8 @@
 
 //@ ignore-cross-compile
 // Reason: the compiled binary is executed
+//@ ignore-i686-pc-windows-gnu weak symbols broken with MinGW linker
+//@ ignore-x86_64-pc-windows-gnu weak symbols broken with MinGW linker
 
 use run_make_support::{build_native_static_lib, run, rustc};
 
diff --git a/tests/run-make/naked-symbol-visibility/a_rust_dylib.rs b/tests/run-make/naked-symbol-visibility/a_rust_dylib.rs
index ce787f83ade6d..8d699a665ae24 100644
--- a/tests/run-make/naked-symbol-visibility/a_rust_dylib.rs
+++ b/tests/run-make/naked-symbol-visibility/a_rust_dylib.rs
@@ -51,17 +51,6 @@ pub extern "C" fn public_naked_generic<T: TraitWithConst>() -> u32 {
     naked_asm!("mov rax, {}", "ret", const T::COUNT)
 }
 
-#[linkage = "external"]
-extern "C" fn vanilla_external_linkage() -> u32 {
-    42
-}
-
-#[unsafe(naked)]
-#[linkage = "external"]
-extern "C" fn naked_external_linkage() -> u32 {
-    naked_asm!("mov rax, 42", "ret")
-}
-
 #[cfg(not(windows))]
 #[linkage = "weak"]
 extern "C" fn vanilla_weak_linkage() -> u32 {
diff --git a/tests/run-make/naked-symbol-visibility/rmake.rs b/tests/run-make/naked-symbol-visibility/rmake.rs
index 69317c872f895..1acbe11dc4ae4 100644
--- a/tests/run-make/naked-symbol-visibility/rmake.rs
+++ b/tests/run-make/naked-symbol-visibility/rmake.rs
@@ -29,9 +29,6 @@ fn main() {
     // -Zshare-generics.
     global_function(&rdylib, "public_naked_generic");
 
-    global_function(&rdylib, "vanilla_external_linkage");
-    global_function(&rdylib, "naked_external_linkage");
-
     // FIXME: make this work on windows (gnu and msvc). See the PR
     // https://github.com/rust-lang/rust/pull/128362 for some approaches
     // that don't work
diff --git a/tests/rustdoc-json/impls/blanket-ambig-on-nonrigid-assoc-next-solver.rs b/tests/rustdoc-json/impls/blanket-ambig-on-nonrigid-assoc-next-solver.rs
new file mode 100644
index 0000000000000..8f3af90a2598e
--- /dev/null
+++ b/tests/rustdoc-json/impls/blanket-ambig-on-nonrigid-assoc-next-solver.rs
@@ -0,0 +1,23 @@
+//@ compile-flags: -Znext-solver
+
+// Regression test for <https://github.com/rust-lang/rust/issues/162557>
+
+pub trait Service<Request> {
+    type Future;
+}
+
+pub trait ZebraService<Request>: Service<Request> {}
+
+impl<MaybeVerify, Request> ZebraService<Request> for MaybeVerify where
+    MaybeVerify: Service<Request, Future: 'static>
+{
+}
+
+pub struct Verifier;
+
+impl Service<()> for Verifier {
+    type Future = &'static ();
+}
+
+//@ set blanket = "$.index[?(@.inner.impl.blanket_impl.generic=='MaybeVerify')].id"
+//@ has "$.index[?(@.name=='Verifier')].inner.struct.impls[*]" $blanket
diff --git a/tests/ui/array-slice-vec/vec-res-add.stderr b/tests/ui/array-slice-vec/vec-res-add.stderr
index 6d5ad1d3c9694..4e13dbd0366d0 100644
--- a/tests/ui/array-slice-vec/vec-res-add.stderr
+++ b/tests/ui/array-slice-vec/vec-res-add.stderr
@@ -8,7 +8,6 @@ LL |     let k = i + j;
    |
 note: `Vec<R>` does not implement `Add`
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-  ::: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
    = note: `Vec<R>` is defined in another crate
 
diff --git a/tests/ui/asm/naked-functions/naked-functions.rs b/tests/ui/asm/naked-functions/naked-functions.rs
index d994b1151514a..e7da65a169074 100644
--- a/tests/ui/asm/naked-functions/naked-functions.rs
+++ b/tests/ui/asm/naked-functions/naked-functions.rs
@@ -224,7 +224,7 @@ pub extern "C" fn compatible_doc_attributes() {
     naked_asm!("", options(raw));
 }
 
-#[linkage = "external"]
+#[linkage = "weak"]
 #[unsafe(naked)]
 pub extern "C" fn compatible_linkage() {
     naked_asm!("", options(raw));
diff --git a/tests/ui/attributes/codegen_attr_on_required_trait_method.rs b/tests/ui/attributes/codegen_attr_on_required_trait_method.rs
index 737ebf7f2b144..2ea4e0b5a395c 100644
--- a/tests/ui/attributes/codegen_attr_on_required_trait_method.rs
+++ b/tests/ui/attributes/codegen_attr_on_required_trait_method.rs
@@ -11,7 +11,7 @@ trait Test {
     //~^ ERROR cannot be used on required trait methods [unused_attributes]
     //~| WARN previously accepted
     fn method2(&self);
-    #[linkage = "common"]
+    #[linkage = "weak"]
     //~^ ERROR `linkage` attribute cannot be used on required trait methods
     fn method3(&self);
     #[track_caller]
diff --git a/tests/ui/attributes/codegen_attr_on_required_trait_method.stderr b/tests/ui/attributes/codegen_attr_on_required_trait_method.stderr
index b5452ba2882c0..729231956337d 100644
--- a/tests/ui/attributes/codegen_attr_on_required_trait_method.stderr
+++ b/tests/ui/attributes/codegen_attr_on_required_trait_method.stderr
@@ -1,7 +1,7 @@
 error: the `linkage` attribute cannot be used on required trait methods
   --> $DIR/codegen_attr_on_required_trait_method.rs:14:7
    |
-LL |     #[linkage = "common"]
+LL |     #[linkage = "weak"]
    |       ^^^^^^^
    |
    = help: the `linkage` attribute can be applied to foreign functions, foreign statics, functions with a body, and statics
diff --git a/tests/ui/attributes/macro_export_on_decl_macro.rs b/tests/ui/attributes/macro_export_on_decl_macro.rs
index e6fe66ac6c30e..413b844cc1b83 100644
--- a/tests/ui/attributes/macro_export_on_decl_macro.rs
+++ b/tests/ui/attributes/macro_export_on_decl_macro.rs
@@ -6,4 +6,10 @@
 #[macro_export] //~ ERROR `#[macro_export]` has no effect on declarative macro definitions
 pub macro foo() {}
 
+// `#[macro_export]` on `macro_rules!` is valid and should not emit unused_attributes
+#[macro_export]
+macro_rules! bar {
+    () => {};
+}
+
 fn main() {}
diff --git a/tests/ui/const-generics/renamed-feature-gates.stderr b/tests/ui/const-generics/renamed-feature-gates.stderr
index b5478b7412f0e..96e68daf5ac3a 100644
--- a/tests/ui/const-generics/renamed-feature-gates.stderr
+++ b/tests/ui/const-generics/renamed-feature-gates.stderr
@@ -4,7 +4,7 @@ error[E0557]: feature has been removed
 LL | #![feature(min_generic_const_args)]
    |            ^^^^^^^^^^^^^^^^^^^^^^ feature has been removed
    |
-   = note: removed in CURRENT_RUSTC_VERSION
+   = note: removed in 1.100.0
    = note: renamed to `gca_min_const_items`
 
 error[E0557]: feature has been removed
@@ -13,7 +13,7 @@ error[E0557]: feature has been removed
 LL | #![feature(generic_const_args)]
    |            ^^^^^^^^^^^^^^^^^^ feature has been removed
    |
-   = note: removed in CURRENT_RUSTC_VERSION
+   = note: removed in 1.100.0
    = note: renamed to `gca_const_items`
 
 error[E0557]: feature has been removed
@@ -22,7 +22,7 @@ error[E0557]: feature has been removed
 LL | #![feature(macroless_generic_const_args)]
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ feature has been removed
    |
-   = note: removed in CURRENT_RUSTC_VERSION
+   = note: removed in 1.100.0
    = note: renamed to `gca_macroless_args`
 
 error[E0557]: feature has been removed
@@ -31,7 +31,7 @@ error[E0557]: feature has been removed
 LL | #![feature(macroless_const_item_generic_const_args)]
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ feature has been removed
    |
-   = note: removed in CURRENT_RUSTC_VERSION
+   = note: removed in 1.100.0
    = note: renamed to `gca_macroless_items`
 
 error: aborting due to 4 previous errors
diff --git a/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr
index ab823c8fc73b9..38440af675feb 100644
--- a/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr
+++ b/tests/ui/consts/const_in_pattern/suggest_equality_comparison_instead_of_pattern_matching.stderr
@@ -123,7 +123,6 @@ LL |             V => {}
    |             ^ constant of non-structural type
    |
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-  ::: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
    = note: `Vec<()>` is not usable in patterns
    |
@@ -144,7 +143,6 @@ LL |         if let V = vec![] {}
    |                ^ constant of non-structural type
    |
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-  ::: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
    = note: `Vec<()>` is not usable in patterns
    |
@@ -160,7 +158,6 @@ LL |         let V = vec![] else { return; };
    |             ^ constant of non-structural type
    |
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-  ::: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
    = note: `Vec<()>` is not usable in patterns
    |
@@ -176,7 +173,6 @@ LL |         let V = Vec::new() else { return; };
    |             ^ constant of non-structural type
    |
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-  ::: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
    = note: `Vec<()>` is not usable in patterns
    |
diff --git a/tests/ui/impl-trait/precise-capturing/auxiliary/overcapture-attr-pm.rs b/tests/ui/impl-trait/precise-capturing/auxiliary/overcapture-attr-pm.rs
new file mode 100644
index 0000000000000..1c2e196ccc619
--- /dev/null
+++ b/tests/ui/impl-trait/precise-capturing/auxiliary/overcapture-attr-pm.rs
@@ -0,0 +1,7 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro_attribute]
+pub fn rpc(_attr: TokenStream, _item: TokenStream) -> TokenStream {
+    "pub fn generated(x: &u8) -> impl Sized { *x }".parse().unwrap()
+}
diff --git a/tests/ui/impl-trait/precise-capturing/overcapture-suggestion-in-macro-issue-139567.rs b/tests/ui/impl-trait/precise-capturing/overcapture-suggestion-in-macro-issue-139567.rs
new file mode 100644
index 0000000000000..761678281598a
--- /dev/null
+++ b/tests/ui/impl-trait/precise-capturing/overcapture-suggestion-in-macro-issue-139567.rs
@@ -0,0 +1,36 @@
+//@ edition: 2018
+//@ proc-macro: overcapture-attr-pm.rs
+
+#![allow(unused)]
+#![deny(impl_trait_overcaptures)]
+
+#[overcapture_attr_pm::rpc]
+pub fn from_attr_macro() {}
+//~^^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
+
+pub fn plain(x: &u8) -> impl Sized { *x }
+//~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
+
+macro_rules! mk {
+    ($ret:ty) => {
+        pub fn from_macro_rules(x: &u8) -> $ret { *x }
+    };
+}
+
+mk!(impl Sized);
+//~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+//~| WARN this changes meaning in Rust 2024
+
+macro_rules! mk_body {
+    () => {
+        pub fn from_macro_body(x: &u8) -> impl Sized { *x }
+        //~^ ERROR `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+        //~| WARN this changes meaning in Rust 2024
+    };
+}
+
+mk_body!();
+
+fn main() {}
diff --git a/tests/ui/impl-trait/precise-capturing/overcapture-suggestion-in-macro-issue-139567.stderr b/tests/ui/impl-trait/precise-capturing/overcapture-suggestion-in-macro-issue-139567.stderr
new file mode 100644
index 0000000000000..9f70c2f075942
--- /dev/null
+++ b/tests/ui/impl-trait/precise-capturing/overcapture-suggestion-in-macro-issue-139567.stderr
@@ -0,0 +1,89 @@
+error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:7:1
+   |
+LL | #[overcapture_attr_pm::rpc]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: specifically, this lifetime is in scope but not mentioned in the type's bounds
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:7:1
+   |
+LL | #[overcapture_attr_pm::rpc]
+   | ^
+   = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
+note: the lint level is defined here
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:5:9
+   |
+LL | #![deny(impl_trait_overcaptures)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^
+   = note: this error originates in the attribute macro `overcapture_attr_pm::rpc` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:12:25
+   |
+LL | pub fn plain(x: &u8) -> impl Sized { *x }
+   |                         ^^^^^^^^^^
+   |
+note: specifically, this lifetime is in scope but not mentioned in the type's bounds
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:12:17
+   |
+LL | pub fn plain(x: &u8) -> impl Sized { *x }
+   |                 ^
+   = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
+help: use the precise capturing `use<...>` syntax to make the captures explicit
+   |
+LL | pub fn plain(x: &u8) -> impl Sized + use<> { *x }
+   |                                    +++++++
+
+error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:22:5
+   |
+LL | macro_rules! mk {
+...
+LL | mk!(impl Sized);
+   |     ^^^^^^^^^^
+   |
+note: specifically, this lifetime is in scope but not mentioned in the type's bounds
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:18:36
+   |
+LL |         pub fn from_macro_rules(x: &u8) -> $ret { *x }
+   |                                    ^
+...
+LL | mk!(impl Sized);
+   | --------------- in this macro invocation
+   = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
+help: use the precise capturing `use<...>` syntax to make the captures explicit
+   |
+LL | mk!(impl Sized + use<>);
+   |                +++++++
+
+error: `impl Sized` will capture more lifetimes than possibly intended in edition 2024
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:28:43
+   |
+LL | macro_rules! mk_body {
+LL |     () => {
+LL |         pub fn from_macro_body(x: &u8) -> impl Sized { *x }
+   |                                           ^^^^^^^^^^
+...
+LL | mk_body!();
+   | ---------- in this macro invocation
+   |
+note: specifically, this lifetime is in scope but not mentioned in the type's bounds
+  --> $DIR/overcapture-suggestion-in-macro-issue-139567.rs:28:35
+   |
+LL |         pub fn from_macro_body(x: &u8) -> impl Sized { *x }
+   |                                   ^
+...
+LL | mk_body!();
+   | ---------- in this macro invocation
+   = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
+
+error: aborting due to 4 previous errors
+
diff --git a/tests/ui/linkage-attr/auxiliary/def_external.rs b/tests/ui/linkage-attr/auxiliary/def_external.rs
deleted file mode 100644
index 2300930e513af..0000000000000
--- a/tests/ui/linkage-attr/auxiliary/def_external.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#![feature(linkage)]
-#![crate_type = "lib"]
-
-#[linkage="external"]
-pub static EXTERN: u32 = 0;
diff --git a/tests/ui/linkage-attr/auxiliary/def_weak.rs b/tests/ui/linkage-attr/auxiliary/def_weak.rs
new file mode 100644
index 0000000000000..a8940f73c5536
--- /dev/null
+++ b/tests/ui/linkage-attr/auxiliary/def_weak.rs
@@ -0,0 +1,5 @@
+#![feature(linkage)]
+#![crate_type = "lib"]
+
+#[linkage = "weak"]
+pub static WEAK: u32 = 0;
diff --git a/tests/ui/linkage-attr/common-linkage-non-zero-init.rs b/tests/ui/linkage-attr/common-linkage-non-zero-init.rs
deleted file mode 100644
index 512616251c2f7..0000000000000
--- a/tests/ui/linkage-attr/common-linkage-non-zero-init.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ build-fail
-//@ failure-status: 101
-//@ known-bug: #109681
-//@ ignore-wasm32 this appears to SIGABRT on wasm, not fail cleanly
-//@ compile-flags: -Z verify-llvm-ir
-//@ ignore-backends: gcc
-
-// This test verifies that we continue to hit the LLVM error for common linkage with non-zero
-// initializers, since it generates invalid LLVM IR.
-// Linkages are internal features marked as perma-unstable, so we don't need to fix the issue
-// for now.
-#![crate_type="lib"]
-#![feature(linkage)]
-
-#[linkage = "common"]
-#[no_mangle]
-pub static TEST: bool = true;
diff --git a/tests/ui/linkage-attr/common-linkage-non-zero-init.stderr b/tests/ui/linkage-attr/common-linkage-non-zero-init.stderr
deleted file mode 100644
index 93015bb2bac12..0000000000000
--- a/tests/ui/linkage-attr/common-linkage-non-zero-init.stderr
+++ /dev/null
@@ -1,3 +0,0 @@
-'common' global must have a zero initializer!
-ptr @TEST
-rustc-LLVM ERROR: Broken module found, compilation aborted!
diff --git a/tests/ui/linkage-attr/linkage-attr-does-not-panic-llvm-issue-33992.rs b/tests/ui/linkage-attr/linkage-attr-does-not-panic-llvm-issue-33992.rs
index 0717a2d5a6c9e..e1ad2405b1df8 100644
--- a/tests/ui/linkage-attr/linkage-attr-does-not-panic-llvm-issue-33992.rs
+++ b/tests/ui/linkage-attr/linkage-attr-does-not-panic-llvm-issue-33992.rs
@@ -1,15 +1,9 @@
 //@ run-pass
 //@ ignore-apple
-//@ ignore-wasm32 common linkage not implemented right now
+//@ ignore-wasm32 linkonce linkage not working right now
 
 #![feature(linkage)]
 
-#[linkage = "external"]
-pub static TEST2: bool = true;
-
-#[linkage = "internal"]
-pub static TEST3: bool = true;
-
 #[cfg(not(target_env = "msvc"))]
 #[linkage = "linkonce"]
 pub static TEST4: bool = true;
diff --git a/tests/ui/linkage-attr/linkage-import.rs b/tests/ui/linkage-attr/linkage-import.rs
index 838d1fc29a238..427a487ef1905 100644
--- a/tests/ui/linkage-attr/linkage-import.rs
+++ b/tests/ui/linkage-attr/linkage-import.rs
@@ -1,8 +1,10 @@
 //@ build-pass
-//@ aux-build:def_external.rs
+//@ aux-build:def_weak.rs
+//@ ignore-i686-pc-windows-gnu weak symbols broken with MinGW linker
+//@ ignore-x86_64-pc-windows-gnu weak symbols broken with MinGW linker
 
-extern crate def_external as dep;
+extern crate def_weak as dep;
 
 fn main() {
-    println!("{:p}", &dep::EXTERN);
+    println!("{:p}", &dep::WEAK);
 }
diff --git a/tests/ui/linkage-attr/linkage3.stderr b/tests/ui/linkage-attr/linkage3.stderr
index aa25cd39ba291..616f80df09c8b 100644
--- a/tests/ui/linkage-attr/linkage3.stderr
+++ b/tests/ui/linkage-attr/linkage3.stderr
@@ -4,7 +4,7 @@ error[E0539]: malformed `linkage` attribute input
 LL |     #[linkage = "foo"]
    |       ^^^^^^^^^^-----
    |                 |
-   |                 valid arguments are `available_externally`, `common`, `extern_weak`, `external`, `internal`, `linkonce`, `linkonce_odr`, `weak` or `weak_odr`
+   |                 valid arguments are `available_externally`, `extern_weak`, `linkonce`, `linkonce_odr`, `weak` or `weak_odr`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/linkage-attr/linkage4.rs b/tests/ui/linkage-attr/linkage4.rs
index 3b935f9723dc1..25df81189d8f5 100644
--- a/tests/ui/linkage-attr/linkage4.rs
+++ b/tests/ui/linkage-attr/linkage4.rs
@@ -1,4 +1,4 @@
-#[linkage = "external"]
+#[linkage = "weak"]
 static foo: isize = 0;
 //~^^ ERROR: the `linkage` attribute is experimental and not portable
 
diff --git a/tests/ui/linkage-attr/linkage4.stderr b/tests/ui/linkage-attr/linkage4.stderr
index a5970d100581a..2f04ceee5199d 100644
--- a/tests/ui/linkage-attr/linkage4.stderr
+++ b/tests/ui/linkage-attr/linkage4.stderr
@@ -1,7 +1,7 @@
 error[E0658]: the `linkage` attribute is experimental and not portable across platforms
   --> $DIR/linkage4.rs:1:3
    |
-LL | #[linkage = "external"]
+LL | #[linkage = "weak"]
    |   ^^^^^^^
    |
    = note: see issue #29603 <https://github.com/rust-lang/rust/issues/29603> for more information
diff --git a/tests/ui/lint/inline-exported.rs b/tests/ui/lint/inline-exported.rs
index 6a23cd58236ff..25ca5f0633079 100644
--- a/tests/ui/lint/inline-exported.rs
+++ b/tests/ui/lint/inline-exported.rs
@@ -17,12 +17,8 @@ fn export_name() {}
 
 #[inline]
 //~^ ERROR: `#[inline]` is ignored on externally exported functions
-#[linkage = "external"]
-fn external_linkage() {}
+#[linkage = "weak"]
+fn weak_linkage() {}
 
 #[inline]
 fn normal() {}
-
-#[inline]
-#[linkage = "internal"] // not exported
-fn internal_linkage() {}
diff --git a/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr b/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
index c03137fcc4151..7c176162ad184 100644
--- a/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
+++ b/tests/ui/pattern/deref-patterns/implicit-const-deref.stderr
@@ -8,7 +8,6 @@ LL |         EMPTY => {}
    |         ^^^^^ constant of non-structural type
    |
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-  ::: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
    = note: `Vec<()>` is not usable in patterns
    |
diff --git a/tests/ui/pattern/issue-115599.stderr b/tests/ui/pattern/issue-115599.stderr
index 280516deba14b..f776623ff75b2 100644
--- a/tests/ui/pattern/issue-115599.stderr
+++ b/tests/ui/pattern/issue-115599.stderr
@@ -8,7 +8,6 @@ LL |     if let CONST_STRING = empty_str {}
    |            ^^^^^^^^^^^^ constant of non-structural type
    |
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-  ::: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
    = note: `Vec<u8>` is not usable in patterns
    |
diff --git a/tests/ui/pattern/pattern-tyvar-2.stderr b/tests/ui/pattern/pattern-tyvar-2.stderr
index 4761a4e829b85..6676d5129872b 100644
--- a/tests/ui/pattern/pattern-tyvar-2.stderr
+++ b/tests/ui/pattern/pattern-tyvar-2.stderr
@@ -8,7 +8,6 @@ LL | fn foo(t: Bar) -> isize { match t { Bar::T1(_, Some(x)) => { return x * 3;
    |
 note: `Vec<isize>` does not implement `Mul<{integer}>`
   --> $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
-  ::: $SRC_DIR/alloc/src/vec/mod.rs:LL:COL
    |
    = note: `Vec<isize>` is defined in another crate
 
diff --git a/tests/ui/traits/next-solver/successful-goal-during-ambiguity-reporting.rs b/tests/ui/traits/next-solver/successful-goal-during-ambiguity-reporting.rs
index 1032554301487..643170d9249c3 100644
--- a/tests/ui/traits/next-solver/successful-goal-during-ambiguity-reporting.rs
+++ b/tests/ui/traits/next-solver/successful-goal-during-ambiguity-reporting.rs
@@ -16,6 +16,7 @@ impl DeserTrait<'_> for &'static MyTrait {}
 //~^ ERROR expected a type, found a trait
 
 fn test() -> impl Send {
+    //~^ ERROR type annotations needed
     testfn(&DeserStruct)
 }
 
diff --git a/tests/ui/traits/next-solver/successful-goal-during-ambiguity-reporting.stderr b/tests/ui/traits/next-solver/successful-goal-during-ambiguity-reporting.stderr
index ca2a80c8d0a12..e0cd1954276dd 100644
--- a/tests/ui/traits/next-solver/successful-goal-during-ambiguity-reporting.stderr
+++ b/tests/ui/traits/next-solver/successful-goal-during-ambiguity-reporting.stderr
@@ -9,6 +9,13 @@ help: you can add the `dyn` keyword if you want a trait object
 LL | impl DeserTrait<'_> for &'static dyn MyTrait {}
    |                                  +++
 
-error: aborting due to 1 previous error
+error[E0284]: type annotations needed: cannot satisfy `test::{opaque#0} == impl MyTrait + 'static`
+  --> $DIR/successful-goal-during-ambiguity-reporting.rs:18:14
+   |
+LL | fn test() -> impl Send {
+   |              ^^^^^^^^^ cannot satisfy `test::{opaque#0} == impl MyTrait + 'static`
+
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0782`.
+Some errors have detailed explanations: E0284, E0782.
+For more information about an error, try `rustc --explain E0284`.
diff --git a/triagebot.toml b/triagebot.toml
index 77acf0edda0a6..d42afdda622fc 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -1564,6 +1564,21 @@ cc = ["@mejrs"]
 message = "Some changes occurred to diagnostic attributes."
 cc = ["@mejrs"]
 
+[mentions."compiler/rustc_codegen_llvm/src/debuginfo"]
+cc = ["@Walnut356"]
+[mentions."src/etc/debugger_tester"]
+cc = ["@Walnut356"]
+[mentions."src/etc/natvis"]
+cc = ["@Walnut356"]
+[mentions."src/etc/gdb_lookup.py"]
+cc = ["@Walnut356"]
+[mentions."src/etc/gdb_providers.py"]
+cc = ["@Walnut356"]
+[mentions."src/etc/lldb_lookup.py"]
+cc = ["@Walnut356"]
+[mentions."src/etc/lldb_providers.py"]
+cc = ["@Walnut356"]
+
 [mentions."RELEASES.md"]
 message = """
 `RELEASES.md` was changed. Upon merging, each section will be automatically synced with its \