## Top method regressions

<details>
<summary>800 (211.64 % of base) - StackExchange.Redis.Format:MeasureUInt64(ulong):int</summary>

```diff
 ; Assembly listing for method StackExchange.Redis.Format:MeasureUInt64(ulong):int (FullOpts)
 ; Emitting BLENDED_CODE for x64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 42 single block inlinees; 36 inlinees without PGO data
+; 0 inlinees with PGO data; 41 single block inlinees; 36 inlinees without PGO data
 
 G_M000_IG01:
        push     rbp
-       sub      rsp, 48
-       lea      rbp, [rsp+0x30]
+       push     r15
+       push     r14
+       push     r13
+       push     r12
+       push     rbx
+       sub      rsp, 56
+       lea      rbp, [rsp+0x60]
        mov      rax, 0xD1FFAB1E
-       mov      qword ptr [rbp-0x08], rax
+       mov      qword ptr [rbp-0x30], rax
+       mov      rbx, rdi
  
 G_M000_IG02:
-       lea      rax, [rbp-0x20]
-       mov      rdx, rdi
+       lea      r15, [rbp-0x48]
+       mov      word  ptr [rbp-0x58], 0
+       movzx    r14, byte  ptr [rbp-0x58]
+       movzx    r13, byte  ptr [rbp-0x57]
+       mov      esi, r14d
+       or       esi, r13d
+       je       G_M000_IG24
+ 
+G_M000_IG03:
+       mov      r12d, r14d
+       or       r12d, 32
+       cmp      r12d, 103
+       jle      G_M000_IG07
+       cmp      r12d, 110
+       jne      SHORT G_M000_IG04
+       mov      rsi, r15
+       mov      edx, 20
+       lea      rcx, [rbp-0x50]
+       mov      rdi, rbx
+       movzx    r8, word  ptr [rbp-0x58]
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Buffers.Text.FormattingHelpers:TryFormat[ulong](ulong,System.Span`1[byte],byref,System.Buffers.StandardFormat):bool
+       jmp      G_M000_IG35
+ 
+G_M000_IG04:
+       cmp      r12d, 114
+       je       G_M000_IG08
+       cmp      r12d, 120
+       jne      G_M000_IG43
+       add      r14d, -33
+       movzx    rcx, r14w
+       xor      edi, edi
+       cmp      r13d, 255
+       cmove    r13d, edi
+       mov      edi, 1
+       test     r13d, r13d
+       cmovle   r13d, edi
+       mov      rdi, rbx
+       or       rdi, 1
+       lzcnt    rdi, rdi
+       xor      edi, 63
+       sar      edi, 2
+       inc      edi
+       cmp      r13d, edi
+       mov      esi, edi
+       cmovge   esi, r13d
+       cmp      esi, 20
+       jg       SHORT G_M000_IG05
+       mov      dword ptr [rbp-0x50], esi
+       cmp      esi, 20
+       ja       G_M000_IG42
+       mov      rdi, r15
+       mov      rdx, rbx
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Number:Int64ToHexChars[byte](System.Span`1[byte],ulong,int)
+       mov      eax, 1
+       jmp      SHORT G_M000_IG06
+ 
+G_M000_IG05:
+       xor      eax, eax
+       mov      dword ptr [rbp-0x50], eax
+ 
+G_M000_IG06:
+       jmp      G_M000_IG35
+ 
+G_M000_IG07:
+       cmp      r12d, 100
+       je       SHORT G_M000_IG09
+       cmp      r12d, 103
+       jne      G_M000_IG43
+ 
+G_M000_IG08:
+       lea      rdi, [rbp-0x58]
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Buffers.StandardFormat:get_HasPrecision():bool:this
+       test     eax, eax
+       jne      G_M000_IG44
+ 
+G_M000_IG09:
+       movzx    rax, byte  ptr [rbp-0x57]
+       xor      edx, edx
+       cmp      eax, 255
+       cmove    eax, edx
+       mov      rdx, rbx
        or       rdx, 1
        lzcnt    rdx, rdx
        xor      edx, 63
-       mov      r9, 0xD1FFAB1E
-       movzx    r9, byte  ptr [r9+rdx]
+       mov      rcx, 0xD1FFAB1E
+       movzx    rdx, byte  ptr [rcx+rdx]
+       mov      rcx, 0xD1FFAB1E
+       cmp      rbx, qword ptr [rcx+8*rdx]
+       setb     cl
+       movzx    rcx, cl
+       sub      edx, ecx
+       cmp      eax, edx
+       mov      ecx, edx
+       cmovge   ecx, eax
+       cmp      ecx, 20
+       jle      SHORT G_M000_IG11
+       xor      ecx, ecx
+       mov      dword ptr [rbp-0x50], ecx
+ 
+G_M000_IG10:
+       jmp      SHORT G_M000_IG17
+ 
+G_M000_IG11:
+       mov      dword ptr [rbp-0x50], ecx
+       cmp      eax, edx
+       jle      G_M000_IG20
+       cmp      rbx, 100
+       jae      SHORT G_M000_IG19
+ 
+G_M000_IG12:
+       mov      rdi, rbx
+       jmp      SHORT G_M000_IG14
+       align    [8 bytes for IG13]
+ 
+G_M000_IG13:
+       dec      eax
        mov      rdx, 0xD1FFAB1E
-       cmp      rdi, qword ptr [rdx+8*r9]
+       mulx     rdx, rdx, rdi
+       shr      rdx, 3
+       lea      rsi, [rdx+4*rdx]
+       add      rsi, rsi
+       mov      r8, rdi
+       sub      r8, rsi
+       mov      rdi, rdx
+       dec      ecx
+       cmp      ecx, 20
+       jae      G_M000_IG46
+       mov      edx, ecx
+       add      r8d, 48
+       mov      byte  ptr [r15+rdx], r8b
+ 
+G_M000_IG14:
+       test     rdi, rdi
+       jne      SHORT G_M000_IG13
+ 
+G_M000_IG15:
+       test     eax, eax
+       jg       SHORT G_M000_IG13
+ 
+G_M000_IG16:
+       mov      ecx, 1
+ 
+G_M000_IG17:
+       mov      eax, ecx
+       jmp      G_M000_IG35
+ 
+G_M000_IG18:
+       mov      rbx, rdi
+ 
+G_M000_IG19:
+       add      ecx, -2
+       add      eax, -2
+       mov      rdi, 0xD1FFAB1E
+       mov      rdx, rbx
+       shr      rdx, 2
+       mulx     rdx, rdx, rdi
+       shr      rdx, 2
+       imul     rdi, rdx, 100
+       sub      rbx, rdi
+       mov      rdi, rdx
+       cmp      ecx, 20
+       ja       G_M000_IG42
+       mov      edx, ecx
+       add      rdx, r15
+       cmp      ebx, 100
+       jae      G_M000_IG46
+       mov      esi, ebx
+       mov      r8, 0xD1FFAB1E
+       movzx    rsi, word  ptr [r8+2*rsi]
+       mov      word  ptr [rdx], si
+       cmp      rdi, 100
+       jae      SHORT G_M000_IG18
+       jmp      SHORT G_M000_IG14
+ 
+G_M000_IG20:
+       mov      rax, r15
+       mov      rdi, rbx
+       cmp      rdi, 10
+       jb       G_M000_IG41
+ 
+G_M000_IG21:
+       cmp      rdi, 100
+       jae      G_M000_IG39
+ 
+G_M000_IG22:
+       mov      rdx, rdi
+       jmp      G_M000_IG40
+ 
+G_M000_IG23:
+       add      ecx, -2
+       cmp      ecx, 20
+       ja       G_M000_IG42
+       mov      edx, 20
+       sub      edx, ecx
+       cmp      edx, 2
+       jb       G_M000_IG42
+       add      rax, rcx
+       mov      ecx, edi
+       cmp      ecx, 100
+       jae      G_M000_IG46
+       mov      rdx, 0xD1FFAB1E
+       movzx    rcx, word  ptr [rdx+2*rcx]
+       mov      word  ptr [rax], cx
+       jmp      G_M000_IG16
+ 
+G_M000_IG24:
+       mov      rdx, rbx
+       or       rdx, 1
+       lzcnt    rdx, rdx
+       xor      edx, 63
+       mov      rax, 0xD1FFAB1E
+       movzx    rax, byte  ptr [rax+rdx]
+       mov      rdx, 0xD1FFAB1E
+       cmp      rbx, qword ptr [rdx+8*rax]
        setb     dl
        movzx    rdx, dl
-       sub      r9d, edx
-       cmp      r9d, 20
-       jle      SHORT G_M000_IG05
+       sub      eax, edx
+       cmp      eax, 20
+       jle      SHORT G_M000_IG26
+       xor      eax, eax
+       mov      dword ptr [rbp-0x50], eax
  
-G_M000_IG03:
-       xor      r9d, r9d
-       mov      dword ptr [rbp-0x28], r9d
+G_M000_IG25:
+       jmp      G_M000_IG35
  
-G_M000_IG04:
-       jmp      SHORT G_M000_IG10
+G_M000_IG26:
+       mov      dword ptr [rbp-0x50], eax
+       mov      rcx, rbx
+       cmp      rcx, 10
+       jb       G_M000_IG33
  
-G_M000_IG05:
-       mov      dword ptr [rbp-0x28], r9d
-       cmp      rdi, 10
-       jb       G_M000_IG16
+G_M000_IG27:
+       cmp      rcx, 100
+       jae      SHORT G_M000_IG31
  
-G_M000_IG06:
-       cmp      rdi, 100
-       jae      SHORT G_M000_IG14
+G_M000_IG28:
+       mov      rdx, rcx
+       jmp      G_M000_IG32
  
-G_M000_IG07:
-       mov      rcx, rdi
-       jmp      G_M000_IG15
- 
-G_M000_IG08:
-       add      r9d, -2
-       mov      ecx, r9d
-       add      rcx, 2
-       cmp      rcx, 20
-       ja       G_M000_IG17
-       add      rax, r9
-       mov      r9d, edi
+G_M000_IG29:
+       add      eax, -2
+       cmp      eax, 20
+       ja       G_M000_IG42
+       mov      rdx, rcx
+       add      rax, r15
+       mov      r9d, edx
        cmp      r9d, 100
-       jae      G_M000_IG19
+       jae      G_M000_IG46
        mov      rcx, 0xD1FFAB1E
        movzx    r9, word  ptr [rcx+2*r9]
        mov      word  ptr [rax], r9w
+       jmp      SHORT G_M000_IG34
  
-G_M000_IG09:
-       mov      r9d, 1
+G_M000_IG30:
+       mov      rcx, rdx
  
-G_M000_IG10:
-       test     r9d, r9d
-       je       G_M000_IG18
-       mov      eax, dword ptr [rbp-0x28]
+G_M000_IG31:
+       add      eax, -2
+       mov      rdi, 0xD1FFAB1E
+       mov      rdx, rcx
+       shr      rdx, 2
+       mulx     rdx, rdx, rdi
+       shr      rdx, 2
+       imul     rdi, rdx, 100
+       sub      rcx, rdi
+       cmp      eax, 20
+       ja       G_M000_IG42
+       mov      edi, eax
+       add      rdi, r15
+       cmp      ecx, 100
+       jae      G_M000_IG46
+       mov      ecx, ecx
+       mov      rsi, 0xD1FFAB1E
+       movzx    rcx, word  ptr [rsi+2*rcx]
+       mov      word  ptr [rdi], cx
+       cmp      rdx, 100
+       jae      SHORT G_M000_IG30
+ 
+G_M000_IG32:
+       cmp      rdx, 10
+       mov      rcx, rdx
+       jae      G_M000_IG29
+ 
+G_M000_IG33:
+       dec      eax
+       cmp      eax, 20
+       jae      G_M000_IG46
+       add      ecx, 48
+       mov      byte  ptr [r15+rax], cl
+ 
+G_M000_IG34:
+       mov      eax, 1
+ 
+G_M000_IG35:
+       test     eax, eax
+       je       G_M000_IG45
+       mov      eax, dword ptr [rbp-0x50]
        mov      r9, 0xD1FFAB1E
-       cmp      qword ptr [rbp-0x08], r9
-       je       SHORT G_M000_IG11
+       cmp      qword ptr [rbp-0x30], r9
+       je       SHORT G_M000_IG36
        call     CORINFO_HELP_FAIL_FAST
  
-G_M000_IG11:
+G_M000_IG36:
        nop      
  
-G_M000_IG12:
-       add      rsp, 48
+G_M000_IG37:
+       add      rsp, 56
+       pop      rbx
+       pop      r12
+       pop      r13
+       pop      r14
+       pop      r15
        pop      rbp
        ret      
  
-G_M000_IG13:
-       mov      rdi, rcx
+G_M000_IG38:
+       mov      rdi, rdx
  
-G_M000_IG14:
-       add      r9d, -2
-       mov      rcx, 0xD1FFAB1E
+G_M000_IG39:
+       add      ecx, -2
+       mov      rsi, 0xD1FFAB1E
        mov      rdx, rdi
        shr      rdx, 2
-       mulx     rcx, rcx, rcx
-       shr      rcx, 2
-       imul     rdx, rcx, 100
-       sub      rdi, rdx
-       mov      edx, r9d
-       lea      rsi, [rdx+0x02]
-       cmp      rsi, 20
-       ja       SHORT G_M000_IG17
-       add      rdx, rax
+       mulx     rdx, rdx, rsi
+       shr      rdx, 2
+       imul     rsi, rdx, 100
+       sub      rdi, rsi
+       cmp      ecx, 20
+       ja       SHORT G_M000_IG42
+       mov      esi, ecx
+       add      rsi, rax
        cmp      edi, 100
-       jae      SHORT G_M000_IG19
+       jae      SHORT G_M000_IG46
        mov      edi, edi
-       mov      rsi, 0xD1FFAB1E
-       movzx    rdi, word  ptr [rsi+2*rdi]
-       mov      word  ptr [rdx], di
-       cmp      rcx, 100
-       jae      SHORT G_M000_IG13
+       mov      r8, 0xD1FFAB1E
+       movzx    rdi, word  ptr [r8+2*rdi]
+       mov      word  ptr [rsi], di
+       cmp      rdx, 100
+       jae      SHORT G_M000_IG38
  
-G_M000_IG15:
-       cmp      rcx, 10
-       mov      rdi, rcx
-       jae      G_M000_IG08
+G_M000_IG40:
+       cmp      rdx, 10
+       mov      rdi, rdx
+       jae      G_M000_IG23
  
-G_M000_IG16:
-       dec      r9d
-       cmp      r9d, 20
-       jae      SHORT G_M000_IG19
+G_M000_IG41:
+       dec      ecx
+       cmp      ecx, 20
+       jae      SHORT G_M000_IG46
        add      edi, 48
-       mov      byte  ptr [rax+r9], dil
-       jmp      G_M000_IG09
+       mov      byte  ptr [rax+rcx], dil
+       jmp      G_M000_IG16
  
-G_M000_IG17:
+G_M000_IG42:
        mov      rax, 0xD1FFAB1E
        call     [rax]System.ThrowHelper:ThrowArgumentOutOfRangeException()
        int3     
  
-G_M000_IG18:
+G_M000_IG43:
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.ThrowHelper:ThrowFormatException_BadFormatSpecifier()
+       int3     
+ 
+G_M000_IG44:
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Buffers.Text.Utf8Formatter:ThrowGWithPrecisionNotSupported()
+       int3     
+ 
+G_M000_IG45:
        mov      rax, 0xD1FFAB1E
        call     [rax]StackExchange.Redis.Format:ThrowFormatFailed()
        int3     
  
-G_M000_IG19:
+G_M000_IG46:
        call     CORINFO_HELP_RNGCHKFAIL
        int3     
  
-; Total bytes of code 378 for method StackExchange.Redis.Format:MeasureUInt64(ulong):int (FullOpts)
+; Total bytes of code 1178 for method StackExchange.Redis.Format:MeasureUInt64(ulong):int (FullOpts)
 
```

</details>


<details>
<summary>568 (99.13 % of base) - StackExchange.Redis.Format:FormatInt32(int,System.Span`1[byte]):int</summary>

```diff
 ; Assembly listing for method StackExchange.Redis.Format:FormatInt32(int,System.Span`1[byte]):int (FullOpts)
 ; Emitting BLENDED_CODE for x64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
-; 0 inlinees with PGO data; 38 single block inlinees; 36 inlinees without PGO data
+; 0 inlinees with PGO data; 37 single block inlinees; 36 inlinees without PGO data
 
 G_M000_IG01:
        push     rbp
+       push     r15
+       push     r14
+       push     r13
+       push     r12
        push     rbx
-       push     rax
-       lea      rbp, [rsp+0x10]
+       sub      rsp, 24
+       lea      rbp, [rsp+0x40]
+       mov      ebx, edi
+       mov      r14, rsi
+       mov      r15d, edx
  
 G_M000_IG02:
-       test     edi, edi
-       jl       G_M000_IG11
+       mov      word  ptr [rbp-0x38], 0
+       movzx    r13, byte  ptr [rbp-0x38]
+       movzx    rdx, byte  ptr [rbp-0x37]
+       mov      esi, r13d
+       or       esi, edx
+       je       G_M000_IG18
  
 G_M000_IG03:
-       mov      eax, edi
-       or       eax, 1
-       lzcnt    eax, eax
-       xor      eax, 31
-       mov      ecx, edi
-       mov      r8, 0xD1FFAB1E
-       add      rcx, qword ptr [r8+8*rax]
-       sar      rcx, 32
-       cmp      ecx, edx
+       mov      r12d, r13d
+       or       r12d, 32
+       cmp      r12d, 103
        jle      SHORT G_M000_IG05
-       xor      ecx, ecx
-       mov      dword ptr [rbp-0x10], ecx
+       cmp      r12d, 110
+       jne      SHORT G_M000_IG04
+       mov      rsi, r14
+       mov      edx, r15d
+       lea      rcx, [rbp-0x30]
+       mov      edi, ebx
+       movzx    r8, word  ptr [rbp-0x38]
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Buffers.Text.FormattingHelpers:TryFormat[int](int,System.Span`1[byte],byref,System.Buffers.StandardFormat):bool
+       jmp      G_M000_IG37
  
 G_M000_IG04:
-       jmp      SHORT G_M000_IG10
+       cmp      r12d, 114
+       je       SHORT G_M000_IG06
+       cmp      r12d, 120
+       jne      G_M000_IG44
+       add      r13d, -33
+       movzx    rsi, r13w
+       xor      ecx, ecx
+       cmp      edx, 255
+       cmove    edx, ecx
+       mov      rcx, r14
+       mov      r8d, r15d
+       mov      edi, ebx
+       lea      r9, [rbp-0x30]
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Number:TryInt32ToHexStr[byte](int,char,int,System.Span`1[byte],byref):bool
+       jmp      G_M000_IG37
  
 G_M000_IG05:
-       mov      dword ptr [rbp-0x10], ecx
-       cmp      edi, 10
-       jb       G_M000_IG28
+       cmp      r12d, 100
+       je       SHORT G_M000_IG07
+       cmp      r12d, 103
+       jne      G_M000_IG44
  
 G_M000_IG06:
-       cmp      edi, 100
-       jae      G_M000_IG25
+       lea      rdi, [rbp-0x38]
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Buffers.StandardFormat:get_HasPrecision():bool:this
+       test     eax, eax
+       jne      G_M000_IG45
  
 G_M000_IG07:
-       mov      r8d, edi
+       test     ebx, ebx
+       jl       SHORT G_M000_IG08
+       movzx    rsi, byte  ptr [rbp-0x37]
+       xor      edx, edx
+       cmp      esi, 255
+       cmove    esi, edx
+       mov      rdx, r14
+       mov      ecx, r15d
+       lea      r8, [rbp-0x30]
+       mov      edi, ebx
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Number:TryUInt32ToDecStr[byte](uint,int,System.Span`1[byte],byref):bool
+       jmp      G_M000_IG37
  
 G_M000_IG08:
-       cmp      r8d, 10
-       mov      edi, r8d
-       jb       G_M000_IG28
-       add      ecx, -2
-       mov      eax, ecx
-       add      rax, 2
-       mov      edx, edx
-       cmp      rax, rdx
-       ja       G_M000_IG29
+       movzx    rsi, byte  ptr [rbp-0x37]
+       xor      eax, eax
+       cmp      esi, 255
+       cmovne   eax, esi
+       mov      ecx, 1
+       test     eax, eax
+       cmovle   eax, ecx
+       mov      ecx, ebx
+       neg      ecx
        mov      edx, ecx
-       add      rdx, rsi
-       mov      eax, edi
-       mov      rcx, 0xD1FFAB1E
-       movzx    rax, word  ptr [rcx+2*rax]
-       mov      word  ptr [rdx], ax
+       or       edx, 1
+       lzcnt    edx, edx
+       xor      edx, 31
+       mov      rdi, 0xD1FFAB1E
+       add      rcx, qword ptr [rdi+8*rdx]
+       sar      rcx, 32
+       cmp      eax, ecx
+       cmovge   ecx, eax
+       inc      ecx
+       cmp      ecx, r15d
+       jg       G_M000_IG16
+       mov      dword ptr [rbp-0x30], ecx
+       mov      edx, ebx
+       neg      edx
+       cmp      edx, 100
+       jae      SHORT G_M000_IG15
  
 G_M000_IG09:
-       mov      ecx, 1
+       mov      edi, edx
+       jmp      SHORT G_M000_IG11
+       align    [1 bytes for IG10]
  
 G_M000_IG10:
-       jmp      G_M000_IG23
+       dec      eax
+       mov      edx, 0xD1FFAB1E
+       mov      esi, edi
+       imul     rdx, rsi
+       shr      rdx, 35
+       lea      esi, [rdx+4*rdx]
+       add      esi, esi
+       mov      r8d, edi
+       sub      r8d, esi
+       mov      edi, edx
+       dec      ecx
+       cmp      ecx, r15d
+       jae      G_M000_IG47
+       mov      edx, ecx
+       add      r8d, 48
+       mov      byte  ptr [r14+rdx], r8b
  
 G_M000_IG11:
-       mov      rax, rsi
-       mov      ecx, edx
+       test     edi, edi
+       jne      SHORT G_M000_IG10
+ 
+G_M000_IG12:
+       test     eax, eax
+       jg       SHORT G_M000_IG10
+ 
+G_M000_IG13:
+       test     r15d, r15d
+       je       G_M000_IG47
+       mov      byte  ptr [r14], 45
+       mov      eax, 1
+       jmp      SHORT G_M000_IG17
+ 
+G_M000_IG14:
        mov      edx, edi
-       neg      edx
-       mov      esi, edx
+ 
+G_M000_IG15:
+       add      ecx, -2
+       add      eax, -2
+       mov      edi, edx
+       imul     rdi, rdi, 0xD1FFAB1E
+       shr      rdi, 37
+       imul     esi, edi, 100
+       sub      edx, esi
+       cmp      ecx, r15d
+       ja       G_M000_IG43
+       mov      esi, r15d
+       sub      esi, ecx
+       cmp      esi, 2
+       jb       G_M000_IG43
+       mov      esi, ecx
+       add      rsi, r14
+       cmp      edx, 100
+       jae      G_M000_IG47
+       mov      r8, 0xD1FFAB1E
+       movzx    rdx, word  ptr [r8+2*rdx]
+       mov      word  ptr [rsi], dx
+       cmp      edi, 100
+       jae      SHORT G_M000_IG14
+       jmp      SHORT G_M000_IG11
+ 
+G_M000_IG16:
+       xor      eax, eax
+       mov      dword ptr [rbp-0x30], eax
+ 
+G_M000_IG17:
+       jmp      G_M000_IG37
+ 
+G_M000_IG18:
+       test     ebx, ebx
+       jl       G_M000_IG26
+       mov      edx, ebx
+       or       edx, 1
+       xor      eax, eax
+       lzcnt    eax, edx
+       xor      eax, 31
+       mov      ecx, ebx
+       mov      rdx, 0xD1FFAB1E
+       add      rcx, qword ptr [rdx+8*rax]
+       sar      rcx, 32
+       cmp      ecx, r15d
+       jle      SHORT G_M000_IG20
+       xor      ecx, ecx
+       mov      dword ptr [rbp-0x30], ecx
+ 
+G_M000_IG19:
+       xor      eax, eax
+       jmp      SHORT G_M000_IG25
+ 
+G_M000_IG20:
+       mov      dword ptr [rbp-0x30], ecx
+       mov      rax, r14
+       mov      edx, r15d
+       cmp      ebx, 10
+       jb       G_M000_IG42
+ 
+G_M000_IG21:
+       cmp      ebx, 100
+       jae      G_M000_IG40
+ 
+G_M000_IG22:
+       mov      edi, ebx
+       jmp      G_M000_IG41
+       align    [2 bytes for IG28]
+ 
+G_M000_IG23:
+       add      ecx, -2
+       cmp      ecx, edx
+       ja       G_M000_IG43
+       sub      edx, ecx
+       cmp      edx, 2
+       jb       G_M000_IG43
+       add      rax, rcx
+       mov      ecx, ebx
+       mov      rdx, 0xD1FFAB1E
+       movzx    rcx, word  ptr [rdx+2*rcx]
+       mov      word  ptr [rax], cx
+ 
+G_M000_IG24:
+       mov      eax, 1
+ 
+G_M000_IG25:
+       jmp      G_M000_IG37
+ 
+G_M000_IG26:
+       xor      eax, eax
+       cmp      edx, 255
+       cmovne   eax, edx
+       mov      rcx, r14
+       mov      edx, r15d
+       mov      edi, 1
+       test     eax, eax
+       cmovle   eax, edi
+       mov      edi, ebx
+       neg      edi
+       mov      esi, edi
        or       esi, 1
        lzcnt    esi, esi
        xor      esi, 31
        mov      r8, 0xD1FFAB1E
-       add      rdx, qword ptr [r8+8*rsi]
-       sar      rdx, 32
-       mov      esi, 1
-       cmp      edx, 1
-       cmovg    esi, edx
-       inc      esi
-       cmp      esi, ecx
-       jg       G_M000_IG20
-       mov      dword ptr [rbp-0x10], esi
-       mov      edx, edi
-       neg      edx
-       mov      edi, 1
-       cmp      edx, 100
-       jae      SHORT G_M000_IG17
+       add      rdi, qword ptr [r8+8*rsi]
+       sar      rdi, 32
+       cmp      eax, edi
+       cmovge   edi, eax
+       inc      edi
+       cmp      edi, edx
+       jg       G_M000_IG34
+       mov      dword ptr [rbp-0x30], edi
+       mov      esi, ebx
+       neg      esi
+       cmp      esi, 100
+       jae      SHORT G_M000_IG33
  
-G_M000_IG12:
-       mov      r9d, edx
-       jmp      SHORT G_M000_IG14
-       align    [8 bytes for IG13]
+G_M000_IG27:
+       mov      r8d, esi
+       jmp      SHORT G_M000_IG29
  
-G_M000_IG13:
+G_M000_IG28:
+       dec      eax
+       mov      esi, 0xD1FFAB1E
+       mov      r9d, r8d
+       imul     rsi, r9
+       shr      rsi, 35
+       lea      r9d, [rsi+4*rsi]
+       add      r9d, r9d
+       mov      r10d, r8d
+       sub      r10d, r9d
+       mov      r8d, esi
        dec      edi
-       mov      edx, 0xD1FFAB1E
-       mov      r8d, r9d
-       imul     rdx, r8
-       shr      rdx, 35
-       lea      r8d, [rdx+4*rdx]
-       add      r8d, r8d
-       mov      r10d, r9d
-       sub      r10d, r8d
-       mov      r9d, edx
-       dec      esi
-       cmp      esi, ecx
-       jae      G_M000_IG31
-       mov      edx, esi
+       cmp      edi, edx
+       jae      G_M000_IG47
+       mov      esi, edi
        add      r10d, 48
-       mov      byte  ptr [rax+rdx], r10b
+       mov      byte  ptr [rcx+rsi], r10b
  
-G_M000_IG14:
-       test     r9d, r9d
-       jne      SHORT G_M000_IG13
+G_M000_IG29:
+       test     r8d, r8d
+       jne      SHORT G_M000_IG28
  
-G_M000_IG15:
-       test     edi, edi
-       jg       SHORT G_M000_IG13
+G_M000_IG30:
+       test     eax, eax
+       jg       SHORT G_M000_IG28
  
-G_M000_IG16:
-       test     ecx, ecx
-       je       G_M000_IG31
-       mov      byte  ptr [rax], 45
+G_M000_IG31:
+       test     edx, edx
+       je       G_M000_IG47
+       mov      byte  ptr [rcx], 45
        mov      ebx, 1
-       jmp      SHORT G_M000_IG22
-       align    [0 bytes for IG18]
+       jmp      SHORT G_M000_IG36
  
-G_M000_IG17:
-       mov      r8d, ecx
+G_M000_IG32:
+       mov      esi, r8d
  
-G_M000_IG18:
-       add      esi, -2
+G_M000_IG33:
        add      edi, -2
-       mov      r9d, edx
-       imul     r9, r9, 0xD1FFAB1E
-       shr      r9, 37
-       imul     r10d, r9d, 100
-       sub      edx, r10d
-       mov      r10d, esi
-       add      r10, 2
-       cmp      r10, r8
-       ja       G_M000_IG29
-       mov      r10d, esi
-       add      r10, rax
-       cmp      edx, 100
-       jae      G_M000_IG31
-       mov      r11, 0xD1FFAB1E
-       movzx    rdx, word  ptr [r11+2*rdx]
-       mov      word  ptr [r10], dx
-       cmp      r9d, 100
-       jb       SHORT G_M000_IG14
- 
-G_M000_IG19:
-       mov      edx, r9d
-       jmp      SHORT G_M000_IG18
- 
-G_M000_IG20:
-       xor      eax, eax
-       mov      dword ptr [rbp-0x10], eax
- 
-G_M000_IG21:
-       xor      ebx, ebx
- 
-G_M000_IG22:
-       mov      ecx, ebx
- 
-G_M000_IG23:
-       test     ecx, ecx
-       je       G_M000_IG30
-       mov      eax, dword ptr [rbp-0x10]
- 
-G_M000_IG24:
-       add      rsp, 8
-       pop      rbx
-       pop      rbp
-       ret      
- 
-G_M000_IG25:
-       mov      eax, edx
-       align    [0 bytes for IG26]
- 
-G_M000_IG26:
-       add      ecx, -2
-       mov      r8d, edi
+       add      eax, -2
+       mov      r8d, esi
        imul     r8, r8, 0xD1FFAB1E
        shr      r8, 37
        imul     r9d, r8d, 100
-       sub      edi, r9d
-       mov      r9d, ecx
-       add      r9, 2
-       cmp      r9, rax
-       ja       SHORT G_M000_IG29
-       mov      r9d, ecx
-       add      r9, rsi
-       cmp      edi, 100
-       jae      SHORT G_M000_IG31
+       sub      esi, r9d
+       cmp      edi, edx
+       ja       G_M000_IG43
+       mov      r9d, edx
+       sub      r9d, edi
+       cmp      r9d, 2
+       jb       G_M000_IG43
+       mov      r9d, edi
+       add      r9, rcx
+       cmp      esi, 100
+       jae      G_M000_IG47
        mov      r10, 0xD1FFAB1E
-       movzx    rdi, word  ptr [r10+2*rdi]
-       mov      word  ptr [r9], di
+       movzx    rsi, word  ptr [r10+2*rsi]
+       mov      word  ptr [r9], si
        cmp      r8d, 100
-       jb       G_M000_IG08
+       jae      SHORT G_M000_IG32
+       jmp      SHORT G_M000_IG29
  
-G_M000_IG27:
-       mov      edi, r8d
-       jmp      SHORT G_M000_IG26
+G_M000_IG34:
+       xor      eax, eax
+       mov      dword ptr [rbp-0x30], eax
  
-G_M000_IG28:
+G_M000_IG35:
+       xor      ebx, ebx
+ 
+G_M000_IG36:
+       mov      eax, ebx
+ 
+G_M000_IG37:
+       test     eax, eax
+       je       G_M000_IG46
+       mov      eax, dword ptr [rbp-0x30]
+ 
+G_M000_IG38:
+       add      rsp, 24
+       pop      rbx
+       pop      r12
+       pop      r13
+       pop      r14
+       pop      r15
+       pop      rbp
+       ret      
+ 
+G_M000_IG39:
+       mov      ebx, edi
+ 
+G_M000_IG40:
+       add      ecx, -2
+       mov      edi, ebx
+       imul     rdi, rdi, 0xD1FFAB1E
+       shr      rdi, 37
+       imul     esi, edi, 100
+       sub      ebx, esi
+       cmp      ecx, edx
+       ja       SHORT G_M000_IG43
+       mov      esi, edx
+       sub      esi, ecx
+       cmp      esi, 2
+       jb       SHORT G_M000_IG43
+       mov      esi, ecx
+       add      rsi, rax
+       cmp      ebx, 100
+       jae      SHORT G_M000_IG47
+       mov      r8d, ebx
+       mov      r9, 0xD1FFAB1E
+       movzx    r8, word  ptr [r9+2*r8]
+       mov      word  ptr [rsi], r8w
+       cmp      edi, 100
+       jae      SHORT G_M000_IG39
+ 
+G_M000_IG41:
+       cmp      edi, 10
+       mov      ebx, edi
+       jae      G_M000_IG23
+ 
+G_M000_IG42:
        dec      ecx
        cmp      ecx, edx
-       jae      SHORT G_M000_IG31
+       jae      SHORT G_M000_IG47
        mov      edx, ecx
-       lea      eax, [rdi+0x30]
-       mov      byte  ptr [rsi+rdx], al
-       jmp      G_M000_IG09
+       lea      ecx, [rbx+0x30]
+       mov      byte  ptr [rax+rdx], cl
+       jmp      G_M000_IG24
  
-G_M000_IG29:
+G_M000_IG43:
        mov      rax, 0xD1FFAB1E
        call     [rax]System.ThrowHelper:ThrowArgumentOutOfRangeException()
        int3     
  
-G_M000_IG30:
+G_M000_IG44:
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.ThrowHelper:ThrowFormatException_BadFormatSpecifier()
+       int3     
+ 
+G_M000_IG45:
+       mov      rax, 0xD1FFAB1E
+       call     [rax]System.Buffers.Text.Utf8Formatter:ThrowGWithPrecisionNotSupported()
+       int3     
+ 
+G_M000_IG46:
        mov      rax, 0xD1FFAB1E
        call     [rax]StackExchange.Redis.Format:ThrowFormatFailed()
        int3     
  
-G_M000_IG31:
+G_M000_IG47:
        call     CORINFO_HELP_RNGCHKFAIL
        int3     
  
-; Total bytes of code 573 for method StackExchange.Redis.Format:FormatInt32(int,System.Span`1[byte]):int (FullOpts)
+; Total bytes of code 1141 for method StackExchange.Redis.Format:FormatInt32(int,System.Span`1[byte]):int (FullOpts)
 
```

</details>


<details>
<summary>422 (215.31 % of base) - System.SpanHelpers:SequenceCompareTo(byref,int,byref,int):int</summary>

```diff
 ; Assembly listing for method System.SpanHelpers:SequenceCompareTo(byref,int,byref,int):int (FullOpts)
 ; Emitting BLENDED_CODE for 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; 6 single block inlinees; 0 inlinees without PGO data
 
 G_M000_IG01:
        push     rbp
        mov      rbp, rsp
  
 G_M000_IG02:
-       mov      eax, esi
-       sub      eax, ecx
        cmp      rdi, rdx
-       je       G_M000_IG10
+       je       SHORT G_M000_IG07
  
 G_M000_IG03:
        cmp      esi, ecx
-       cmovae   esi, ecx
-       mov      ecx, esi
-       xor      esi, esi
-       cmp      rcx, 4
-       jb       SHORT G_M000_IG07
-       cmp      rcx, 16
-       jb       SHORT G_M000_IG05
-       lea      r8, [rcx-0x10]
-       vmovups  ymm0, ymmword ptr [rdi]
-       vpcmpnequw k1, ymm0, ymmword ptr [rdx]
-       kortestw k1, k1
-       jne      SHORT G_M000_IG05
-       align    [3 bytes for IG04]
+       mov      eax, ecx
+       cmovb    eax, esi
+       xor      r8d, r8d
+       cmp      rax, 64
+       jae      G_M000_IG16
+       cmp      rax, 32
+       jae      G_M000_IG12
+       cmp      rax, 16
+       jae      SHORT G_M000_IG09
+       cmp      rax, 8
+       jbe      SHORT G_M000_IG05
+       lea      r9, [rax-0x08]
+       test     r9, r9
+       je       SHORT G_M000_IG05
+       align    [0 bytes for IG04]
  
 G_M000_IG04:
-       add      rsi, 16
-       cmp      r8, rsi
-       jb       SHORT G_M000_IG05
-       vmovups  ymm0, ymmword ptr [rdi+2*rsi]
-       vpcmpnequw k1, ymm0, ymmword ptr [rdx+2*rsi]
-       kortestw k1, k1
-       je       SHORT G_M000_IG04
+       mov      r10, qword ptr [rdi+r8]
+       cmp      r10, qword ptr [rdx+r8]
+       jne      SHORT G_M000_IG05
+       add      r8, 8
+       cmp      r9, r8
+       ja       SHORT G_M000_IG04
  
 G_M000_IG05:
-       lea      r8, [rsi+0x04]
-       cmp      rcx, r8
-       jb       SHORT G_M000_IG07
-       align    [0 bytes for IG06]
+       cmp      rax, r8
+       jbe      SHORT G_M000_IG07
+       align    [8 bytes for IG06]
  
 G_M000_IG06:
-       mov      r8, qword ptr [rdi+2*rsi]
-       cmp      r8, qword ptr [rdx+2*rsi]
-       jne      SHORT G_M000_IG07
-       add      rsi, 4
-       lea      r8, [rsi+0x04]
-       cmp      rcx, r8
-       jae      SHORT G_M000_IG06
+       movzx    r9, byte  ptr [rdi+r8]
+       movzx    r10, byte  ptr [rdx+r8]
+       sub      r9d, r10d
+       jne      SHORT G_M000_IG08
+       inc      r8
+       cmp      rax, r8
+       ja       SHORT G_M000_IG06
  
 G_M000_IG07:
-       lea      r8, [rsi+0x02]
-       cmp      rcx, r8
-       jb       SHORT G_M000_IG08
-       mov      r9d, dword ptr [rdi+2*rsi]
-       cmp      r9d, dword ptr [rdx+2*rsi]
-       cmove    rsi, r8
+       mov      r9d, esi
+       sub      r9d, ecx
+       jmp      G_M000_IG21
+       align    [0 bytes for IG13]
  
 G_M000_IG08:
-       cmp      rsi, rcx
-       jae      SHORT G_M000_IG10
-       align    [8 bytes for IG09]
+       jmp      G_M000_IG21
  
 G_M000_IG09:
-       movzx    r8, word  ptr [rdi+2*rsi]
-       movzx    r9, word  ptr [rdx+2*rsi]
-       sub      r8d, r9d
+       lea      r9, [rax-0x10]
+       test     r9, r9
+       je       SHORT G_M000_IG10
+       vmovups  xmm0, xmmword ptr [rdi]
+       vpcmpeqb xmm0, xmm0, xmmword ptr [rdx]
+       vpmovmskb eax, xmm0
+       cmp      eax, 0xFFFF
        jne      SHORT G_M000_IG11
-       inc      rsi
-       cmp      rsi, rcx
-       jb       SHORT G_M000_IG09
  
 G_M000_IG10:
-       vzeroupper 
-       pop      rbp
-       ret      
+       mov      r8, r9
+       vmovups  xmm0, xmmword ptr [rdi+r8]
+       vpcmpeqb xmm0, xmm0, xmmword ptr [rdx+r8]
+       vpmovmskb eax, xmm0
+       cmp      eax, 0xFFFF
+       je       SHORT G_M000_IG07
  
 G_M000_IG11:
-       mov      eax, r8d
+       mov      r9d, eax
+       not      r9d
+       xor      ecx, ecx
+       tzcnt    ecx, r9d
+       mov      esi, ecx
+       add      rsi, r8
+       mov      r8, rsi
+       jmp      G_M000_IG20
  
 G_M000_IG12:
+       lea      r9, [rax-0x20]
+       test     r9, r9
+       je       SHORT G_M000_IG14
+ 
+G_M000_IG13:
+       vmovups  ymm0, ymmword ptr [rdi+r8]
+       vpcmpeqb ymm0, ymm0, ymmword ptr [rdx+r8]
+       vpmovmskb eax, ymm0
+       cmp      eax, -1
+       jne      SHORT G_M000_IG15
+       add      r8, 32
+       cmp      r9, r8
+       ja       SHORT G_M000_IG13
+ 
+G_M000_IG14:
+       mov      r8, r9
+       vmovups  ymm0, ymmword ptr [rdi+r8]
+       vpcmpeqb ymm0, ymm0, ymmword ptr [rdx+r8]
+       vpmovmskb eax, ymm0
+       cmp      eax, -1
+       je       G_M000_IG07
+ 
+G_M000_IG15:
+       mov      r9d, eax
+       not      r9d
+       xor      ecx, ecx
+       tzcnt    ecx, r9d
+       mov      esi, ecx
+       add      rsi, r8
+       mov      r8, rsi
+       jmp      SHORT G_M000_IG20
+       align    [0 bytes for IG17]
+ 
+G_M000_IG16:
+       lea      r9, [rax-0x40]
+       test     r9, r9
+       je       SHORT G_M000_IG18
+ 
+G_M000_IG17:
+       vmovups  zmm0, zmmword ptr [rdi+r8]
+       vpcmpeqb k1, zmm0, zmmword ptr [rdx+r8]
+       kmovq    rax, k1
+       cmp      rax, -1
+       jne      SHORT G_M000_IG19
+       add      r8, 64
+       cmp      r9, r8
+       ja       SHORT G_M000_IG17
+ 
+G_M000_IG18:
+       mov      r8, r9
+       vmovups  zmm0, zmmword ptr [rdi+r8]
+       vpcmpeqb k1, zmm0, zmmword ptr [rdx+r8]
+       kmovq    rax, k1
+       cmp      rax, -1
+       je       G_M000_IG07
+ 
+G_M000_IG19:
+       mov      r9, rax
+       not      r9
+       xor      eax, eax
+       tzcnt    rax, r9
+       mov      eax, eax
+       add      rax, r8
+       mov      r8, rax
+ 
+G_M000_IG20:
+       movzx    r9, byte  ptr [rdi+r8]
+       movzx    rax, byte  ptr [rdx+r8]
+       sub      r9d, eax
+ 
+G_M000_IG21:
+       mov      eax, r9d
+ 
+G_M000_IG22:
        vzeroupper 
        pop      rbp
        ret      
  
-; Total bytes of code 196 for method System.SpanHelpers:SequenceCompareTo(byref,int,byref,int):int (FullOpts)
+; Total bytes of code 422 for method System.SpanHelpers:SequenceCompareTo(byref,int,byref,int):int (FullOpts)
 
```

</details>


<details>
<summary>301 (4.86 % of base) - SixLabors.Fonts.Unicode.BidiAlgorithm:ProcessIsolatedRunSequence(int,int,int):this</summary>

```diff
 ; Assembly listing for method SixLabors.Fonts.Unicode.BidiAlgorithm:ProcessIsolatedRunSequence(int,int,int):this (FullOpts)
 ; Emitting BLENDED_CODE for x64 + VEX + EVEX on Unix
 ; FullOpts code
 ; optimized code
 ; rbp based frame
 ; fully interruptible
 ; No PGO data
 ; 0 inlinees with PGO data; 370 single block inlinees; 67 inlinees without PGO data
 
 G_M000_IG01:
        push     rbp
        push     r15
        push     r14
        push     r13
        push     r12
        push     rbx
-       sub      rsp, 312
-       lea      rbp, [rsp+0x160]
+       sub      rsp, 280
+       lea      rbp, [rsp+0x140]
        xor      eax, eax
        mov      qword ptr [rbp-0xD8], rax
        vxorps   xmm8, xmm8, xmm8
        vmovdqu32 zmmword ptr [rbp-0xD0], zmm8
        vmovdqu32 zmmword ptr [rbp-0x90], zmm8
        mov      dword ptr [rbp-0x30], edx
        mov      rbx, rdi
        mov      r15d, esi
        mov      r13d, ecx
  
 G_M000_IG02:
        cmp      byte  ptr [rbx], bl
        lea      r12, bword ptr [rbx+0x78]
        lea      rdi, bword ptr [rbx+0xB8]
        mov      eax, dword ptr [rdi+0x08]
-       mov      dword ptr [rbp-0xDC], eax
        mov      rcx, gword ptr [rdi]
-       mov      gword ptr [rbp-0x120], rcx
+       mov      gword ptr [rbp-0x110], rcx
        mov      edi, dword ptr [r12+0x0C]
        cmp      edi, eax
        jl       SHORT G_M000_IG04
  
 G_M000_IG03:
+       mov      dword ptr [rbp-0xDC], eax
        jmp      SHORT G_M000_IG05
  
 G_M000_IG04:
+       mov      dword ptr [rbp-0xDC], eax
        mov      esi, eax
        mov      rdx, 0xD1FFAB1E
        mov      r8, 0xD1FFAB1E
        call     [r8]SixLabors.ThrowHelper:ThrowArgumentOutOfRangeExceptionForMustBeGreaterThanOrEqualTo[int](int,int,System.String)
  
 G_M000_IG05:
        vmovdqu  xmm0, xmmword ptr [r12]
        vmovdqu  xmmword ptr [rbp-0x78], xmm0
  
 G_M000_IG06:
-       mov      rcx, gword ptr [rbp-0x120]
+       mov      rcx, gword ptr [rbp-0x110]
        mov      gword ptr [rbp-0x68], rcx
        lea      r12, bword ptr [rbx+0xC8]
        mov      rcx, r12
-       mov      bword ptr [rbp-0x148], rcx
+       mov      bword ptr [rbp-0x128], rcx
        mov      rsi, gword ptr [rbp-0x78]
        mov      rdi, rcx
        call     CORINFO_HELP_ASSIGN_REF
        mov      rdi, qword ptr [rbp-0x70]
-       mov      rax, bword ptr [rbp-0x148]
+       mov      rax, bword ptr [rbp-0x128]
        mov      qword ptr [rax+0x08], rdi
        lea      rdi, bword ptr [rax+0x10]
        mov      rsi, gword ptr [rbp-0x68]
        call     CORINFO_HELP_ASSIGN_REF
        mov      rdi, qword ptr [rbp-0x60]
-       mov      rsi, bword ptr [rbp-0x148]
+       mov      rsi, bword ptr [rbp-0x128]
        mov      qword ptr [rsi+0x18], rdi
        xor      edi, edi
        mov      dword ptr [rbx+0xE0], edi
-       mov      edi, dword ptr [rbp-0xDC]
-       mov      dword ptr [rbx+0xE4], edi
+       mov      eax, dword ptr [rbp-0xDC]
+       mov      dword ptr [rbx+0xE4], eax
        lea      rax, bword ptr [rbx+0x48]
-       mov      bword ptr [rbp-0x100], rax
+       mov      bword ptr [rbp-0xF8], rax
        lea      rdi, bword ptr [rbx+0xB8]
        mov      ecx, dword ptr [rdi+0x08]
-       mov      dword ptr [rbp-0xE0], ecx
        mov      r8, gword ptr [rdi]
-       mov      gword ptr [rbp-0x128], r8
+       mov      gword ptr [rbp-0x118], r8
        mov      edi, dword ptr [rax+0x0C]
        cmp      edi, ecx
        jl       SHORT G_M000_IG08
  
 G_M000_IG07:
+       mov      dword ptr [rbp-0xE0], ecx
        jmp      SHORT G_M000_IG09
  
 G_M000_IG08:
+       mov      dword ptr [rbp-0xE0], ecx
        mov      esi, ecx
        mov      rdx, 0xD1FFAB1E
        mov      r9, 0xD1FFAB1E
        call     [r9]SixLabors.ThrowHelper:ThrowArgumentOutOfRangeExceptionForMustBeGreaterThanOrEqualTo[int](int,int,System.String)
  
 G_M000_IG09:
-       mov      rax, bword ptr [rbp-0x100]
+       mov      rax, bword ptr [rbp-0xF8]
        vmovdqu  xmm0, xmmword ptr [rax]
        vmovdqu  xmmword ptr [rbp-0x98], xmm0
  
 G_M000_IG10:
-       mov      r8, gword ptr [rbp-0x128]
+       mov      r8, gword ptr [rbp-0x118]
        mov      gword ptr [rbp-0x88], r8
        lea      rax, bword ptr [rbx+0xE8]
-       mov      bword ptr [rbp-0x150], rax
+       mov      bword ptr [rbp-0x130], rax
        mov      rsi, gword ptr [rbp-0x98]
        mov      rdi, rax
        call     CORINFO_HELP_ASSIGN_REF
        mov      rdi, qword ptr [rbp-0x90]
-       mov      rax, bword ptr [rbp-0x150]
+       mov      rax, bword ptr [rbp-0x130]
        mov      qword ptr [rax+0x08], rdi
        lea      rdi, bword ptr [rax+0x10]
        mov      rsi, gword ptr [rbp-0x88]
        call     CORINFO_HELP_ASSIGN_REF
        mov      rdi, qword ptr [rbp-0x80]
-       mov      rsi, bword ptr [rbp-0x150]
+       mov      rsi, bword ptr [rbp-0x130]
        mov      qword ptr [rsi+0x18], rdi
        xor      edi, edi
        mov      dword ptr [rbx+0x100], edi
-       mov      edi, dword ptr [rbp-0xE0]
-       mov      dword ptr [rbx+0x104], edi
+       mov      eax, dword ptr [rbp-0xE0]
+       mov      dword ptr [rbx+0x104], eax
        mov      rax, gword ptr [rbx+0x168]
-       mov      gword ptr [rbp-0x118], rax
+       mov      gword ptr [rbp-0x120], rax
        mov      ecx, dword ptr [rbx+0x170]
-       mov      dword ptr [rbp-0xF0], ecx
+       mov      dword ptr [rbp-0xE4], ecx
        mov      r8d, dword ptr [rbx+0x174]
-       mov      dword ptr [rbp-0xF4], r8d
+       mov      dword ptr [rbp-0xE8], r8d
        lea      rdi, bword ptr [rbx+0xB8]
-       mov      r9d, dword ptr [rdi+0x08]
-       mov      dword ptr [rbp-0xE4], r9d
-       mov      r10, gword ptr [rdi]
-       mov      gword ptr [rbp-0x130], r10
-       cmp      r8d, r9d
+       mov      esi, dword ptr [rdi+0x08]
+       mov      rdi, gword ptr [rdi]
+       mov      gword ptr [rbp-0x110], rdi
+       mov      r10d, esi
+       mov      edi, r8d
+       mov      esi, r10d
+       cmp      edi, esi
        jl       SHORT G_M000_IG12
  
 G_M000_IG11:
-       mov      rax, gword ptr [rbp-0x118]
+       mov      dword ptr [rbp-0xDC], r10d
+       mov      rax, gword ptr [rbp-0x120]
        jmp      SHORT G_M000_IG13
  
 G_M000_IG12:
        mov      edi, r8d
-       mov      esi, r9d
+       mov      dword ptr [rbp-0xDC], r10d
+       mov      esi, r10d
        mov      rdx, 0xD1FFAB1E
        mov      r11, 0xD1FFAB1E
        call     [r11]SixLabors.ThrowHelper:ThrowArgumentOutOfRangeExceptionForMustBeGreaterThanOrEqualTo[int](int,int,System.String)
-       mov      rax, gword ptr [rbp-0x118]
+       mov      rax, gword ptr [rbp-0x120]
  
 G_M000_IG13:
        lea      rdi, bword ptr [rbx+0x108]
        mov      rsi, rax
        call     CORINFO_HELP_ASSIGN_REF
-       mov      edi, dword ptr [rbp-0xF0]
+       mov      edi, dword ptr [rbp-0xE4]
        mov      dword ptr [rbx+0x110], edi
-       mov      edi, dword ptr [rbp-0xF4]
+       mov      edi, dword ptr [rbp-0xE8]
        mov      dword ptr [rbx+0x114], edi
        lea      rdi, bword ptr [rbx+0x118]
-       mov      rsi, gword ptr [rbp-0x130]
+       mov      rsi, gword ptr [rbp-0x110]
        call     CORINFO_HELP_ASSIGN_REF
        xor      edi, edi
        mov      dword ptr [rbx+0x120], edi
-       mov      edi, dword ptr [rbp-0xE4]
+       mov      edi, dword ptr [rbp-0xDC]
        mov      dword ptr [rbx+0x124], edi
        cmp      byte  ptr [rbx+0x44], 0
        je       G_M000_IG23
  
 G_M000_IG14:
        lea      rax, bword ptr [rbx+0x58]
-       mov      bword ptr [rbp-0x108], rax
+       mov      bword ptr [rbp-0x100], rax
        lea      rdi, bword ptr [rbx+0xB8]
-       mov      ecx, dword ptr [rdi+0x08]
-       mov      dword ptr [rbp-0xE8], ecx
+       mov      esi, dword ptr [rdi+0x08]
        mov      r8, gword ptr [rdi]
-       mov      gword ptr [rbp-0x138], r8
+       mov      gword ptr [rbp-0x118], r8
+       mov      r8d, esi
        mov      edi, dword ptr [rax+0x0C]
-       cmp      edi, ecx
+       cmp      edi, r8d
        jl       SHORT G_M000_IG16
  
 G_M000_IG15:
+       mov      dword ptr [rbp-0xE0], r8d
        jmp      SHORT G_M000_IG17
        align    [0 bytes for IG55]
  
 G_M000_IG16:
-       mov      esi, ecx
+       mov      dword ptr [rbp-0xE0], r8d
+       mov      esi, r8d
        mov      rdx, 0xD1FFAB1E
        mov      r9, 0xD1FFAB1E
        call     [r9]SixLabors.ThrowHelper:ThrowArgumentOutOfRangeExceptionForMustBeGreaterThanOrEqualTo[int](int,int,System.String)
  
 G_M000_IG17:
-       mov      rax, bword ptr [rbp-0x108]
+       mov      rax, bword ptr [rbp-0x100]
        vmovdqu  xmm0, xmmword ptr [rax]
        vmovdqu  xmmword ptr [rbp-0xB8], xmm0
  
 G_M000_IG18:
-       mov      r8, gword ptr [rbp-0x138]
-       mov      gword ptr [rbp-0xA8], r8
+       mov      rcx, gword ptr [rbp-0x118]
+       mov      gword ptr [rbp-0xA8], rcx
        lea      rax, bword ptr [rbx+0x128]
-       mov      bword ptr [rbp-0x158], rax
+       mov      bword ptr [rbp-0x138], rax
        mov      rsi, gword ptr [rbp-0xB8]
        mov      rdi, rax
        call     CORINFO_HELP_ASSIGN_REF
        mov      rdi, qword ptr [rbp-0xB0]
-       mov      rax, bword ptr [rbp-0x158]
+       mov      rax, bword ptr [rbp-0x138]
        mov      qword ptr [rax+0x08], rdi
        lea      rdi, bword ptr [rax+0x10]
        mov      rsi, gword ptr [rbp-0xA8]
        call     CORINFO_HELP_ASSIGN_REF
        mov      rdi, qword ptr [rbp-0xA0]
-       mov      rsi, bword ptr [rbp-0x158]
+       mov      rsi, bword ptr [rbp-0x138]
        mov      qword ptr [rsi+0x18], rdi
        xor      edi, edi
        mov      dword ptr [rbx+0x140], edi
-       mov      edi, dword ptr [rbp-0xE8]
-       mov      dword ptr [rbx+0x144], edi
-       lea      rax, bword ptr [rbx+0x68]
-       mov      bword ptr [rbp-0x110], rax
-       lea      rdi, bword ptr [rbx+0xB8]
-       mov      ecx, dword ptr [rdi+0x08]
-       mov      dword ptr [rbp-0xEC], ecx
-       mov      r8, gword ptr [rdi]
-       mov      gword ptr [rbp-0x140], r8
-       mov      edi, dword ptr [rax+0x0C]
-       cmp      edi, ecx
+       mov      eax, dword ptr [rbp-0xE0]
+       mov      dword ptr [rbx+0x144], eax
+       lea      rcx, bword ptr [rbx+0x68]
+       mov      bword ptr [rbp-0x108], rcx
+       lea      rax, bword ptr [rbx+0xB8]
+       mov      edi, dword ptr [rax+0x08]
+       mov      rsi, gword ptr [rax]
+       mov      gword ptr [rbp-0x118], rsi
+       mov      r8d, edi
+       mov      edi, dword ptr [rcx+0x0C]
+       cmp      edi, r8d
        jl       SHORT G_M000_IG20
  
 G_M000_IG19:
+       mov      dword ptr [rbp-0xE0], r8d
        jmp      SHORT G_M000_IG21
  
 G_M000_IG20:
-       mov      esi, ecx
+       mov      dword ptr [rbp-0xE0], r8d
+       mov      esi, r8d
        mov      rdx, 0xD1FFAB1E
        mov      r9, 0xD1FFAB1E
        call     [r9]SixLabors.ThrowHelper:ThrowArgumentOutOfRangeExceptionForMustBeGreaterThanOrEqualTo[int](int,int,System.String)
  
 G_M000_IG21:
-       mov      rax, bword ptr [rbp-0x110]
-       vmovdqu  xmm0, xmmword ptr [rax]
+       mov      rcx, bword ptr [rbp-0x108]
+       vmovdqu  xmm0, xmmword ptr [rcx]
        vmovdqu  xmmword ptr [rbp-0xD8], xmm0
  
 G_M000_IG22:
-       mov      r8, gword ptr [rbp-0x140]
-       mov      gword ptr [rbp-0xC8], r8
+       mov      rax, gword ptr [rbp-0x118]
+       mov      gword ptr [rbp-0xC8], rax
        lea      rax, bword ptr [rbx+0x148]
-       mov      bword ptr [rbp-0x160], rax
+       mov      bword ptr [rbp-0x140], rax
        mov      rsi, gword ptr [rbp-0xD8]
        mov      rdi, rax
        call     CORINFO_HELP_ASSIGN_REF
        mov      rdi, qword ptr [rbp-0xD0]
-       mov      rax, bword ptr [rbp-0x160]
+       mov      rax, bword ptr [rbp-0x140]
        mov      qword ptr [rax+0x08], rdi
        lea      rdi, bword ptr [rax+0x10]
        mov      rsi, gword ptr [rbp-0xC8]
        call     CORINFO_HELP_ASSIGN_REF
        mov      rdi, qword ptr [rbp-0xC0]
-       mov      rax, bword ptr [rbp-0x160]
+       mov      rax, bword ptr [rbp-0x140]
        mov      qword ptr [rax+0x18], rdi
        xor      edi, edi
        mov      dword ptr [rbx+0x160], edi
-       mov      edi, dword ptr [rbp-0xEC]
+       mov      edi, dword ptr [rbp-0xE0]
        mov      dword ptr [rbx+0x164], edi
  
 G_M000_IG23:
        mov      dword ptr [rbx+0x38], r13d
        and      r13d, 1
        mov      dword ptr [rbx+0x3C], r13d
        mov      edi, dword ptr [rbx+0xE4]
        mov      dword ptr [rbx+0x40], edi
        xor      edi, edi
        xor      eax, eax
        mov      dword ptr [rbp-0x38], eax
        xor      ecx, ecx
        mov      dword ptr [rbp-0x3C], ecx
        xor      edx, edx
        mov      dword ptr [rbp-0x40], edx
        xor      esi, esi
        xor      r8d, r8d
        mov      dword ptr [rbp-0x48], r8d
        mov      dword ptr [rbp-0x2C], r15d
        mov      r9d, r15d
        xor      r13d, r13d
        jmp      G_M000_IG37
  
 G_M000_IG24:
        or       eax, r8d
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG25:
        movsxd   rcx, r13d
        mov      eax, dword ptr [rax+4*rcx]
        mov      rcx, gword ptr [r10]
        mov      r8d, dword ptr [r10+0x08]
        mov      r10d, dword ptr [r10+0x0C]
        test     rcx, rcx
        je       SHORT G_M000_IG27
  
 G_M000_IG26:
-       mov      edx, r8d
-       mov      r10d, r10d
-       add      rdx, r10
-       mov      r10d, dword ptr [rcx+0x08]
-       cmp      rdx, r10
+       mov      edx, dword ptr [rcx+0x08]
+       cmp      r8d, edx
        ja       G_M000_IG281
+       sub      edx, r8d
+       cmp      edx, r10d
+       jb       G_M000_IG281
        mov      r8d, r8d
        lea      rcx, bword ptr [rcx+4*r8+0x10]
        jmp      SHORT G_M000_IG28
  
 G_M000_IG27:
        or       r8d, r10d
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG28:
        cdqe     
        mov      eax, dword ptr [rcx+4*rax]
        lea      ecx, [rax-0x02]
        cmp      ecx, 20
        ja       G_M000_IG46
  
 G_M000_IG29:
        mov      ecx, ecx
        lea      r8, [reloc @RWD00]
        mov      r8d, dword ptr [r8+4*rcx]
        lea      r10, G_M000_IG02
        add      r8, r10
        jmp      r8
  
 G_M000_IG30:
        mov      r9d, 13
-       jmp      SHORT G_M000_IG36
+       jmp      G_M000_IG36
  
 G_M000_IG31:
        mov      rax, r12
        mov      rcx, gword ptr [r11]
        mov      r8d, dword ptr [r11+0x08]
        mov      r10d, dword ptr [r11+0x0C]
        test     rcx, rcx
        je       SHORT G_M000_IG32
-       mov      r11d, r8d
-       add      r10, r11
        mov      r11d, dword ptr [rcx+0x08]
-       cmp      r10, r11
+       cmp      r8d, r11d
        ja       G_M000_IG281
+       sub      r11d, r8d
+       cmp      r11d, r10d
+       jb       G_M000_IG281
        lea      rcx, bword ptr [rcx+4*r8+0x10]
        jmp      SHORT G_M000_IG33
  
 G_M000_IG32:
        or       r8d, r10d
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG33:
        movsxd   r8, r13d
        mov      ecx, dword ptr [rcx+4*r8]
        mov      r8, gword ptr [rax]
        mov      r10d, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     r8, r8
        je       SHORT G_M000_IG34
-       mov      r11d, r10d
-       add      rax, r11
        mov      r11d, dword ptr [r8+0x08]
-       cmp      rax, r11
+       cmp      r10d, r11d
        ja       G_M000_IG281
-       lea      rax, bword ptr [r8+4*r10+0x10]
+       sub      r11d, r10d
+       cmp      r11d, eax
+       jb       G_M000_IG281
+       mov      eax, r10d
+       lea      rax, bword ptr [r8+4*rax+0x10]
        jmp      SHORT G_M000_IG35
  
 G_M000_IG34:
        or       eax, r10d
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG35:
        movsxd   rcx, ecx
        mov      dword ptr [rax+4*rcx], r9d
  
 G_M000_IG36:
        inc      r13d
  
 G_M000_IG37:
        cmp      r13d, dword ptr [rbx+0x40]
-       jge      SHORT G_M000_IG47
+       jge      G_M000_IG47
  
 G_M000_IG38:
        mov      r10, r12
        lea      r11, bword ptr [r10+0x10]
        mov      rax, r11
        mov      rcx, gword ptr [rax]
        mov      r8d, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     rcx, rcx
        je       G_M000_IG24
  
 G_M000_IG39:
-       mov      edx, r8d
-       mov      eax, eax
-       add      rax, rdx
        mov      edx, dword ptr [rcx+0x08]
-       cmp      rax, rdx
+       cmp      r8d, edx
        ja       G_M000_IG281
-       mov      r8d, r8d
-       lea      rax, bword ptr [rcx+4*r8+0x10]
+       sub      edx, r8d
+       cmp      edx, eax
+       jb       G_M000_IG281
+       mov      eax, r8d
+       lea      rax, bword ptr [rcx+4*rax+0x10]
        jmp      G_M000_IG25
  
 G_M000_IG40:
        mov      dword ptr [rbp-0x40], 1
        jmp      SHORT G_M000_IG46
  
 G_M000_IG41:
        mov      dword ptr [rbp-0x44], 1
        mov      esi, dword ptr [rbp-0x44]
        jmp      SHORT G_M000_IG46
  
 G_M000_IG42:
        mov      dword ptr [rbp-0x48], 1
        jmp      SHORT G_M000_IG46
  
 G_M000_IG43:
        mov      dword ptr [rbp-0x3C], 1
        jmp      SHORT G_M000_IG46
  
 G_M000_IG44:
        mov      edi, 1
        jmp      SHORT G_M000_IG46
  
 G_M000_IG45:
        mov      dword ptr [rbp-0x38], 1
  
 G_M000_IG46:
        mov      r9d, eax
        jmp      G_M000_IG36
  
 G_M000_IG47:
        mov      dword ptr [rbp-0x34], edi
        test     edi, edi
        je       G_M000_IG70
  
 G_M000_IG48:
        xor      r13d, r13d
        jmp      G_M000_IG63
  
 G_M000_IG49:
        or       ecx, edx
        jne      G_M000_IG281
        xor      rax, rax
        mov      dword ptr [rbp-0x44], esi
  
 G_M000_IG50:
        movsxd   rcx, r13d
        mov      eax, dword ptr [rax+4*rcx]
        mov      rcx, gword ptr [r9]
        mov      rdx, rcx
        mov      esi, dword ptr [r9+0x08]
        mov      r14d, esi
        mov      r9d, dword ptr [r9+0x0C]
-       mov      dword ptr [rbp-0xF8], r9d
+       mov      dword ptr [rbp-0xEC], r9d
        mov      edi, r9d
        test     rdx, rdx
        je       SHORT G_M000_IG52
  
 G_M000_IG51:
-       mov      r15d, r14d
-       mov      edi, edi
-       add      rdi, r15
        mov      r15d, dword ptr [rdx+0x08]
-       cmp      rdi, r15
+       cmp      r14d, r15d
        ja       G_M000_IG281
+       sub      r15d, r14d
+       cmp      r15d, edi
+       jb       G_M000_IG281
        mov      edi, r14d
        lea      rdi, bword ptr [rdx+4*rdi+0x10]
        jmp      SHORT G_M000_IG53
  
 G_M000_IG52:
        or       edi, r14d
        jne      G_M000_IG281
        xor      rdi, rdi
  
 G_M000_IG53:
        cdqe     
        cmp      dword ptr [rdi+4*rax], 3
        jne      G_M000_IG62
  
 G_M000_IG54:
        lea      edi, [r13-0x01]
        test     edi, edi
        jl       G_M000_IG62
  
 G_M000_IG55:
        mov      rax, r10
        mov      edx, r8d
        mov      r14d, r11d
        test     rax, rax
        je       SHORT G_M000_IG57
  
 G_M000_IG56:
-       mov      r15d, edx
-       mov      r14d, r14d
-       add      r15, r14
-       mov      r14d, dword ptr [rax+0x08]
-       cmp      r15, r14
+       mov      r15d, dword ptr [rax+0x08]
+       cmp      edx, r15d
        ja       G_M000_IG281
+       sub      r15d, edx
+       cmp      r15d, r14d
+       jb       G_M000_IG281
        mov      edx, edx
        lea      rax, bword ptr [rax+4*rdx+0x10]
        jmp      SHORT G_M000_IG58
  
 G_M000_IG57:
        or       edx, r14d
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG58:
        mov      eax, dword ptr [rax+4*rdi]
        mov      rdx, rcx
        mov      r14d, esi
        mov      r15d, r9d
        test     rdx, rdx
        je       SHORT G_M000_IG60
  
 G_M000_IG59:
-       mov      r9d, r14d
-       mov      r15d, r15d
-       add      r9, r15
-       mov      r15d, dword ptr [rdx+0x08]
-       cmp      r9, r15
+       mov      r9d, dword ptr [rdx+0x08]
+       cmp      r14d, r9d
        ja       G_M000_IG281
+       sub      r9d, r14d
+       cmp      r9d, r15d
+       jb       G_M000_IG281
        mov      r9d, r14d
        lea      rdx, bword ptr [rdx+4*r9+0x10]
        jmp      SHORT G_M000_IG61
  
 G_M000_IG60:
        or       r15d, r14d
        jne      G_M000_IG281
        xor      rdx, rdx
  
 G_M000_IG61:
        cdqe     
        mov      eax, dword ptr [rdx+4*rax]
        cmp      eax, 2
        jbe      SHORT G_M000_IG65
        dec      edi
-       mov      r9d, dword ptr [rbp-0xF8]
+       mov      r9d, dword ptr [rbp-0xEC]
        jns      G_M000_IG55
  
 G_M000_IG62:
        inc      r13d
        mov      esi, dword ptr [rbp-0x44]
  
 G_M000_IG63:
        cmp      r13d, dword ptr [rbx+0x40]
        jge      G_M000_IG70
        mov      r9, r12
        lea      r11, bword ptr [r9+0x10]
        mov      r10, gword ptr [r11]
        mov      rax, r10
        mov      r8d, dword ptr [r11+0x08]
        mov      ecx, r8d
        mov      r11d, dword ptr [r11+0x0C]
        mov      edx, r11d
        test     rax, rax
        je       G_M000_IG49
  
 G_M000_IG64:
        mov      dword ptr [rbp-0x44], esi
-       mov      esi, ecx
-       mov      edx, edx
-       add      rdx, rsi
        mov      esi, dword ptr [rax+0x08]
-       cmp      rdx, rsi
+       cmp      ecx, esi
        ja       G_M000_IG281
+       sub      esi, ecx
+       cmp      esi, edx
+       jb       G_M000_IG281
        mov      ecx, ecx
        lea      rax, bword ptr [rax+4*rcx+0x10]
        jmp      G_M000_IG50
  
 G_M000_IG65:
        cmp      eax, 2
        jne      SHORT G_M000_IG62
        test     r10, r10
        je       SHORT G_M000_IG66
-       mov      edi, r8d
-       mov      r11d, r11d
-       add      rdi, r11
-       mov      eax, dword ptr [r10+0x08]
-       cmp      rdi, rax
+       mov      edi, dword ptr [r10+0x08]
+       cmp      r8d, edi
        ja       G_M000_IG281
+       sub      edi, r8d
+       cmp      edi, r11d
+       jb       G_M000_IG281
        mov      r8d, r8d
        lea      rdi, bword ptr [r10+4*r8+0x10]
        jmp      SHORT G_M000_IG67
  
 G_M000_IG66:
        or       r8d, r11d
        jne      G_M000_IG281
        xor      rdi, rdi
  
 G_M000_IG67:
        movsxd   rax, r13d
        mov      edi, dword ptr [rdi+4*rax]
-       mov      r9d, dword ptr [rbp-0xF8]
+       mov      r9d, dword ptr [rbp-0xEC]
        test     rcx, rcx
        je       SHORT G_M000_IG69
-       mov      eax, esi
-       add      rax, r9
-       mov      edx, dword ptr [rcx+0x08]
-       cmp      rax, rdx
+       mov      eax, dword ptr [rcx+0x08]
+       cmp      esi, eax
        ja       G_M000_IG281
+       sub      eax, esi
+       cmp      eax, r9d
+       jb       G_M000_IG281
        mov      esi, esi
        lea      rax, bword ptr [rcx+4*rsi+0x10]
  
 G_M000_IG68:
        movsxd   rdi, edi
        mov      dword ptr [rax+4*rdi], 6
        mov      esi, 1
        mov      dword ptr [rbp-0x44], esi
        jmp      G_M000_IG62
  
 G_M000_IG69:
        or       esi, r9d
        jne      G_M000_IG281
        xor      rax, rax
        jmp      SHORT G_M000_IG68
  
 G_M000_IG70:
        cmp      dword ptr [rbp-0x38], 0
        je       G_M000_IG86
  
 G_M000_IG71:
        xor      r13d, r13d
        jmp      G_M000_IG85
        align    [0 bytes for IG72]
  
 G_M000_IG72:
        mov      rax, r12
        lea      r11, bword ptr [rax+0x10]
        mov      r9, r11
        mov      r10, gword ptr [r9]
        mov      r14d, dword ptr [r9+0x08]
        mov      r9d, dword ptr [r9+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG74
  
 G_M000_IG73:
-       mov      r8d, r14d
-       mov      r9d, r9d
-       add      r8, r9
-       mov      r9d, dword ptr [r10+0x08]
-       cmp      r8, r9
+       mov      r8d, dword ptr [r10+0x08]
+       cmp      r14d, r8d
        ja       G_M000_IG281
-       mov      r8d, r14d
-       lea      r8, bword ptr [r10+4*r8+0x10]
+       sub      r8d, r14d
+       cmp      r8d, r9d
+       jb       G_M000_IG281
+       mov      r9d, r14d
+       lea      r8, bword ptr [r10+4*r9+0x10]
        mov      r9, r8
        jmp      SHORT G_M000_IG75
  
 G_M000_IG74:
        or       r9d, r14d
        jne      G_M000_IG281
        xor      r9, r9
  
 G_M000_IG75:
        movsxd   r10, r13d
        mov      r9d, dword ptr [r9+4*r10]
        mov      r10, gword ptr [rax]
        mov      r14d, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG77
  
 G_M000_IG76:
-       mov      r8d, r14d
-       mov      eax, eax
-       add      rax, r8
        mov      r8d, dword ptr [r10+0x08]
-       cmp      rax, r8
+       cmp      r14d, r8d
        ja       G_M000_IG281
+       sub      r8d, r14d
+       cmp      r8d, eax
+       jb       G_M000_IG281
        mov      eax, r14d
        lea      rax, bword ptr [r10+4*rax+0x10]
        jmp      SHORT G_M000_IG78
  
 G_M000_IG77:
        or       eax, r14d
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG78:
        movsxd   r9, r9d
        cmp      dword ptr [rax+4*r9], 2
        jne      G_M000_IG84
  
 G_M000_IG79:
        mov      rax, r12
        mov      r9, gword ptr [r11]
        mov      r10d, dword ptr [r11+0x08]
        mov      r11d, dword ptr [r11+0x0C]
        test     r9, r9
        je       SHORT G_M000_IG80
-       mov      r14d, r10d
-       add      r11, r14
        mov      r14d, dword ptr [r9+0x08]
-       cmp      r11, r14
+       cmp      r10d, r14d
        ja       G_M000_IG281
+       sub      r14d, r10d
+       cmp      r14d, r11d
+       jb       G_M000_IG281
        lea      r9, bword ptr [r9+4*r10+0x10]
        jmp      SHORT G_M000_IG81
  
 G_M000_IG80:
        or       r10d, r11d
        jne      G_M000_IG281
        xor      r9, r9
  
 G_M000_IG81:
        movsxd   r10, r13d
        mov      r9d, dword ptr [r9+4*r10]
        mov      r10, gword ptr [rax]
        mov      r11d, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG82
-       mov      r14d, r11d
-       add      rax, r14
        mov      r14d, dword ptr [r10+0x08]
-       cmp      rax, r14
+       cmp      r11d, r14d
        ja       G_M000_IG281
-       lea      rax, bword ptr [r10+4*r11+0x10]
+       sub      r14d, r11d
+       cmp      r14d, eax
+       jb       G_M000_IG281
+       mov      eax, r11d
+       lea      rax, bword ptr [r10+4*rax+0x10]
        jmp      SHORT G_M000_IG83
  
 G_M000_IG82:
        or       eax, r11d
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG83:
        movsxd   r9, r9d
        mov      dword ptr [rax+4*r9], 1
  
 G_M000_IG84:
        inc      r13d
  
 G_M000_IG85:
        cmp      r13d, dword ptr [rbx+0x40]
        jl       G_M000_IG72
  
 G_M000_IG86:
        mov      ecx, dword ptr [rbp-0x3C]
        mov      eax, ecx
        or       eax, dword ptr [rbp-0x40]
        jne      G_M000_IG172
  
 G_M000_IG87:
        mov      edi, dword ptr [rbp-0x34]
  
 G_M000_IG88:
        mov      r8d, dword ptr [rbp-0x48]
        test     r8d, edi
        je       G_M000_IG233
  
 G_M000_IG89:
        xor      r13d, r13d
        jmp      G_M000_IG232
        align    [0 bytes for IG101]
  
 G_M000_IG90:
        mov      r15d, dword ptr [rbp-0x2C]
        mov      edi, r15d
        xor      r13d, r13d
        jmp      G_M000_IG263
  
 G_M000_IG91:
        mov      rax, r12
        lea      r11, bword ptr [rax+0x10]
        mov      rcx, r11
        mov      rdx, gword ptr [rcx]
        mov      edi, dword ptr [rcx+0x08]
        mov      ecx, dword ptr [rcx+0x0C]
        test     rdx, rdx
        je       SHORT G_M000_IG93
  
 G_M000_IG92:
-       mov      esi, edi
-       mov      ecx, ecx
-       add      rcx, rsi
        mov      esi, dword ptr [rdx+0x08]
-       cmp      rcx, rsi
+       cmp      edi, esi
        ja       G_M000_IG281
-       mov      edi, edi
-       lea      rcx, bword ptr [rdx+4*rdi+0x10]
+       sub      esi, edi
+       cmp      esi, ecx
+       jb       G_M000_IG281
+       cmp      byte  ptr [rdx], dl
+       mov      ecx, edi
+       lea      rcx, bword ptr [rdx+4*rcx+0x10]
        jmp      SHORT G_M000_IG94
  
 G_M000_IG93:
        or       ecx, edi
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG94:
        movsxd   rdx, r13d
        mov      ecx, dword ptr [rcx+4*rdx]
        mov      rdx, gword ptr [rax]
        mov      edi, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     rdx, rdx
        je       SHORT G_M000_IG96
  
 G_M000_IG95:
-       mov      esi, edi
-       mov      eax, eax
-       add      rax, rsi
        mov      esi, dword ptr [rdx+0x08]
-       cmp      rax, rsi
+       cmp      edi, esi
        ja       G_M000_IG281
-       mov      edi, edi
-       lea      rax, bword ptr [rdx+4*rdi+0x10]
+       sub      esi, edi
+       cmp      esi, eax
+       jb       G_M000_IG281
+       cmp      byte  ptr [rdx], dl
+       mov      eax, edi
+       lea      rax, bword ptr [rdx+4*rax+0x10]
        jmp      SHORT G_M000_IG97
  
 G_M000_IG96:
        or       eax, edi
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG97:
        movsxd   rcx, ecx
        mov      eax, dword ptr [rax+4*rcx]
        lea      ecx, [rax-0x0A]
        cmp      ecx, 3
        jbe      SHORT G_M000_IG100
  
 G_M000_IG98:
        add      eax, -19
        cmp      eax, 3
        jbe      SHORT G_M000_IG100
  
 G_M000_IG99:
        mov      r14d, dword ptr [rbp-0x30]
        jmp      G_M000_IG136
  
 G_M000_IG100:
        mov      eax, r13d
        mov      ecx, eax
        jmp      SHORT G_M000_IG102
  
 G_M000_IG101:
        inc      ecx
  
 G_M000_IG102:
        cmp      ecx, dword ptr [rbx+0x40]
        jge      G_M000_IG110
        mov      rdx, r12
        mov      rdi, r11
        mov      rsi, gword ptr [rdi]
        mov      r8d, dword ptr [rdi+0x08]
        mov      edi, dword ptr [rdi+0x0C]
        test     rsi, rsi
        je       SHORT G_M000_IG104
  
 G_M000_IG103:
-       mov      r9d, r8d
-       mov      edi, edi
-       add      rdi, r9
        mov      r9d, dword ptr [rsi+0x08]
-       cmp      rdi, r9
+       cmp      r8d, r9d
        ja       G_M000_IG281
-       mov      r8d, r8d
-       lea      rdi, bword ptr [rsi+4*r8+0x10]
+       sub      r9d, r8d
+       cmp      r9d, edi
+       jb       G_M000_IG281
+       cmp      byte  ptr [rsi], sil
+       mov      edi, r8d
+       lea      rdi, bword ptr [rsi+4*rdi+0x10]
        jmp      SHORT G_M000_IG105
  
 G_M000_IG104:
        or       edi, r8d
        jne      G_M000_IG281
        xor      rdi, rdi
  
 G_M000_IG105:
        movsxd   rsi, ecx
        mov      edi, dword ptr [rdi+4*rsi]
        mov      rsi, gword ptr [rdx]
        mov      r8d, dword ptr [rdx+0x08]
        mov      edx, dword ptr [rdx+0x0C]
        test     rsi, rsi
        je       SHORT G_M000_IG107
  
 G_M000_IG106:
-       mov      r9d, r8d
-       mov      edx, edx
-       add      rdx, r9
        mov      r9d, dword ptr [rsi+0x08]
-       cmp      rdx, r9
+       cmp      r8d, r9d
        ja       G_M000_IG281
-       mov      r8d, r8d
-       lea      rdx, bword ptr [rsi+4*r8+0x10]
+       sub      r9d, r8d
+       cmp      r9d, edx
+       jb       G_M000_IG281
+       cmp      byte  ptr [rsi], sil
+       mov      edx, r8d
+       lea      rdx, bword ptr [rsi+4*rdx+0x10]
        jmp      SHORT G_M000_IG108
  
 G_M000_IG107:
        or       edx, r8d
        jne      G_M000_IG281
        xor      rdx, rdx
  
 G_M000_IG108:
        movsxd   rdi, edi
        mov      edx, dword ptr [rdx+4*rdi]
        lea      edi, [rdx-0x0A]
        cmp      edi, 3
        jbe      G_M000_IG101
  
 G_M000_IG109:
        add      edx, -19
        cmp      edx, 3
        jbe      G_M000_IG101
  
 G_M000_IG110:
        test     eax, eax
        je       G_M000_IG116
        mov      rdx, r12
        mov      rdi, r11
        mov      rsi, gword ptr [rdi]
        mov      r8d, dword ptr [rdi+0x08]
        mov      edi, dword ptr [rdi+0x0C]
        test     rsi, rsi
        je       SHORT G_M000_IG111
-       mov      r9d, r8d
-       add      rdi, r9
        mov      r9d, dword ptr [rsi+0x08]
-       cmp      rdi, r9
+       cmp      r8d, r9d
        ja       G_M000_IG281
-       lea      rdi, bword ptr [rsi+4*r8+0x10]
+       sub      r9d, r8d
+       cmp      r9d, edi
+       jb       G_M000_IG281
+       cmp      byte  ptr [rsi], sil
+       mov      edi, r8d
+       lea      rdi, bword ptr [rsi+4*rdi+0x10]
        jmp      SHORT G_M000_IG112
  
 G_M000_IG111:
        or       edi, r8d
        jne      G_M000_IG281
        xor      rdi, rdi
  
 G_M000_IG112:
        lea      esi, [rax-0x01]
        movsxd   rsi, esi
        mov      edi, dword ptr [rdi+4*rsi]
        mov      rsi, gword ptr [rdx]
        mov      r8d, dword ptr [rdx+0x08]
        mov      edx, dword ptr [rdx+0x0C]
        test     rsi, rsi
        je       SHORT G_M000_IG113
-       mov      r9d, r8d
-       add      rdx, r9
        mov      r9d, dword ptr [rsi+0x08]
-       cmp      rdx, r9
+       cmp      r8d, r9d
        ja       G_M000_IG281
-       lea      rdx, bword ptr [rsi+4*r8+0x10]
+       sub      r9d, r8d
+       cmp      r9d, edx
+       jb       G_M000_IG281
+       cmp      byte  ptr [rsi], sil
+       mov      edx, r8d
+       lea      rdx, bword ptr [rsi+4*rdx+0x10]
        jmp      SHORT G_M000_IG114
  
 G_M000_IG113:
        or       edx, r8d
        jne      G_M000_IG281
        xor      rdx, rdx
  
 G_M000_IG114:
        movsxd   rdi, edi
        mov      edx, dword ptr [rdx+4*rdi]
        cmp      edx, 3
        je       SHORT G_M000_IG115
        cmp      edx, 6
        jne      SHORT G_M000_IG117
  
 G_M000_IG115:
        mov      edx, 1
        jmp      SHORT G_M000_IG117
  
 G_M000_IG116:
        mov      edx, r15d
  
 G_M000_IG117:
        cmp      ecx, dword ptr [rbx+0x40]
        je       G_M000_IG124
        mov      rdi, r12
        mov      rsi, r11
        mov      r8, gword ptr [rsi]
        mov      r9d, dword ptr [rsi+0x08]
        mov      esi, dword ptr [rsi+0x0C]
        test     r8, r8
        je       SHORT G_M000_IG118
-       mov      r10d, r9d
-       add      rsi, r10
        mov      r10d, dword ptr [r8+0x08]
-       cmp      rsi, r10
+       cmp      r9d, r10d
        ja       G_M000_IG281
-       lea      rsi, bword ptr [r8+4*r9+0x10]
+       sub      r10d, r9d
+       cmp      r10d, esi
+       jb       G_M000_IG281
+       cmp      byte  ptr [r8], r8b
+       mov      esi, r9d
+       lea      rsi, bword ptr [r8+4*rsi+0x10]
        jmp      SHORT G_M000_IG119
  
 G_M000_IG118:
        or       esi, r9d
        jne      G_M000_IG281
        xor      rsi, rsi
  
 G_M000_IG119:
        movsxd   r8, ecx
        mov      esi, dword ptr [rsi+4*r8]
        mov      r8, gword ptr [rdi]
        mov      r9d, dword ptr [rdi+0x08]
        mov      edi, dword ptr [rdi+0x0C]
        test     r8, r8
        je       SHORT G_M000_IG120
-       mov      r10d, r9d
-       add      rdi, r10
        mov      r10d, dword ptr [r8+0x08]
-       cmp      rdi, r10
+       cmp      r9d, r10d
        ja       G_M000_IG281
-       lea      rdi, bword ptr [r8+4*r9+0x10]
+       sub      r10d, r9d
+       cmp      r10d, edi
+       jb       G_M000_IG281
+       cmp      byte  ptr [r8], r8b
+       mov      edi, r9d
+       lea      rdi, bword ptr [r8+4*rdi+0x10]
        jmp      SHORT G_M000_IG121
  
 G_M000_IG120:
        or       edi, r9d
        jne      G_M000_IG281
        xor      rdi, rdi
  
 G_M000_IG121:
        movsxd   rsi, esi
        mov      edi, dword ptr [rdi+4*rsi]
        cmp      edi, 3
        je       SHORT G_M000_IG123
        cmp      edi, 6
        je       SHORT G_M000_IG123
  
 G_M000_IG122:
        mov      r14d, dword ptr [rbp-0x30]
        jmp      SHORT G_M000_IG125
        align    [0 bytes for IG128]
  
 G_M000_IG123:
        mov      edi, 1
        mov      r14d, dword ptr [rbp-0x30]
        jmp      SHORT G_M000_IG125
  
 G_M000_IG124:
        mov      r14d, dword ptr [rbp-0x30]
        mov      edi, r14d
  
 G_M000_IG125:
        cmp      edx, edi
        je       SHORT G_M000_IG126
-       mov      edx, dword ptr [rbx+0x3C]
+       mov      edi, dword ptr [rbx+0x3C]
        jmp      SHORT G_M000_IG127
  
 G_M000_IG126:
-       mov      edx, edi
+       mov      edi, edx
  
 G_M000_IG127:
        cmp      eax, ecx
        jge      G_M000_IG135
  
 G_M000_IG128:
-       mov      rdi, r12
+       mov      rdx, r12
        mov      rsi, r11
        mov      r8, gword ptr [rsi]
        mov      r9d, dword ptr [rsi+0x08]
        mov      esi, dword ptr [rsi+0x0C]
        test     r8, r8
        je       SHORT G_M000_IG130
  
 G_M000_IG129:
-       mov      r10d, r9d
-       mov      esi, esi
-       add      rsi, r10
        mov      r10d, dword ptr [r8+0x08]
-       cmp      rsi, r10
+       cmp      r9d, r10d
        ja       G_M000_IG281
-       mov      r9d, r9d
-       lea      rsi, bword ptr [r8+4*r9+0x10]
+       sub      r10d, r9d
+       cmp      r10d, esi
+       jb       G_M000_IG281
+       cmp      byte  ptr [r8], r8b
+       mov      esi, r9d
+       lea      rsi, bword ptr [r8+4*rsi+0x10]
        jmp      SHORT G_M000_IG131
  
 G_M000_IG130:
        or       esi, r9d
        jne      G_M000_IG281
        xor      rsi, rsi
  
 G_M000_IG131:
        movsxd   r8, eax
        mov      esi, dword ptr [rsi+4*r8]
-       mov      r8, gword ptr [rdi]
-       mov      r9d, dword ptr [rdi+0x08]
-       mov      edi, dword ptr [rdi+0x0C]
+       mov      r8, gword ptr [rdx]
+       mov      r9d, dword ptr [rdx+0x08]
+       mov      edx, dword ptr [rdx+0x0C]
        test     r8, r8
        je       SHORT G_M000_IG133
  
 G_M000_IG132:
-       mov      r10d, r9d
-       mov      edi, edi
-       add      rdi, r10
        mov      r10d, dword ptr [r8+0x08]
-       cmp      rdi, r10
+       cmp      r9d, r10d
        ja       G_M000_IG281
+       sub      r10d, r9d
+       cmp      r10d, edx
+       jb       G_M000_IG281
        cmp      byte  ptr [r8], r8b
-       mov      r9d, r9d
-       lea      rdi, bword ptr [r8+4*r9+0x10]
+       mov      edx, r9d
+       lea      rdx, bword ptr [r8+4*rdx+0x10]
        jmp      SHORT G_M000_IG134
  
 G_M000_IG133:
-       or       edi, r9d
+       or       edx, r9d
        jne      G_M000_IG281
-       xor      rdi, rdi
+       xor      rdx, rdx
  
 G_M000_IG134:
        movsxd   rsi, esi
-       mov      dword ptr [rdi+4*rsi], edx
+       mov      dword ptr [rdx+4*rsi], edi
        inc      eax
        cmp      eax, ecx
        jl       G_M000_IG128
  
 G_M000_IG135:
        mov      r13d, ecx
  
 G_M000_IG136:
        inc      r13d
        mov      dword ptr [rbp-0x30], r14d
  
 G_M000_IG137:
        cmp      r13d, dword ptr [rbx+0x40]
        jl       G_M000_IG91
  
 G_M000_IG138:
        xor      r13d, r13d
        test     byte  ptr [rbx+0x38], 1
        jne      G_M000_IG152
        jmp      G_M000_IG168
  
 G_M000_IG139:
        or       edx, edi
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG140:
        movsxd   rdx, r13d
        mov      ecx, dword ptr [rcx+4*rdx]
        mov      rdx, gword ptr [rax]
        mov      edi, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     rdx, rdx
        je       SHORT G_M000_IG142
  
 G_M000_IG141:
-       mov      esi, edi
-       mov      eax, eax
-       add      rax, rsi
        mov      esi, dword ptr [rdx+0x08]
-       cmp      rax, rsi
+       cmp      edi, esi
        ja       G_M000_IG281
+       sub      esi, edi
+       cmp      esi, eax
+       jb       G_M000_IG281
        cmp      byte  ptr [rdx], dl
-       mov      edi, edi
-       lea      rax, bword ptr [rdx+4*rdi+0x10]
+       mov      eax, edi
+       lea      rax, bword ptr [rdx+4*rax+0x10]
        jmp      SHORT G_M000_IG143
  
 G_M000_IG142:
        or       eax, edi
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG143:
        movsxd   rcx, ecx
        mov      eax, dword ptr [rax+4*rcx]
        lea      rcx, bword ptr [rbx+0x108]
        lea      rdx, bword ptr [rcx+0x10]
        mov      rdi, gword ptr [rdx]
        mov      esi, dword ptr [rdx+0x08]
        mov      edx, dword ptr [rdx+0x0C]
        test     rdi, rdi
        je       SHORT G_M000_IG145
  
 G_M000_IG144:
-       mov      r8d, esi
-       mov      edx, edx
-       add      rdx, r8
        mov      r8d, dword ptr [rdi+0x08]
-       cmp      rdx, r8
+       cmp      esi, r8d
        ja       G_M000_IG281
+       sub      r8d, esi
+       cmp      r8d, edx
+       jb       G_M000_IG281
        cmp      byte  ptr [rdi], dil
-       mov      esi, esi
-       lea      rdx, bword ptr [rdi+4*rsi+0x10]
+       mov      edx, esi
+       lea      rdx, bword ptr [rdi+4*rdx+0x10]
        jmp      SHORT G_M000_IG146
  
 G_M000_IG145:
        or       edx, esi
        jne      G_M000_IG281
        xor      rdx, rdx
  
 G_M000_IG146:
        movsxd   rdi, r13d
        mov      edx, dword ptr [rdx+4*rdi]
        mov      rdi, gword ptr [rcx]
        mov      esi, dword ptr [rcx+0x08]
        mov      ecx, dword ptr [rcx+0x0C]
        test     rdi, rdi
        je       SHORT G_M000_IG148
  
 G_M000_IG147:
-       mov      r8d, esi
-       mov      ecx, ecx
-       add      rcx, r8
        mov      r8d, dword ptr [rdi+0x08]
-       cmp      rcx, r8
+       cmp      esi, r8d
        ja       G_M000_IG281
+       sub      r8d, esi
+       cmp      r8d, ecx
+       jb       G_M000_IG281
        cmp      byte  ptr [rdi], dil
-       mov      esi, esi
-       lea      rcx, bword ptr [rdi+rsi+0x10]
+       mov      ecx, esi
+       lea      rcx, bword ptr [rdi+rcx+0x10]
        jmp      SHORT G_M000_IG149
  
 G_M000_IG148:
        or       ecx, esi
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG149:
        movsxd   rdx, edx
        add      rcx, rdx
        cmp      eax, 1
        je       SHORT G_M000_IG151
  
 G_M000_IG150:
        inc      byte  ptr [rcx]
  
 G_M000_IG151:
        inc      r13d
  
 G_M000_IG152:
        cmp      r13d, dword ptr [rbx+0x40]
        jge      G_M000_IG171
        mov      rax, r12
        lea      r11, bword ptr [rax+0x10]
        mov      rcx, gword ptr [r11]
        mov      edx, dword ptr [r11+0x08]
        mov      edi, dword ptr [r11+0x0C]
        test     rcx, rcx
        je       G_M000_IG139
  
 G_M000_IG153:
-       mov      esi, edx
-       mov      edi, edi
-       add      rdi, rsi
        mov      esi, dword ptr [rcx+0x08]
-       cmp      rdi, rsi
+       cmp      edx, esi
        ja       G_M000_IG281
+       sub      esi, edx
+       cmp      esi, edi
+       jb       G_M000_IG281
        cmp      byte  ptr [rcx], cl
        mov      edx, edx
        lea      rcx, bword ptr [rcx+4*rdx+0x10]
        jmp      G_M000_IG140
  
 G_M000_IG154:
        or       ecx, edi
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG155:
        movsxd   rdx, r13d
        mov      ecx, dword ptr [rcx+4*rdx]
        mov      rdx, gword ptr [rax]
        mov      edi, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     rdx, rdx
        je       SHORT G_M000_IG157
  
 G_M000_IG156:
-       mov      esi, edi
-       mov      eax, eax
-       add      rax, rsi
        mov      esi, dword ptr [rdx+0x08]
-       cmp      rax, rsi
+       cmp      edi, esi
        ja       G_M000_IG281
+       sub      esi, edi
+       cmp      esi, eax
+       jb       G_M000_IG281
        cmp      byte  ptr [rdx], dl
-       mov      edi, edi
-       lea      rax, bword ptr [rdx+4*rdi+0x10]
+       mov      eax, edi
+       lea      rax, bword ptr [rdx+4*rax+0x10]
        jmp      SHORT G_M000_IG158
  
 G_M000_IG157:
        or       eax, edi
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG158:
        movsxd   rcx, ecx
        mov      eax, dword ptr [rax+4*rcx]
        lea      rcx, bword ptr [rbx+0x108]
        lea      rdx, bword ptr [rcx+0x10]
        mov      rdi, gword ptr [rdx]
        mov      esi, dword ptr [rdx+0x08]
        mov      edx, dword ptr [rdx+0x0C]
        test     rdi, rdi
        je       SHORT G_M000_IG160
  
 G_M000_IG159:
-       mov      r8d, esi
-       mov      edx, edx
-       add      rdx, r8
        mov      r8d, dword ptr [rdi+0x08]
-       cmp      rdx, r8
+       cmp      esi, r8d
        ja       G_M000_IG281
+       sub      r8d, esi
+       cmp      r8d, edx
+       jb       G_M000_IG281
        cmp      byte  ptr [rdi], dil
-       mov      esi, esi
-       lea      rdx, bword ptr [rdi+4*rsi+0x10]
+       mov      edx, esi
+       lea      rdx, bword ptr [rdi+4*rdx+0x10]
        jmp      SHORT G_M000_IG161
  
 G_M000_IG160:
        or       edx, esi
        jne      G_M000_IG281
        xor      rdx, rdx
  
 G_M000_IG161:
        movsxd   rdi, r13d
        mov      edx, dword ptr [rdx+4*rdi]
        mov      rdi, gword ptr [rcx]
        mov      esi, dword ptr [rcx+0x08]
        mov      ecx, dword ptr [rcx+0x0C]
        test     rdi, rdi
        je       SHORT G_M000_IG163
  
 G_M000_IG162:
-       mov      r8d, esi
-       mov      ecx, ecx
-       add      rcx, r8
        mov      r8d, dword ptr [rdi+0x08]
-       cmp      rcx, r8
+       cmp      esi, r8d
        ja       G_M000_IG281
+       sub      r8d, esi
+       cmp      r8d, ecx
+       jb       G_M000_IG281
        cmp      byte  ptr [rdi], dil
-       mov      esi, esi
-       lea      rcx, bword ptr [rdi+rsi+0x10]
+       mov      ecx, esi
+       lea      rcx, bword ptr [rdi+rcx+0x10]
        jmp      SHORT G_M000_IG164
  
 G_M000_IG163:
        or       ecx, esi
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG164:
        movsxd   rdx, edx
        add      rcx, rdx
        cmp      eax, 1
        je       SHORT G_M000_IG170
  
 G_M000_IG165:
        cmp      eax, 3
        je       SHORT G_M000_IG166
        cmp      eax, 6
        jne      SHORT G_M000_IG167
  
 G_M000_IG166:
        add      byte  ptr [rcx], 2
  
 G_M000_IG167:
        inc      r13d
  
 G_M000_IG168:
        cmp      r13d, dword ptr [rbx+0x40]
        jge      SHORT G_M000_IG171
        mov      rax, r12
        lea      r11, bword ptr [rax+0x10]
        mov      rcx, r11
        mov      rdx, gword ptr [rcx]
        mov      edi, dword ptr [rcx+0x08]
        mov      ecx, dword ptr [rcx+0x0C]
        test     rdx, rdx
        je       G_M000_IG154
  
 G_M000_IG169:
-       mov      esi, edi
-       mov      ecx, ecx
-       add      rcx, rsi
        mov      esi, dword ptr [rdx+0x08]
-       cmp      rcx, rsi
+       cmp      edi, esi
        ja       G_M000_IG281
+       sub      esi, edi
+       cmp      esi, ecx
+       jb       G_M000_IG281
        cmp      byte  ptr [rdx], dl
-       mov      edi, edi
-       lea      rcx, bword ptr [rdx+4*rdi+0x10]
+       mov      ecx, edi
+       lea      rcx, bword ptr [rdx+4*rcx+0x10]
        jmp      G_M000_IG155
  
 G_M000_IG170:
        inc      byte  ptr [rcx]
        jmp      SHORT G_M000_IG167
  
 G_M000_IG171:
-       add      rsp, 312
+       add      rsp, 280
        pop      rbx
        pop      r12
        pop      r13
        pop      r14
        pop      r15
        pop      rbp
        ret      
  
 G_M000_IG172:
        mov      edi, dword ptr [rbp-0x34]
        or       esi, edi
        je       G_M000_IG88
        mov      r13d, 1
        jmp      G_M000_IG190
        align    [0 bytes for IG209]
  
 G_M000_IG173:
-       or       esi, r10d
+       or       edx, r14d
        jne      G_M000_IG281
-       xor      rsi, rsi
+       xor      rdx, rdx
  
 G_M000_IG174:
        movsxd   r9, r13d
-       mov      esi, dword ptr [rsi+4*r9]
+       mov      edx, dword ptr [rdx+4*r9]
        mov      r9, gword ptr [rax]
-       mov      r10d, dword ptr [rax+0x08]
+       mov      r14, r9
+       mov      ecx, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
-       test     r9, r9
+       test     r14, r14
        je       SHORT G_M000_IG176
  
 G_M000_IG175:
-       mov      r14d, r10d
-       mov      eax, eax
-       add      rax, r14
-       mov      r14d, dword ptr [r9+0x08]
-       cmp      rax, r14
+       mov      r8d, dword ptr [r14+0x08]
+       cmp      ecx, r8d
        ja       G_M000_IG281
-       mov      r10d, r10d
-       lea      rax, bword ptr [r9+4*r10+0x10]
+       sub      r8d, ecx
+       cmp      r8d, eax
+       jb       G_M000_IG281
+       mov      eax, ecx
+       lea      rax, bword ptr [r14+4*rax+0x10]
        jmp      SHORT G_M000_IG177
  
 G_M000_IG176:
-       or       eax, r10d
+       or       eax, ecx
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG177:
-       movsxd   rsi, esi
-       lea      rax, bword ptr [rax+4*rsi]
+       movsxd   rcx, edx
+       lea      rax, bword ptr [rax+4*rcx]
        cmp      dword ptr [rax], 4
        je       G_M000_IG192
  
 G_M000_IG178:
        cmp      dword ptr [rax], 7
        jne      G_M000_IG189
-       mov      rsi, r12
-       mov      r9, r11
-       mov      r10, gword ptr [r9]
-       mov      r14d, dword ptr [r9+0x08]
-       mov      r9d, dword ptr [r9+0x0C]
-       test     r10, r10
+       mov      rcx, r12
+       mov      rdx, rsi
+       mov      r14d, r10d
+       mov      r8d, r11d
+       test     rdx, rdx
        je       SHORT G_M000_IG179
-       mov      edx, r14d
-       add      rdx, r9
-       mov      r9d, dword ptr [r10+0x08]
-       cmp      rdx, r9
+       mov      r15d, dword ptr [rdx+0x08]
+       cmp      r14d, r15d
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
-       mov      r9, rdx
+       sub      r15d, r14d
+       cmp      r15d, r8d
+       jb       G_M000_IG281
+       mov      r8d, r14d
+       lea      rdx, bword ptr [rdx+4*r8+0x10]
        jmp      SHORT G_M000_IG180
  
 G_M000_IG179:
-       or       r9d, r14d
+       or       r8d, r14d
        jne      G_M000_IG281
-       xor      r9, r9
+       xor      rdx, rdx
  
 G_M000_IG180:
-       lea      r10d, [r13-0x01]
-       movsxd   r10, r10d
-       mov      r9d, dword ptr [r9+4*r10]
-       mov      r10, gword ptr [rsi]
-       mov      r14d, dword ptr [rsi+0x08]
-       mov      esi, dword ptr [rsi+0x0C]
-       test     r10, r10
+       lea      r8d, [r13-0x01]
+       movsxd   r8, r8d
+       mov      edx, dword ptr [rdx+4*r8]
+       mov      r8, r9
+       mov      r14d, dword ptr [rcx+0x08]
+       mov      ecx, dword ptr [rcx+0x0C]
+       test     r8, r8
        je       SHORT G_M000_IG181
-       mov      edx, r14d
-       add      rdx, rsi
-       mov      esi, dword ptr [r10+0x08]
-       cmp      rdx, rsi
+       mov      r15d, dword ptr [r8+0x08]
+       cmp      r14d, r15d
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
-       mov      rsi, rdx
+       sub      r15d, r14d
+       cmp      r15d, ecx
+       jb       G_M000_IG281
+       mov      ecx, r14d
+       lea      rcx, bword ptr [r8+4*rcx+0x10]
        jmp      SHORT G_M000_IG182
  
 G_M000_IG181:
-       or       esi, r14d
+       or       ecx, r14d
        jne      G_M000_IG281
-       xor      rsi, rsi
+       xor      rcx, rcx
  
 G_M000_IG182:
-       movsxd   r9, r9d
-       mov      esi, dword ptr [rsi+4*r9]
-       mov      r9, r12
-       mov      r10, gword ptr [r11]
-       mov      r14d, dword ptr [r11+0x08]
-       mov      r11d, dword ptr [r11+0x0C]
-       test     r10, r10
+       movsxd   rdx, edx
+       mov      ecx, dword ptr [rcx+4*rdx]
+       mov      rdx, r12
+       test     rsi, rsi
        je       SHORT G_M000_IG183
-       mov      edx, r14d
-       add      rdx, r11
-       mov      r11d, dword ptr [r10+0x08]
-       cmp      rdx, r11
+       mov      r8d, dword ptr [rsi+0x08]
+       cmp      r10d, r8d
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
-       mov      r10, rdx
+       sub      r8d, r10d
+       cmp      r8d, r11d
+       jb       G_M000_IG281
+       mov      r10d, r10d
+       lea      rsi, bword ptr [rsi+4*r10+0x10]
        jmp      SHORT G_M000_IG184
  
 G_M000_IG183:
-       or       r11d, r14d
+       or       r10d, r11d
        jne      G_M000_IG281
-       xor      r10, r10
+       xor      rsi, rsi
  
 G_M000_IG184:
-       lea      r11d, [r13+0x01]
-       movsxd   r11, r11d
-       mov      r10d, dword ptr [r10+4*r11]
-       mov      r11, gword ptr [r9]
-       mov      r14d, dword ptr [r9+0x08]
-       mov      r9d, dword ptr [r9+0x0C]
-       test     r11, r11
+       lea      r8d, [r13+0x01]
+       movsxd   r8, r8d
+       mov      esi, dword ptr [rsi+4*r8]
+       mov      r8d, dword ptr [rdx+0x08]
+       mov      edx, dword ptr [rdx+0x0C]
+       test     r9, r9
        je       SHORT G_M000_IG185
-       mov      edx, r14d
-       add      rdx, r9
-       mov      r9d, dword ptr [r11+0x08]
-       cmp      rdx, r9
+       mov      r10d, dword ptr [r9+0x08]
+       cmp      r8d, r10d
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r11+4*rdx+0x10]
-       mov      r9, rdx
+       sub      r10d, r8d
+       cmp      r10d, edx
+       jb       G_M000_IG281
+       mov      edx, r8d
+       lea      rdx, bword ptr [r9+4*rdx+0x10]
        jmp      SHORT G_M000_IG186
  
 G_M000_IG185:
-       or       r9d, r14d
+       or       edx, r8d
        jne      G_M000_IG281
-       xor      r9, r9
+       xor      rdx, rdx
  
 G_M000_IG186:
-       movsxd   r10, r10d
-       mov      r9d, dword ptr [r9+4*r10]
-       cmp      esi, 6
+       movsxd   rsi, esi
+       mov      edx, dword ptr [rdx+4*rsi]
+       cmp      ecx, 6
        jne      SHORT G_M000_IG187
-       cmp      r9d, 6
+       cmp      edx, 6
        je       SHORT G_M000_IG188
  
 G_M000_IG187:
-       cmp      esi, 3
+       cmp      ecx, 3
        jne      SHORT G_M000_IG189
-       cmp      r9d, 3
+       cmp      edx, 3
        jne      SHORT G_M000_IG189
  
 G_M000_IG188:
-       mov      dword ptr [rax], esi
+       mov      dword ptr [rax], ecx
  
 G_M000_IG189:
        inc      r13d
  
 G_M000_IG190:
        mov      eax, dword ptr [rbx+0x40]
        dec      eax
        cmp      r13d, eax
        jge      G_M000_IG88
        mov      rax, r12
        lea      r11, bword ptr [rax+0x10]
-       mov      rsi, r11
-       mov      r9, gword ptr [rsi]
-       mov      r10d, dword ptr [rsi+0x08]
-       mov      esi, dword ptr [rsi+0x0C]
+       mov      rsi, gword ptr [r11]
+       mov      r9, rsi
+       mov      r10d, dword ptr [r11+0x08]
+       mov      r14d, r10d
+       mov      r11d, dword ptr [r11+0x0C]
+       mov      edx, r11d
        test     r9, r9
        je       G_M000_IG173
  
 G_M000_IG191:
-       mov      r14d, r10d
-       mov      esi, esi
-       add      rsi, r14
-       mov      r14d, dword ptr [r9+0x08]
-       cmp      rsi, r14
+       mov      ecx, dword ptr [r9+0x08]
+       cmp      r14d, ecx
        ja       G_M000_IG281
-       mov      r10d, r10d
-       lea      rsi, bword ptr [r9+4*r10+0x10]
+       sub      ecx, r14d
+       cmp      ecx, edx
+       jb       G_M000_IG281
+       mov      edx, r14d
+       lea      rcx, bword ptr [r9+4*rdx+0x10]
+       mov      rdx, rcx
        jmp      G_M000_IG174
  
 G_M000_IG192:
-       mov      rsi, r12
-       mov      r9, r11
-       mov      r10, gword ptr [r9]
-       mov      r14d, dword ptr [r9+0x08]
-       mov      r9d, dword ptr [r9+0x0C]
-       test     r10, r10
+       mov      rcx, r12
+       mov      rdx, rsi
+       mov      r14d, r10d
+       mov      r8d, r11d
+       test     rdx, rdx
        je       SHORT G_M000_IG193
-       mov      edx, r14d
-       add      rdx, r9
-       mov      r9d, dword ptr [r10+0x08]
-       cmp      rdx, r9
+       mov      r15d, dword ptr [rdx+0x08]
+       cmp      r14d, r15d
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
-       mov      r9, rdx
+       sub      r15d, r14d
+       cmp      r15d, r8d
+       jb       G_M000_IG281
+       mov      r8d, r14d
+       lea      rdx, bword ptr [rdx+4*r8+0x10]
        jmp      SHORT G_M000_IG194
  
 G_M000_IG193:
-       or       r9d, r14d
+       or       r8d, r14d
        jne      G_M000_IG281
-       xor      r9, r9
+       xor      rdx, rdx
  
 G_M000_IG194:
-       lea      r10d, [r13-0x01]
-       movsxd   r10, r10d
-       mov      r9d, dword ptr [r9+4*r10]
-       mov      r10, gword ptr [rsi]
-       mov      r14d, dword ptr [rsi+0x08]
-       mov      esi, dword ptr [rsi+0x0C]
-       test     r10, r10
+       lea      r8d, [r13-0x01]
+       movsxd   r8, r8d
+       mov      edx, dword ptr [rdx+4*r8]
+       mov      r8, r9
+       mov      r14d, dword ptr [rcx+0x08]
+       mov      ecx, dword ptr [rcx+0x0C]
+       test     r8, r8
        je       SHORT G_M000_IG195
-       mov      edx, r14d
-       add      rdx, rsi
-       mov      esi, dword ptr [r10+0x08]
-       cmp      rdx, rsi
+       mov      r15d, dword ptr [r8+0x08]
+       cmp      r14d, r15d
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
-       mov      rsi, rdx
+       sub      r15d, r14d
+       cmp      r15d, ecx
+       jb       G_M000_IG281
+       mov      ecx, r14d
+       lea      rcx, bword ptr [r8+4*rcx+0x10]
        jmp      SHORT G_M000_IG196
  
 G_M000_IG195:
-       or       esi, r14d
+       or       ecx, r14d
        jne      G_M000_IG281
-       xor      rsi, rsi
+       xor      rcx, rcx
  
 G_M000_IG196:
-       movsxd   r9, r9d
-       mov      esi, dword ptr [rsi+4*r9]
-       mov      r9, r12
-       mov      r10, gword ptr [r11]
-       mov      r14d, dword ptr [r11+0x08]
-       mov      r11d, dword ptr [r11+0x0C]
-       test     r10, r10
+       movsxd   rdx, edx
+       mov      ecx, dword ptr [rcx+4*rdx]
+       mov      rdx, r12
+       mov      r8d, r10d
+       mov      r10d, r11d
+       test     rsi, rsi
        je       SHORT G_M000_IG197
-       mov      edx, r14d
-       add      rdx, r11
-       mov      r11d, dword ptr [r10+0x08]
-       cmp      rdx, r11
+       mov      r11d, dword ptr [rsi+0x08]
+       cmp      r8d, r11d
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
-       mov      r10, rdx
+       sub      r11d, r8d
+       cmp      r11d, r10d
+       jb       G_M000_IG281
+       lea      rsi, bword ptr [rsi+4*r8+0x10]
        jmp      SHORT G_M000_IG198
  
 G_M000_IG197:
-       or       r11d, r14d
+       or       r8d, r10d
        jne      G_M000_IG281
-       xor      r10, r10
+       xor      rsi, rsi
  
 G_M000_IG198:
-       lea      r11d, [r13+0x01]
-       movsxd   r11, r11d
-       mov      r10d, dword ptr [r10+4*r11]
-       mov      r11, gword ptr [r9]
-       mov      r14d, dword ptr [r9+0x08]
-       mov      r9d, dword ptr [r9+0x0C]
-       test     r11, r11
+       lea      r8d, [r13+0x01]
+       movsxd   r8, r8d
+       mov      esi, dword ptr [rsi+4*r8]
+       mov      r8, r9
+       mov      r9d, dword ptr [rdx+0x08]
+       mov      edx, dword ptr [rdx+0x0C]
+       test     r8, r8
        je       SHORT G_M000_IG199
-       mov      edx, r14d
-       add      rdx, r9
-       mov      r9d, dword ptr [r11+0x08]
-       cmp      rdx, r9
+       mov      r10d, dword ptr [r8+0x08]
+       cmp      r9d, r10d
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r11+4*rdx+0x10]
-       mov      r9, rdx
+       sub      r10d, r9d
+       cmp      r10d, edx
+       jb       G_M000_IG281
+       mov      edx, r9d
+       lea      rdx, bword ptr [r8+4*rdx+0x10]
        jmp      SHORT G_M000_IG200
  
 G_M000_IG199:
-       or       r9d, r14d
+       or       edx, r9d
        jne      G_M000_IG281
-       xor      r9, r9
+       xor      rdx, rdx
  
 G_M000_IG200:
-       movsxd   r10, r10d
-       mov      r9d, dword ptr [r9+4*r10]
-       cmp      esi, 3
+       movsxd   rsi, esi
+       mov      edx, dword ptr [rdx+4*rsi]
+       cmp      ecx, 3
        jne      G_M000_IG189
-       cmp      r9d, 3
+       cmp      edx, 3
        jne      G_M000_IG189
        mov      dword ptr [rax], 3
        jmp      G_M000_IG189
  
 G_M000_IG201:
        mov      rax, r12
        lea      r11, bword ptr [rax+0x10]
        mov      rsi, r11
        mov      r9, gword ptr [rsi]
        mov      r10d, dword ptr [rsi+0x08]
        mov      esi, dword ptr [rsi+0x0C]
        test     r9, r9
        je       SHORT G_M000_IG203
  
 G_M000_IG202:
-       mov      r14d, r10d
-       mov      esi, esi
-       add      rsi, r14
        mov      r14d, dword ptr [r9+0x08]
-       cmp      rsi, r14
+       cmp      r10d, r14d
        ja       G_M000_IG281
-       mov      r10d, r10d
-       lea      rsi, bword ptr [r9+4*r10+0x10]
+       sub      r14d, r10d
+       cmp      r14d, esi
+       jb       G_M000_IG281
+       mov      esi, r10d
+       lea      rsi, bword ptr [r9+4*rsi+0x10]
        jmp      SHORT G_M000_IG204
  
 G_M000_IG203:
        or       esi, r10d
        jne      G_M000_IG281
        xor      rsi, rsi
  
 G_M000_IG204:
        movsxd   r9, r13d
        mov      esi, dword ptr [rsi+4*r9]
        mov      r9, gword ptr [rax]
        mov      r10d, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     r9, r9
        je       SHORT G_M000_IG206
  
 G_M000_IG205:
-       mov      r14d, r10d
-       mov      eax, eax
-       add      rax, r14
        mov      r14d, dword ptr [r9+0x08]
-       cmp      rax, r14
+       cmp      r10d, r14d
        ja       G_M000_IG281
-       mov      r10d, r10d
-       lea      rax, bword ptr [r9+4*r10+0x10]
+       sub      r14d, r10d
+       cmp      r14d, eax
+       jb       G_M000_IG281
+       mov      eax, r10d
+       lea      rax, bword ptr [r9+4*rax+0x10]
        jmp      SHORT G_M000_IG207
  
 G_M000_IG206:
        or       eax, r10d
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG207:
        movsxd   rsi, esi
        cmp      dword ptr [rax+4*rsi], 5
        jne      G_M000_IG231
  
 G_M000_IG208:
        mov      eax, r13d
        jmp      SHORT G_M000_IG210
  
 G_M000_IG209:
        inc      eax
  
 G_M000_IG210:
        cmp      eax, dword ptr [rbx+0x40]
        jge      G_M000_IG217
        mov      rsi, r12
        mov      r9, r11
        mov      r10, gword ptr [r9]
        mov      r14d, dword ptr [r9+0x08]
        mov      r9d, dword ptr [r9+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG212
  
 G_M000_IG211:
-       mov      edx, r14d
-       mov      r9d, r9d
-       add      rdx, r9
-       mov      r9d, dword ptr [r10+0x08]
-       cmp      rdx, r9
+       mov      edx, dword ptr [r10+0x08]
+       cmp      r14d, edx
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
+       sub      edx, r14d
+       cmp      edx, r9d
+       jb       G_M000_IG281
+       mov      r9d, r14d
+       lea      rdx, bword ptr [r10+4*r9+0x10]
        mov      r9, rdx
        jmp      SHORT G_M000_IG213
  
 G_M000_IG212:
        or       r9d, r14d
        jne      G_M000_IG281
        xor      r9, r9
  
 G_M000_IG213:
        movsxd   r10, eax
        mov      r9d, dword ptr [r9+4*r10]
        mov      r10, gword ptr [rsi]
        mov      r14d, dword ptr [rsi+0x08]
        mov      esi, dword ptr [rsi+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG215
  
 G_M000_IG214:
-       mov      edx, r14d
-       mov      esi, esi
-       add      rdx, rsi
-       mov      esi, dword ptr [r10+0x08]
-       cmp      rdx, rsi
+       mov      edx, dword ptr [r10+0x08]
+       cmp      r14d, edx
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
+       sub      edx, r14d
+       cmp      edx, esi
+       jb       G_M000_IG281
+       mov      esi, r14d
+       lea      rdx, bword ptr [r10+4*rsi+0x10]
        mov      rsi, rdx
        jmp      SHORT G_M000_IG216
  
 G_M000_IG215:
        or       esi, r14d
        jne      G_M000_IG281
        xor      rsi, rsi
  
 G_M000_IG216:
        movsxd   r9, r9d
        cmp      dword ptr [rsi+4*r9], 5
        je       G_M000_IG209
  
 G_M000_IG217:
        test     r13d, r13d
        jne      SHORT G_M000_IG218
        mov      r15d, dword ptr [rbp-0x2C]
        mov      esi, r15d
        jmp      G_M000_IG223
  
 G_M000_IG218:
        mov      rsi, r12
        mov      r9, r11
        mov      r10, gword ptr [r9]
        mov      r14d, dword ptr [r9+0x08]
        mov      r9d, dword ptr [r9+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG219
-       mov      edx, r14d
-       add      rdx, r9
-       mov      r9d, dword ptr [r10+0x08]
-       cmp      rdx, r9
+       mov      edx, dword ptr [r10+0x08]
+       cmp      r14d, edx
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
+       sub      edx, r14d
+       cmp      edx, r9d
+       jb       G_M000_IG281
+       mov      r9d, r14d
+       lea      rdx, bword ptr [r10+4*r9+0x10]
        mov      r9, rdx
        jmp      SHORT G_M000_IG220
  
 G_M000_IG219:
        or       r9d, r14d
        jne      G_M000_IG281
        xor      r9, r9
  
 G_M000_IG220:
        lea      r10d, [r13-0x01]
        movsxd   r10, r10d
        mov      r9d, dword ptr [r9+4*r10]
        mov      r10, gword ptr [rsi]
        mov      r14d, dword ptr [rsi+0x08]
        mov      esi, dword ptr [rsi+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG221
-       mov      edx, r14d
-       add      rdx, rsi
-       mov      esi, dword ptr [r10+0x08]
-       cmp      rdx, rsi
+       mov      edx, dword ptr [r10+0x08]
+       cmp      r14d, edx
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
+       sub      edx, r14d
+       cmp      edx, esi
+       jb       G_M000_IG281
+       mov      esi, r14d
+       lea      rdx, bword ptr [r10+4*rsi+0x10]
        mov      rsi, rdx
        jmp      SHORT G_M000_IG222
  
 G_M000_IG221:
        or       esi, r14d
        jne      G_M000_IG281
        xor      rsi, rsi
  
 G_M000_IG222:
        movsxd   r9, r9d
        mov      esi, dword ptr [rsi+4*r9]
        mov      r15d, dword ptr [rbp-0x2C]
  
 G_M000_IG223:
        cmp      esi, 3
        je       G_M000_IG278
        cmp      eax, dword ptr [rbx+0x40]
        jne      SHORT G_M000_IG224
        mov      r14d, dword ptr [rbp-0x30]
        mov      esi, r14d
        jmp      G_M000_IG229
  
 G_M000_IG224:
        mov      rsi, r12
        mov      r9, r11
        mov      r10, gword ptr [r9]
        mov      r14d, dword ptr [r9+0x08]
        mov      r9d, dword ptr [r9+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG225
-       mov      edx, r14d
-       add      rdx, r9
-       mov      r9d, dword ptr [r10+0x08]
-       cmp      rdx, r9
+       mov      edx, dword ptr [r10+0x08]
+       cmp      r14d, edx
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
+       sub      edx, r14d
+       cmp      edx, r9d
+       jb       G_M000_IG281
+       mov      r9d, r14d
+       lea      rdx, bword ptr [r10+4*r9+0x10]
        mov      r9, rdx
        jmp      SHORT G_M000_IG226
  
 G_M000_IG225:
        or       r9d, r14d
        jne      G_M000_IG281
        xor      r9, r9
  
 G_M000_IG226:
        movsxd   r10, eax
        mov      r9d, dword ptr [r9+4*r10]
        mov      r10, gword ptr [rsi]
        mov      r14d, dword ptr [rsi+0x08]
        mov      esi, dword ptr [rsi+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG227
-       mov      edx, r14d
-       add      rdx, rsi
-       mov      esi, dword ptr [r10+0x08]
-       cmp      rdx, rsi
+       mov      edx, dword ptr [r10+0x08]
+       cmp      r14d, edx
        ja       G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
+       sub      edx, r14d
+       cmp      edx, esi
+       jb       G_M000_IG281
+       mov      esi, r14d
+       lea      rdx, bword ptr [r10+4*rsi+0x10]
        mov      rsi, rdx
        jmp      SHORT G_M000_IG228
  
 G_M000_IG227:
        or       esi, r14d
        jne      G_M000_IG281
        xor      rsi, rsi
  
 G_M000_IG228:
        movsxd   r9, r9d
        mov      esi, dword ptr [rsi+4*r9]
  
 G_M000_IG229:
        cmp      esi, 3
        je       G_M000_IG278
  
 G_M000_IG230:
        mov      r13d, eax
        mov      dword ptr [rbp-0x2C], r15d
  
 G_M000_IG231:
        inc      r13d
  
 G_M000_IG232:
        cmp      r13d, dword ptr [rbx+0x40]
        jl       G_M000_IG201
  
 G_M000_IG233:
+       mov      ecx, dword ptr [rbp-0x3C]
        or       ecx, r8d
        or       ecx, dword ptr [rbp-0x40]
        je       G_M000_IG246
  
 G_M000_IG234:
        xor      r13d, r13d
        jmp      G_M000_IG245
        align    [0 bytes for IG235]
  
 G_M000_IG235:
        mov      rax, r12
        lea      r11, bword ptr [rax+0x10]
        mov      rcx, gword ptr [r11]
        mov      edx, dword ptr [r11+0x08]
        mov      esi, dword ptr [r11+0x0C]
        test     rcx, rcx
        je       SHORT G_M000_IG237
  
 G_M000_IG236:
-       mov      r8d, edx
-       mov      esi, esi
-       add      rsi, r8
        mov      r8d, dword ptr [rcx+0x08]
-       cmp      rsi, r8
+       cmp      edx, r8d
        ja       G_M000_IG281
+       sub      r8d, edx
+       cmp      r8d, esi
+       jb       G_M000_IG281
        mov      edx, edx
        lea      rcx, bword ptr [rcx+4*rdx+0x10]
        jmp      SHORT G_M000_IG238
  
 G_M000_IG237:
        or       edx, esi
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG238:
        movsxd   rdx, r13d
        mov      ecx, dword ptr [rcx+4*rdx]
        mov      rdx, gword ptr [rax]
        mov      esi, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     rdx, rdx
        je       SHORT G_M000_IG240
  
 G_M000_IG239:
-       mov      r8d, esi
-       mov      eax, eax
-       add      rax, r8
        mov      r8d, dword ptr [rdx+0x08]
-       cmp      rax, r8
+       cmp      esi, r8d
        ja       G_M000_IG281
-       mov      esi, esi
-       lea      rax, bword ptr [rdx+4*rsi+0x10]
+       sub      r8d, esi
+       cmp      r8d, eax
+       jb       G_M000_IG281
+       mov      eax, esi
+       lea      rax, bword ptr [rdx+4*rax+0x10]
        jmp      SHORT G_M000_IG241
  
 G_M000_IG240:
        or       eax, esi
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG241:
        movsxd   rcx, ecx
        lea      rax, bword ptr [rax+4*rcx]
        mov      ecx, dword ptr [rax]
        lea      edx, [rcx-0x04]
        cmp      edx, 1
        jbe      SHORT G_M000_IG243
  
 G_M000_IG242:
        cmp      ecx, 7
        jne      SHORT G_M000_IG244
  
 G_M000_IG243:
        mov      dword ptr [rax], 13
  
 G_M000_IG244:
        inc      r13d
  
 G_M000_IG245:
        cmp      r13d, dword ptr [rbx+0x40]
        jl       G_M000_IG235
  
 G_M000_IG246:
        test     edi, edi
        jne      G_M000_IG90
  
 G_M000_IG247:
        mov      r15d, dword ptr [rbp-0x2C]
        jmp      G_M000_IG264
        align    [0 bytes for IG248]
  
 G_M000_IG248:
        mov      rax, r12
        lea      r11, bword ptr [rax+0x10]
        mov      rcx, r11
        mov      rdx, gword ptr [rcx]
        mov      esi, dword ptr [rcx+0x08]
        mov      ecx, dword ptr [rcx+0x0C]
        test     rdx, rdx
        je       SHORT G_M000_IG250
  
 G_M000_IG249:
-       mov      r8d, esi
-       mov      ecx, ecx
-       add      rcx, r8
        mov      r8d, dword ptr [rdx+0x08]
-       cmp      rcx, r8
+       cmp      esi, r8d
        ja       G_M000_IG281
-       mov      esi, esi
-       lea      rcx, bword ptr [rdx+4*rsi+0x10]
+       sub      r8d, esi
+       cmp      r8d, ecx
+       jb       G_M000_IG281
+       cmp      byte  ptr [rdx], dl
+       mov      ecx, esi
+       lea      rcx, bword ptr [rdx+4*rcx+0x10]
        jmp      SHORT G_M000_IG251
  
 G_M000_IG250:
        or       ecx, esi
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG251:
        movsxd   rdx, r13d
        mov      ecx, dword ptr [rcx+4*rdx]
        mov      rdx, gword ptr [rax]
        mov      esi, dword ptr [rax+0x08]
        mov      eax, dword ptr [rax+0x0C]
        test     rdx, rdx
        je       SHORT G_M000_IG253
  
 G_M000_IG252:
-       mov      r8d, esi
-       mov      eax, eax
-       add      rax, r8
        mov      r8d, dword ptr [rdx+0x08]
-       cmp      rax, r8
+       cmp      esi, r8d
        ja       G_M000_IG281
-       mov      esi, esi
-       lea      rax, bword ptr [rdx+4*rsi+0x10]
+       sub      r8d, esi
+       cmp      r8d, eax
+       jb       G_M000_IG281
+       cmp      byte  ptr [rdx], dl
+       mov      eax, esi
+       lea      rax, bword ptr [rdx+4*rax+0x10]
        jmp      SHORT G_M000_IG254
  
 G_M000_IG253:
        or       eax, esi
        jne      G_M000_IG281
        xor      rax, rax
  
 G_M000_IG254:
        movsxd   rcx, ecx
        lea      rax, bword ptr [rax+4*rcx]
        cmp      dword ptr [rax], 3
        jne      G_M000_IG260
  
 G_M000_IG255:
        test     edi, edi
        jne      G_M000_IG260
        mov      rcx, r12
        mov      rdx, r11
        mov      rsi, gword ptr [rdx]
        mov      r8d, dword ptr [rdx+0x08]
        mov      edx, dword ptr [rdx+0x0C]
        test     rsi, rsi
        je       SHORT G_M000_IG256
-       mov      r9d, r8d
-       add      rdx, r9
        mov      r9d, dword ptr [rsi+0x08]
-       cmp      rdx, r9
+       cmp      r8d, r9d
        ja       G_M000_IG281
-       lea      rdx, bword ptr [rsi+4*r8+0x10]
+       sub      r9d, r8d
+       cmp      r9d, edx
+       jb       G_M000_IG281
+       cmp      byte  ptr [rsi], sil
+       mov      edx, r8d
+       lea      rdx, bword ptr [rsi+4*rdx+0x10]
        jmp      SHORT G_M000_IG257
  
 G_M000_IG256:
        or       edx, r8d
        jne      G_M000_IG281
        xor      rdx, rdx
  
 G_M000_IG257:
        movsxd   rsi, r13d
        mov      edx, dword ptr [rdx+4*rsi]
        mov      rsi, gword ptr [rcx]
        mov      r8d, dword ptr [rcx+0x08]
        mov      ecx, dword ptr [rcx+0x0C]
        test     rsi, rsi
        je       SHORT G_M000_IG258
-       mov      r9d, r8d
-       add      rcx, r9
        mov      r9d, dword ptr [rsi+0x08]
-       cmp      rcx, r9
+       cmp      r8d, r9d
        ja       G_M000_IG281
-       lea      rcx, bword ptr [rsi+4*r8+0x10]
+       sub      r9d, r8d
+       cmp      r9d, ecx
+       jb       G_M000_IG281
+       cmp      byte  ptr [rsi], sil
+       mov      ecx, r8d
+       lea      rcx, bword ptr [rsi+4*rcx+0x10]
        jmp      SHORT G_M000_IG259
  
 G_M000_IG258:
        or       ecx, r8d
        jne      G_M000_IG281
        xor      rcx, rcx
  
 G_M000_IG259:
        movsxd   rdx, edx
        xor      esi, esi
        mov      dword ptr [rcx+4*rdx], esi
  
 G_M000_IG260:
        cmp      dword ptr [rax], 1
        ja       SHORT G_M000_IG262
  
 G_M000_IG261:
        mov      edi, dword ptr [rax]
  
 G_M000_IG262:
        inc      r13d
  
 G_M000_IG263:
        cmp      r13d, dword ptr [rbx+0x40]
        jl       G_M000_IG248
  
 G_M000_IG264:
        cmp      byte  ptr [rbx+0x44], 0
        je       G_M000_IG273
  
 G_M000_IG265:
        mov      rdi, rbx
        mov      rax, 0xD1FFAB1E
        call     [rax]SixLabors.Fonts.Unicode.BidiAlgorithm:LocatePairedBrackets():System.Collections.Generic.List`1[SixLabors.Fonts.Unicode.BidiAlgorithm+BracketPair]:this
        mov      r13, rax
        xor      esi, esi
        xor      eax, eax
        mov      ecx, dword ptr [r13+0x10]
        mov      dword ptr [rbp-0x50], ecx
        test     ecx, ecx
        jle      G_M000_IG273
  
 G_M000_IG266:
        cmp      eax, dword ptr [r13+0x10]
        jae      G_M000_IG282
        mov      rsi, gword ptr [r13+0x08]
        cmp      eax, dword ptr [rsi+0x08]
        jae      G_M000_IG283
        mov      dword ptr [rbp-0x4C], eax
        mov      edi, eax
        mov      rsi, qword ptr [rsi+8*rdi+0x10]
        mov      qword ptr [rbp-0x58], rsi
        lea      rsi, [rbp-0x58]
        mov      rdi, rbx
        mov      rdx, 0xD1FFAB1E
        call     [rdx]SixLabors.Fonts.Unicode.BidiAlgorithm:InspectPairedBracket(byref):int:this
        cmp      eax, 13
        je       SHORT G_M000_IG272
  
 G_M000_IG267:
        test     eax, eax
        je       SHORT G_M000_IG268
        cmp      eax, 1
        jne      SHORT G_M000_IG269
  
 G_M000_IG268:
        cmp      eax, dword ptr [rbx+0x3C]
        je       SHORT G_M000_IG271
  
 G_M000_IG269:
        lea      rsi, [rbp-0x58]
        mov      rdi, rbx
        mov      edx, r15d
        mov      rax, 0xD1FFAB1E
        call     [rax]SixLabors.Fonts.Unicode.BidiAlgorithm:InspectBeforePairedBracket(byref,int):int:this
        cmp      eax, dword ptr [rbx+0x3C]
        je       SHORT G_M000_IG270
        cmp      eax, 13
        jne      SHORT G_M000_IG271
  
 G_M000_IG270:
        mov      eax, dword ptr [rbx+0x3C]
  
 G_M000_IG271:
        lea      rsi, [rbp-0x58]
        mov      rdi, rbx
        mov      edx, eax
        mov      rax, 0xD1FFAB1E
        call     [rax]SixLabors.Fonts.Unicode.BidiAlgorithm:SetPairedBracketDirection(byref,int):this
  
 G_M000_IG272:
        mov      eax, dword ptr [rbp-0x4C]
        inc      eax
        mov      ecx, dword ptr [rbp-0x50]
        cmp      eax, ecx
        jl       G_M000_IG266
  
 G_M000_IG273:
        xor      eax, eax
        xor      r13d, r13d
        jmp      G_M000_IG137
        align    [0 bytes for IG274]
  
 G_M000_IG274:
        or       r9d, r14d
        jne      G_M000_IG281
        xor      r9, r9
  
 G_M000_IG275:
        movsxd   r10, r13d
        mov      r9d, dword ptr [r9+4*r10]
        mov      r10, gword ptr [rsi]
        mov      r14d, dword ptr [rsi+0x08]
        mov      esi, dword ptr [rsi+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG280
  
 G_M000_IG276:
-       mov      edx, r14d
-       mov      esi, esi
-       add      rdx, rsi
-       mov      esi, dword ptr [r10+0x08]
-       cmp      rdx, rsi
+       mov      edx, dword ptr [r10+0x08]
+       cmp      r14d, edx
        ja       SHORT G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
+       sub      edx, r14d
+       cmp      edx, esi
+       jb       SHORT G_M000_IG281
+       mov      esi, r14d
+       lea      rdx, bword ptr [r10+4*rsi+0x10]
        mov      rsi, rdx
  
 G_M000_IG277:
        movsxd   r9, r9d
        mov      dword ptr [rsi+4*r9], 3
        inc      r13d
  
 G_M000_IG278:
        cmp      r13d, eax
        jge      G_M000_IG230
        mov      rsi, r12
        mov      r9, r11
        mov      r10, gword ptr [r9]
        mov      r14d, dword ptr [r9+0x08]
        mov      r9d, dword ptr [r9+0x0C]
        test     r10, r10
        je       SHORT G_M000_IG274
  
 G_M000_IG279:
-       mov      edx, r14d
-       mov      r9d, r9d
-       add      rdx, r9
-       mov      r9d, dword ptr [r10+0x08]
-       cmp      rdx, r9
+       mov      edx, dword ptr [r10+0x08]
+       cmp      r14d, edx
        ja       SHORT G_M000_IG281
-       mov      edx, r14d
-       lea      rdx, bword ptr [r10+4*rdx+0x10]
+       sub      edx, r14d
+       cmp      edx, r9d
+       jb       SHORT G_M000_IG281
+       mov      r9d, r14d
+       lea      rdx, bword ptr [r10+4*r9+0x10]
        mov      r9, rdx
        jmp      SHORT G_M000_IG275
  
 G_M000_IG280:
        or       esi, r14d
        jne      SHORT G_M000_IG281
        xor      rsi, rsi
        jmp      SHORT G_M000_IG277
  
 G_M000_IG281:
        mov      rax, 0xD1FFAB1E
        call     [rax]System.ThrowHelper:ThrowArgumentOutOfRangeException()
        int3     
  
 G_M000_IG282:
        mov      rax, 0xD1FFAB1E
        call     [rax]System.ThrowHelper:ThrowArgumentOutOfRange_IndexMustBeLessException()
        int3     
  
 G_M000_IG283:
        call     CORINFO_HELP_RNGCHKFAIL
        int3     
  
 RWD00  	dd	G_M000_IG45 - G_M000_IG02
        	dd	G_M000_IG44 - G_M000_IG02
        	dd	G_M000_IG43 - G_M000_IG02
        	dd	G_M000_IG42 - G_M000_IG02
        	dd	G_M000_IG41 - G_M000_IG02
        	dd	G_M000_IG40 - G_M000_IG02
        	dd	G_M000_IG31 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG46 - G_M000_IG02
        	dd	G_M000_IG30 - G_M000_IG02
        	dd	G_M000_IG30 - G_M000_IG02
        	dd	G_M000_IG30 - G_M000_IG02
        	dd	G_M000_IG30 - G_M000_IG02
 
-; Total bytes of code 6197 for method SixLabors.Fonts.Unicode.BidiAlgorithm:ProcessIsolatedRunSequence(int,int,int):this (FullOpts)
+; Total bytes of code 6498 for method SixLabors.Fonts.Unicode.BidiAlgorithm:ProcessIsolatedRunSequence(int,int,int):this (FullOpts)
 
```

</details>



