Additional changes

jfd16 · jfd16 · commit 7b5eb623761c · 2021-02-08T17:44:39.000-08:00
diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigInteger.cs
@@ -464,7 +464,7 @@ public BigInteger(ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigE
             AssertValid();
         }
 
-        private BigInteger(int n, uint[]? rgu)
+        internal BigInteger(int n, uint[]? rgu)
         {
             _sign = n;
             _bits = rgu;
@@ -683,8 +683,7 @@ public static BigInteger Parse(string value, IFormatProvider? provider)
 
         public static BigInteger Parse(string value, NumberStyles style, IFormatProvider? provider)
         {
-            (int sign, uint[]? bits) = BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));
-            return new BigInteger(sign, bits);
+            return BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));
         }
 
         public static bool TryParse([NotNullWhen(true)] string? value, out BigInteger result)
@@ -694,17 +693,12 @@ public static bool TryParse([NotNullWhen(true)] string? value, out BigInteger re
 
         public static bool TryParse([NotNullWhen(true)] string? value, NumberStyles style, IFormatProvider? provider, out BigInteger result)
         {
-            bool success = BigNumber.TryParseBigInteger(
-                value, style, NumberFormatInfo.GetInstance(provider), out int sign, out uint[]? bits);
-
-            result = new BigInteger(sign, bits);
-            return success;
+            return BigNumber.TryParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider), out result);
         }
 
         public static BigInteger Parse(ReadOnlySpan<char> value, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)
         {
-            (int sign, uint[]? bits) = BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));
-            return new BigInteger(sign, bits);
+            return BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));
         }
 
         public static bool TryParse(ReadOnlySpan<char> value, out BigInteger result)
@@ -714,11 +708,7 @@ public static bool TryParse(ReadOnlySpan<char> value, out BigInteger result)
 
         public static bool TryParse(ReadOnlySpan<char> value, NumberStyles style, IFormatProvider? provider, out BigInteger result)
         {
-            bool success = BigNumber.TryParseBigInteger(
-                value, style, NumberFormatInfo.GetInstance(provider), out int sign, out uint[]? bits);
-
-            result = new BigInteger(sign, bits);
-            return success;
+            return BigNumber.TryParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider), out result);
         }
 
         public static int Compare(BigInteger left, BigInteger right)
