Previously missed (1) — in code that hasn't changed since the last review.

src/libraries/System.Private.CoreLib/src/System/Numerics/BigIntegerCalculator.Shared.cs:787

• This structured-multiplication kernel is only referenced from System.Runtime.Numerics-specific files, but placing it in the shared source also emits it into System.Private.CoreLib. The same applies to the repeated-run helpers, scalar division machinery, and relocated RightShiftSelf; repository-wide caller searches find no CoreLib consumers for those methods. Please keep or conditionally compile the Numerics-only kernels outside SYSTEM_PRIVATE_CORELIB, otherwise this optimization adds hundreds of lines of unused IL to CoreLib without binary-size evidence.

        internal static void MultiplyNaiveSparse(ReadOnlySpan<nuint> left, ReadOnlySpan<nuint> right, Span<nuint> bits)

Previously missed (2) — in code that hasn't changed since the last review.

src/libraries/System.Private.CoreLib/src/System/Numerics/BigIntegerCalculator.Shared.cs:994

• The 32-bit implementation in this else branch is unreachable: the only production call sites in Square and Multiply both require nint.Size == 8 before invoking this helper. Either remove the 32-bit branch to avoid carrying dead arithmetic code, or remove those caller guards and add x86 coverage if the path is intended to run there.

            else
            {
                if (((ulong)(uint)repeatedLimb * convolutionLength) > uint.MaxValue)

src/libraries/System.Runtime.Numerics/src/System/Numerics/BigIntegerCalculator.PowTables.cs:78

• This explanation omits the adjacent base-7 constant and therefore does not describe how Log2OfSevenFractionalBits or log2OfSevenLower is derived. Include floor((log2(7) - 2) * 2^64) and state that prepending 2 reconstructs both the base-5 and base-7 values.

This issue also appears in the following locations of the same file:

• line 123
• line 402

            // Accordingly, these constants are:
            //   floor((log2(3) - 1) * 2^64)
            //   floor((log2(5) - 2) * 2^64)
            // Prepending 1 and 2 below reconstructs floor(log2(3) * 2^64) and
            // floor(log2(5) * 2^64), respectively.

src/libraries/System.Runtime.Numerics/src/System/Numerics/BigIntegerCalculator.PowTables.cs:125

• These hand-authored packed tables are executable arithmetic data, but the added tests do not validate every cached entry against an independent calculation (for example, several intermediate powers are never selected by the deterministic cases). A single bad limb would silently return an incorrect BigInteger.Pow result. Add a test that enumerates every 3/5/7 entry for the native layout and compares it with repeated multiplication; the existing x86/x64 test runs will then validate both layouts.

        private static ReadOnlySpan<ulong> Pow3TableStorage64 =>
        [
            1, 0x0006954FE21E3E81, // 3^32

src/libraries/System.Runtime.Numerics/src/System/Numerics/BigIntegerCalculator.PowTables.cs:408

• Both the 32-bit and 64-bit packed power tables are embedded in every architecture-neutral build, so this optimization adds a substantial amount of permanent assembly data even though only one layout is used per process. Please report the resulting System.Runtime.Numerics binary-size delta and weigh it against the end-to-end gains; if the cost is material, consider a representation that avoids duplicating every limb while preserving startup performance.

        private static ReadOnlySpan<int> Pow3TableIndices32 =>
        [
            0, 2, 5, 10, 18, 32, 59,
        ];

        private static ReadOnlySpan<uint> Pow3TableStorage32 =>
        [