[JitDiff X64] [tannergooding] Remove some unsafe usage from the float-format ...

[MihuBot]

Job completed in 16 minutes 57 seconds (remote runner delay: 31 seconds).
dotnet/runtime#121308

Diffs

Diffs

Found 83 files with textual diffs.

Summary of Code Size diffs:
(Lower is better)

Total bytes of base: 45920719
Total bytes of diff: 45921549
Total bytes of delta: 830 (0.00 % of base)
Total relative delta: 1.91
    diff is a regression.
    relative diff is a regression.


Total byte diff includes 422 bytes from reconciling methods
	Base had    9 unique methods,      795 unique bytes
	Diff had   25 unique methods,     1217 unique bytes

Top file regressions (bytes):
         830 : System.Private.CoreLib.dasm (0.01 % of base)

1 total files with Code Size differences (0 improved, 1 regressed), 259 unchanged.

Top method regressions (bytes):
         444 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:ShiftLeft(int):this (FullOpts) (0 base, 1 diff methods)
         375 (Infinity of base) : System.Private.CoreLib.dasm - System.Number:ConvertBigIntegerToFloatingPointBits[double](byref,int,bool):ulong (FullOpts) (0 base, 1 diff methods)
         249 (25.33 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:DivRem(byref,byref,byref,byref) (FullOpts)
         136 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Pow2(int,byref) (FullOpts) (0 base, 1 diff methods)
          88 (48.62 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Add(byref,byref,byref) (FullOpts)
          70 (17.68 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Multiply(byref,byref,byref) (FullOpts)
          61 (19.37 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:HeuristicDivide(byref,byref):uint (FullOpts)
          50 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Clear(int):this (FullOpts) (0 base, 1 diff methods)
          49 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(byref):int (FullOpts) (0 base, 1 diff methods)
          33 (17.10 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Multiply(byref,uint,byref) (FullOpts)
          29 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:GetBlock(int):uint:this (FullOpts) (0 base, 1 diff methods)
          24 (27.91 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Multiply10():this (FullOpts)
          22 (25.29 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:SubtractDivisor(byref,int,byref,ulong):uint (FullOpts)
          18 (27.27 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:AddDivisor(byref,int,byref):uint (FullOpts)
          17 (21.79 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Compare(byref,byref):int (FullOpts)
          15 (15.15 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Add(uint):this (FullOpts)
          13 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(ulong):int (FullOpts) (0 base, 1 diff methods)
          13 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:DivRem32(int,byref):int (FullOpts) (0 base, 1 diff methods)
          12 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(uint):int (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[byte,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[double,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[int,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[long,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[short,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[System.__Canon,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[System.Nullable`1[int],System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[System.Numerics.Vector`1[float],System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[byte,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[double,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[int,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[long,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[short,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[System.__Canon,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[System.Nullable`1[int],System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[System.Numerics.Vector`1[float],System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)

Top method improvements (bytes):
        -304 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:ShiftLeft(uint):this (FullOpts) (1 base, 0 diff methods)
        -282 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number:ConvertBigIntegerToFloatingPointBits[double](byref,uint,bool):ulong (FullOpts) (1 base, 0 diff methods)
        -103 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Pow2(uint,byref) (FullOpts) (1 base, 0 diff methods)
         -68 (-21.45 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Pow10(uint,byref) (FullOpts)
         -29 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Clear(uint):this (FullOpts) (1 base, 0 diff methods)
         -29 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(byref):uint (FullOpts) (1 base, 0 diff methods)
         -25 (-0.73 % of base) : System.Private.CoreLib.dasm - System.Number:Dragon4(ulong,int,uint,bool,int,bool,System.Span`1[byte],byref):uint (FullOpts)
         -25 (-10.16 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:MultiplyPow10(uint):this (FullOpts)
         -24 (-6.74 % of base) : System.Private.CoreLib.dasm - System.Number:AccumulateDecimalDigitsIntoBigInteger(byref,uint,uint,byref) (FullOpts)
         -24 (-1.56 % of base) : System.Private.CoreLib.dasm - System.Number:NumberToFloatingPointBitsSlow[double](byref,uint,uint,uint):ulong (FullOpts)
         -23 (-13.53 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Multiply(byref):this (FullOpts)
         -13 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(ulong):uint (FullOpts) (1 base, 0 diff methods)
         -13 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:DivRem32(uint,byref):uint (FullOpts) (1 base, 0 diff methods)
         -12 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(uint):uint (FullOpts) (1 base, 0 diff methods)
         -10 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:GetBlock(uint):uint:this (FullOpts) (1 base, 0 diff methods)

Top method regressions (percentages):
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[byte,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[double,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[int,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[long,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[short,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[System.__Canon,System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[System.Nullable`1[int],System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           8 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayElementRefReadOnly[System.Numerics.Vector`1[float],System.Nullable`1[int]](byref,int):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[byte,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[double,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[int,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[long,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[short,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[System.__Canon,System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[System.Nullable`1[int],System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
           4 (Infinity of base) : System.Private.CoreLib.dasm - <PrivateImplementationDetails>:InlineArrayFirstElementRefReadOnly[System.Numerics.Vector`1[float],System.Nullable`1[int]](byref):byref (FullOpts) (0 base, 1 diff methods)
         375 (Infinity of base) : System.Private.CoreLib.dasm - System.Number:ConvertBigIntegerToFloatingPointBits[double](byref,int,bool):ulong (FullOpts) (0 base, 1 diff methods)
          50 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Clear(int):this (FullOpts) (0 base, 1 diff methods)
          49 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(byref):int (FullOpts) (0 base, 1 diff methods)
          12 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(uint):int (FullOpts) (0 base, 1 diff methods)
          13 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(ulong):int (FullOpts) (0 base, 1 diff methods)
          13 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:DivRem32(int,byref):int (FullOpts) (0 base, 1 diff methods)
          29 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:GetBlock(int):uint:this (FullOpts) (0 base, 1 diff methods)
         136 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Pow2(int,byref) (FullOpts) (0 base, 1 diff methods)
         444 (Infinity of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:ShiftLeft(int):this (FullOpts) (0 base, 1 diff methods)
          88 (48.62 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Add(byref,byref,byref) (FullOpts)
          24 (27.91 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Multiply10():this (FullOpts)
          18 (27.27 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:AddDivisor(byref,int,byref):uint (FullOpts)
         249 (25.33 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:DivRem(byref,byref,byref,byref) (FullOpts)
          22 (25.29 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:SubtractDivisor(byref,int,byref,ulong):uint (FullOpts)
          17 (21.79 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Compare(byref,byref):int (FullOpts)
          61 (19.37 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:HeuristicDivide(byref,byref):uint (FullOpts)
          70 (17.68 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Multiply(byref,byref,byref) (FullOpts)
          33 (17.10 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Multiply(byref,uint,byref) (FullOpts)
          15 (15.15 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Add(uint):this (FullOpts)

Top method improvements (percentages):
        -282 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number:ConvertBigIntegerToFloatingPointBits[double](byref,uint,bool):ulong (FullOpts) (1 base, 0 diff methods)
         -29 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Clear(uint):this (FullOpts) (1 base, 0 diff methods)
         -29 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(byref):uint (FullOpts) (1 base, 0 diff methods)
         -12 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(uint):uint (FullOpts) (1 base, 0 diff methods)
         -13 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:CountSignificantBits(ulong):uint (FullOpts) (1 base, 0 diff methods)
         -13 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:DivRem32(uint,byref):uint (FullOpts) (1 base, 0 diff methods)
         -10 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:GetBlock(uint):uint:this (FullOpts) (1 base, 0 diff methods)
        -103 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Pow2(uint,byref) (FullOpts) (1 base, 0 diff methods)
        -304 (-100.00 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:ShiftLeft(uint):this (FullOpts) (1 base, 0 diff methods)
         -68 (-21.45 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Pow10(uint,byref) (FullOpts)
         -23 (-13.53 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:Multiply(byref):this (FullOpts)
         -25 (-10.16 % of base) : System.Private.CoreLib.dasm - System.Number+BigInteger:MultiplyPow10(uint):this (FullOpts)
         -24 (-6.74 % of base) : System.Private.CoreLib.dasm - System.Number:AccumulateDecimalDigitsIntoBigInteger(byref,uint,uint,byref) (FullOpts)
         -24 (-1.56 % of base) : System.Private.CoreLib.dasm - System.Number:NumberToFloatingPointBitsSlow[double](byref,uint,uint,uint):ulong (FullOpts)
         -25 (-0.73 % of base) : System.Private.CoreLib.dasm - System.Number:Dragon4(ulong,int,uint,bool,int,bool,System.Span`1[byte],byref):uint (FullOpts)

50 total methods with Code Size differences (15 improved, 35 regressed), 282902 unchanged.

--------------------------------------------------------------------------------

Artifacts:

• build-clr-checked-main.zip (87 MB)
• build-artifacts-main.zip (674 MB)
• build-clr-checked-pr.zip (87 MB)
• build-artifacts-pr.zip (675 MB)
• jit-diffs-pr.zip (154 MB)
• jit-diffs-main.zip (154 MB)
• diff-frameworks.txt (17 KB)
• ShortDiffsRegressions.md (56 KB)
• LongDiffsRegressions.md (140 KB)
• LongDiffsImprovements.md (175 KB)
• ShortDiffsImprovements.md (39 KB)

[MihuBot]

Top method regressions

88 (48.62 % of base) - System.Number+BigInteger:Add(byref,byref,byref)

 ; Assembly listing for method System.Number+BigInteger:Add(byref,byref,byref) (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 1 single block inlinees; 0 inlinees without PGO data
+; 0 inlinees with PGO data; 19 single block inlinees; 0 inlinees without PGO data
 ; Final local variable assignments
 ;
-;  V00 arg0         [V00,T08] (  5,  5   )   byref  ->  rdi         single-def
-;  V01 arg1         [V01,T09] (  5,  5   )   byref  ->  rsi         single-def
-;  V02 arg2         [V02,T04] (  9, 13   )   byref  ->  rdx         single-def
-;  V03 loc0         [V03,T07] (  4, 10   )   byref  ->   r8         single-def
-;  V04 loc1         [V04,T11] (  3,  6   )   byref  ->  rdi         single-def
-;  V05 loc2         [V05,T10] (  5,  7   )     int  ->  rax        
-;  V06 loc3         [V06,T12] (  3,  6   )     int  ->  rcx        
-;  V07 loc4         [V07,T02] (  6, 18   )    long  ->  registers  
-;  V08 loc5         [V08,T00] (  9, 29.50)     int  ->   r9        
-;  V09 loc6         [V09,T03] (  5, 17   )     int  ->  r10        
-;  V10 loc7         [V10,T01] (  8, 25.50)     int  ->  r11        
+;  V00 arg0         [V00,T09] (  6,  6   )   byref  ->  rdi         single-def
+;  V01 arg1         [V01,T10] (  6,  6   )   byref  ->  rsi         single-def
+;  V02 arg2         [V02,T05] (  9, 13   )   byref  ->  rdx         single-def
+;  V03 loc0         [V03,T08] (  4, 10   )   byref  ->  rax         single-def
+;  V04 loc1         [V04,T17] (  3,  6   )   byref  ->  rdi         single-def
+;  V05 loc2         [V05,T16] (  5,  7   )     int  ->  rcx        
+;  V06 loc3         [V06,T18] (  3,  6   )     int  ->  rsi        
+;  V07 loc4         [V07,T03] (  6, 18   )    long  ->  registers  
+;  V08 loc5         [V08,T00] ( 11, 37.50)     int  ->   r9        
+;* V09 loc6         [V09,T22] (  0,  0   )     int  ->  zero-ref   
+;  V10 loc7         [V10,T01] ( 11, 34   )     int  ->  r11        
 ;* V11 loc8         [V11    ] (  0,  0   )     int  ->  zero-ref   
-;  V12 loc9         [V12,T05] (  3, 12   )    long  ->  rsi        
-;  V13 loc10        [V13,T06] (  3, 12   )    long  ->  rcx        
-;# V14 OutArgs      [V14    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
-;  V15 tmp1         [V15,T15] (  2,  2   )   byref  ->   r8        
-;  V16 tmp2         [V16,T16] (  2,  2   )   byref  ->  rdi        
-;* V17 tmp3         [V17    ] (  0,  0   )   byref  ->  zero-ref    single-def "dup spill"
-;  V18 cse0         [V18,T13] (  3,  3   )     int  ->  rax         "CSE #01: moderate"
-;  V19 cse1         [V19,T14] (  3,  3   )     int  ->  rcx         "CSE #02: moderate"
+;  V12 loc9         [V12,T06] (  3, 12   )    long  ->   r8        
+;* V13 loc10        [V13    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V14 loc11        [V14    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V15 loc12        [V15    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;  V16 loc13        [V16,T07] (  3, 12   )    long  ->  rdi        
+;* V17 loc14        [V17    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V18 loc15        [V18    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V19 loc16        [V19    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;# V20 OutArgs      [V20    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
+;  V21 tmp1         [V21,T19] (  2,  2   )   byref  ->  rax        
+;  V22 tmp2         [V22,T20] (  2,  2   )   byref  ->  rdi        
+;  V23 tmp3         [V23,T04] (  2, 16   )    long  ->   r8         "impAppendStmt"
+;* V24 tmp4         [V24    ] (  0,  0   )   byref  ->  zero-ref    single-def "dup spill"
+;* V25 tmp5         [V25    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V26 tmp6         [V26    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V27 tmp7         [V27    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V28 tmp8         [V28    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V29 tmp9         [V29    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V30 tmp10        [V30    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V31 tmp11        [V31    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V32 tmp12        [V32    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V33 tmp13        [V33    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V34 tmp14        [V34    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V35 tmp15        [V35    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V36 tmp16        [V36    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V37 tmp17        [V37    ] (  0,  0   )   byref  ->  zero-ref    "field V13._reference (fldOffset=0x0)" P-INDEP
+;* V38 tmp18        [V38    ] (  0,  0   )     int  ->  zero-ref    "field V13._length (fldOffset=0x8)" P-INDEP
+;* V39 tmp19        [V39    ] (  0,  0   )   byref  ->  zero-ref    "field V14._reference (fldOffset=0x0)" P-INDEP
+;* V40 tmp20        [V40    ] (  0,  0   )     int  ->  zero-ref    "field V14._length (fldOffset=0x8)" P-INDEP
+;* V41 tmp21        [V41    ] (  0,  0   )   byref  ->  zero-ref    "field V15._reference (fldOffset=0x0)" P-INDEP
+;* V42 tmp22        [V42    ] (  0,  0   )     int  ->  zero-ref    "field V15._length (fldOffset=0x8)" P-INDEP
+;* V43 tmp23        [V43    ] (  0,  0   )   byref  ->  zero-ref    "field V17._reference (fldOffset=0x0)" P-INDEP
+;* V44 tmp24        [V44    ] (  0,  0   )     int  ->  zero-ref    "field V17._length (fldOffset=0x8)" P-INDEP
+;* V45 tmp25        [V45    ] (  0,  0   )   byref  ->  zero-ref    "field V18._reference (fldOffset=0x0)" P-INDEP
+;* V46 tmp26        [V46    ] (  0,  0   )     int  ->  zero-ref    "field V18._length (fldOffset=0x8)" P-INDEP
+;* V47 tmp27        [V47    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V19._reference (fldOffset=0x0)" P-INDEP
+;* V48 tmp28        [V48    ] (  0,  0   )     int  ->  zero-ref    "field V19._length (fldOffset=0x8)" P-INDEP
+;  V49 tmp29        [V49,T11] (  2,  8   )   byref  ->  rbx         "field V26._reference (fldOffset=0x0)" P-INDEP
+;* V50 tmp30        [V50    ] (  0,  0   )     int  ->  zero-ref    "field V26._length (fldOffset=0x8)" P-INDEP
+;  V51 tmp31        [V51,T12] (  2,  8   )   byref  ->  rbx         "field V28._reference (fldOffset=0x0)" P-INDEP
+;* V52 tmp32        [V52    ] (  0,  0   )     int  ->  zero-ref    "field V28._length (fldOffset=0x8)" P-INDEP
+;  V53 tmp33        [V53,T13] (  2,  8   )   byref  ->  r15         "field V30._reference (fldOffset=0x0)" P-INDEP
+;* V54 tmp34        [V54    ] (  0,  0   )     int  ->  zero-ref    "field V30._length (fldOffset=0x8)" P-INDEP
+;  V55 tmp35        [V55,T14] (  2,  8   )   byref  ->  rdi         "field V32._reference (fldOffset=0x0)" P-INDEP
+;* V56 tmp36        [V56    ] (  0,  0   )     int  ->  zero-ref    "field V32._length (fldOffset=0x8)" P-INDEP
+;  V57 tmp37        [V57,T15] (  2,  8   )   byref  ->  rsi         "field V34._reference (fldOffset=0x0)" P-INDEP
+;* V58 tmp38        [V58    ] (  0,  0   )     int  ->  zero-ref    "field V34._length (fldOffset=0x8)" P-INDEP
+;  V59 tmp39        [V59,T21] (  2,  1   )   byref  ->  rax         single-def "field V36._reference (fldOffset=0x0)" P-INDEP
+;* V60 tmp40        [V60    ] (  0,  0   )     int  ->  zero-ref    "field V36._length (fldOffset=0x8)" P-INDEP
+;  V61 rat0         [V61,T02] (  6, 21   )    long  ->  r10         "Widened IV V09"
 ;
-; Lcl frame size = 0
+; Lcl frame size = 8
 
 G_M53155_IG01:
        push     rbp
        push     r15
+       push     r14
        push     rbx
-       lea      rbp, [rsp+0x10]
-						;; size=9 bbWeight=1 PerfScore 3.50
+       push     rax
+       lea      rbp, [rsp+0x20]
+						;; size=12 bbWeight=1 PerfScore 5.50
 G_M53155_IG02:
        mov      eax, dword ptr [rdi]
-       mov      ecx, dword ptr [rsi]
-       cmp      eax, ecx
-       mov      r8, rdi
-       cmovl    r8, rsi
-       cmovge   rdi, rsi
-       mov      eax, dword ptr [r8]
+       cmp      eax, dword ptr [rsi]
+       mov      rax, rdi
+       cmovl    rax, rsi
        mov      ecx, dword ptr [rdi]
-       mov      dword ptr [rdx], eax
-       xor      esi, esi
+       cmp      ecx, dword ptr [rsi]
+       cmovge   rdi, rsi
+       mov      ecx, dword ptr [rax]
+       mov      esi, dword ptr [rdi]
+       mov      dword ptr [rdx], ecx
+       xor      r8d, r8d
        xor      r9d, r9d
        xor      r10d, r10d
        xor      r11d, r11d
-       test     ecx, ecx
+       test     esi, esi
        jg       SHORT G_M53155_IG06
-						;; size=39 bbWeight=1 PerfScore 12.25
+						;; size=41 bbWeight=1 PerfScore 18.00
 G_M53155_IG03:
-       mov      rbx, rsi
+       mov      rbx, r8
        jmp      SHORT G_M53155_IG07
        align    [0 bytes for IG08]
 						;; size=5 bbWeight=0.50 PerfScore 1.12
 G_M53155_IG04:
        xor      eax, eax
        mov      dword ptr [rdx], eax
-       jmp      SHORT G_M53155_IG11
-						;; size=6 bbWeight=0.50 PerfScore 1.62
+       jmp      G_M53155_IG11
+						;; size=9 bbWeight=0.50 PerfScore 1.62
 G_M53155_IG05:
-       mov      rsi, rbx
+       mov      r8, rbx
 						;; size=3 bbWeight=2 PerfScore 0.50
 G_M53155_IG06:
-       movsxd   rbx, r9d
-       mov      ebx, dword ptr [r8+4*rbx+0x04]
-       add      rsi, rbx
-       movsxd   rbx, r10d
-       mov      ebx, dword ptr [rdi+4*rbx+0x04]
-       add      rsi, rbx
-       mov      rbx, rsi
+       lea      rbx, bword ptr [rax+0x04]
+       cmp      r9d, 116
+       jae      G_M53155_IG12
+       mov      r15d, r9d
+       mov      ebx, dword ptr [rbx+4*r15]
+       add      r8, rbx
+       lea      rbx, bword ptr [rdi+0x04]
+       cmp      r10d, 116
+       jae      G_M53155_IG12
+       mov      ebx, dword ptr [rbx+4*r10]
+       add      r8, rbx
+       mov      rbx, r8
        shr      rbx, 32
-       movsxd   r15, r11d
-       mov      dword ptr [rdx+4*r15+0x04], esi
+       lea      r15, bword ptr [rdx+0x04]
+       cmp      r11d, 116
+       jae      G_M53155_IG12
+       mov      r14d, r11d
+       mov      dword ptr [r15+4*r14], r8d
        inc      r9d
        inc      r10d
        inc      r11d
-       cmp      r10d, ecx
+       cmp      r10d, esi
        jl       SHORT G_M53155_IG05
-						;; size=50 bbWeight=4 PerfScore 36.00
+						;; size=87 bbWeight=4 PerfScore 56.00
 G_M53155_IG07:
-       cmp      r9d, eax
+       cmp      r9d, ecx
        jge      SHORT G_M53155_IG09
 						;; size=5 bbWeight=0.50 PerfScore 0.62
 G_M53155_IG08:
-       movsxd   rcx, r9d
-       mov      ecx, dword ptr [r8+4*rcx+0x04]
-       add      rcx, rbx
-       mov      rbx, rcx
+       lea      rdi, bword ptr [rax+0x04]
+       cmp      r9d, 116
+       jae      SHORT G_M53155_IG12
+       mov      esi, r9d
+       mov      edi, dword ptr [rdi+4*rsi]
+       add      rdi, rbx
+       mov      rbx, rdi
        shr      rbx, 32
-       movsxd   rdi, r11d
-       mov      dword ptr [rdx+4*rdi+0x04], ecx
+       lea      rsi, bword ptr [rdx+0x04]
+       cmp      r11d, 116
+       jae      SHORT G_M53155_IG12
+       mov      r8d, r11d
+       mov      dword ptr [rsi+4*r8], edi
        inc      r9d
        inc      r11d
-       cmp      r9d, eax
+       cmp      r9d, ecx
        jl       SHORT G_M53155_IG08
-						;; size=36 bbWeight=4 PerfScore 25.00
+						;; size=54 bbWeight=4 PerfScore 39.00
 G_M53155_IG09:
        test     rbx, rbx
        je       SHORT G_M53155_IG11
 						;; size=5 bbWeight=1 PerfScore 1.25
 G_M53155_IG10:
-       cmp      eax, 116
-       jae      SHORT G_M53155_IG04
-       movsxd   rax, r11d
-       mov      dword ptr [rdx+4*rax+0x04], 1
+       cmp      ecx, 116
+       jae      G_M53155_IG04
+       lea      rax, bword ptr [rdx+0x04]
+       cmp      r11d, 116
+       jae      SHORT G_M53155_IG12
+       mov      ecx, r11d
+       mov      dword ptr [rax+4*rcx], 1
        inc      dword ptr [rdx]
-						;; size=18 bbWeight=0.50 PerfScore 2.75
+						;; size=31 bbWeight=0.50 PerfScore 3.62
 G_M53155_IG11:
+       add      rsp, 8
        pop      rbx
+       pop      r14
        pop      r15
        pop      rbp
        ret      
-						;; size=5 bbWeight=1 PerfScore 2.50
+						;; size=11 bbWeight=1 PerfScore 3.25
+G_M53155_IG12:
+       call     CORINFO_HELP_RNGCHKFAIL
+       int3     
+						;; size=6 bbWeight=0 PerfScore 0.00
 
-; Total bytes of code 181, prolog size 9, PerfScore 87.12, instruction count 65, allocated bytes for code 181 (MethodHash=2d89305c) for method System.Number+BigInteger:Add(byref,byref,byref) (FullOpts)
+; Total bytes of code 269, prolog size 12, PerfScore 130.50, instruction count 89, allocated bytes for code 269 (MethodHash=2d89305c) for method System.Number+BigInteger:Add(byref,byref,byref) (FullOpts)
 ; ============================================================

61 (19.37 % of base) - System.Number+BigInteger:HeuristicDivide(byref,byref):uint

 ; Assembly listing for method System.Number+BigInteger:HeuristicDivide(byref,byref):uint (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
+; 0 inlinees with PGO data; 30 single block inlinees; 0 inlinees without PGO data
 ; Final local variable assignments
 ;
-;  V00 arg0         [V00,T01] ( 13, 29   )   byref  ->  rbx         single-def
-;  V01 arg1         [V01,T06] (  7, 12   )   byref  ->  r15         single-def
-;  V02 loc0         [V02,T00] ( 15, 36   )     int  ->  r14        
-;  V03 loc1         [V03,T18] (  2,  1   )     int  ->  rax        
-;  V04 loc2         [V04,T16] (  6,  3   )     int  ->  r13        
-;  V05 loc3         [V05,T02] (  5, 16.50)     int  ->  rdi        
-;  V06 loc4         [V06,T12] (  3,  8.50)    long  ->  rsi        
-;  V07 loc5         [V07,T13] (  3,  8.50)    long  ->  rax        
-;  V08 loc6         [V08,T07] (  3, 12   )    long  ->   r8        
-;  V09 loc7         [V09,T08] (  3, 12   )    long  ->   r9        
-;  V10 loc8         [V10,T03] (  5, 16.50)     int  ->  rax        
-;  V11 loc9         [V11,T14] (  3,  8.50)    long  ->  rcx        
-;  V12 loc10        [V12,T09] (  3, 12   )    long  ->  rdi        
-;# V13 OutArgs      [V13    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
-;  V14 cse0         [V14,T17] (  3,  1.50)    long  ->  [rbp-0x28]  spill-single-def "CSE #01: moderate"
-;  V15 cse1         [V15,T10] (  3, 12   )     int  ->  rdi         "CSE #04: moderate"
-;  V16 cse2         [V16,T11] (  3, 12   )     int  ->  rax         "CSE #06: moderate"
-;  V17 cse3         [V17,T04] (  4, 16   )    long  ->  rdx         "CSE #03: aggressive"
-;  V18 cse4         [V18,T05] (  4, 16   )    long  ->  rdx         "CSE #05: aggressive"
-;  V19 cse5         [V19,T15] (  2,  4.50)    long  ->  rcx         hoist "CSE #02: moderate"
+;  V00 arg0         [V00,T24] (  7,  5   )   byref  ->  rbx         single-def
+;  V01 arg1         [V01,T26] (  5,  4   )   byref  ->  rsi         single-def
+;  V02 loc0         [V02,T00] ( 15, 36   )     int  ->  r15        
+;  V03 loc1         [V03,T28] (  3,  1.50)     int  ->  rax        
+;  V04 loc2         [V04,T25] (  6,  6.50)     int  ->  r12        
+;* V05 loc3         [V05    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V06 loc4         [V06    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;  V07 loc5         [V07,T02] (  6, 20.50)     int  ->  rdi        
+;  V08 loc6         [V08,T13] (  3,  8.50)    long  ->  rax        
+;  V09 loc7         [V09,T14] (  3,  8.50)    long  ->  rcx        
+;  V10 loc8         [V10,T09] (  3, 12   )    long  ->  rdx        
+;  V11 loc9         [V11,T10] (  3, 12   )    long  ->   r9        
+;* V12 loc10        [V12    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V13 loc11        [V13    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V14 loc12        [V14    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V15 loc13        [V15    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;  V16 loc14        [V16,T03] (  6, 20.50)     int  ->  rax        
+;  V17 loc15        [V17,T15] (  3,  8.50)    long  ->  rcx        
+;  V18 loc16        [V18,T11] (  3, 12   )    long  ->  rdx        
+;* V19 loc17        [V19    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V20 loc18        [V20    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V21 loc19        [V21    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V22 loc20        [V22    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;# V23 OutArgs      [V23    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
+;  V24 tmp1         [V24,T27] (  2,  2   )     int  ->  rdx         "impAppendStmt"
+;  V25 tmp2         [V25,T08] (  2, 16   )    long  ->  rdx         "impAppendStmt"
+;* V26 tmp3         [V26    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V27 tmp4         [V27    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V28 tmp5         [V28    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V29 tmp6         [V29    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V30 tmp7         [V30    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V31 tmp8         [V31    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V32 tmp9         [V32    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V33 tmp10        [V33    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V34 tmp11        [V34    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V35 tmp12        [V35    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V36 tmp13        [V36    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V37 tmp14        [V37    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V38 tmp15        [V38    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V39 tmp16        [V39    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V40 tmp17        [V40    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V41 tmp18        [V41    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V42 tmp19        [V42    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V43 tmp20        [V43    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V44 tmp21        [V44    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V45 tmp22        [V45    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V46 tmp23        [V46    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V05._reference (fldOffset=0x0)" P-INDEP
+;* V47 tmp24        [V47    ] (  0,  0   )     int  ->  zero-ref    "field V05._length (fldOffset=0x8)" P-INDEP
+;* V48 tmp25        [V48    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V06._reference (fldOffset=0x0)" P-INDEP
+;* V49 tmp26        [V49    ] (  0,  0   )     int  ->  zero-ref    "field V06._length (fldOffset=0x8)" P-INDEP
+;* V50 tmp27        [V50    ] (  0,  0   )   byref  ->  zero-ref    "field V12._reference (fldOffset=0x0)" P-INDEP
+;* V51 tmp28        [V51    ] (  0,  0   )     int  ->  zero-ref    "field V12._length (fldOffset=0x8)" P-INDEP
+;* V52 tmp29        [V52    ] (  0,  0   )   byref  ->  zero-ref    "field V13._reference (fldOffset=0x0)" P-INDEP
+;* V53 tmp30        [V53    ] (  0,  0   )     int  ->  zero-ref    "field V13._length (fldOffset=0x8)" P-INDEP
+;* V54 tmp31        [V54    ] (  0,  0   )   byref  ->  zero-ref    "field V14._reference (fldOffset=0x0)" P-INDEP
+;* V55 tmp32        [V55    ] (  0,  0   )     int  ->  zero-ref    "field V14._length (fldOffset=0x8)" P-INDEP
+;* V56 tmp33        [V56    ] (  0,  0   )   byref  ->  zero-ref    "field V15._reference (fldOffset=0x0)" P-INDEP
+;* V57 tmp34        [V57    ] (  0,  0   )     int  ->  zero-ref    "field V15._length (fldOffset=0x8)" P-INDEP
+;* V58 tmp35        [V58    ] (  0,  0   )   byref  ->  zero-ref    "field V19._reference (fldOffset=0x0)" P-INDEP
+;* V59 tmp36        [V59    ] (  0,  0   )     int  ->  zero-ref    "field V19._length (fldOffset=0x8)" P-INDEP
+;* V60 tmp37        [V60    ] (  0,  0   )   byref  ->  zero-ref    "field V20._reference (fldOffset=0x0)" P-INDEP
+;* V61 tmp38        [V61    ] (  0,  0   )     int  ->  zero-ref    "field V20._length (fldOffset=0x8)" P-INDEP
+;* V62 tmp39        [V62    ] (  0,  0   )   byref  ->  zero-ref    "field V21._reference (fldOffset=0x0)" P-INDEP
+;* V63 tmp40        [V63    ] (  0,  0   )     int  ->  zero-ref    "field V21._length (fldOffset=0x8)" P-INDEP
+;* V64 tmp41        [V64    ] (  0,  0   )   byref  ->  zero-ref    "field V22._reference (fldOffset=0x0)" P-INDEP
+;* V65 tmp42        [V65    ] (  0,  0   )     int  ->  zero-ref    "field V22._length (fldOffset=0x8)" P-INDEP
+;  V66 tmp43        [V66,T30] (  2,  1   )   byref  ->  rdx         single-def "field V27._reference (fldOffset=0x0)" P-INDEP
+;* V67 tmp44        [V67    ] (  0,  0   )     int  ->  zero-ref    "field V27._length (fldOffset=0x8)" P-INDEP
+;  V68 tmp45        [V68,T31] (  2,  1   )   byref  ->  rdi         single-def "field V29._reference (fldOffset=0x0)" P-INDEP
+;* V69 tmp46        [V69    ] (  0,  0   )     int  ->  zero-ref    "field V29._length (fldOffset=0x8)" P-INDEP
+;  V70 tmp47        [V70,T16] (  2,  8   )   byref  ->  rdx         "field V31._reference (fldOffset=0x0)" P-INDEP
+;* V71 tmp48        [V71    ] (  0,  0   )     int  ->  zero-ref    "field V31._length (fldOffset=0x8)" P-INDEP
+;  V72 tmp49        [V72,T17] (  2,  8   )   byref  ->   r9         "field V33._reference (fldOffset=0x0)" P-INDEP
+;* V73 tmp50        [V73    ] (  0,  0   )     int  ->  zero-ref    "field V33._length (fldOffset=0x8)" P-INDEP
+;  V74 tmp51        [V74,T18] (  2,  8   )   byref  ->  rdx         "field V35._reference (fldOffset=0x0)" P-INDEP
+;* V75 tmp52        [V75    ] (  0,  0   )     int  ->  zero-ref    "field V35._length (fldOffset=0x8)" P-INDEP
+;  V76 tmp53        [V76,T19] (  2,  8   )   byref  ->  rdi         "field V37._reference (fldOffset=0x0)" P-INDEP
+;* V77 tmp54        [V77    ] (  0,  0   )     int  ->  zero-ref    "field V37._length (fldOffset=0x8)" P-INDEP
+;  V78 tmp55        [V78,T20] (  2,  8   )   byref  ->  rdx         "field V39._reference (fldOffset=0x0)" P-INDEP
+;* V79 tmp56        [V79    ] (  0,  0   )     int  ->  zero-ref    "field V39._length (fldOffset=0x8)" P-INDEP
+;  V80 tmp57        [V80,T21] (  2,  8   )   byref  ->  rsi         "field V41._reference (fldOffset=0x0)" P-INDEP
+;* V81 tmp58        [V81    ] (  0,  0   )     int  ->  zero-ref    "field V41._length (fldOffset=0x8)" P-INDEP
+;  V82 tmp59        [V82,T22] (  2,  8   )   byref  ->  rsi         "field V43._reference (fldOffset=0x0)" P-INDEP
+;* V83 tmp60        [V83    ] (  0,  0   )     int  ->  zero-ref    "field V43._length (fldOffset=0x8)" P-INDEP
+;  V84 tmp61        [V84,T23] (  2,  8   )   byref  ->  rax         "field V45._reference (fldOffset=0x0)" P-INDEP
+;* V85 tmp62        [V85    ] (  0,  0   )     int  ->  zero-ref    "field V45._length (fldOffset=0x8)" P-INDEP
+;  V86 cse0         [V86,T29] (  3,  1.50)    long  ->  rax         "CSE #01: conservative"
+;  V87 cse1         [V87,T01] (  8, 25   )   byref  ->  r14         "CSE #04: aggressive"
+;  V88 cse2         [V88,T12] (  4,  9   )   byref  ->  r13         "CSE #02: moderate"
+;  V89 cse3         [V89,T04] (  4, 16   )     int  ->  rax         "CSE #06: aggressive"
+;  V90 cse4         [V90,T05] (  4, 16   )     int  ->  rcx         "CSE #08: aggressive"
+;  V91 cse5         [V91,T06] (  4, 16   )    long  ->   r8         "CSE #05: aggressive"
+;  V92 cse6         [V92,T07] (  4, 16   )    long  ->  rdi         "CSE #07: aggressive"
 ;
-; Lcl frame size = 16
+; Lcl frame size = 8
 
 G_M38309_IG01:
        push     rbp
        push     r15
        push     r14
        push     r13
+       push     r12
        push     rbx
-       sub      rsp, 16
+       push     rax
        lea      rbp, [rsp+0x30]
        mov      rbx, rdi
-       mov      r15, rsi
-						;; size=23 bbWeight=1 PerfScore 6.25
+						;; size=19 bbWeight=1 PerfScore 7.75
 G_M38309_IG02:
-       mov      r14d, dword ptr [r15]
-       cmp      dword ptr [rbx], r14d
+       mov      r15d, dword ptr [rsi]
+       cmp      dword ptr [rbx], r15d
        jl       G_M38309_IG15
 						;; size=12 bbWeight=1 PerfScore 6.00
 G_M38309_IG03:
-       lea      eax, [r14-0x01]
-       cdqe     
-       mov      qword ptr [rbp-0x28], rax
-       mov      eax, dword ptr [rbx+4*rax+0x04]
-       mov      rdx, qword ptr [rbp-0x28]
-       mov      edi, dword ptr [r15+4*rdx+0x04]
+       lea      eax, [r15-0x01]
+       lea      r14, bword ptr [rbx+0x04]
+       mov      rdx, r14
+       cmp      eax, 116
+       jae      G_M38309_IG17
+       mov      edx, dword ptr [rdx+4*rax]
+       lea      r13, bword ptr [rsi+0x04]
+       mov      rdi, r13
+       mov      edi, dword ptr [rdi+4*rax]
        inc      edi
+       mov      eax, edx
        xor      edx, edx
        div      edx:eax, edi
-       mov      r13d, eax
-       test     r13d, r13d
-       je       SHORT G_M38309_IG08
-		  ;; NOP compensation instructions of 4 bytes.
+       mov      r12d, eax
+       test     r12d, r12d
+       je       G_M38309_IG08
        xor      edi, edi
-       xor      esi, esi
        xor      eax, eax
-       mov      ecx, r13d
+       xor      ecx, ecx
        align    [0 bytes for IG04]
-						;; size=50 bbWeight=0.50 PerfScore 17.38
+						;; size=59 bbWeight=0.50 PerfScore 17.62
 G_M38309_IG04:
-       movsxd   rdx, edi
-       mov      r8d, dword ptr [r15+4*rdx+0x04]
-       imul     r8, rcx
-       add      r8, rax
-       mov      rax, r8
+       mov      rdx, r13
+       cmp      edi, 116
+       jae      G_M38309_IG17
+       mov      r8d, edi
+       mov      edx, dword ptr [rdx+4*r8]
+       mov      r9d, r12d
+       imul     rdx, r9
+       add      rdx, rcx
+       mov      rcx, rdx
+       shr      rcx, 32
+       mov      r9, r14
+       mov      r9d, dword ptr [r9+4*r8]
+       mov      edx, edx
+       sub      r9, rdx
+       sub      r9, rax
+       mov      rax, r9
        shr      rax, 32
-       mov      r9d, dword ptr [rbx+4*rdx+0x04]
-       mov      r8d, r8d
-       sub      r9, r8
-       sub      r9, rsi
-       mov      rsi, r9
-       shr      rsi, 32
-       and      rsi, 1
-       mov      dword ptr [rbx+4*rdx+0x04], r9d
+       and      rax, 1
+       mov      rdx, r14
+       mov      dword ptr [rdx+4*r8], r9d
        inc      edi
-       cmp      edi, r14d
+       cmp      edi, r15d
        jl       SHORT G_M38309_IG04
-						;; size=59 bbWeight=4 PerfScore 46.00
+						;; size=76 bbWeight=4 PerfScore 55.00
 G_M38309_IG05:
-       test     r14d, r14d
+       test     r15d, r15d
        jle      SHORT G_M38309_IG07
-       align    [11 bytes for IG06]
-						;; size=16 bbWeight=0.25 PerfScore 0.38
+       align    [5 bytes for IG06]
+						;; size=10 bbWeight=0.25 PerfScore 0.38
 G_M38309_IG06:
-       lea      edi, [r14-0x01]
-       movsxd   rsi, edi
-       cmp      dword ptr [rbx+4*rsi+0x04], 0
+       mov      rdi, r14
+       lea      eax, [r15-0x01]
+       cmp      eax, 116
+       jae      G_M38309_IG17
+       mov      ecx, eax
+       cmp      dword ptr [rdi+4*rcx], 0
        jne      SHORT G_M38309_IG07
-       mov      r14d, edi
-       test     r14d, r14d
+       mov      r15d, eax
+       test     r15d, r15d
        jg       SHORT G_M38309_IG06
-						;; size=22 bbWeight=4 PerfScore 25.00
+						;; size=32 bbWeight=4 PerfScore 31.00
 G_M38309_IG07:
-       mov      dword ptr [rbx], r14d
+       mov      dword ptr [rbx], r15d
 						;; size=3 bbWeight=0.50 PerfScore 0.50
 G_M38309_IG08:
        mov      rdi, rbx
-       mov      rsi, r15
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Compare(byref,byref):int
        call     [rax]System.Number+BigInteger:Compare(byref,byref):int
        test     eax, eax
        jl       SHORT G_M38309_IG13
-       inc      r13d
+		  ;; NOP compensation instructions of 4 bytes.
+       inc      r12d
        xor      eax, eax
        xor      ecx, ecx
        align    [0 bytes for IG09]
-						;; size=29 bbWeight=0.50 PerfScore 2.88
+						;; size=30 bbWeight=0.50 PerfScore 2.75
 G_M38309_IG09:
-       movsxd   rdx, eax
-       mov      edi, dword ptr [rbx+4*rdx+0x04]
-       mov      esi, dword ptr [r15+4*rdx+0x04]
-       sub      rdi, rsi
-       sub      rdi, rcx
-       mov      rcx, rdi
+       mov      rdx, r14
+       cmp      eax, 116
+       jae      SHORT G_M38309_IG17
+		  ;; NOP compensation instructions of 4 bytes.
+       mov      edi, eax
+       mov      edx, dword ptr [rdx+4*rdi]
+       mov      rsi, r13
+       mov      esi, dword ptr [rsi+4*rdi]
+       sub      rdx, rsi
+       sub      rdx, rcx
+       mov      rcx, rdx
        shr      rcx, 32
        and      rcx, 1
-       mov      dword ptr [rbx+4*rdx+0x04], edi
+       mov      rsi, r14
+       mov      dword ptr [rsi+4*rdi], edx
        inc      eax
-       cmp      eax, r14d
+       cmp      eax, r15d
        jl       SHORT G_M38309_IG09
-						;; size=40 bbWeight=4 PerfScore 33.00
+						;; size=53 bbWeight=4 PerfScore 41.00
 G_M38309_IG10:
-       test     r14d, r14d
+       test     r15d, r15d
        jle      SHORT G_M38309_IG12
-       align    [0 bytes for IG11]
-						;; size=5 bbWeight=0.25 PerfScore 0.31
+       align    [5 bytes for IG11]
+						;; size=10 bbWeight=0.25 PerfScore 0.38
 G_M38309_IG11:
-       lea      eax, [r14-0x01]
-       movsxd   rcx, eax
-       cmp      dword ptr [rbx+4*rcx+0x04], 0
+       mov      rax, r14
+       lea      ecx, [r15-0x01]
+       cmp      ecx, 116
+       jae      SHORT G_M38309_IG17
+       mov      edx, ecx
+       cmp      dword ptr [rax+4*rdx], 0
        jne      SHORT G_M38309_IG12
-       mov      r14d, eax
-       test     r14d, r14d
+       mov      r15d, ecx
+       test     r15d, r15d
        jg       SHORT G_M38309_IG11
-						;; size=22 bbWeight=4 PerfScore 25.00
+						;; size=28 bbWeight=4 PerfScore 31.00
 G_M38309_IG12:
-       mov      dword ptr [rbx], r14d
+       mov      dword ptr [rbx], r15d
 						;; size=3 bbWeight=0.50 PerfScore 0.50
 G_M38309_IG13:
-       mov      eax, r13d
+       mov      eax, r12d
 						;; size=3 bbWeight=0.50 PerfScore 0.12
 G_M38309_IG14:
-       add      rsp, 16
+       add      rsp, 8
        pop      rbx
+       pop      r12
        pop      r13
        pop      r14
        pop      r15
        pop      rbp
        ret      
-						;; size=13 bbWeight=0.50 PerfScore 1.88
+						;; size=15 bbWeight=0.50 PerfScore 2.12
 G_M38309_IG15:
        xor      eax, eax
 						;; size=2 bbWeight=0.50 PerfScore 0.12
 G_M38309_IG16:
-       add      rsp, 16
+       add      rsp, 8
        pop      rbx
+       pop      r12
        pop      r13
        pop      r14
        pop      r15
        pop      rbp
        ret      
-						;; size=13 bbWeight=0.50 PerfScore 1.88
+						;; size=15 bbWeight=0.50 PerfScore 2.12
+G_M38309_IG17:
+       call     CORINFO_HELP_RNGCHKFAIL
+       int3     
+						;; size=6 bbWeight=0 PerfScore 0.00
 
-; Total bytes of code 315, prolog size 23, PerfScore 167.19, instruction count 106, allocated bytes for code 315 (MethodHash=daac6a5a) for method System.Number+BigInteger:HeuristicDivide(byref,byref):uint (FullOpts)
+; Total bytes of code 376, prolog size 19, PerfScore 198.38, instruction count 129, allocated bytes for code 376 (MethodHash=daac6a5a) for method System.Number+BigInteger:HeuristicDivide(byref,byref):uint (FullOpts)
 ; ============================================================

33 (17.10 % of base) - System.Number+BigInteger:Multiply(byref,uint,byref)

 ; Assembly listing for method System.Number+BigInteger:Multiply(byref,uint,byref) (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 4 single block inlinees; 4 inlinees without PGO data
+; 0 inlinees with PGO data; 19 single block inlinees; 4 inlinees without PGO data
 ; Final local variable assignments
 ;
 ;  V00 arg0         [V00,T04] (  6,  8   )   byref  ->  rdi         single-def
-;  V01 arg1         [V01,T06] (  6,  4   )     int  ->  rsi         single-def
-;  V02 arg2         [V02,T00] ( 14, 15   )   byref  ->  rax         single-def
-;  V03 loc0         [V03,T07] (  5,  6   )     int  ->  rbx        
-;  V04 loc1         [V04,T01] (  6, 17   )     int  ->  rdx        
+;  V01 arg1         [V01,T08] (  6,  4   )     int  ->  rsi         single-def
+;  V02 arg2         [V02,T01] ( 14, 15   )   byref  ->  rax         single-def
+;  V03 loc0         [V03,T09] (  5,  6   )     int  ->  rbx        
+;  V04 loc1         [V04,T00] (  8, 21.50)     int  ->  rdx        
 ;  V05 loc2         [V05,T05] (  5,  9.50)     int  ->  rcx        
-;  V06 loc3         [V06,T12] (  3,  1.50)     int  ->  rdi        
+;  V06 loc3         [V06,T14] (  3,  1.50)     int  ->  rdi        
 ;  V07 loc4         [V07,T02] (  3, 12   )    long  ->  rcx        
-;# V08 OutArgs      [V08    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
-;  V09 tmp1         [V09,T13] (  3,  1.50)     int  ->  rcx         "Inline return value spill temp"
-;  V10 tmp2         [V10,T09] (  4,  4   )    long  ->  rcx         "Inlining Arg"
-;  V11 tmp3         [V11,T11] (  3,  3   )     int  ->  rcx         "Inlining Arg"
-;  V12 tmp4         [V12,T14] (  3,  1.50)     int  ->  rdx         "Inline stloc first use temp"
-;* V13 tmp5         [V13    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
-;* V14 tmp6         [V14    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
-;* V15 tmp7         [V15    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
-;  V16 cse0         [V16,T10] (  5,  3.50)     int  ->  rbx         "CSE #01: moderate"
-;  V17 cse1         [V17,T15] (  3,  1.50)    long  ->  rdx         "CSE #02: moderate"
-;  V18 cse2         [V18,T08] (  4,  5.50)    long  ->  r15         hoist multi-def "CSE #03: aggressive"
-;  V19 cse3         [V19,T03] (  3, 12   )    long  ->  rsi         "CSE #04: aggressive"
+;* V08 loc5         [V08    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V09 loc6         [V09    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V10 loc7         [V10    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;# V11 OutArgs      [V11    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
+;  V12 tmp1         [V12,T15] (  3,  1.50)     int  ->  rcx         "Inline return value spill temp"
+;* V13 tmp2         [V13    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;  V14 tmp3         [V14,T11] (  4,  4   )    long  ->  rcx         "Inlining Arg"
+;  V15 tmp4         [V15,T13] (  3,  3   )     int  ->  rcx         "Inlining Arg"
+;* V16 tmp5         [V16    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V17 tmp6         [V17    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V18 tmp7         [V18    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;  V19 tmp8         [V19,T16] (  3,  1.50)     int  ->  rdx         "Inline stloc first use temp"
+;* V20 tmp9         [V20    ] (  0,  0   )   byref  ->  zero-ref    "impAppendStmt"
+;* V21 tmp10        [V21    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V22 tmp11        [V22    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V23 tmp12        [V23    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
+;* V24 tmp13        [V24    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V25 tmp14        [V25    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V26 tmp15        [V26    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V27 tmp16        [V27    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V28 tmp17        [V28    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V29 tmp18        [V29    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V30 tmp19        [V30    ] (  0,  0   )   byref  ->  zero-ref    "field V08._reference (fldOffset=0x0)" P-INDEP
+;* V31 tmp20        [V31    ] (  0,  0   )     int  ->  zero-ref    "field V08._length (fldOffset=0x8)" P-INDEP
+;* V32 tmp21        [V32    ] (  0,  0   )   byref  ->  zero-ref    "field V09._reference (fldOffset=0x0)" P-INDEP
+;* V33 tmp22        [V33    ] (  0,  0   )     int  ->  zero-ref    "field V09._length (fldOffset=0x8)" P-INDEP
+;* V34 tmp23        [V34    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V10._reference (fldOffset=0x0)" P-INDEP
+;* V35 tmp24        [V35    ] (  0,  0   )     int  ->  zero-ref    "field V10._length (fldOffset=0x8)" P-INDEP
+;  V36 tmp25        [V36,T06] (  2,  8   )   byref  ->  rsi         "field V25._reference (fldOffset=0x0)" P-INDEP
+;* V37 tmp26        [V37    ] (  0,  0   )     int  ->  zero-ref    "field V25._length (fldOffset=0x8)" P-INDEP
+;  V38 tmp27        [V38,T07] (  2,  8   )   byref  ->  rsi         "field V27._reference (fldOffset=0x0)" P-INDEP
+;* V39 tmp28        [V39    ] (  0,  0   )     int  ->  zero-ref    "field V27._length (fldOffset=0x8)" P-INDEP
+;  V40 tmp29        [V40,T18] (  2,  1   )   byref  ->  rdi         single-def "field V29._reference (fldOffset=0x0)" P-INDEP
+;* V41 tmp30        [V41    ] (  0,  0   )     int  ->  zero-ref    "field V29._length (fldOffset=0x8)" P-INDEP
+;  V42 cse0         [V42,T12] (  5,  3.50)     int  ->  rbx         "CSE #01: moderate"
+;  V43 cse1         [V43,T17] (  3,  1.50)    long  ->  rdx         "CSE #02: moderate"
+;  V44 cse2         [V44,T10] (  4,  5.50)    long  ->  r15         hoist multi-def "CSE #03: moderate"
+;  V45 cse3         [V45,T03] (  3, 12   )    long  ->   r8         "CSE #06: aggressive"
 ;
 ; Lcl frame size = 0
 
 G_M6434_IG01:
        push     rbp
        push     r15
        push     rbx
        lea      rbp, [rsp+0x10]
        mov      rax, rdx
 						;; size=12 bbWeight=1 PerfScore 3.75
 G_M6434_IG02:
        mov      ebx, dword ptr [rdi]
        cmp      ebx, 1
-       jle      SHORT G_M6434_IG08
-						;; size=7 bbWeight=1 PerfScore 3.25
+       jle      G_M6434_IG08
+						;; size=11 bbWeight=1 PerfScore 3.25
 G_M6434_IG03:
        cmp      esi, 1
        jbe      SHORT G_M6434_IG07
        xor      edx, edx
        xor      ecx, ecx
        mov      r15d, esi
        align    [0 bytes for IG04]
 						;; size=12 bbWeight=0.50 PerfScore 1.00
 G_M6434_IG04:
-       movsxd   rsi, edx
-       mov      r8d, dword ptr [rdi+4*rsi+0x04]
-       imul     r8, r15
+       lea      rsi, bword ptr [rdi+0x04]
+       cmp      edx, 116
+       jae      G_M6434_IG15
+       mov      r8d, edx
+       mov      esi, dword ptr [rsi+4*r8]
+       imul     rsi, r15
        mov      ecx, ecx
-       add      rcx, r8
+       add      rcx, rsi
        cmp      byte  ptr [rax], al
-       mov      dword ptr [rax+4*rsi+0x04], ecx
+       lea      rsi, bword ptr [rax+0x04]
+       mov      dword ptr [rsi+4*r8], ecx
        shr      rcx, 32
        inc      edx
        cmp      edx, ebx
        jl       SHORT G_M6434_IG04
-						;; size=33 bbWeight=4 PerfScore 43.00
+						;; size=49 bbWeight=4 PerfScore 52.00
 G_M6434_IG05:
        mov      edi, ebx
        test     ecx, ecx
        je       SHORT G_M6434_IG06
        cmp      ebx, 116
        jae      SHORT G_M6434_IG12
-       movsxd   rdi, edx
-       mov      dword ptr [rax+4*rdi+0x04], ecx
+       lea      rdi, bword ptr [rax+0x04]
+       cmp      edx, 116
+       jae      SHORT G_M6434_IG15
+       mov      edx, edx
+       mov      dword ptr [rdi+4*rdx], ecx
        lea      edi, [rbx+0x01]
-						;; size=21 bbWeight=0.50 PerfScore 2.25
+						;; size=28 bbWeight=0.50 PerfScore 3.12
 G_M6434_IG06:
        mov      dword ptr [rax], edi
        jmp      SHORT G_M6434_IG14
 						;; size=4 bbWeight=0.50 PerfScore 1.50
 G_M6434_IG07:
        test     esi, esi
        je       SHORT G_M6434_IG12
        mov      edx, ebx
        mov      dword ptr [rax], edx
        movsxd   rdx, edx
        shl      rdx, 2
        lea      rsi, bword ptr [rdi+0x04]
        lea      rdi, bword ptr [rax+0x04]
        mov      rax, 0xD1FFAB1E      ; code for System.SpanHelpers:Memmove(byref,byref,nuint)
        call     [rax]System.SpanHelpers:Memmove(byref,byref,nuint)
        jmp      SHORT G_M6434_IG14
 						;; size=37 bbWeight=0.50 PerfScore 4.75
 G_M6434_IG08:
        test     ebx, ebx
        jg       SHORT G_M6434_IG09
        xor      ecx, ecx
        jmp      SHORT G_M6434_IG10
 						;; size=8 bbWeight=0.50 PerfScore 1.75
 G_M6434_IG09:
        mov      ecx, dword ptr [rdi+0x04]
 						;; size=3 bbWeight=0.50 PerfScore 1.00
 G_M6434_IG10:
        mov      ecx, ecx
        mov      r15d, esi
        imul     rcx, r15
        mov      rdx, rcx
        shr      rdx, 32
        je       SHORT G_M6434_IG11
        mov      dword ptr [rax+0x04], ecx
        mov      dword ptr [rax+0x08], edx
        mov      dword ptr [rax], 2
        jmp      SHORT G_M6434_IG14
 						;; size=32 bbWeight=0.50 PerfScore 4.62
 G_M6434_IG11:
        test     ecx, ecx
        jne      SHORT G_M6434_IG13
 						;; size=4 bbWeight=0.50 PerfScore 0.62
 G_M6434_IG12:
        xor      ecx, ecx
        mov      dword ptr [rax], ecx
        jmp      SHORT G_M6434_IG14
 						;; size=6 bbWeight=0.50 PerfScore 1.62
 G_M6434_IG13:
        mov      dword ptr [rax+0x04], ecx
        mov      dword ptr [rax], 1
 						;; size=9 bbWeight=0.50 PerfScore 1.00
 G_M6434_IG14:
        pop      rbx
        pop      r15
        pop      rbp
        ret      
 						;; size=5 bbWeight=1 PerfScore 2.50
+G_M6434_IG15:
+       call     CORINFO_HELP_RNGCHKFAIL
+       int3     
+						;; size=6 bbWeight=0 PerfScore 0.00
 
-; Total bytes of code 193, prolog size 12, PerfScore 72.62, instruction count 72, allocated bytes for code 193 (MethodHash=71b0e6dd) for method System.Number+BigInteger:Multiply(byref,uint,byref) (FullOpts)
+; Total bytes of code 226, prolog size 12, PerfScore 82.50, instruction count 81, allocated bytes for code 226 (MethodHash=71b0e6dd) for method System.Number+BigInteger:Multiply(byref,uint,byref) (FullOpts)
 ; ============================================================

24 (27.91 % of base) - System.Number+BigInteger:Multiply10():this

 ; Assembly listing for method System.Number+BigInteger:Multiply10():this (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 2 single block inlinees; 0 inlinees without PGO data
+; 0 inlinees with PGO data; 11 single block inlinees; 0 inlinees without PGO data
 ; Final local variable assignments
 ;
-;  V00 this         [V00,T01] (  8, 12.50)   byref  ->  rdi         this single-def
-;  V01 loc0         [V01,T00] (  6, 17   )     int  ->  rcx        
-;  V02 loc1         [V02,T06] (  4,  5.50)     int  ->  rax        
-;  V03 loc2         [V03,T05] (  5,  9.50)    long  ->  rdx        
+;  V00 this         [V00,T05] (  7,  8.50)   byref  ->  rdi         this single-def
+;  V01 loc0         [V01,T00] (  8, 21.50)     int  ->  rax        
+;  V02 loc1         [V02,T09] (  4,  5.50)     int  ->  rcx        
+;  V03 loc2         [V03,T06] (  5,  9.50)    long  ->  rdx        
 ;  V04 loc3         [V04,T02] (  3, 12   )    long  ->   r8        
 ;  V05 loc4         [V05,T03] (  3, 12   )    long  ->   r8        
-;# V06 OutArgs      [V06    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
-;  V07 cse0         [V07,T07] (  3,  2.50)     int  ->  rax         "CSE #01: aggressive"
-;  V08 cse1         [V08,T04] (  3, 12   )    long  ->  rsi         "CSE #02: aggressive"
+;* V06 loc5         [V06    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V07 loc6         [V07    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V08 loc7         [V08    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;# V09 OutArgs      [V09    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
+;* V10 tmp1         [V10    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V11 tmp2         [V11    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V12 tmp3         [V12    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V13 tmp4         [V13    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V14 tmp5         [V14    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V15 tmp6         [V15    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V16 tmp7         [V16    ] (  0,  0   )   byref  ->  zero-ref    "field V06._reference (fldOffset=0x0)" P-INDEP
+;* V17 tmp8         [V17    ] (  0,  0   )     int  ->  zero-ref    "field V06._length (fldOffset=0x8)" P-INDEP
+;* V18 tmp9         [V18    ] (  0,  0   )   byref  ->  zero-ref    "field V07._reference (fldOffset=0x0)" P-INDEP
+;* V19 tmp10        [V19    ] (  0,  0   )     int  ->  zero-ref    "field V07._length (fldOffset=0x8)" P-INDEP
+;* V20 tmp11        [V20    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V08._reference (fldOffset=0x0)" P-INDEP
+;* V21 tmp12        [V21    ] (  0,  0   )     int  ->  zero-ref    "field V08._length (fldOffset=0x8)" P-INDEP
+;  V22 tmp13        [V22,T07] (  2,  8   )   byref  ->   r8         "field V11._reference (fldOffset=0x0)" P-INDEP
+;* V23 tmp14        [V23    ] (  0,  0   )     int  ->  zero-ref    "field V11._length (fldOffset=0x8)" P-INDEP
+;  V24 tmp15        [V24,T08] (  2,  8   )   byref  ->  r10         "field V13._reference (fldOffset=0x0)" P-INDEP
+;* V25 tmp16        [V25    ] (  0,  0   )     int  ->  zero-ref    "field V13._length (fldOffset=0x8)" P-INDEP
+;  V26 tmp17        [V26,T10] (  2,  1   )   byref  ->  rsi         single-def "field V15._reference (fldOffset=0x0)" P-INDEP
+;* V27 tmp18        [V27    ] (  0,  0   )     int  ->  zero-ref    "field V15._length (fldOffset=0x8)" P-INDEP
+;  V28 cse0         [V28,T01] (  4, 12.50)   byref  ->  rsi         "CSE #02: aggressive"
+;  V29 cse1         [V29,T04] (  3, 12   )    long  ->   r9         "CSE #03: aggressive"
 ;
 ; Lcl frame size = 0
 
 G_M24569_IG01:
        push     rbp
        mov      rbp, rsp
 						;; size=4 bbWeight=1 PerfScore 1.25
 G_M24569_IG02:
-       mov      eax, dword ptr [rdi]
-       test     eax, eax
+       cmp      dword ptr [rdi], 0
        je       SHORT G_M24569_IG07
-						;; size=6 bbWeight=1 PerfScore 3.25
+						;; size=5 bbWeight=1 PerfScore 4.00
 G_M24569_IG03:
-       xor      ecx, ecx
+       xor      eax, eax
+       mov      ecx, dword ptr [rdi]
        xor      edx, edx
-       align    [0 bytes for IG04]
-						;; size=4 bbWeight=0.50 PerfScore 0.25
+       align    [1 bytes for IG04]
+						;; size=7 bbWeight=0.50 PerfScore 1.38
 G_M24569_IG04:
-       movsxd   rsi, ecx
-       mov      r8d, dword ptr [rdi+4*rsi+0x04]
-       lea      r9, [8*r8]
+       lea      rsi, bword ptr [rdi+0x04]
+       mov      r8, rsi
+       cmp      eax, 116
+       jae      SHORT G_M24569_IG08
+       mov      r9d, eax
+       mov      r8d, dword ptr [r8+4*r9]
+       lea      r10, [8*r8]
        add      r8, r8
-       add      r8, r9
+       add      r8, r10
        add      r8, rdx
        mov      rdx, r8
        shr      rdx, 32
-       mov      dword ptr [rdi+4*rsi+0x04], r8d
-       inc      ecx
-       cmp      ecx, eax
+       mov      r10, rsi
+       mov      dword ptr [r10+4*r9], r8d
+       inc      eax
+       cmp      eax, ecx
        jl       SHORT G_M24569_IG04
-						;; size=43 bbWeight=4 PerfScore 27.00
+						;; size=56 bbWeight=4 PerfScore 36.00
 G_M24569_IG05:
        test     rdx, rdx
        je       SHORT G_M24569_IG07
-       cmp      eax, 116
+       cmp      ecx, 116
        jae      SHORT G_M24569_IG06
-       movsxd   rcx, ecx
-       mov      dword ptr [rdi+4*rcx+0x04], edx
-       inc      eax
-       mov      dword ptr [rdi], eax
+       cmp      eax, 116
+       jae      SHORT G_M24569_IG08
+       mov      eax, eax
+       mov      dword ptr [rsi+4*rax], edx
+       inc      ecx
+       mov      dword ptr [rdi], ecx
        jmp      SHORT G_M24569_IG07
-						;; size=23 bbWeight=0.50 PerfScore 3.50
+						;; size=26 bbWeight=0.50 PerfScore 4.12
 G_M24569_IG06:
        xor      eax, eax
        mov      dword ptr [rdi], eax
 						;; size=4 bbWeight=0.50 PerfScore 0.62
 G_M24569_IG07:
        pop      rbp
        ret      
 						;; size=2 bbWeight=1 PerfScore 1.50
+G_M24569_IG08:
+       call     CORINFO_HELP_RNGCHKFAIL
+       int3     
+						;; size=6 bbWeight=0 PerfScore 0.00
 
-; Total bytes of code 86, prolog size 4, PerfScore 37.38, instruction count 33, allocated bytes for code 86 (MethodHash=90daa006) for method System.Number+BigInteger:Multiply10():this (FullOpts)
+; Total bytes of code 110, prolog size 4, PerfScore 48.88, instruction count 42, allocated bytes for code 110 (MethodHash=90daa006) for method System.Number+BigInteger:Multiply10():this (FullOpts)
 ; ============================================================

22 (25.29 % of base) - System.Number+BigInteger:SubtractDivisor(byref,int,byref,ulong):uint

 ; Assembly listing for method System.Number+BigInteger:SubtractDivisor(byref,int,byref,ulong):uint (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
+; 0 inlinees with PGO data; 6 single block inlinees; 0 inlinees without PGO data
 ; Final local variable assignments
 ;
-;  V00 arg0         [V00,T02] (  4, 10   )   byref  ->  rdi         single-def
-;  V01 arg1         [V01,T07] (  3,  6   )     int  ->  rsi         single-def
-;  V02 arg2         [V02,T06] (  4,  7   )   byref  ->  rdx         single-def
-;  V03 arg3         [V03,T08] (  3,  6   )    long  ->  rcx         single-def
-;  V04 loc0         [V04,T09] (  3,  6   )     int  ->  rax        
+;  V00 arg0         [V00,T03] (  4, 10   )   byref  ->  rdi         single-def
+;  V01 arg1         [V01,T08] (  3,  6   )     int  ->  rsi         single-def
+;  V02 arg2         [V02,T07] (  4,  7   )   byref  ->  rdx         single-def
+;  V03 arg3         [V03,T09] (  3,  6   )    long  ->  rcx         single-def
+;  V04 loc0         [V04,T12] (  3,  6   )     int  ->  rax        
 ;  V05 loc1         [V05,T00] (  9, 26   )    long  ->   r8        
-;  V06 loc2         [V06,T01] (  6, 21   )     int  ->   r9        
+;* V06 loc2         [V06,T13] (  0,  0   )     int  ->  zero-ref   
 ;  V07 loc3         [V07,T04] (  3, 12   )     int  ->  r10        
-;  V08 loc4         [V08,T03] (  3, 12   )   byref  ->  r11        
-;# V09 OutArgs      [V09    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
-;  V10 cse0         [V10,T05] (  3, 12   )     int  ->  rbx         "CSE #01: aggressive"
+;* V08 loc4         [V08    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;* V09 loc5         [V09    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.Span`1[uint]>
+;# V10 OutArgs      [V10    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
+;  V11 tmp1         [V11,T02] (  3, 24   )   byref  ->  r11         "dup spill"
+;* V12 tmp2         [V12    ] (  0,  0   )   byref  ->  zero-ref   
+;* V13 tmp3         [V13    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V14 tmp4         [V14    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V15 tmp5         [V15    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V16 tmp6         [V16    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "NewObj constructor temp" <System.Span`1[uint]>
+;* V17 tmp7         [V17    ] (  0,  0   )   byref  ->  zero-ref    "field V08._reference (fldOffset=0x0)" P-INDEP
+;* V18 tmp8         [V18    ] (  0,  0   )     int  ->  zero-ref    "field V08._length (fldOffset=0x8)" P-INDEP
+;* V19 tmp9         [V19    ] (  0,  0   )   byref  ->  zero-ref    "field V09._reference (fldOffset=0x0)" P-INDEP
+;* V20 tmp10        [V20    ] (  0,  0   )     int  ->  zero-ref    "field V09._length (fldOffset=0x8)" P-INDEP
+;  V21 tmp11        [V21,T10] (  2,  8   )   byref  ->  r10         "field V14._reference (fldOffset=0x0)" P-INDEP
+;* V22 tmp12        [V22    ] (  0,  0   )     int  ->  zero-ref    "field V14._length (fldOffset=0x8)" P-INDEP
+;  V23 tmp13        [V23,T11] (  2,  8   )   byref  ->  r11         "field V16._reference (fldOffset=0x0)" P-INDEP
+;* V24 tmp14        [V24    ] (  0,  0   )     int  ->  zero-ref    "field V16._length (fldOffset=0x8)" P-INDEP
+;  V25 cse0         [V25,T05] (  3, 12   )     int  ->  rbx         "CSE #01: moderate"
+;  V26 cse1         [V26,T06] (  3, 12   )     int  ->  rbx         "CSE #02: moderate"
+;  V27 rat0         [V27,T01] (  7, 25   )    long  ->   r9         "Widened IV V06"
 ;
-; Lcl frame size = 0
+; Lcl frame size = 8
 
 G_M8508_IG01:
        push     rbp
        push     rbx
-       lea      rbp, [rsp+0x08]
-						;; size=7 bbWeight=1 PerfScore 2.50
+       push     rax
+       lea      rbp, [rsp+0x10]
+						;; size=8 bbWeight=1 PerfScore 3.50
 G_M8508_IG02:
        mov      eax, dword ptr [rdx]
        xor      r8d, r8d
        xor      r9d, r9d
        test     eax, eax
        jle      SHORT G_M8508_IG06
        align    [0 bytes for IG03]
 						;; size=12 bbWeight=1 PerfScore 3.75
 G_M8508_IG03:
-       movsxd   r10, r9d
-       mov      r10d, dword ptr [rdx+4*r10+0x04]
+       lea      r10, bword ptr [rdx+0x04]
+       cmp      r9d, 116
+       jae      SHORT G_M8508_IG08
+       mov      r10d, dword ptr [r10+4*r9]
        imul     r10, rcx
        add      r8, r10
        mov      r10d, r8d
        shr      r8, 32
        cmp      byte  ptr [rdi], dil
-       lea      r11d, [rsi+r9]
-       movsxd   r11, r11d
-       lea      r11, bword ptr [rdi+4*r11+0x04]
+       lea      r11, bword ptr [rdi+0x04]
+       lea      ebx, [rsi+r9]
+       cmp      ebx, 116
+       jae      SHORT G_M8508_IG08
+       lea      r11, bword ptr [r11+4*rbx]
        mov      ebx, dword ptr [r11]
        cmp      ebx, r10d
        jae      SHORT G_M8508_IG05
-						;; size=45 bbWeight=4 PerfScore 53.00
+						;; size=56 bbWeight=4 PerfScore 63.00
 G_M8508_IG04:
        inc      r8
 						;; size=3 bbWeight=2 PerfScore 0.50
 G_M8508_IG05:
        sub      ebx, r10d
        mov      dword ptr [r11], ebx
        inc      r9d
        cmp      r9d, eax
        jl       SHORT G_M8508_IG03
 						;; size=14 bbWeight=4 PerfScore 11.00
 G_M8508_IG06:
        mov      eax, r8d
 						;; size=3 bbWeight=1 PerfScore 0.25
 G_M8508_IG07:
+       add      rsp, 8
        pop      rbx
        pop      rbp
        ret      
-						;; size=3 bbWeight=1 PerfScore 2.00
+						;; size=7 bbWeight=1 PerfScore 2.25
+G_M8508_IG08:
+       call     CORINFO_HELP_RNGCHKFAIL
+       int3     
+						;; size=6 bbWeight=0 PerfScore 0.00
 
-; Total bytes of code 87, prolog size 7, PerfScore 73.00, instruction count 32, allocated bytes for code 87 (MethodHash=aa03dec3) for method System.Number+BigInteger:SubtractDivisor(byref,int,byref,ulong):uint (FullOpts)
+; Total bytes of code 109, prolog size 8, PerfScore 84.25, instruction count 40, allocated bytes for code 109 (MethodHash=aa03dec3) for method System.Number+BigInteger:SubtractDivisor(byref,int,byref,ulong):uint (FullOpts)
 ; ============================================================

Note: some changes were skipped as they were too large to fit into a comment.

Larger list of diffs: https://gist.github.com/MihuBot/6737ae342b34bbe654007aa36303fc56

[MihuBot]

Top method improvements

-68 (-21.45 % of base) - System.Number+BigInteger:Pow10(uint,byref)

 ; Assembly listing for method System.Number+BigInteger:Pow10(uint,byref) (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 6 single block inlinees; 2 inlinees without PGO data
+; 0 inlinees with PGO data; 9 single block inlinees; 2 inlinees without PGO data
 ; Final local variable assignments
 ;
-;  V00 arg0         [V00,T08] (  3,  3   )     int  ->  rdi         single-def
-;  V01 arg1         [V01,T07] (  3,  3   )   byref  ->  rsi         single-def
-;  V02 loc0         [V02    ] (  4,  2.50)  struct (472) [rbp-0x3E0]  do-not-enreg[XSF] addr-exposed ld-addr-op ptr unsafe-buffer <System.Number+BigInteger>
-;  V03 loc1         [V03,T03] (  6,  9   )   byref  ->  registers   ptr
-;  V04 loc2         [V04    ] (  2,  2   )  struct (472) [rbp-0x208]  do-not-enreg[XSF] addr-exposed ld-addr-op unsafe-buffer <System.Number+BigInteger>
-;  V05 loc3         [V05,T06] (  4,  7   )   byref  ->  registers   ptr
-;* V06 loc4         [V06,T14] (  0,  0   )     int  ->  zero-ref    ptr
+;  V00 arg0         [V00,T00] ( 10, 22   )     int  ->  rbx        
+;  V01 arg1         [V01,T06] (  4,  4   )   byref  ->  r15         single-def
+;  V02 loc0         [V02    ] (  4,  2.50)  struct (472) [rbp-0x200]  do-not-enreg[XSF] addr-exposed ld-addr-op <System.Number+BigInteger>
+;  V03 loc1         [V03,T03] (  6,  9   )   byref  ->  registers  
+;  V04 loc2         [V04    ] (  2,  2   )  struct (472) [rbp-0x3D8]  do-not-enreg[XSF] addr-exposed ld-addr-op <System.Number+BigInteger>
+;  V05 loc3         [V05,T05] (  4,  7   )   byref  ->  registers  
+;* V06 loc4         [V06,T10] (  0,  0   )     int  ->  zero-ref   
 ;* V07 loc5         [V07    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.ReadOnlySpan`1[uint]>
-;  V08 loc6         [V08    ] (  3,  6   )   byref  ->  [rbp-0x3E8]  must-init pinned ptr
+;* V08 loc6         [V08    ] (  0,  0   )   byref  ->  zero-ref   
 ;* V09 loc7         [V09    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.ReadOnlySpan`1[uint]>
 ;* V10 loc8         [V10    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.ReadOnlySpan`1[int]>
-;  V11 loc9         [V11,T10] (  2,  4   )   byref  ->  rsi        
-;  V12 tmp0         [V12,T15] (  1,  1   )     int  ->  [rbp-0x3EC]  do-not-enreg[V] "GSCookie dummy"
-;# V13 OutArgs      [V13    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
-;  V14 tmp2         [V14,T11] (  2,  4   )     int  ->  rdi         "Span.get_Item index"
-;  V15 tmp3         [V15,T02] (  3, 12   )     int  ->  rdi         "Span.get_Item index"
-;  V16 tmp4         [V16,T04] (  2,  8   )   byref  ->  r13         "impSpillLclRefs"
-;* V17 tmp5         [V17    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[uint]>
-;  V18 tmp6         [V18,T09] (  3,  5   )     int  ->  rdi         "Inlining Arg"
-;* V19 tmp7         [V19    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[uint]>
-;* V20 tmp8         [V20    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[int]>
-;  V21 tmp9         [V21,T13] (  3,  3   )     int  ->  rdx         "Inline stloc first use temp"
-;* V22 tmp10        [V22    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
-;* V23 tmp11        [V23    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
-;* V24 tmp12        [V24    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
-;* V25 tmp13        [V25    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V07._reference (fldOffset=0x0)" P-INDEP
-;* V26 tmp14        [V26    ] (  0,  0   )     int  ->  zero-ref    "field V07._length (fldOffset=0x8)" P-INDEP
-;* V27 tmp15        [V27    ] (  0,  0   )   byref  ->  zero-ref    "field V09._reference (fldOffset=0x0)" P-INDEP
-;* V28 tmp16        [V28    ] (  0,  0   )     int  ->  zero-ref    "field V09._length (fldOffset=0x8)" P-INDEP
-;* V29 tmp17        [V29    ] (  0,  0   )   byref  ->  zero-ref    "field V10._reference (fldOffset=0x0)" P-INDEP
-;* V30 tmp18        [V30    ] (  0,  0   )     int  ->  zero-ref    "field V10._length (fldOffset=0x8)" P-INDEP
-;* V31 tmp19        [V31    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V17._reference (fldOffset=0x0)" P-INDEP
-;* V32 tmp20        [V32    ] (  0,  0   )     int  ->  zero-ref    "field V17._length (fldOffset=0x8)" P-INDEP
-;* V33 tmp21        [V33    ] (  0,  0   )   byref  ->  zero-ref    "field V19._reference (fldOffset=0x0)" P-INDEP
-;* V34 tmp22        [V34    ] (  0,  0   )     int  ->  zero-ref    "field V19._length (fldOffset=0x8)" P-INDEP
-;* V35 tmp23        [V35    ] (  0,  0   )   byref  ->  zero-ref    "field V20._reference (fldOffset=0x0)" P-INDEP
-;* V36 tmp24        [V36    ] (  0,  0   )     int  ->  zero-ref    "field V20._length (fldOffset=0x8)" P-INDEP
-;  V37 tmp25        [V37,T05] (  2,  8   )    long  ->  rsi         "Cast away GC"
-;  V38 GsCookie     [V38    ] (  1,  1   )    long  ->  [rbp-0x30]  do-not-enreg[X] addr-exposed "GSSecurityCookie"
-;  V39 tmp27        [V39,T00] (  9, 21   )     int  ->  r15         "shadowVar"
-;  V40 tmp28        [V40,T12] (  3,  3   )   byref  ->  rbx         single-def "shadowVar"
-;  V41 rat0         [V41,T01] (  5, 13   )    long  ->  r12         "Widened IV V06"
+;# V11 OutArgs      [V11    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
+;  V12 tmp1         [V12,T08] (  2,  4   )     int  ->  rsi         "Span.get_Item index"
+;  V13 tmp2         [V13,T02] (  3, 12   )     int  ->  rsi         "Span.get_Item index"
+;  V14 tmp3         [V14,T04] (  2,  8   )   byref  ->  r13         "impSpillLclRefs"
+;* V15 tmp4         [V15    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[uint]>
+;  V16 tmp5         [V16,T07] (  3,  5   )     int  ->  rsi         "Inlining Arg"
+;* V17 tmp6         [V17    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[uint]>
+;* V18 tmp7         [V18    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[int]>
+;  V19 tmp8         [V19,T09] (  3,  3   )     int  ->  rdx         "Inline stloc first use temp"
+;* V20 tmp9         [V20    ] (  0,  0   )   byref  ->  zero-ref    "impAppendStmt"
+;* V21 tmp10        [V21    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V22 tmp11        [V22    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V23 tmp12        [V23    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
+;* V24 tmp13        [V24    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V07._reference (fldOffset=0x0)" P-INDEP
+;* V25 tmp14        [V25    ] (  0,  0   )     int  ->  zero-ref    "field V07._length (fldOffset=0x8)" P-INDEP
+;* V26 tmp15        [V26    ] (  0,  0   )   byref  ->  zero-ref    "field V09._reference (fldOffset=0x0)" P-INDEP
+;* V27 tmp16        [V27    ] (  0,  0   )     int  ->  zero-ref    "field V09._length (fldOffset=0x8)" P-INDEP
+;* V28 tmp17        [V28    ] (  0,  0   )   byref  ->  zero-ref    "field V10._reference (fldOffset=0x0)" P-INDEP
+;* V29 tmp18        [V29    ] (  0,  0   )     int  ->  zero-ref    "field V10._length (fldOffset=0x8)" P-INDEP
+;* V30 tmp19        [V30    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V15._reference (fldOffset=0x0)" P-INDEP
+;* V31 tmp20        [V31    ] (  0,  0   )     int  ->  zero-ref    "field V15._length (fldOffset=0x8)" P-INDEP
+;* V32 tmp21        [V32    ] (  0,  0   )   byref  ->  zero-ref    "field V17._reference (fldOffset=0x0)" P-INDEP
+;* V33 tmp22        [V33    ] (  0,  0   )     int  ->  zero-ref    "field V17._length (fldOffset=0x8)" P-INDEP
+;* V34 tmp23        [V34    ] (  0,  0   )   byref  ->  zero-ref    "field V18._reference (fldOffset=0x0)" P-INDEP
+;* V35 tmp24        [V35    ] (  0,  0   )     int  ->  zero-ref    "field V18._length (fldOffset=0x8)" P-INDEP
+;  V36 rat0         [V36,T01] (  5, 13   )    long  ->  r12         "Widened IV V06"
 ;
-; Lcl frame size = 968
+; Lcl frame size = 952
 
 G_M21633_IG01:
        push     rbp
        push     r15
        push     r14
        push     r13
        push     r12
        push     rbx
-       sub      rsp, 968
-       lea      rbp, [rsp+0x3F0]
-       xor      eax, eax
-       mov      qword ptr [rbp-0x3E8], rax
-       mov      qword ptr [rbp-0x30], 0xD1FFAB1E
-						;; size=42 bbWeight=1 PerfScore 9.00
+       sub      rsp, 952
+       lea      rbp, [rsp+0x3E0]
+       mov      ebx, edi
+       mov      r15, rsi
+						;; size=30 bbWeight=1 PerfScore 7.25
 G_M21633_IG02:
-       mov      rbx, rsi
-       mov      r15d, edi
-       mov      edi, r15d
-       and      edi, 7
-       mov      rsi, 0xD1FFAB1E      ; static handle
-       mov      edi, dword ptr [rsi+4*rdi]
-       test     edi, edi
+       mov      esi, ebx
+       and      esi, 7
+       mov      rdi, 0xD1FFAB1E      ; static handle
+       mov      esi, dword ptr [rdi+4*rsi]
+       test     esi, esi
        je       SHORT G_M21633_IG04
-						;; size=29 bbWeight=1 PerfScore 4.50
+						;; size=22 bbWeight=1 PerfScore 4.00
 G_M21633_IG03:
-       mov      dword ptr [rbp-0x3DC], edi
-       mov      dword ptr [rbp-0x3E0], 1
+       mov      dword ptr [rbp-0x1FC], esi
+       mov      dword ptr [rbp-0x200], 1
        jmp      SHORT G_M21633_IG05
 						;; size=18 bbWeight=0.50 PerfScore 2.00
 G_M21633_IG04:
-       xor      edi, edi
-       mov      dword ptr [rbp-0x3E0], edi
+       xor      esi, esi
+       mov      dword ptr [rbp-0x200], esi
 						;; size=8 bbWeight=0.50 PerfScore 0.62
 G_M21633_IG05:
-       lea      r14, bword ptr [rbp-0x3E0]
-       xor      edi, edi
-       mov      dword ptr [rbp-0x208], edi
-       lea      r13, bword ptr [rbp-0x208]
-       shr      r15d, 3
-						;; size=26 bbWeight=1 PerfScore 2.75
+       lea      r14, bword ptr [rbp-0x200]
+       xor      esi, esi
+       mov      dword ptr [rbp-0x3D8], esi
+       lea      r13, bword ptr [rbp-0x3D8]
+       shr      ebx, 3
+						;; size=25 bbWeight=1 PerfScore 2.75
 G_M21633_IG06:
        xor      r12d, r12d
-       test     r15d, r15d
+       test     ebx, ebx
        je       SHORT G_M21633_IG10
-						;; size=8 bbWeight=1 PerfScore 1.50
+						;; size=7 bbWeight=1 PerfScore 1.50
 G_M21633_IG07:
-       test     r15b, 1
+       test     bl, 1
        je       SHORT G_M21633_IG09
-						;; size=6 bbWeight=4 PerfScore 5.00
+						;; size=5 bbWeight=4 PerfScore 5.00
 G_M21633_IG08:
        cmp      r12d, 8
-       jae      G_M21633_IG13
-       mov      rdi, 0xD1FFAB1E      ; static handle
-       mov      edi, dword ptr [rdi+4*r12]
-       cmp      edi, 234
-       jae      G_M21633_IG13
+       jae      SHORT G_M21633_IG12
        mov      rsi, 0xD1FFAB1E      ; static handle
-       lea      rdi, bword ptr [rsi+4*rdi]
-       mov      bword ptr [rbp-0x3E8], rdi
-       mov      rsi, bword ptr [rbp-0x3E8]
+       mov      esi, dword ptr [rsi+4*r12]
+       cmp      esi, 234
+       jae      SHORT G_M21633_IG12
+       mov      rdi, 0xD1FFAB1E      ; static handle
+       lea      rsi, bword ptr [rdi+4*rsi]
        mov      rdi, r14
        mov      rdx, r13
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,byref,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,byref,byref)
-       xor      edx, edx
-       mov      bword ptr [rbp-0x3E8], rdx
        mov      rax, r13
        mov      r13, r14
        mov      r14, rax
-						;; size=100 bbWeight=2 PerfScore 26.50
+						;; size=69 bbWeight=2 PerfScore 20.00
 G_M21633_IG09:
        inc      r12d
-       shr      r15d, 1
+       shr      ebx, 1
        jne      SHORT G_M21633_IG07
-						;; size=8 bbWeight=4 PerfScore 7.00
+						;; size=7 bbWeight=4 PerfScore 7.00
 G_M21633_IG10:
        mov      edx, dword ptr [r14]
-       mov      dword ptr [rbx], edx
+       mov      dword ptr [r15], edx
        movsxd   rdx, edx
        shl      rdx, 2
        lea      rsi, bword ptr [r14+0x04]
-       lea      rdi, bword ptr [rbx+0x04]
+       lea      rdi, bword ptr [r15+0x04]
        mov      rax, 0xD1FFAB1E      ; code for System.SpanHelpers:Memmove(byref,byref,nuint)
        call     [rax]System.SpanHelpers:Memmove(byref,byref,nuint)
-       cmp      qword ptr [rbp-0x30], 0xD1FFAB1E
-       je       SHORT G_M21633_IG11
-       call     CORINFO_HELP_FAIL_FAST
-						;; size=47 bbWeight=1 PerfScore 12.00
-G_M21633_IG11:
        nop      
-						;; size=1 bbWeight=1 PerfScore 0.25
-G_M21633_IG12:
-       add      rsp, 968
+						;; size=34 bbWeight=1 PerfScore 8.25
+G_M21633_IG11:
+       add      rsp, 952
        pop      rbx
        pop      r12
        pop      r13
        pop      r14
        pop      r15
        pop      rbp
        ret      
 						;; size=18 bbWeight=1 PerfScore 4.25
-G_M21633_IG13:
+G_M21633_IG12:
        call     CORINFO_HELP_RNGCHKFAIL
        int3     
 						;; size=6 bbWeight=0 PerfScore 0.00
 
-; Total bytes of code 317, prolog size 42, PerfScore 75.38, instruction count 78, allocated bytes for code 317 (MethodHash=8392ab7e) for method System.Number+BigInteger:Pow10(uint,byref) (FullOpts)
+; Total bytes of code 249, prolog size 30, PerfScore 62.62, instruction count 68, allocated bytes for code 249 (MethodHash=8392ab7e) for method System.Number+BigInteger:Pow10(uint,byref) (FullOpts)
 ; ============================================================

-25 (-10.16 % of base) - System.Number+BigInteger:MultiplyPow10(uint):this

 ; Assembly listing for method System.Number+BigInteger:MultiplyPow10(uint):this (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; partially interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 4 single block inlinees; 3 inlinees without PGO data
+; 0 inlinees with PGO data; 7 single block inlinees; 3 inlinees without PGO data
 ; Final local variable assignments
 ;
-;  V00 this         [V00,T01] (  3,  3   )   byref  ->  rdi         this single-def
-;  V01 arg1         [V01,T02] (  3,  3   )     int  ->  rsi         single-def
+;  V00 this         [V00,T00] ( 10,  6   )   byref  ->  rbx         this single-def
+;  V01 arg1         [V01,T01] (  5,  4   )     int  ->  rdi         single-def
 ;* V02 loc0         [V02    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op <System.ReadOnlySpan`1[uint]>
-;  V03 loc1         [V03    ] (  4,  2   )  struct (472) [rbp-0x1F0]  do-not-enreg[XSF] addr-exposed ld-addr-op unsafe-buffer <System.Number+BigInteger>
-;  V04 tmp0         [V04,T07] (  1,  1   )     int  ->  [rbp-0x3CC]  do-not-enreg[V] "GSCookie dummy"
-;# V05 OutArgs      [V05    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
-;* V06 tmp2         [V06    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[uint]>
-;* V07 tmp3         [V07    ] (  0,  0   )     int  ->  zero-ref    "Inlining Arg"
-;  V08 tmp4         [V08    ] (  3,  1.50)  struct (472) [rbp-0x3C8]  do-not-enreg[XSF] addr-exposed ld-addr-op ptr unsafe-buffer "Inline ldloca(s) first use temp" <System.Number+BigInteger>
-;  V09 tmp5         [V09,T06] (  2,  1   )     int  ->  rsi         "Inline return value spill temp"
-;  V10 tmp6         [V10,T04] (  3,  1.50)     int  ->  rdx         "Inline stloc first use temp"
+;  V03 loc1         [V03    ] (  4,  2   )  struct (472) [rbp-0x1E8]  do-not-enreg[XSF] addr-exposed ld-addr-op <System.Number+BigInteger>
+;# V04 OutArgs      [V04    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
+;* V05 tmp1         [V05    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[uint]>
+;* V06 tmp2         [V06    ] (  0,  0   )     int  ->  zero-ref    "Inlining Arg"
+;  V07 tmp3         [V07    ] (  3,  1.50)  struct (472) [rbp-0x3C0]  do-not-enreg[XSF] addr-exposed ld-addr-op "Inline ldloca(s) first use temp" <System.Number+BigInteger>
+;  V08 tmp4         [V08,T04] (  2,  1   )     int  ->  rsi         "Inline return value spill temp"
+;  V09 tmp5         [V09,T02] (  3,  1.50)     int  ->  rdx         "Inline stloc first use temp"
+;* V10 tmp6         [V10    ] (  0,  0   )   byref  ->  zero-ref    "impAppendStmt"
 ;* V11 tmp7         [V11    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
 ;* V12 tmp8         [V12    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
 ;* V13 tmp9         [V13    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V02._reference (fldOffset=0x0)" P-INDEP
 ;* V14 tmp10        [V14    ] (  0,  0   )     int  ->  zero-ref    "field V02._length (fldOffset=0x8)" P-INDEP
-;* V15 tmp11        [V15    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V06._reference (fldOffset=0x0)" P-INDEP
-;* V16 tmp12        [V16    ] (  0,  0   )     int  ->  zero-ref    "field V06._length (fldOffset=0x8)" P-INDEP
-;  V17 GsCookie     [V17    ] (  1,  1   )    long  ->  [rbp-0x18]  do-not-enreg[X] addr-exposed "GSSecurityCookie"
-;  V18 tmp14        [V18,T00] (  9,  5   )   byref  ->  rbx         single-def "shadowVar"
-;  V19 tmp15        [V19,T03] (  4,  3   )     int  ->  rax         "shadowVar"
-;  V20 cse0         [V20,T05] (  3,  1.50)     int  ->  r15         "CSE #01: moderate"
+;* V15 tmp11        [V15    ] (  0,  0   )   byref  ->  zero-ref    single-def "field V05._reference (fldOffset=0x0)" P-INDEP
+;* V16 tmp12        [V16    ] (  0,  0   )     int  ->  zero-ref    "field V05._length (fldOffset=0x8)" P-INDEP
+;  V17 cse0         [V17,T03] (  3,  1.50)     int  ->  r15         "CSE #01: moderate"
 ;
-; Lcl frame size = 960
+; Lcl frame size = 944
 
 G_M34615_IG01:
        push     rbp
        push     r15
        push     rbx
-       sub      rsp, 960
-       lea      rbp, [rsp+0x3D0]
-       mov      qword ptr [rbp-0x18], 0xD1FFAB1E
-						;; size=27 bbWeight=1 PerfScore 4.75
-G_M34615_IG02:
-       mov      eax, esi
+       sub      rsp, 944
+       lea      rbp, [rsp+0x3C0]
        mov      rbx, rdi
-       cmp      eax, 9
+       mov      edi, esi
+						;; size=24 bbWeight=1 PerfScore 4.25
+G_M34615_IG02:
+       cmp      edi, 9
        jbe      G_M34615_IG05
-						;; size=14 bbWeight=1 PerfScore 1.75
+						;; size=9 bbWeight=1 PerfScore 1.25
 G_M34615_IG03:
        cmp      dword ptr [rbx], 0
        je       G_M34615_IG06
-       lea      rsi, [rbp-0x1F0]
-       mov      edi, eax
+       lea      rsi, [rbp-0x1E8]
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Pow10(uint,byref)
        call     [rax]System.Number+BigInteger:Pow10(uint,byref)
-       mov      r15d, dword ptr [rbp-0x1F0]
+       mov      r15d, dword ptr [rbp-0x1E8]
        cmp      r15d, 1
        jle      SHORT G_M34615_IG04
        mov      edx, dword ptr [rbx]
-       mov      dword ptr [rbp-0x3C8], edx
+       mov      dword ptr [rbp-0x3C0], edx
        movsxd   rdx, edx
        shl      rdx, 2
        lea      rsi, bword ptr [rbx+0x04]
-       lea      rdi, [rbp-0x3C4]
+       lea      rdi, [rbp-0x3BC]
        mov      rax, 0xD1FFAB1E      ; code for System.SpanHelpers:Memmove(byref,byref,nuint)
        call     [rax]System.SpanHelpers:Memmove(byref,byref,nuint)
-       lea      rdi, [rbp-0x3C8]
-       lea      rsi, [rbp-0x1F0]
+       lea      rdi, [rbp-0x3C0]
+       lea      rsi, [rbp-0x1E8]
        mov      rdx, rbx
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,byref,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,byref,byref)
        jmp      SHORT G_M34615_IG06
-						;; size=112 bbWeight=0.50 PerfScore 12.38
+						;; size=110 bbWeight=0.50 PerfScore 12.25
 G_M34615_IG04:
        xor      esi, esi
        test     r15d, r15d
-       cmovg    esi, dword ptr [rbp-0x1EC]
+       cmovg    esi, dword ptr [rbp-0x1E4]
        mov      rdi, rbx
        mov      rdx, rbx
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,uint,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,uint,byref)
        jmp      SHORT G_M34615_IG06
 						;; size=32 bbWeight=0.50 PerfScore 4.12
 G_M34615_IG05:
-       mov      esi, eax
+       mov      esi, edi
        mov      rdi, 0xD1FFAB1E      ; static handle
        mov      esi, dword ptr [rdi+4*rsi]
        mov      rdi, rbx
        mov      rdx, rbx
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,uint,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,uint,byref)
 						;; size=33 bbWeight=0.50 PerfScore 3.12
 G_M34615_IG06:
-       cmp      qword ptr [rbp-0x18], 0xD1FFAB1E
-       je       SHORT G_M34615_IG07
-       call     CORINFO_HELP_FAIL_FAST
-						;; size=15 bbWeight=1 PerfScore 4.00
-G_M34615_IG07:
        nop      
 						;; size=1 bbWeight=1 PerfScore 0.25
-G_M34615_IG08:
-       add      rsp, 960
+G_M34615_IG07:
+       add      rsp, 944
        pop      rbx
        pop      r15
        pop      rbp
        ret      
 						;; size=12 bbWeight=1 PerfScore 2.75
 
-; Total bytes of code 246, prolog size 27, PerfScore 33.12, instruction count 57, allocated bytes for code 246 (MethodHash=b6b678c8) for method System.Number+BigInteger:MultiplyPow10(uint):this (FullOpts)
+; Total bytes of code 221, prolog size 19, PerfScore 28.00, instruction count 52, allocated bytes for code 221 (MethodHash=b6b678c8) for method System.Number+BigInteger:MultiplyPow10(uint):this (FullOpts)
 ; ============================================================

-24 (-6.74 % of base) - System.Number:AccumulateDecimalDigitsIntoBigInteger(byref,uint,uint,byref)

 ; Assembly listing for method System.Number:AccumulateDecimalDigitsIntoBigInteger(byref,uint,uint,byref) (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; partially interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 7 single block inlinees; 5 inlinees without PGO data
+; 0 inlinees with PGO data; 10 single block inlinees; 5 inlinees without PGO data
 ; Final local variable assignments
 ;
-;  V00 arg0         [V00,T08] (  3,  3   )   byref  ->  rdi         single-def
-;  V01 arg1         [V01,T10] (  3,  3   )     int  ->  rsi         single-def
-;  V02 arg2         [V02,T11] (  3,  3   )     int  ->  rdx         single-def
-;  V03 arg3         [V03,T09] (  3,  3   )   byref  ->  rcx         single-def
+;  V00 arg0         [V00,T09] (  3,  3   )   byref  ->  rdi         single-def
+;  V01 arg1         [V01,T05] (  4,  4   )     int  ->  rsi         single-def
+;  V02 arg2         [V02,T10] (  3,  3   )     int  ->  rdx         single-def
+;  V03 arg3         [V03,T00] ( 12, 23   )   byref  ->  rbx         single-def
 ;  V04 loc0         [V04,T03] (  4, 13   )    long  ->  r15        
 ;  V05 loc1         [V05,T02] (  7, 20   )     int  ->  r14        
-;* V06 loc2         [V06    ] (  0,  0   )     int  ->  zero-ref    ptr
+;* V06 loc2         [V06    ] (  0,  0   )     int  ->  zero-ref   
 ;  V07 loc3         [V07,T04] (  2,  8   )     int  ->  r12        
 ;# V08 OutArgs      [V08    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
 ;* V09 tmp1         [V09    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "Inlining Arg" <System.Span`1[byte]>
-;  V10 tmp2         [V10,T00] (  8, 24   )     int  ->  r13         "Inline return value spill temp"
-;  V11 tmp3         [V11    ] (  4,  8   )  struct (472) [rbp-0x208]  do-not-enreg[XSF] addr-exposed ld-addr-op unsafe-buffer "Inline ldloca(s) first use temp" <System.Number+BigInteger>
+;  V10 tmp2         [V10,T01] (  8, 24   )     int  ->  r13         "Inline return value spill temp"
+;  V11 tmp3         [V11    ] (  4,  8   )  struct (472) [rbp-0x200]  do-not-enreg[XSF] addr-exposed ld-addr-op "Inline ldloca(s) first use temp" <System.Number+BigInteger>
 ;* V12 tmp4         [V12    ] (  0,  0   )  struct (16) zero-ref    ld-addr-op "Inline stloc first use temp" <System.ReadOnlySpan`1[uint]>
-;  V13 tmp5         [V13,T17] (  1,  1   )     int  ->  [rbp-0x3E4]  do-not-enreg[V] "GSCookie dummy for inlinee"
-;* V14 tmp6         [V14    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[uint]>
-;* V15 tmp7         [V15    ] (  0,  0   )     int  ->  zero-ref    "Inlining Arg"
-;  V16 tmp8         [V16    ] (  3,  6   )  struct (472) [rbp-0x3E0]  do-not-enreg[XSF] addr-exposed ld-addr-op ptr unsafe-buffer "Inline ldloca(s) first use temp" <System.Number+BigInteger>
-;  V17 tmp9         [V17,T05] (  3,  6   )     int  ->  rsi         "Inline return value spill temp"
-;  V18 tmp10        [V18,T06] (  3,  6   )     int  ->  rdx         "Inline stloc first use temp"
+;* V13 tmp5         [V13    ] (  0,  0   )  struct (16) zero-ref    "ReadOnlySpan<T> for CreateSpan<T>" <System.ReadOnlySpan`1[uint]>
+;* V14 tmp6         [V14    ] (  0,  0   )     int  ->  zero-ref    "Inlining Arg"
+;  V15 tmp7         [V15    ] (  3,  6   )  struct (472) [rbp-0x3D8]  do-not-enreg[XSF] addr-exposed ld-addr-op "Inline ldloca(s) first use temp" <System.Number+BigInteger>
+;  V16 tmp8         [V16,T06] (  3,  6   )     int  ->  rsi         "Inline return value spill temp"
+;  V17 tmp9         [V17,T07] (  3,  6   )     int  ->  rdx         "Inline stloc first use temp"
+;* V18 tmp10        [V18    ] (  0,  0   )   byref  ->  zero-ref    "impAppendStmt"
 ;* V19 tmp11        [V19    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
 ;* V20 tmp12        [V20    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
-;  V21 tmp13        [V21,T14] (  2,  2   )   byref  ->  r15         single-def "field V09._reference (fldOffset=0x0)" P-INDEP
+;  V21 tmp13        [V21,T12] (  2,  2   )   byref  ->  r15         single-def "field V09._reference (fldOffset=0x0)" P-INDEP
 ;* V22 tmp14        [V22    ] (  0,  0   )     int  ->  zero-ref    "field V09._length (fldOffset=0x8)" P-INDEP
 ;* V23 tmp15        [V23    ] (  0,  0   )   byref  ->  zero-ref    "field V12._reference (fldOffset=0x0)" P-INDEP
 ;* V24 tmp16        [V24    ] (  0,  0   )     int  ->  zero-ref    "field V12._length (fldOffset=0x8)" P-INDEP
-;* V25 tmp17        [V25    ] (  0,  0   )   byref  ->  zero-ref    "field V14._reference (fldOffset=0x0)" P-INDEP
-;* V26 tmp18        [V26    ] (  0,  0   )     int  ->  zero-ref    "field V14._length (fldOffset=0x8)" P-INDEP
-;  V27 tmp19        [V27,T12] (  2,  4   )    long  ->  r15         "Cast away GC"
-;  V28 GsCookie     [V28    ] (  1,  1   )    long  ->  [rbp-0x30]  do-not-enreg[X] addr-exposed "GSSecurityCookie"
-;  V29 tmp21        [V29,T15] (  2,  2   )   byref  ->  rdi         single-def "shadowVar"
-;  V30 tmp22        [V30,T13] (  3,  3   )     int  ->  rsi         "shadowVar"
-;  V31 tmp23        [V31,T16] (  2,  2   )     int  ->  rdx         "shadowVar"
-;  V32 tmp24        [V32,T01] ( 11, 22   )   byref  ->  rbx         single-def "shadowVar"
-;  V33 cse0         [V33,T07] (  3,  6   )     int  ->  rax         "CSE #01: aggressive"
+;* V25 tmp17        [V25    ] (  0,  0   )   byref  ->  zero-ref    "field V13._reference (fldOffset=0x0)" P-INDEP
+;* V26 tmp18        [V26    ] (  0,  0   )     int  ->  zero-ref    "field V13._length (fldOffset=0x8)" P-INDEP
+;  V27 tmp19        [V27,T11] (  2,  4   )    long  ->  r15         "Cast away GC"
+;  V28 cse0         [V28,T08] (  3,  6   )     int  ->  rax         "CSE #01: moderate"
 ;
-; Lcl frame size = 968
+; Lcl frame size = 952
 
 G_M44268_IG01:
        push     rbp
        push     r15
        push     r14
        push     r13
        push     r12
        push     rbx
-       sub      rsp, 968
-       lea      rbp, [rsp+0x3F0]
-       mov      qword ptr [rbp-0x30], 0xD1FFAB1E
-						;; size=33 bbWeight=1 PerfScore 7.75
-G_M44268_IG02:
+       sub      rsp, 952
+       lea      rbp, [rsp+0x3E0]
        mov      rbx, rcx
+						;; size=28 bbWeight=1 PerfScore 7.00
+G_M44268_IG02:
        xor      eax, eax
        mov      dword ptr [rbx], eax
        mov      r15, bword ptr [rdi+0x10]
        mov      r14d, esi
        add      r15, r14
        mov      r14d, edx
        sub      r14d, esi
        je       G_M44268_IG13
-						;; size=29 bbWeight=1 PerfScore 5.50
+						;; size=26 bbWeight=1 PerfScore 5.25
 G_M44268_IG03:
        cmp      r14d, 9
        ja       SHORT G_M44268_IG05
 						;; size=6 bbWeight=4 PerfScore 5.00
 G_M44268_IG04:
        mov      r13d, r14d
        jmp      SHORT G_M44268_IG06
 						;; size=5 bbWeight=2 PerfScore 4.50
 G_M44268_IG05:
        mov      r13d, 9
 						;; size=6 bbWeight=2 PerfScore 0.50
 G_M44268_IG06:
        mov      rdi, r15
        mov      esi, r13d
        mov      rax, 0xD1FFAB1E      ; code for System.Number:DigitsToUInt32(ptr,int):uint
        call     [rax]System.Number:DigitsToUInt32(ptr,int):uint
        mov      r12d, eax
        cmp      r13d, 9
        jbe      G_M44268_IG11
 						;; size=31 bbWeight=4 PerfScore 21.00
 G_M44268_IG07:
        cmp      dword ptr [rbx], 0
        je       G_M44268_IG12
-       lea      rsi, [rbp-0x208]
+       lea      rsi, [rbp-0x200]
        mov      edi, r13d
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Pow10(uint,byref)
        call     [rax]System.Number+BigInteger:Pow10(uint,byref)
-       mov      eax, dword ptr [rbp-0x208]
+       mov      eax, dword ptr [rbp-0x200]
        cmp      eax, 1
        jle      SHORT G_M44268_IG08
        mov      edx, dword ptr [rbx]
-       mov      dword ptr [rbp-0x3E0], edx
+       mov      dword ptr [rbp-0x3D8], edx
        movsxd   rdx, edx
        shl      rdx, 2
        lea      rsi, bword ptr [rbx+0x04]
-       lea      rdi, [rbp-0x3DC]
+       lea      rdi, [rbp-0x3D4]
        mov      rax, 0xD1FFAB1E      ; code for System.SpanHelpers:Memmove(byref,byref,nuint)
        call     [rax]System.SpanHelpers:Memmove(byref,byref,nuint)
-       lea      rdi, [rbp-0x3E0]
-       lea      rsi, [rbp-0x208]
+       lea      rdi, [rbp-0x3D8]
+       lea      rsi, [rbp-0x200]
        mov      rdx, rbx
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,byref,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,byref,byref)
        jmp      SHORT G_M44268_IG12
 						;; size=111 bbWeight=2 PerfScore 49.50
 G_M44268_IG08:
        test     eax, eax
        jg       SHORT G_M44268_IG09
        xor      esi, esi
        jmp      SHORT G_M44268_IG10
 						;; size=8 bbWeight=2 PerfScore 7.00
 G_M44268_IG09:
-       mov      esi, dword ptr [rbp-0x204]
+       mov      esi, dword ptr [rbp-0x1FC]
 						;; size=6 bbWeight=2 PerfScore 2.00
 G_M44268_IG10:
        mov      rdi, rbx
        mov      rdx, rbx
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,uint,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,uint,byref)
        jmp      SHORT G_M44268_IG12
 						;; size=20 bbWeight=2 PerfScore 11.50
 G_M44268_IG11:
        mov      esi, r13d
        mov      rdi, 0xD1FFAB1E      ; static handle
        mov      esi, dword ptr [rdi+4*rsi]
        mov      rdi, rbx
        mov      rdx, rbx
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,uint,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,uint,byref)
 						;; size=34 bbWeight=2 PerfScore 12.50
 G_M44268_IG12:
        mov      rdi, rbx
        mov      esi, r12d
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Add(uint):this
        call     [rax]System.Number+BigInteger:Add(uint):this
-       mov      r9d, r13d
-       add      r15, r9
+       mov      eax, r13d
+       add      r15, rax
        sub      r14d, r13d
        jne      G_M44268_IG03
 						;; size=33 bbWeight=4 PerfScore 22.00
 G_M44268_IG13:
-       cmp      qword ptr [rbp-0x30], 0xD1FFAB1E
-       je       SHORT G_M44268_IG14
-       call     CORINFO_HELP_FAIL_FAST
-						;; size=15 bbWeight=1 PerfScore 4.00
-G_M44268_IG14:
-       nop      
-						;; size=1 bbWeight=1 PerfScore 0.25
-G_M44268_IG15:
-       add      rsp, 968
+       add      rsp, 952
        pop      rbx
        pop      r12
        pop      r13
        pop      r14
        pop      r15
        pop      rbp
        ret      
 						;; size=18 bbWeight=1 PerfScore 4.25
 
-; Total bytes of code 356, prolog size 33, PerfScore 157.25, instruction count 90, allocated bytes for code 356 (MethodHash=93865313) for method System.Number:AccumulateDecimalDigitsIntoBigInteger(byref,uint,uint,byref) (FullOpts)
+; Total bytes of code 332, prolog size 25, PerfScore 152.00, instruction count 85, allocated bytes for code 332 (MethodHash=93865313) for method System.Number:AccumulateDecimalDigitsIntoBigInteger(byref,uint,uint,byref) (FullOpts)
 ; ============================================================

-23 (-13.53 % of base) - System.Number+BigInteger:Multiply(byref):this

 ; Assembly listing for method System.Number+BigInteger:Multiply(byref):this (FullOpts)
 ; Emitting BLENDED_CODE for generic X64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; partially interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 1 single block inlinees; 2 inlinees without PGO data
+; 0 inlinees with PGO data; 4 single block inlinees; 2 inlinees without PGO data
 ; Final local variable assignments
 ;
-;  V00 this         [V00,T00] (  3,  3   )   byref  ->  rdi         this single-def
-;  V01 arg1         [V01,T01] (  3,  3   )   byref  ->  rsi         single-def
-;  V02 loc0         [V02    ] (  3,  1.50)  struct (472) [rbp-0x1F8]  do-not-enreg[XSF] addr-exposed ld-addr-op ptr unsafe-buffer <System.Number+BigInteger>
-;  V03 tmp0         [V03,T07] (  1,  1   )     int  ->  [rbp-0x1FC]  do-not-enreg[V] "GSCookie dummy"
-;# V04 OutArgs      [V04    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
-;  V05 tmp2         [V05,T05] (  3,  1.50)     int  ->  rsi         "Inline return value spill temp"
-;  V06 tmp3         [V06,T06] (  3,  1.50)     int  ->  rdx         "Inline stloc first use temp"
-;* V07 tmp4         [V07    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
-;* V08 tmp5         [V08    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
-;  V09 GsCookie     [V09    ] (  1,  1   )    long  ->  [rbp-0x20]  do-not-enreg[X] addr-exposed "GSSecurityCookie"
-;  V10 tmp7         [V10,T02] (  6,  3.50)   byref  ->  r15         single-def "shadowVar"
-;  V11 tmp8         [V11,T03] (  4,  3   )   byref  ->  rbx         single-def "shadowVar"
-;  V12 cse0         [V12,T04] (  3,  2.50)     int  ->  r14         "CSE #01: aggressive"
+;  V00 this         [V00,T00] (  7,  4.50)   byref  ->  rbx         this single-def
+;  V01 arg1         [V01,T01] (  5,  4   )   byref  ->  r15         single-def
+;  V02 loc0         [V02    ] (  3,  1.50)  struct (472) [rbp-0x1F0]  do-not-enreg[XSF] addr-exposed ld-addr-op <System.Number+BigInteger>
+;# V03 OutArgs      [V03    ] (  1,  1   )  struct ( 0) [rsp+0x00]  do-not-enreg[XS] addr-exposed "OutgoingArgSpace" <Empty>
+;  V04 tmp1         [V04,T03] (  3,  1.50)     int  ->  rsi         "Inline return value spill temp"
+;* V05 tmp2         [V05    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;  V06 tmp3         [V06,T04] (  3,  1.50)     int  ->  rdx         "Inline stloc first use temp"
+;* V07 tmp4         [V07    ] (  0,  0   )   byref  ->  zero-ref    "impAppendStmt"
+;* V08 tmp5         [V08    ] (  0,  0   )   byref  ->  zero-ref    "Inlining Arg"
+;* V09 tmp6         [V09    ] (  0,  0   )    long  ->  zero-ref    "Inlining Arg"
+;  V10 cse0         [V10,T02] (  3,  2.50)     int  ->  r14         "CSE #01: aggressive"
 ;
-; Lcl frame size = 488
+; Lcl frame size = 472
 
 G_M32594_IG01:
        push     rbp
        push     r15
        push     r14
        push     rbx
-       sub      rsp, 488
-       lea      rbp, [rsp+0x200]
-       mov      qword ptr [rbp-0x20], 0xD1FFAB1E
-						;; size=29 bbWeight=1 PerfScore 5.75
+       sub      rsp, 472
+       lea      rbp, [rsp+0x1F0]
+       mov      rbx, rdi
+       mov      r15, rsi
+						;; size=27 bbWeight=1 PerfScore 5.25
 G_M32594_IG02:
-       mov      rbx, rsi
-       mov      r15, rdi
-       mov      r14d, dword ptr [rbx]
+       mov      r14d, dword ptr [r15]
        cmp      r14d, 1
        jle      SHORT G_M32594_IG04
-						;; size=15 bbWeight=1 PerfScore 3.75
+						;; size=9 bbWeight=1 PerfScore 3.25
 G_M32594_IG03:
-       mov      edx, dword ptr [r15]
-       mov      dword ptr [rbp-0x1F8], edx
+       mov      edx, dword ptr [rbx]
+       mov      dword ptr [rbp-0x1F0], edx
        movsxd   rdx, edx
        shl      rdx, 2
-       lea      rsi, bword ptr [r15+0x04]
-       lea      rdi, [rbp-0x1F4]
+       lea      rsi, bword ptr [rbx+0x04]
+       lea      rdi, [rbp-0x1EC]
        mov      rax, 0xD1FFAB1E      ; code for System.SpanHelpers:Memmove(byref,byref,nuint)
        call     [rax]System.SpanHelpers:Memmove(byref,byref,nuint)
-       lea      rdi, [rbp-0x1F8]
-       mov      rsi, rbx
-       mov      rdx, r15
+       lea      rdi, [rbp-0x1F0]
+       mov      rsi, r15
+       mov      rdx, rbx
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,byref,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,byref,byref)
        jmp      SHORT G_M32594_IG07
-						;; size=66 bbWeight=0.50 PerfScore 7.12
+						;; size=65 bbWeight=0.50 PerfScore 7.12
 G_M32594_IG04:
        test     r14d, r14d
        jg       SHORT G_M32594_IG05
        xor      esi, esi
        jmp      SHORT G_M32594_IG06
 						;; size=9 bbWeight=0.50 PerfScore 1.75
 G_M32594_IG05:
-       mov      esi, dword ptr [rbx+0x04]
-						;; size=3 bbWeight=0.50 PerfScore 1.00
+       mov      esi, dword ptr [r15+0x04]
+						;; size=4 bbWeight=0.50 PerfScore 1.00
 G_M32594_IG06:
-       mov      rdi, r15
-       mov      rdx, r15
+       mov      rdi, rbx
+       mov      rdx, rbx
        mov      rax, 0xD1FFAB1E      ; code for System.Number+BigInteger:Multiply(byref,uint,byref)
        call     [rax]System.Number+BigInteger:Multiply(byref,uint,byref)
 						;; size=18 bbWeight=0.50 PerfScore 1.88
 G_M32594_IG07:
-       cmp      qword ptr [rbp-0x20], 0xD1FFAB1E
-       je       SHORT G_M32594_IG08
-       call     CORINFO_HELP_FAIL_FAST
-						;; size=15 bbWeight=1 PerfScore 4.00
-G_M32594_IG08:
        nop      
 						;; size=1 bbWeight=1 PerfScore 0.25
-G_M32594_IG09:
-       add      rsp, 488
+G_M32594_IG08:
+       add      rsp, 472
        pop      rbx
        pop      r14
        pop      r15
        pop      rbp
        ret      
 						;; size=14 bbWeight=1 PerfScore 3.25
 
-; Total bytes of code 170, prolog size 29, PerfScore 28.75, instruction count 45, allocated bytes for code 170 (MethodHash=bc9980ad) for method System.Number+BigInteger:Multiply(byref):this (FullOpts)
+; Total bytes of code 147, prolog size 21, PerfScore 23.75, instruction count 41, allocated bytes for code 147 (MethodHash=bc9980ad) for method System.Number+BigInteger:Multiply(byref):this (FullOpts)
 ; ============================================================

Note: some changes were skipped as they were too large to fit into a comment.

Larger list of diffs: https://gist.github.com/MihuBot/07ba208c69d2e93f84ffbbd5a124b867

[MihuBot]

@tannergooding