diff --git a/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs b/src/libraries/System.Runtime.Numerics/src/System/Numerics/BigNumber.cs
@@ -325,49 +325,48 @@ internal static bool TryValidateParseStyleInteger(NumberStyles style, [NotNullWh
             return true;
         }
 
-        internal static bool TryParseBigInteger(string? value, NumberStyles style, NumberFormatInfo info, out int sign, out uint[]? bits)
+        internal static bool TryParseBigInteger(string? value, NumberStyles style, NumberFormatInfo info, out BigInteger result)
         {
             if (value == null)
             {
-                sign = 0;
-                bits = null;
+                result = default;
                 return false;
             }
 
-            return TryParseBigInteger(value.AsSpan(), style, info, out sign, out bits);
+            return TryParseBigInteger(value.AsSpan(), style, info, out result);
         }
 
-        internal static bool TryParseBigInteger(ReadOnlySpan<char> value, NumberStyles style, NumberFormatInfo info, out int sign, out uint[]? bits)
+        internal static bool TryParseBigInteger(ReadOnlySpan<char> value, NumberStyles style, NumberFormatInfo info, out BigInteger result)
         {
-            sign = 0;
-            bits = null;
-
             ArgumentException? e;
             if (!TryValidateParseStyleInteger(style, out e))
                 throw e; // TryParse still throws ArgumentException on invalid NumberStyles
 
             BigNumberBuffer bignumber = BigNumberBuffer.Create();
             if (!FormatProvider.TryStringToBigInteger(value, style, info, bignumber.digits, out bignumber.precision, out bignumber.scale, out bignumber.sign))
+            {
+                result = default;
                 return false;
+            }
 
             if ((style & NumberStyles.AllowHexSpecifier) != 0)
             {
-                if (!HexNumberToBigInteger(ref bignumber, out sign, out bits))
+                if (!HexNumberToBigInteger(ref bignumber, out result))
                 {
                     return false;
                 }
             }
             else
             {
-                if (!NumberToBigInteger(ref bignumber, out sign, out bits))
+                if (!NumberToBigInteger(ref bignumber, out result))
                 {
                     return false;
                 }
             }
             return true;
         }
 
-        internal static (int sign, uint[]? bits) ParseBigInteger(string value, NumberStyles style, NumberFormatInfo info)
+        internal static BigInteger ParseBigInteger(string value, NumberStyles style, NumberFormatInfo info)
         {
             if (value == null)
             {
@@ -377,41 +376,41 @@ internal static (int sign, uint[]? bits) ParseBigInteger(string value, NumberSty
             return ParseBigInteger(value.AsSpan(), style, info);
         }
 
-        internal static (int sign, uint[]? bits) ParseBigInteger(ReadOnlySpan<char> value, NumberStyles style, NumberFormatInfo info)
+        internal static BigInteger ParseBigInteger(ReadOnlySpan<char> value, NumberStyles style, NumberFormatInfo info)
         {
             ArgumentException? e;
             if (!TryValidateParseStyleInteger(style, out e))
                 throw e;
 
-            if (!TryParseBigInteger(value, style, info, out int sign, out uint[]? bits))
+            if (!TryParseBigInteger(value, style, info, out BigInteger result))
             {
                 throw new FormatException(SR.Overflow_ParseBigInteger);
             }
-            return (sign, bits);
+            return result;
         }
 
-        private static bool HexNumberToBigInteger(ref BigNumberBuffer number, out int sign, out uint[]? bits)
+        private static bool HexNumberToBigInteger(ref BigNumberBuffer number, out BigInteger result)
         {
-            sign = 0;
-            bits = null;
-
             if (number.digits == null || number.digits.Length == 0)
+            {
+                result = default;
                 return false;
+            }
 
             const int DigitsPerBlock = 8;
 
             int totalDigitCount = number.digits.Length - 1;   // Ignore trailing '\0'
             int blockCount, partialDigitCount;
 
-            if (totalDigitCount % DigitsPerBlock == 0)
+            if ((uint)totalDigitCount % DigitsPerBlock == 0)
             {
                 blockCount = totalDigitCount / DigitsPerBlock;
                 partialDigitCount = 0;
             }
             else
             {
-                blockCount = (totalDigitCount / DigitsPerBlock) + 1;
-                partialDigitCount = DigitsPerBlock - (totalDigitCount % DigitsPerBlock);
+                blockCount = Math.DivRem(totalDigitCount, DigitsPerBlock, out int mod) + 1;
+                partialDigitCount = DigitsPerBlock - mod;
             }
 
             bool isNegative = HexConverter.FromChar(number.digits[0]) >= 8;
@@ -427,22 +426,45 @@ private static bool HexNumberToBigInteger(ref BigNumberBuffer number, out int si
 
             try
             {
-                foreach (ReadOnlyMemory<char> digitsChunk in number.digits.GetChunks())
-                    ProcessChunk(digitsChunk.Span, bitsBuffer);
+                foreach (ReadOnlyMemory<char> digitsChunkMem in number.digits.GetChunks())
+                {
+                    ReadOnlySpan<char> chunkDigits = digitsChunkMem.Span;
+                    for (int i = 0; i < chunkDigits.Length; i++)
+                    {
+                        char digitChar = chunkDigits[i];
+                        if (digitChar == '\0')
+                            break;
+
+                        int hexValue = HexConverter.FromChar(digitChar);
+                        Debug.Assert(hexValue != 0xFF);
+
+                        partialValue = (partialValue << 4) | (uint)hexValue;
+                        partialDigitCount++;
+
+                        if (partialDigitCount == DigitsPerBlock)
+                        {
+                            bitsBuffer[bitsBufferPos] = (int)partialValue;
+                            bitsBufferPos--;
+                            partialValue = 0;
+                            partialDigitCount = 0;
+                        }
+                    }
+                }
 
                 Debug.Assert(partialDigitCount == 0 && bitsBufferPos == -1);
 
                 // BigInteger requires leading zero blocks to be truncated.
-                int blockCountNoLeadingZeros = blockCount;
-                while (blockCountNoLeadingZeros > 0 && bitsBuffer[blockCountNoLeadingZeros - 1] == 0)
-                    blockCountNoLeadingZeros--;
+                bitsBuffer = bitsBuffer.TrimEnd(0);
 
-                if (blockCountNoLeadingZeros == 0)
+                int sign;
+                uint[]? bits;
+
+                if (bitsBuffer.IsEmpty)
                 {
                     sign = 0;
                     bits = null;
                 }
-                else if (blockCountNoLeadingZeros == 1)
+                else if (bitsBuffer.Length == 1)
                 {
                     sign = bitsBuffer[0];
                     bits = null;
@@ -456,50 +478,24 @@ private static bool HexNumberToBigInteger(ref BigNumberBuffer number, out int si
                 else
                 {
                     sign = isNegative ? -1 : 1;
-                    bits = MemoryMarshal.Cast<int, uint>(bitsBuffer).Slice(0, blockCountNoLeadingZeros).ToArray();
+                    bits = MemoryMarshal.Cast<int, uint>(bitsBuffer).ToArray();
 
                     if (isNegative)
                         NumericsHelpers.DangerousMakeTwosComplement(bits);
                 }
 
+                result = new BigInteger(sign, bits);
                 return true;
             }
             finally
             {
                 if (arrayFromPool != null)
                     ArrayPool<int>.Shared.Return(arrayFromPool);
             }
-
-            void ProcessChunk(ReadOnlySpan<char> chunkDigits, Span<int> _bitsBuffer)
-            {
-                for (int i = 0; i < chunkDigits.Length; i++)
-                {
-                    char digitChar = chunkDigits[i];
-                    if (digitChar == '\0')
-                        return;
-
-                    int hexValue = HexConverter.FromChar(digitChar);
-                    Debug.Assert(hexValue != 0xFF);
-
-                    partialValue = (partialValue << 4) | (uint)hexValue;
-                    partialDigitCount++;
-
-                    if (partialDigitCount == DigitsPerBlock)
-                    {
-                        _bitsBuffer[bitsBufferPos] = (int)partialValue;
-                        bitsBufferPos--;
-                        partialValue = 0;
-                        partialDigitCount = 0;
-                    }
-                }
-            }
         }
 
-        private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign, out uint[]? bits)
+        private static bool NumberToBigInteger(ref BigNumberBuffer number, out BigInteger result)
         {
-            sign = 0;
-            bits = null;
-
             Span<int> stackBuffer = stackalloc int[BigInteger.StackallocUInt32Limit];
             Span<int> currentBuffer = stackBuffer;
             int currentBufferSize = 0;
@@ -517,9 +513,11 @@ private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign,
             {
                 foreach (ReadOnlyMemory<char> digitsChunk in number.digits.GetChunks())
                 {
-                    bool isValid = ProcessChunk(digitsChunk.Span, ref currentBuffer);
-                    if (!isValid)
+                    if (!ProcessChunk(digitsChunk.Span, ref currentBuffer))
+                    {
+                        result = default;
                         return false;
+                    }
                 }
 
                 if (partialDigitCount > 0)
@@ -536,12 +534,15 @@ private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign,
                 if (trailingZeroCount > 0)
                     MultiplyAdd(ref currentBuffer, s_uint32PowersOfTen[trailingZeroCount], 0);
 
+                int sign;
+                uint[]? bits;
+
                 if (currentBufferSize == 0)
                 {
                     sign = 0;
                     bits = null;
                 }
-                else if (currentBufferSize == 1 && currentBuffer[0] <= int.MaxValue)
+                else if (currentBufferSize == 1 && (uint)currentBuffer[0] <= int.MaxValue)
                 {
                     sign = number.sign ? -currentBuffer[0] : currentBuffer[0];
                     bits = null;
@@ -552,6 +553,7 @@ private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign,
                     bits = MemoryMarshal.Cast<int, uint>(currentBuffer).Slice(0, currentBufferSize).ToArray();
                 }
 
+                result = new BigInteger(sign, bits);
                 return true;
             }
             finally
@@ -560,7 +562,7 @@ private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign,
                     ArrayPool<int>.Shared.Return(arrayFromPool);
             }
 
-            bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<int> _currentBuffer)
+            bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<int> currentBuffer)
             {
                 int remainingIntDigitCount = Math.Max(numberScale - totalDigitCount, 0);
                 ReadOnlySpan<char> intDigitsSpan = chunkDigits.Slice(0, Math.Min(remainingIntDigitCount, chunkDigits.Length));
@@ -578,7 +580,7 @@ bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<int> _currentBuffer)
                     // Update the buffer when enough partial digits have been accumulated.
                     if (partialDigitCount == MaxPartialDigits)
                     {
-                        MultiplyAdd(ref _currentBuffer, TenPowMaxPartial, partialValue);
+                        MultiplyAdd(ref currentBuffer, TenPowMaxPartial, partialValue);
                         partialValue = 0;
                         partialDigitCount = 0;
                     }
@@ -598,9 +600,9 @@ bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<int> _currentBuffer)
                 return true;
             }
 
-            void MultiplyAdd(ref Span<int> _currentBuffer, uint multiplier, uint addValue)
+            void MultiplyAdd(ref Span<int> currentBuffer, uint multiplier, uint addValue)
             {
-                Span<int> curBits = _currentBuffer.Slice(0, currentBufferSize);
+                Span<int> curBits = currentBuffer.Slice(0, currentBufferSize);
                 uint carry = addValue;
 
                 for (int i = 0; i < curBits.Length; i++)
@@ -613,19 +615,19 @@ void MultiplyAdd(ref Span<int> _currentBuffer, uint multiplier, uint addValue)
                 if (carry == 0)
                     return;
 
-                if (currentBufferSize == _currentBuffer.Length)
+                if (currentBufferSize == currentBuffer.Length)
                 {
                     int[]? arrayToReturn = arrayFromPool;
 
                     arrayFromPool = ArrayPool<int>.Shared.Rent(checked(currentBufferSize * 2));
-                    _currentBuffer.CopyTo(arrayFromPool);
-                    _currentBuffer = arrayFromPool;
+                    currentBuffer.CopyTo(arrayFromPool);
+                    currentBuffer = arrayFromPool;
 
                     if (arrayToReturn != null)
                         ArrayPool<int>.Shared.Return(arrayToReturn);
                 }
 
-                _currentBuffer[currentBufferSize] = (int)carry;
+                currentBuffer[currentBufferSize] = (int)carry;
                 currentBufferSize++;
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -464,7 +464,7 @@ public BigInteger(ReadOnlySpan<byte> value, bool isUnsigned = false, bool isBigE`
`464`	`464`	`AssertValid();`
`465`	`465`	`}`
`466`	`466`
`467`		`- private BigInteger(int n, uint[]? rgu)`
	`467`	`+ internal BigInteger(int n, uint[]? rgu)`
`468`	`468`	`{`
`469`	`469`	`_sign = n;`
`470`	`470`	`_bits = rgu;`
`@@ -683,8 +683,7 @@ public static BigInteger Parse(string value, IFormatProvider? provider)`
`683`	`683`
`684`	`684`	`public static BigInteger Parse(string value, NumberStyles style, IFormatProvider? provider)`
`685`	`685`	`{`
`686`		`- (int sign, uint[]? bits) = BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));`
`687`		`- return new BigInteger(sign, bits);`
	`686`	`+ return BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));`
`688`	`687`	`}`
`689`	`688`
`690`	`689`	`public static bool TryParse([NotNullWhen(true)] string? value, out BigInteger result)`
`@@ -694,17 +693,12 @@ public static bool TryParse([NotNullWhen(true)] string? value, out BigInteger re`
`694`	`693`
`695`	`694`	`public static bool TryParse([NotNullWhen(true)] string? value, NumberStyles style, IFormatProvider? provider, out BigInteger result)`
`696`	`695`	`{`
`697`		`- bool success = BigNumber.TryParseBigInteger(`
`698`		`- value, style, NumberFormatInfo.GetInstance(provider), out int sign, out uint[]? bits);`
`699`		`-`
`700`		`- result = new BigInteger(sign, bits);`
`701`		`- return success;`
	`696`	`+ return BigNumber.TryParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider), out result);`
`702`	`697`	`}`
`703`	`698`
`704`	`699`	`public static BigInteger Parse(ReadOnlySpan<char> value, NumberStyles style = NumberStyles.Integer, IFormatProvider? provider = null)`
`705`	`700`	`{`
`706`		`- (int sign, uint[]? bits) = BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));`
`707`		`- return new BigInteger(sign, bits);`
	`701`	`+ return BigNumber.ParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider));`
`708`	`702`	`}`
`709`	`703`
`710`	`704`	`public static bool TryParse(ReadOnlySpan<char> value, out BigInteger result)`
`@@ -714,11 +708,7 @@ public static bool TryParse(ReadOnlySpan<char> value, out BigInteger result)`
`714`	`708`
`715`	`709`	`public static bool TryParse(ReadOnlySpan<char> value, NumberStyles style, IFormatProvider? provider, out BigInteger result)`
`716`	`710`	`{`
`717`		`- bool success = BigNumber.TryParseBigInteger(`
`718`		`- value, style, NumberFormatInfo.GetInstance(provider), out int sign, out uint[]? bits);`
`719`		`-`
`720`		`- result = new BigInteger(sign, bits);`
`721`		`- return success;`
	`711`	`+ return BigNumber.TryParseBigInteger(value, style, NumberFormatInfo.GetInstance(provider), out result);`
`722`	`712`	`}`
`723`	`713`
`724`	`714`	`public static int Compare(BigInteger left, BigInteger right)`
Original file line number	Diff line number	Diff line change
`@@ -325,49 +325,48 @@ internal static bool TryValidateParseStyleInteger(NumberStyles style, [NotNullWh`
`325`	`325`	`return true;`
`326`	`326`	`}`
`327`	`327`
`328`		`- internal static bool TryParseBigInteger(string? value, NumberStyles style, NumberFormatInfo info, out int sign, out uint[]? bits)`
	`328`	`+ internal static bool TryParseBigInteger(string? value, NumberStyles style, NumberFormatInfo info, out BigInteger result)`
`329`	`329`	`{`
`330`	`330`	`if (value == null)`
`331`	`331`	`{`
`332`		`- sign = 0;`
`333`		`- bits = null;`
	`332`	`+ result = default;`
`334`	`333`	`return false;`
`335`	`334`	`}`
`336`	`335`
`337`		`- return TryParseBigInteger(value.AsSpan(), style, info, out sign, out bits);`
	`336`	`+ return TryParseBigInteger(value.AsSpan(), style, info, out result);`
`338`	`337`	`}`
`339`	`338`
`340`		`- internal static bool TryParseBigInteger(ReadOnlySpan<char> value, NumberStyles style, NumberFormatInfo info, out int sign, out uint[]? bits)`
	`339`	`+ internal static bool TryParseBigInteger(ReadOnlySpan<char> value, NumberStyles style, NumberFormatInfo info, out BigInteger result)`
`341`	`340`	`{`
`342`		`- sign = 0;`
`343`		`- bits = null;`
`344`		`-`
`345`	`341`	`ArgumentException? e;`
`346`	`342`	`if (!TryValidateParseStyleInteger(style, out e))`
`347`	`343`	`throw e; // TryParse still throws ArgumentException on invalid NumberStyles`
`348`	`344`
`349`	`345`	`BigNumberBuffer bignumber = BigNumberBuffer.Create();`
`350`	`346`	`if (!FormatProvider.TryStringToBigInteger(value, style, info, bignumber.digits, out bignumber.precision, out bignumber.scale, out bignumber.sign))`
	`347`	`+ {`
	`348`	`+ result = default;`
`351`	`349`	`return false;`
	`350`	`+ }`
`352`	`351`
`353`	`352`	`if ((style & NumberStyles.AllowHexSpecifier) != 0)`
`354`	`353`	`{`
`355`		`- if (!HexNumberToBigInteger(ref bignumber, out sign, out bits))`
	`354`	`+ if (!HexNumberToBigInteger(ref bignumber, out result))`
`356`	`355`	`{`
`357`	`356`	`return false;`
`358`	`357`	`}`
`359`	`358`	`}`
`360`	`359`	`else`
`361`	`360`	`{`
`362`		`- if (!NumberToBigInteger(ref bignumber, out sign, out bits))`
	`361`	`+ if (!NumberToBigInteger(ref bignumber, out result))`
`363`	`362`	`{`
`364`	`363`	`return false;`
`365`	`364`	`}`
`366`	`365`	`}`
`367`	`366`	`return true;`
`368`	`367`	`}`
`369`	`368`
`370`		`- internal static (int sign, uint[]? bits) ParseBigInteger(string value, NumberStyles style, NumberFormatInfo info)`
	`369`	`+ internal static BigInteger ParseBigInteger(string value, NumberStyles style, NumberFormatInfo info)`
`371`	`370`	`{`
`372`	`371`	`if (value == null)`
`373`	`372`	`{`
`@@ -377,41 +376,41 @@ internal static (int sign, uint[]? bits) ParseBigInteger(string value, NumberSty`
`377`	`376`	`return ParseBigInteger(value.AsSpan(), style, info);`
`378`	`377`	`}`
`379`	`378`
`380`		`- internal static (int sign, uint[]? bits) ParseBigInteger(ReadOnlySpan<char> value, NumberStyles style, NumberFormatInfo info)`
	`379`	`+ internal static BigInteger ParseBigInteger(ReadOnlySpan<char> value, NumberStyles style, NumberFormatInfo info)`
`381`	`380`	`{`
`382`	`381`	`ArgumentException? e;`
`383`	`382`	`if (!TryValidateParseStyleInteger(style, out e))`
`384`	`383`	`throw e;`
`385`	`384`
`386`		`- if (!TryParseBigInteger(value, style, info, out int sign, out uint[]? bits))`
	`385`	`+ if (!TryParseBigInteger(value, style, info, out BigInteger result))`
`387`	`386`	`{`
`388`	`387`	`throw new FormatException(SR.Overflow_ParseBigInteger);`
`389`	`388`	`}`
`390`		`- return (sign, bits);`
	`389`	`+ return result;`
`391`	`390`	`}`
`392`	`391`
`393`		`- private static bool HexNumberToBigInteger(ref BigNumberBuffer number, out int sign, out uint[]? bits)`
	`392`	`+ private static bool HexNumberToBigInteger(ref BigNumberBuffer number, out BigInteger result)`
`394`	`393`	`{`
`395`		`- sign = 0;`
`396`		`- bits = null;`
`397`		`-`
`398`	`394`	`if (number.digits == null \|\| number.digits.Length == 0)`
	`395`	`+ {`
	`396`	`+ result = default;`
`399`	`397`	`return false;`
	`398`	`+ }`
`400`	`399`
`401`	`400`	`const int DigitsPerBlock = 8;`
`402`	`401`
`403`	`402`	`int totalDigitCount = number.digits.Length - 1; // Ignore trailing '\0'`
`404`	`403`	`int blockCount, partialDigitCount;`
`405`	`404`
`406`		`- if (totalDigitCount % DigitsPerBlock == 0)`
	`405`	`+ if ((uint)totalDigitCount % DigitsPerBlock == 0)`
`407`	`406`	`{`
`408`	`407`	`blockCount = totalDigitCount / DigitsPerBlock;`
`409`	`408`	`partialDigitCount = 0;`
`410`	`409`	`}`
`411`	`410`	`else`
`412`	`411`	`{`
`413`		`- blockCount = (totalDigitCount / DigitsPerBlock) + 1;`
`414`		`- partialDigitCount = DigitsPerBlock - (totalDigitCount % DigitsPerBlock);`
	`412`	`+ blockCount = Math.DivRem(totalDigitCount, DigitsPerBlock, out int mod) + 1;`
	`413`	`+ partialDigitCount = DigitsPerBlock - mod;`
`415`	`414`	`}`
`416`	`415`
`417`	`416`	`bool isNegative = HexConverter.FromChar(number.digits[0]) >= 8;`
`@@ -427,22 +426,45 @@ private static bool HexNumberToBigInteger(ref BigNumberBuffer number, out int si`
`427`	`426`
`428`	`427`	`try`
`429`	`428`	`{`
`430`		`- foreach (ReadOnlyMemory<char> digitsChunk in number.digits.GetChunks())`
`431`		`- ProcessChunk(digitsChunk.Span, bitsBuffer);`
	`429`	`+ foreach (ReadOnlyMemory<char> digitsChunkMem in number.digits.GetChunks())`
	`430`	`+ {`
	`431`	`+ ReadOnlySpan<char> chunkDigits = digitsChunkMem.Span;`
	`432`	`+ for (int i = 0; i < chunkDigits.Length; i++)`
	`433`	`+ {`
	`434`	`+ char digitChar = chunkDigits[i];`
	`435`	`+ if (digitChar == '\0')`
	`436`	`+ break;`
	`437`	`+`
	`438`	`+ int hexValue = HexConverter.FromChar(digitChar);`
	`439`	`+ Debug.Assert(hexValue != 0xFF);`
	`440`	`+`
	`441`	`+ partialValue = (partialValue << 4) \| (uint)hexValue;`
	`442`	`+ partialDigitCount++;`
	`443`	`+`
	`444`	`+ if (partialDigitCount == DigitsPerBlock)`
	`445`	`+ {`
	`446`	`+ bitsBuffer[bitsBufferPos] = (int)partialValue;`
	`447`	`+ bitsBufferPos--;`
	`448`	`+ partialValue = 0;`
	`449`	`+ partialDigitCount = 0;`
	`450`	`+ }`
	`451`	`+ }`
	`452`	`+ }`
`432`	`453`
`433`	`454`	`Debug.Assert(partialDigitCount == 0 && bitsBufferPos == -1);`
`434`	`455`
`435`	`456`	`// BigInteger requires leading zero blocks to be truncated.`
`436`		`- int blockCountNoLeadingZeros = blockCount;`
`437`		`- while (blockCountNoLeadingZeros > 0 && bitsBuffer[blockCountNoLeadingZeros - 1] == 0)`
`438`		`- blockCountNoLeadingZeros--;`
	`457`	`+ bitsBuffer = bitsBuffer.TrimEnd(0);`
`439`	`458`
`440`		`- if (blockCountNoLeadingZeros == 0)`
	`459`	`+ int sign;`
	`460`	`+ uint[]? bits;`
	`461`	`+`
	`462`	`+ if (bitsBuffer.IsEmpty)`
`441`	`463`	`{`
`442`	`464`	`sign = 0;`
`443`	`465`	`bits = null;`
`444`	`466`	`}`
`445`		`- else if (blockCountNoLeadingZeros == 1)`
	`467`	`+ else if (bitsBuffer.Length == 1)`
`446`	`468`	`{`
`447`	`469`	`sign = bitsBuffer[0];`
`448`	`470`	`bits = null;`
`@@ -456,50 +478,24 @@ private static bool HexNumberToBigInteger(ref BigNumberBuffer number, out int si`
`456`	`478`	`else`
`457`	`479`	`{`
`458`	`480`	`sign = isNegative ? -1 : 1;`
`459`		`- bits = MemoryMarshal.Cast<int, uint>(bitsBuffer).Slice(0, blockCountNoLeadingZeros).ToArray();`
	`481`	`+ bits = MemoryMarshal.Cast<int, uint>(bitsBuffer).ToArray();`
`460`	`482`
`461`	`483`	`if (isNegative)`
`462`	`484`	`NumericsHelpers.DangerousMakeTwosComplement(bits);`
`463`	`485`	`}`
`464`	`486`
	`487`	`+ result = new BigInteger(sign, bits);`
`465`	`488`	`return true;`
`466`	`489`	`}`
`467`	`490`	`finally`
`468`	`491`	`{`
`469`	`492`	`if (arrayFromPool != null)`
`470`	`493`	`ArrayPool<int>.Shared.Return(arrayFromPool);`
`471`	`494`	`}`
`472`		`-`
`473`		`- void ProcessChunk(ReadOnlySpan<char> chunkDigits, Span<int> _bitsBuffer)`
`474`		`- {`
`475`		`- for (int i = 0; i < chunkDigits.Length; i++)`
`476`		`- {`
`477`		`- char digitChar = chunkDigits[i];`
`478`		`- if (digitChar == '\0')`
`479`		`- return;`
`480`		`-`
`481`		`- int hexValue = HexConverter.FromChar(digitChar);`
`482`		`- Debug.Assert(hexValue != 0xFF);`
`483`		`-`
`484`		`- partialValue = (partialValue << 4) \| (uint)hexValue;`
`485`		`- partialDigitCount++;`
`486`		`-`
`487`		`- if (partialDigitCount == DigitsPerBlock)`
`488`		`- {`
`489`		`- _bitsBuffer[bitsBufferPos] = (int)partialValue;`
`490`		`- bitsBufferPos--;`
`491`		`- partialValue = 0;`
`492`		`- partialDigitCount = 0;`
`493`		`- }`
`494`		`- }`
`495`		`- }`
`496`	`495`	`}`
`497`	`496`
`498`		`- private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign, out uint[]? bits)`
	`497`	`+ private static bool NumberToBigInteger(ref BigNumberBuffer number, out BigInteger result)`
`499`	`498`	`{`
`500`		`- sign = 0;`
`501`		`- bits = null;`
`502`		`-`
`503`	`499`	`Span<int> stackBuffer = stackalloc int[BigInteger.StackallocUInt32Limit];`
`504`	`500`	`Span<int> currentBuffer = stackBuffer;`
`505`	`501`	`int currentBufferSize = 0;`
`@@ -517,9 +513,11 @@ private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign,`
`517`	`513`	`{`
`518`	`514`	`foreach (ReadOnlyMemory<char> digitsChunk in number.digits.GetChunks())`
`519`	`515`	`{`
`520`		`- bool isValid = ProcessChunk(digitsChunk.Span, ref currentBuffer);`
`521`		`- if (!isValid)`
	`516`	`+ if (!ProcessChunk(digitsChunk.Span, ref currentBuffer))`
	`517`	`+ {`
	`518`	`+ result = default;`
`522`	`519`	`return false;`
	`520`	`+ }`
`523`	`521`	`}`
`524`	`522`
`525`	`523`	`if (partialDigitCount > 0)`
`@@ -536,12 +534,15 @@ private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign,`
`536`	`534`	`if (trailingZeroCount > 0)`
`537`	`535`	`MultiplyAdd(ref currentBuffer, s_uint32PowersOfTen[trailingZeroCount], 0);`
`538`	`536`
	`537`	`+ int sign;`
	`538`	`+ uint[]? bits;`
	`539`	`+`
`539`	`540`	`if (currentBufferSize == 0)`
`540`	`541`	`{`
`541`	`542`	`sign = 0;`
`542`	`543`	`bits = null;`
`543`	`544`	`}`
`544`		`- else if (currentBufferSize == 1 && currentBuffer[0] <= int.MaxValue)`
	`545`	`+ else if (currentBufferSize == 1 && (uint)currentBuffer[0] <= int.MaxValue)`
`545`	`546`	`{`
`546`	`547`	`sign = number.sign ? -currentBuffer[0] : currentBuffer[0];`
`547`	`548`	`bits = null;`
`@@ -552,6 +553,7 @@ private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign,`
`552`	`553`	`bits = MemoryMarshal.Cast<int, uint>(currentBuffer).Slice(0, currentBufferSize).ToArray();`
`553`	`554`	`}`
`554`	`555`
	`556`	`+ result = new BigInteger(sign, bits);`
`555`	`557`	`return true;`
`556`	`558`	`}`
`557`	`559`	`finally`
`@@ -560,7 +562,7 @@ private static bool NumberToBigInteger(ref BigNumberBuffer number, out int sign,`
`560`	`562`	`ArrayPool<int>.Shared.Return(arrayFromPool);`
`561`	`563`	`}`
`562`	`564`
`563`		`- bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<int> _currentBuffer)`
	`565`	`+ bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<int> currentBuffer)`
`564`	`566`	`{`
`565`	`567`	`int remainingIntDigitCount = Math.Max(numberScale - totalDigitCount, 0);`
`566`	`568`	`ReadOnlySpan<char> intDigitsSpan = chunkDigits.Slice(0, Math.Min(remainingIntDigitCount, chunkDigits.Length));`
`@@ -578,7 +580,7 @@ bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<int> _currentBuffer)`
`578`	`580`	`// Update the buffer when enough partial digits have been accumulated.`
`579`	`581`	`if (partialDigitCount == MaxPartialDigits)`
`580`	`582`	`{`
`581`		`- MultiplyAdd(ref _currentBuffer, TenPowMaxPartial, partialValue);`
	`583`	`+ MultiplyAdd(ref currentBuffer, TenPowMaxPartial, partialValue);`
`582`	`584`	`partialValue = 0;`
`583`	`585`	`partialDigitCount = 0;`
`584`	`586`	`}`
`@@ -598,9 +600,9 @@ bool ProcessChunk(ReadOnlySpan<char> chunkDigits, ref Span<int> _currentBuffer)`
`598`	`600`	`return true;`
`599`	`601`	`}`
`600`	`602`
`601`		`- void MultiplyAdd(ref Span<int> _currentBuffer, uint multiplier, uint addValue)`
	`603`	`+ void MultiplyAdd(ref Span<int> currentBuffer, uint multiplier, uint addValue)`
`602`	`604`	`{`
`603`		`- Span<int> curBits = _currentBuffer.Slice(0, currentBufferSize);`
	`605`	`+ Span<int> curBits = currentBuffer.Slice(0, currentBufferSize);`
`604`	`606`	`uint carry = addValue;`
`605`	`607`
`606`	`608`	`for (int i = 0; i < curBits.Length; i++)`
`@@ -613,19 +615,19 @@ void MultiplyAdd(ref Span<int> _currentBuffer, uint multiplier, uint addValue)`
`613`	`615`	`if (carry == 0)`
`614`	`616`	`return;`
`615`	`617`
`616`		`- if (currentBufferSize == _currentBuffer.Length)`
	`618`	`+ if (currentBufferSize == currentBuffer.Length)`
`617`	`619`	`{`
`618`	`620`	`int[]? arrayToReturn = arrayFromPool;`
`619`	`621`
`620`	`622`	`arrayFromPool = ArrayPool<int>.Shared.Rent(checked(currentBufferSize * 2));`
`621`		`- _currentBuffer.CopyTo(arrayFromPool);`
`622`		`- _currentBuffer = arrayFromPool;`
	`623`	`+ currentBuffer.CopyTo(arrayFromPool);`
	`624`	`+ currentBuffer = arrayFromPool;`
`623`	`625`
`624`	`626`	`if (arrayToReturn != null)`
`625`	`627`	`ArrayPool<int>.Shared.Return(arrayToReturn);`
`626`	`628`	`}`
`627`	`629`
`628`		`- _currentBuffer[currentBufferSize] = (int)carry;`
	`630`	`+ currentBuffer[currentBufferSize] = (int)carry;`
`629`	`631`	`currentBufferSize++;`
`630`	`632`	`}`
`631`	`633`	`}`