Skip to content

Instantly share code, notes, and snippets.

@alexzzzz

alexzzzz/1_Results.md

Last active December 24, 2018 21:59
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save alexzzzz/d34a474bbdd07a558c5896ee1f371869 to your computer and use it in GitHub Desktop.
Save alexzzzz/d34a474bbdd07a558c5896ee1f371869 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
1_Results.md 
BenchmarkDotNet=v0.11.3, OS=Windows 10.0.17758
Intel Core i5-2500K CPU 3.30GHz (Sandy Bridge), 1 CPU, 4 logical and 4 physical cores
  [Host]        : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0
  LegacyJit x64 : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0
  LegacyJit x86 : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0
  Mono x64      : Mono 5.10.0 (Visual Studio), 64bit 
  Mono x86      : Mono 5.10.0 (Visual Studio), 32bit 
  RyuJit x64    : .NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0
Method Job Runtime Mean Error StdDev Rank
ForEach LegacyJit x64 Clr 508.7 ns 0.2974 ns 0.2782 ns ****
For LegacyJit x64 Clr 772.4 ns 4.4679 ns 4.1792 ns *******
ForReverse LegacyJit x64 Clr 770.9 ns 6.3121 ns 5.9044 ns *******
ForLength LegacyJit x64 Clr 541.4 ns 0.1195 ns 0.0933 ns *****
PtrA LegacyJit x64 Clr 392.5 ns 0.0640 ns 0.0535 ns ***
PtrB LegacyJit x64 Clr 693.0 ns 3.6899 ns 3.4515 ns ******
PtrC LegacyJit x64 Clr 690.8 ns 1.1101 ns 0.8667 ns ******
Unrolled2 LegacyJit x64 Clr 261.7 ns 0.5340 ns 0.4459 ns **
Unrolled4 LegacyJit x64 Clr 252.9 ns 0.2708 ns 0.2114 ns *
Unrolled8 LegacyJit x64 Clr 253.2 ns 2.1159 ns 1.9792 ns *
ForEach LegacyJit x86 Clr 766.6 ns 4.4436 ns 4.1566 ns **
For LegacyJit x86 Clr 1,752.9 ns 0.1642 ns 0.1455 ns *****
ForReverse LegacyJit x86 Clr 1,764.4 ns 10.8727 ns 10.1704 ns *****
ForLength LegacyJit x86 Clr 1,754.3 ns 0.1839 ns 0.1630 ns *****
PtrA LegacyJit x86 Clr 764.6 ns 4.9738 ns 4.6525 ns **
PtrB LegacyJit x86 Clr 852.6 ns 0.1058 ns 0.0938 ns ****
PtrC LegacyJit x86 Clr 851.9 ns 0.4263 ns 0.3328 ns ****
Unrolled2 LegacyJit x86 Clr 786.6 ns 0.3382 ns 0.2641 ns ***
Unrolled4 LegacyJit x86 Clr 783.5 ns 1.2952 ns 1.0112 ns ***
Unrolled8 LegacyJit x86 Clr 747.0 ns 0.1215 ns 0.0948 ns *
ForEach Mono x64 Mono 806.0 ns 4.3706 ns 4.0882 ns ******
For Mono x64 Mono 1,040.6 ns 0.2019 ns 0.1790 ns ********
ForReverse Mono x64 Mono 862.2 ns 0.9932 ns 0.8294 ns *******
ForLength Mono x64 Mono 863.1 ns 3.2236 ns 3.0153 ns *******
PtrA Mono x64 Mono 517.1 ns 3.0706 ns 2.8723 ns *
PtrB Mono x64 Mono 525.0 ns 0.6743 ns 0.6308 ns **
PtrC Mono x64 Mono 526.8 ns 1.3480 ns 1.1257 ns **
Unrolled2 Mono x64 Mono 601.1 ns 5.4925 ns 5.1377 ns ***
Unrolled4 Mono x64 Mono 645.4 ns 1.2010 ns 0.9376 ns ****
Unrolled8 Mono x64 Mono 692.7 ns 4.7277 ns 4.4223 ns *****
ForEach Mono x86 Mono 1,785.0 ns 9.3733 ns 8.7678 ns *
For Mono x86 Mono 1,960.7 ns 17.8606 ns 16.7068 ns **
ForReverse Mono x86 Mono 1,804.8 ns 8.4389 ns 7.8937 ns *
ForLength Mono x86 Mono 1,807.8 ns 9.6444 ns 9.0214 ns *
PtrA Mono x86 Mono 1,812.2 ns 3.3487 ns 3.1324 ns *
PtrB Mono x86 Mono 1,795.7 ns 0.2831 ns 0.2510 ns *
PtrC Mono x86 Mono 1,803.5 ns 11.4482 ns 10.7087 ns *
Unrolled2 Mono x86 Mono 1,777.8 ns 11.6161 ns 10.8657 ns *
Unrolled4 Mono x86 Mono 1,760.7 ns 6.6089 ns 5.5187 ns *
Unrolled8 Mono x86 Mono 1,771.3 ns 23.1209 ns 21.6273 ns *
ForEach RyuJit x64 Clr 617.8 ns 7.1546 ns 6.6924 ns ***
For RyuJit x64 Clr 600.4 ns 0.1556 ns 0.1379 ns **
ForReverse RyuJit x64 Clr 641.1 ns 4.0975 ns 3.8328 ns ****
ForLength RyuJit x64 Clr 598.6 ns 2.4116 ns 2.2558 ns **
PtrA RyuJit x64 Clr 511.2 ns 0.6223 ns 0.4858 ns *
PtrB RyuJit x64 Clr 811.3 ns 1.5125 ns 1.2630 ns *******
PtrC RyuJit x64 Clr 811.1 ns 1.1978 ns 1.0002 ns *******
Unrolled2 RyuJit x64 Clr 677.4 ns 0.1004 ns 0.0784 ns ******
Unrolled4 RyuJit x64 Clr 655.5 ns 0.0687 ns 0.0609 ns *****
Unrolled8 RyuJit x64 Clr 661.5 ns 1.2019 ns 1.0654 ns *****
Raw
2_Program.cs
using System;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Columns;
using BenchmarkDotNet.Configs;
using BenchmarkDotNet.Diagnosers;
using BenchmarkDotNet.Environments;
using BenchmarkDotNet.Exporters;
using BenchmarkDotNet.Exporters.Csv;
using BenchmarkDotNet.Jobs;
using BenchmarkDotNet.Running;
namespace ForEachLength
{
[Config(typeof(Config))]
public class Bench
{
private class Config : ManualConfig
{
public Config()
{
Add(Job.Default.With(Jit.LegacyJit).With(Platform.X64).With(Runtime.Clr).WithId("LegacyJit x64"));
Add(Job.Default.With(Jit.RyuJit).With(Platform.X64).With(Runtime.Clr).WithId("RyuJit x64"));
Add(Job.Default.With(new MonoRuntime("Mono", @"H:\Program Files\Mono\bin\mono.exe")).With(Platform.X64).WithId("Mono x64"));
Add(Job.Default.With(Jit.LegacyJit).With(Platform.X86).With(Runtime.Clr).WithId("LegacyJit x86"));
Add(Job.Default.With(new MonoRuntime("Mono", @"H:\Program Files (x86)\Mono\bin\mono.exe")).With(Platform.X64).WithId("Mono x86"));
Add(MarkdownExporter.GitHub);
Add(CsvMeasurementsExporter.Default);
// The same, using the .With() factory methods:
Add(DisassemblyDiagnoser.Create(new DisassemblyDiagnoserConfig()));
Add(BenchmarkLogicalGroupRule.ByJob);
Add(RankColumn.Stars);
}
}
private static readonly int[] array;
static Bench()
{
array = new int[1000];
var r = new Random();
for (var i = 0; i < array.Length; i++)
{
array[i] = r.Next(int.MaxValue / array.Length) - 1;
}
}
[Benchmark]
public long ForEach()
{
var sum = 0L;
foreach (var i in array)
{
sum += i;
}
return sum;
}
[Benchmark]
public long For()
{
var sum = 0L;
for (var index = 0; index < array.Length; index++)
{
sum += array[index];
}
return sum;
}
[Benchmark]
public long ForReverse()
{
var sum = 0L;
for (var index = array.Length - 1; index >= 0; index--)
{
sum += array[index];
}
return sum;
}
[Benchmark]
public long ForLength()
{
var sum = 0L;
var length = array.Length;
for (var index = 0; index < length; index++)
{
sum += array[index];
}
return sum;
}
[Benchmark]
public unsafe long PtrA()
{
var sum = 0L;
fixed (int* start = &array[0])
{
var end = start + array.Length;
for (var p = start; p < end; p++)
{
sum += *p;
}
}
return sum;
}
[Benchmark]
public unsafe long PtrB()
{
var sum = 0L;
fixed (int* start = &array[0])
{
var end = start + array.Length;
for (var p = start; p < end;)
{
sum += *p++;
}
}
return sum;
}
[Benchmark]
public unsafe long PtrC()
{
var sum = 0L;
fixed (int* start = &array[0])
{
var current = start;
var end = start + array.Length;
while (current < end)
{
sum += *current++;
}
}
return sum;
}
[Benchmark]
public unsafe long Unrolled2()
{
var sum = 0L;
fixed (int* start = &array[0])
{
int length = array.Length;
var current = start;
var end = start + (length & ~1);
while (current < end)
{
sum += *current++;
sum += *current++;
}
sum += *current * (length & 1);
}
return sum;
}
[Benchmark]
public unsafe long Unrolled4()
{
var sum = 0L;
fixed (int* start = &array[0])
{
var end = start + (array.Length & ~3);
var current = start;
while (current < end)
{
sum += *current++;
sum += *current++;
sum += *current++;
sum += *current++;
}
end = start + array.Length;
while (current < end)
{
sum += *current++;
}
}
return sum;
}
[Benchmark]
public unsafe long Unrolled8()
{
var sum = 0L;
fixed (int* start = &array[0])
{
var end = start + (array.Length & ~7);
var current = start;
while (current < end)
{
sum += *current++;
sum += *current++;
sum += *current++;
sum += *current++;
sum += *current++;
sum += *current++;
sum += *current++;
sum += *current++;
}
end = start + array.Length;
while (current < end)
{
sum += *current++;
}
}
return sum;
}
}
public static class Program
{
public static void Main()
{
BenchmarkRunner.Run<Bench>();
}
}
}
Raw
3_Disasm.md

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.ForEach()
       xor     ecx,ecx
       mov     r9,13649A58h
       mov     r9,qword ptr [r9]
       mov     r10,qword ptr [r9+8]
       test    r10d,r10d
       jle     M00_L01
       xor     edx,edx
       xor     r8d,r8d
       nop     dword ptr [rax]
M00_L00:
       mov     eax,dword ptr [r9+r8+10h]
       movsxd  rax,eax
       add     rcx,rax
       inc     edx
       add     r8,4
       cmp     edx,r10d
       jl      M00_L00
M00_L01:
       mov     rax,rcx
; Total bytes of code 57

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.For()
       xor     edx,edx
       mov     rax,13679A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       test    ecx,ecx
       jle     M00_L01
       xor     ecx,ecx
       nop     dword ptr [rax]
M00_L00:
       mov     rax,13679A58h
       mov     rax,qword ptr [rax]
       movsxd  r9,ecx
       mov     r8,qword ptr [rax+8]
       cmp     r9,r8
       jae     M00_L02
       movsxd  rax,dword ptr [rax+r9*4+10h]
       add     rdx,rax
       inc     ecx
       cmp     ecx,r8d
       jl      M00_L00
M00_L01:
       mov     rax,rdx
       add     rsp,28h
       ret
M00_L02:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       add     byte ptr [rax],al
       sbb     dword ptr [rcx+rax],eax
       add     byte ptr [rdx+rax*2],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax-2D1EF60h],bh
       jg      M00_L03
M00_L03:
       add     bl,al
; Total bytes of code 109

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.ForReverse()
       xor     edx,edx
       mov     rax,13809A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       dec     ecx
       test    ecx,ecx
       jl      M00_L01
       nop     dword ptr [rax]
M00_L00:
       mov     r8,13809A58h
       mov     r8,qword ptr [r8]
       movsxd  r9,ecx
       mov     rax,qword ptr [r8+8]
       cmp     r9,rax
       jae     M00_L02
       movsxd  rax,dword ptr [r8+r9*4+10h]
       add     rdx,rax
       dec     ecx
       test    ecx,ecx
       jge     M00_L00
M00_L01:
       mov     rax,rdx
       add     rsp,28h
       ret
       nop
M00_L02:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       add     byte ptr [rax],al
       sbb     dword ptr [rcx+rax],eax
       add     byte ptr [rdx+rax*2],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     al,al
       mov     al,byte ptr [00C300007FFD2E0Dh]
; Total bytes of code 110

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.ForLength()
       xor     edx,edx
       mov     rax,135E9A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       movsxd  r9,ecx
       test    ecx,ecx
       jle     M00_L01
       xor     ecx,ecx
M00_L00:
       mov     r8,135E9A58h
       mov     r8,qword ptr [r8]
       mov     rax,qword ptr [r8+8]
       cmp     rcx,rax
       jae     M00_L02
       movsxd  rax,dword ptr [r8+rcx*4+10h]
       add     rdx,rax
       inc     rcx
       cmp     rcx,r9
       jl      M00_L00
M00_L01:
       mov     rax,rdx
       add     rsp,28h
       ret
       xchg    ax,ax
M00_L02:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       add     byte ptr [rax],al
       sbb     dword ptr [rcx+rax],eax
       add     byte ptr [rdx+rax*2],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax-2D1EE60h],bh
       jg      00007ffd`2e03a00f
; Total bytes of code 107

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.PtrA()
       xor     r8d,r8d
       mov     rcx,13CC9A58h
       mov     rcx,qword ptr [rcx]
       mov     rax,qword ptr [rcx+8]
       test    rax,rax
       jbe     M00_L02
       lea     rax,[rcx+10h]
       mov     qword ptr [rsp+20h],rax
       mov     rdx,qword ptr [rsp+20h]
       mov     rax,13CC9A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       movsxd  rax,ecx
       lea     rcx,[rdx+rax*4]
       cmp     rdx,rcx
       jae     M00_L01
M00_L00:
       movsxd  rax,dword ptr [rdx]
       add     r8,rax
       add     rdx,4
       cmp     rdx,rcx
       jb      M00_L00
M00_L01:
       mov     qword ptr [rsp+20h],0
       mov     rax,r8
       add     rsp,38h
       ret
M00_L02:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       add     byte ptr [rcx],bl
       add     al,1
       add     byte ptr [rdx],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     al,bl
       mov     al,byte ptr [00C300007FFD2E10h]
; Total bytes of code 133

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.PtrB()
       xor     edx,edx
       mov     rcx,133D9A58h
       mov     rcx,qword ptr [rcx]
       mov     rax,qword ptr [rcx+8]
       test    rax,rax
       jbe     M00_L02
       lea     rax,[rcx+10h]
       mov     qword ptr [rsp+20h],rax
       mov     r8,qword ptr [rsp+20h]
       mov     rax,133D9A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       movsxd  rax,ecx
       lea     r9,[r8+rax*4]
       cmp     r8,r9
       jae     M00_L01
M00_L00:
       lea     rcx,[r8+4]
       mov     rax,r8
       mov     r8,rcx
       movsxd  rax,dword ptr [rax]
       add     rdx,rax
       cmp     rcx,r9
       jb      M00_L00
M00_L01:
       mov     qword ptr [rsp+20h],0
       mov     rax,rdx
       add     rsp,38h
       ret
M00_L02:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       sbb     dword ptr [rcx+rax],eax
       add     byte ptr [rdx],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     al,dl
       mov     al,byte ptr [00C300007FFD2E11h]
       add     byte ptr [rax],al
       sbb     dword ptr [rax],eax
; Total bytes of code 137

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.PtrC()
       xor     edx,edx
       mov     rcx,14359A58h
       mov     rcx,qword ptr [rcx]
       mov     rax,qword ptr [rcx+8]
       test    rax,rax
       jbe     M00_L02
       lea     rax,[rcx+10h]
       mov     qword ptr [rsp+20h],rax
       mov     r8,qword ptr [rsp+20h]
       mov     rax,14359A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       movsxd  rax,ecx
       lea     r9,[r8+rax*4]
       cmp     r8,r9
       jae     M00_L01
M00_L00:
       lea     rcx,[r8+4]
       mov     rax,r8
       mov     r8,rcx
       movsxd  rax,dword ptr [rax]
       add     rdx,rax
       cmp     rcx,r9
       jb      M00_L00
M00_L01:
       mov     qword ptr [rsp+20h],0
       mov     rax,rdx
       add     rsp,38h
       ret
M00_L02:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       sbb     dword ptr [rcx+rax],eax
       add     byte ptr [rdx],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     al,dl
       mov     al,byte ptr [00C300007FFD2E0Eh]
       add     byte ptr [rax],al
       sbb     dword ptr [rax],eax
; Total bytes of code 137

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.Unrolled2()
       xor     edx,edx
       mov     rcx,13F69A58h
       mov     rcx,qword ptr [rcx]
       mov     rax,qword ptr [rcx+8]
       test    rax,rax
       jbe     M00_L02
       lea     rax,[rcx+10h]
       mov     qword ptr [rsp+20h],rax
       mov     r9,qword ptr [rsp+20h]
       mov     rax,13F69A58h
       mov     rax,qword ptr [rax]
       mov     r8,qword ptr [rax+8]
       mov     r10,r9
       mov     eax,r8d
       and     eax,0FFFFFFFEh
       movsxd  rax,eax
       lea     r11,[r9+rax*4]
       cmp     r9,r11
       jae     M00_L01
       nop     dword ptr [rax]
M00_L00:
       lea     rcx,[r10+4]
       movsxd  rax,dword ptr [r10]
       add     rdx,rax
       lea     r9,[r10+8]
       add     r10,8
       movsxd  rax,dword ptr [rcx]
       add     rdx,rax
       cmp     r9,r11
       jb      M00_L00
       nop     dword ptr [rax]
M00_L01:
       mov     eax,dword ptr [r9]
       and     r8d,1
       imul    eax,r8d
       movsxd  rax,eax
       add     rdx,rax
       mov     qword ptr [rsp+20h],0
       mov     rax,rdx
       add     rsp,38h
       ret
M00_L02:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       sbb     dword ptr [rcx+rax],eax
       add     byte ptr [rdx],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     al,ah
       mov     al,byte ptr [00C300007FFD2E0Eh]
; Total bytes of code 181

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.Unrolled4()
       xor     edx,edx
       mov     rcx,135B9A58h
       mov     rcx,qword ptr [rcx]
       mov     rax,qword ptr [rcx+8]
       test    rax,rax
       jbe     M00_L04
       lea     rax,[rcx+10h]
       mov     qword ptr [rsp+20h],rax
       mov     r9,qword ptr [rsp+20h]
       mov     rax,135B9A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       and     ecx,0FFFFFFFCh
       movsxd  rax,ecx
       lea     r10,[r9+rax*4]
       mov     r8,r9
       mov     r11,r8
       cmp     r9,r10
       jae     M00_L01
       nop     dword ptr [rax]
M00_L00:
       movsxd  rax,dword ptr [r11]
       add     rdx,rax
       movsxd  rax,dword ptr [r11+4]
       add     rdx,rax
       lea     rcx,[r11+0Ch]
       movsxd  rax,dword ptr [r11+8]
       add     rdx,rax
       lea     r8,[r11+10h]
       add     r11,10h
       movsxd  rax,dword ptr [rcx]
       add     rdx,rax
       cmp     r8,r10
       jb      M00_L00
       nop     dword ptr [rax+rax]
M00_L01:
       mov     rax,135B9A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       movsxd  rax,ecx
       lea     r10,[r9+rax*4]
       cmp     r8,r10
       jae     M00_L03
       nop     dword ptr [rax]
M00_L02:
       lea     rcx,[r8+4]
       mov     rax,r8
       mov     r8,rcx
       movsxd  rax,dword ptr [rax]
       add     rdx,rax
       cmp     rcx,r10
       jb      M00_L02
M00_L03:
       mov     qword ptr [rsp+20h],0
       mov     rax,rdx
       add     rsp,38h
       ret
M00_L04:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       sbb     dword ptr [rcx+rax],eax
       add     byte ptr [rdx],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],cl
       mov     eax,dword ptr [00C300007FFD2E11h]
       add     byte ptr [rax],al
       sbb     dword ptr [rax],eax
; Total bytes of code 233

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit LegacyJIT/clrjit-v4.7.3190.0;compatjit-v4.7.3190.0

; ForEachLength.Bench.Unrolled8()
       xor     r9d,r9d
       mov     rcx,13E69A58h
       mov     rcx,qword ptr [rcx]
       mov     rax,qword ptr [rcx+8]
       test    rax,rax
       jbe     M00_L04
       lea     rax,[rcx+10h]
       mov     qword ptr [rsp+20h],rax
       mov     r8,qword ptr [rsp+20h]
       mov     rax,13E69A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       and     ecx,0FFFFFFF8h
       movsxd  rax,ecx
       lea     r10,[r8+rax*4]
       mov     rdx,r8
       mov     r11,rdx
       cmp     r8,r10
       jae     M00_L01
       xchg    ax,ax
M00_L00:
       movsxd  rax,dword ptr [r11]
       add     r9,rax
       movsxd  rax,dword ptr [r11+4]
       add     r9,rax
       movsxd  rax,dword ptr [r11+8]
       add     r9,rax
       movsxd  rax,dword ptr [r11+0Ch]
       add     r9,rax
       movsxd  rax,dword ptr [r11+10h]
       add     r9,rax
       movsxd  rax,dword ptr [r11+14h]
       add     r9,rax
       lea     rcx,[r11+1Ch]
       movsxd  rax,dword ptr [r11+18h]
       add     r9,rax
       lea     rdx,[r11+20h]
       add     r11,20h
       movsxd  rax,dword ptr [rcx]
       add     r9,rax
       cmp     rdx,r10
       jb      M00_L00
       nop     word ptr [rax+rax]
M00_L01:
       mov     rax,13E69A58h
       mov     rax,qword ptr [rax]
       mov     rcx,qword ptr [rax+8]
       movsxd  rax,ecx
       lea     r10,[r8+rax*4]
       cmp     rdx,r10
       jae     M00_L03
       nop     dword ptr [rax]
M00_L02:
       lea     rcx,[rdx+4]
       mov     rax,rdx
       mov     rdx,rcx
       movsxd  rax,dword ptr [rax]
       add     r9,rax
       cmp     rcx,r10
       jb      M00_L02
M00_L03:
       mov     qword ptr [rsp+20h],0
       mov     rax,r9
       add     rsp,38h
       ret
M00_L04:
       call    clr!TranslateSecurityAttributes+0x87fa0
       nop
       sbb     dword ptr [rcx+rax],eax
       add     byte ptr [rdx],al
       add     byte ptr [rax],al
       add     byte ptr [rax],al
       add     byte ptr [rax],dl
       mov     eax,dword ptr [00C300007FFD2E0Dh]
       add     byte ptr [rax],al
       sbb     dword ptr [rax],eax
; Total bytes of code 265

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.ForEach()
       xor     ecx,ecx
       xor     ebx,ebx
       mov     edi,dword ptr ds:[41D553Ch]
       xor     esi,esi
       cmp     dword ptr [edi+4],0
       jle     M00_L01
M00_L00:
       mov     eax,dword ptr [edi+esi*4+8]
       mov     edx,eax
       sar     edx,1Fh
       add     ecx,eax
       adc     ebx,edx
       inc     esi
       cmp     dword ptr [edi+4],esi
       jg      M00_L00
M00_L01:
       mov     eax,ecx
       mov     edx,ebx
; Total bytes of code 41

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.For()
       mov     dword ptr [ebp-10h],0
       xor     ecx,ecx
       xor     edi,edi
       mov     esi,dword ptr ds:[3C8553Ch]
       mov     eax,dword ptr [esi+4]
       mov     dword ptr [ebp-18h],eax
       test    eax,eax
       jle     M00_L01
       mov     ebx,dword ptr [esi+4]
M00_L00:
       cmp     edi,ebx
       jae     05193945
       mov     eax,dword ptr [esi+edi*4+8]
       cdq
       add     eax,ecx
       adc     edx,dword ptr [ebp-10h]
       mov     dword ptr [ebp-10h],edx
       mov     ecx,eax
       inc     edi
       cmp     dword ptr [ebp-18h],edi
       jg      M00_L00
M00_L01:
       mov     eax,ecx
       mov     edx,dword ptr [ebp-10h]
; Total bytes of code 60

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.ForReverse()
       mov     dword ptr [ebp-10h],0
       xor     ecx,ecx
       mov     edi,dword ptr ds:[38C553Ch]
       mov     esi,dword ptr [edi+4]
       dec     esi
       js      M00_L01
       mov     ebx,dword ptr [edi+4]
M00_L00:
       cmp     esi,ebx
       jae     04ef393c
       mov     eax,dword ptr [edi+esi*4+8]
       cdq
       add     eax,ecx
       adc     edx,dword ptr [ebp-10h]
       mov     dword ptr [ebp-10h],edx
       mov     ecx,eax
       dec     esi
       jns     M00_L00
M00_L01:
       mov     eax,ecx
       mov     edx,dword ptr [ebp-10h]
; Total bytes of code 51

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.ForLength()
       mov     dword ptr [ebp-10h],0
       xor     ecx,ecx
       mov     esi,dword ptr ds:[3CD553Ch]
       mov     eax,dword ptr [esi+4]
       mov     dword ptr [ebp-18h],eax
       xor     edi,edi
       test    eax,eax
       jle     M00_L01
       mov     ebx,dword ptr [esi+4]
M00_L00:
       cmp     edi,ebx
       jae     05123945
       mov     eax,dword ptr [esi+edi*4+8]
       cdq
       add     eax,ecx
       adc     edx,dword ptr [ebp-10h]
       mov     dword ptr [ebp-10h],edx
       mov     ecx,eax
       inc     edi
       cmp     edi,dword ptr [ebp-18h]
       jl      M00_L00
M00_L01:
       mov     eax,ecx
       mov     edx,dword ptr [ebp-10h]
; Total bytes of code 60

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.PtrA()
       xor     ebx,ebx
       xor     edi,edi
       mov     ecx,dword ptr ds:[3E1553Ch]
       cmp     dword ptr [ecx+4],0
       jbe     0536394a
       lea     eax,[ecx+8]
       mov     dword ptr [ebp-10h],eax
       mov     edx,dword ptr [ebp-10h]
       mov     ecx,dword ptr [ecx+4]
       lea     ecx,[edx+ecx*4]
       mov     esi,edx
       cmp     edx,ecx
       jae     M00_L01
M00_L00:
       mov     eax,dword ptr [esi]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       add     esi,4
       cmp     esi,ecx
       jb      M00_L00
M00_L01:
       xor     edx,edx
       mov     dword ptr [ebp-10h],edx
       mov     eax,ebx
       mov     edx,edi
; Total bytes of code 64

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.PtrB()
       xor     ebx,ebx
       xor     edi,edi
       mov     ecx,dword ptr ds:[3A0553Ch]
       cmp     dword ptr [ecx+4],0
       jbe     04ec394c
       lea     eax,[ecx+8]
       mov     dword ptr [ebp-10h],eax
       mov     edx,dword ptr [ebp-10h]
       mov     ecx,dword ptr [ecx+4]
       lea     ecx,[edx+ecx*4]
       mov     esi,edx
       cmp     edx,ecx
       jae     M00_L01
M00_L00:
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       cmp     esi,ecx
       jb      M00_L00
M00_L01:
       xor     edx,edx
       mov     dword ptr [ebp-10h],edx
       mov     eax,ebx
       mov     edx,edi
; Total bytes of code 66

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.PtrC()
       xor     ebx,ebx
       xor     edi,edi
       mov     ecx,dword ptr ds:[433553Ch]
       cmp     dword ptr [ecx+4],0
       jbe     0585394c
       lea     eax,[ecx+8]
       mov     dword ptr [ebp-10h],eax
       mov     edx,dword ptr [ebp-10h]
       mov     esi,edx
       mov     ecx,dword ptr [ecx+4]
       lea     ecx,[edx+ecx*4]
       cmp     edx,ecx
       jae     M00_L01
M00_L00:
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       cmp     esi,ecx
       jb      M00_L00
M00_L01:
       xor     edx,edx
       mov     dword ptr [ebp-10h],edx
       mov     eax,ebx
       mov     edx,edi
; Total bytes of code 66

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.Unrolled2()
       xor     ebx,ebx
       xor     edi,edi
       mov     edx,dword ptr ds:[35C553Ch]
       cmp     dword ptr [edx+4],0
       jbe     04aa397c
       lea     eax,[edx+8]
       mov     dword ptr [ebp-10h],eax
       mov     eax,dword ptr [edx+4]
       mov     dword ptr [ebp-14h],eax
       mov     ecx,dword ptr [ebp-10h]
       mov     esi,ecx
       and     eax,0FFFFFFFEh
       lea     eax,[ecx+eax*4]
       mov     dword ptr [ebp-18h],eax
       cmp     ecx,eax
       jae     M00_L01
M00_L00:
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       cmp     esi,dword ptr [ebp-18h]
       jb      M00_L00
M00_L01:
       mov     eax,dword ptr [ebp-14h]
       and     eax,1
       imul    eax,dword ptr [esi]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       xor     edx,edx
       mov     dword ptr [ebp-10h],edx
       mov     eax,ebx
       mov     edx,edi
; Total bytes of code 110

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.Unrolled4()
       xor     ebx,ebx
       xor     edi,edi
       mov     eax,dword ptr ds:[03A1553Ch]
       cmp     dword ptr [eax+4],0
       jbe     04e939b9
       lea     eax,[eax+8]
       mov     dword ptr [ebp-10h],eax
       mov     eax,dword ptr [ebp-10h]
       mov     dword ptr [ebp-14h],eax
       mov     eax,dword ptr ds:[03A1553Ch]
       mov     ecx,dword ptr [eax+4]
       and     ecx,0FFFFFFFCh
       shl     ecx,2
       add     ecx,dword ptr [ebp-14h]
       mov     esi,dword ptr [ebp-14h]
       cmp     dword ptr [ebp-14h],ecx
       jae     M00_L01
M00_L00:
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       cmp     esi,ecx
       jb      M00_L00
M00_L01:
       mov     eax,dword ptr ds:[03A1553Ch]
       mov     ecx,dword ptr [eax+4]
       shl     ecx,2
       add     ecx,dword ptr [ebp-14h]
       cmp     esi,ecx
       jae     M00_L03
M00_L02:
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       cmp     esi,ecx
       jb      M00_L02
M00_L03:
       xor     edx,edx
       mov     dword ptr [ebp-10h],edx
       mov     eax,ebx
       mov     edx,edi
; Total bytes of code 171

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 32bit LegacyJIT-v4.7.3190.0

; ForEachLength.Bench.Unrolled8()
       xor     ebx,ebx
       xor     edi,edi
       mov     eax,dword ptr ds:[041D553Ch]
       cmp     dword ptr [eax+4],0
       jbe     05753a01
       lea     eax,[eax+8]
       mov     dword ptr [ebp-10h],eax
       mov     eax,dword ptr [ebp-10h]
       mov     dword ptr [ebp-14h],eax
       mov     eax,dword ptr ds:[041D553Ch]
       mov     ecx,dword ptr [eax+4]
       and     ecx,0FFFFFFF8h
       shl     ecx,2
       add     ecx,dword ptr [ebp-14h]
       mov     esi,dword ptr [ebp-14h]
       cmp     dword ptr [ebp-14h],ecx
       jae     M00_L01
M00_L00:
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       cmp     esi,ecx
       jb      M00_L00
M00_L01:
       mov     eax,dword ptr ds:[041D553Ch]
       mov     ecx,dword ptr [eax+4]
       shl     ecx,2
       add     ecx,dword ptr [ebp-14h]
       cmp     esi,ecx
       jae     M00_L03
M00_L02:
       mov     eax,esi
       add     esi,4
       mov     eax,dword ptr [eax]
       mov     edx,eax
       sar     edx,1Fh
       add     ebx,eax
       adc     edi,edx
       cmp     esi,ecx
       jb      M00_L02
M00_L03:
       xor     edx,edx
       mov     dword ptr [ebp-10h],edx
       mov     eax,ebx
       mov     edx,edi
; Total bytes of code 243

Mono 5.10.0 (Visual Studio), 64bit

; ForEach
       sub    $0x28,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       mov    %r14,0x10(%rsp)
       mov    %r15,0x18(%rsp)
       xor    %edi,%edi
       movabs $0x292851cc8d0,%rax
       00 00 
       mov    (%rax),%r15
       xor    %r14d,%r14d
       jmp    4e <EachLength_Bench_ForEach+0x4e>
       lea    0x0(%rsp),%rsp
       movslq %r14d,%rax
       cmp    %eax,0x18(%r15)
       jbe    72 <EachLength_Bench_ForEach+0x72>
       lea    0x20(%r15,%rax,4),%rax
       movslq (%rax),%rsi
       movslq %esi,%rax
       add    %rax,%rdi
       inc    %r14d
       movslq 0x18(%r15),%rax
       cmp    %eax,%r14d
       jl     30 <EachLength_Bench_ForEach+0x30>
       mov    %rdi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       mov    0x10(%rsp),%r14
       mov    0x18(%rsp),%r15
       add    $0x28,%rsp
       retq   
       mov    $0x54,%edx
       mov    $0x189,%ecx
       xchg   %ax,%ax
       movabs $0x292853720d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; For
       sub    $0x18,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       xor    %esi,%esi
       xor    %edi,%edi
       jmp    41 <EachLength_Bench_For+0x41>
       lea    0x0(%rsp),%rsp
       movabs $0x2496ef99ff0,%rax
       00 00 
       mov    (%rax),%rax
       movslq %edi,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    67 <EachLength_Bench_For+0x67>
       lea    0x20(%rax,%rcx,4),%rax
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       inc    %edi
       movabs $0x2496ef99ff0,%rax
       00 00 
       mov    (%rax),%rax
       movslq 0x18(%rax),%rax
       cmp    %eax,%edi
       jl     18 <EachLength_Bench_For+0x18>
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       add    $0x18,%rsp
       retq   
       mov    $0x58,%edx
       mov    $0x189,%ecx
       lea    0x0(%rsp),%rsp
       movabs $0x249709120d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; ForReverse
       sub    $0x18,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       xor    %esi,%esi
       movabs $0x238adfa1950,%rax
       00 00 
       mov    (%rax),%rax
       movslq 0x18(%rax),%rax
       mov    %rax,%rdi
       dec    %edi
       jmp    51 <EachLength_Bench_ForReverse+0x51>
       nop
       movabs $0x238adfa1950,%rax
       00 00 
       mov    (%rax),%rax
       movslq %edi,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    66 <EachLength_Bench_ForReverse+0x66>
       lea    0x20(%rax,%rcx,4),%rax
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       dec    %edi
       test   %edi,%edi
       jge    28 <EachLength_Bench_ForReverse+0x28>
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       add    $0x18,%rsp
       retq   
       mov    $0x48,%edx
       mov    $0x189,%ecx
       lea    0x0(%rsp),%rsp
       nop
       movabs $0x238adf220d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; ForLength
       sub    $0x28,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       mov    %r15,0x10(%rsp)
       xor    %esi,%esi
       movabs $0x243e854f520,%rax
       00 00 
       mov    (%rax),%rax
       movslq 0x18(%rax),%rdi
       xor    %r15d,%r15d
       jmp    5a <EachLength_Bench_ForLength+0x5a>
       lea    0x0(%rsp),%rsp
       nop
       movabs $0x243e854f520,%rax
       00 00 
       mov    (%rax),%rax
       movslq %r15d,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    75 <EachLength_Bench_ForLength+0x75>
       lea    0x20(%rax,%rcx,4),%rax
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       inc    %r15d
       cmp    %edi,%r15d
       jl     30 <EachLength_Bench_ForLength+0x30>
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       mov    0x10(%rsp),%r15
       add    $0x28,%rsp
       retq   
       mov    $0x50,%edx
       mov    $0x189,%ecx
       lea    0x0(%rbp),%rbp
       movabs $0x243e9ec20d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; PtrA
       sub    $0x28,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       mov    %r14,0x10(%rsp)
       mov    %r15,0x18(%rsp)
       xor    %esi,%esi
       movabs $0x23c6ea5aab0,%rax
       00 00 
       mov    (%rax),%rax
       xor    %ecx,%ecx
       movslq %ecx,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    99 <EachLength_Bench_PtrA+0x99>
       lea    0x20(%rax,%rcx,4),%rdi
       mov    %rdi,%rcx
       mov    %rcx,%rax
       movabs $0x23c6ea5aab0,%rdx
       00 00 
       mov    (%rdx),%rdx
       movslq 0x18(%rdx),%rdx
       movslq %edx,%rdx
       mov    $0x4,%r8d
       imul   %r8,%rdx
       mov    %rcx,%r15
       add    %rdx,%r15
       mov    %rax,%r14
       jmp    75 <EachLength_Bench_PtrA+0x75>
       movslq (%r14),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       add    $0x4,%r14
       cmp    %r15,%r14
       jb     68 <EachLength_Bench_PtrA+0x68>
       xor    %eax,%eax
       mov    %eax,%edi
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       mov    0x10(%rsp),%r14
       mov    0x18(%rsp),%r15
       add    $0x28,%rsp
       retq   
       mov    $0x85,%edx
       mov    $0x189,%ecx
       data16 xchg %ax,%ax
       movabs $0x23c6e9820d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; PtrB
       sub    $0x28,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       mov    %r14,0x10(%rsp)
       mov    %r15,0x18(%rsp)
       xor    %esi,%esi
       movabs $0x27e362cc780,%rax
       00 00 
       mov    (%rax),%rax
       xor    %ecx,%ecx
       movslq %ecx,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    9c <EachLength_Bench_PtrB+0x9c>
       lea    0x20(%rax,%rcx,4),%rdi
       mov    %rdi,%rcx
       mov    %rcx,%rax
       movabs $0x27e362cc780,%rdx
       00 00 
       mov    (%rdx),%rdx
       movslq 0x18(%rdx),%rdx
       movslq %edx,%rdx
       mov    $0x4,%r8d
       imul   %r8,%rdx
       mov    %rcx,%r15
       add    %rdx,%r15
       mov    %rax,%r14
       jmp    78 <EachLength_Bench_PtrB+0x78>
       mov    %r14,%rax
       add    $0x4,%r14
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       cmp    %r15,%r14
       jb     68 <EachLength_Bench_PtrB+0x68>
       xor    %eax,%eax
       mov    %eax,%edi
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       mov    0x10(%rsp),%r14
       mov    0x18(%rsp),%r15
       add    $0x28,%rsp
       retq   
       mov    $0x85,%edx
       mov    $0x189,%ecx
       movabs $0x27e364720d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; PtrC
       sub    $0x28,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       mov    %r14,0x10(%rsp)
       mov    %r15,0x18(%rsp)
       xor    %esi,%esi
       movabs $0x1b2661dbba0,%rax
       00 00 
       mov    (%rax),%rax
       xor    %ecx,%ecx
       movslq %ecx,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    9c <EachLength_Bench_PtrC+0x9c>
       lea    0x20(%rax,%rcx,4),%rdi
       mov    %rdi,%rcx
       mov    %rcx,%rax
       mov    %rcx,%r15
       movabs $0x1b2661dbba0,%rcx
       00 00 
       mov    (%rcx),%rcx
       movslq 0x18(%rcx),%rcx
       movslq %ecx,%rcx
       mov    $0x4,%edx
       imul   %rdx,%rcx
       mov    %rax,%r14
       add    %rcx,%r14
       jmp    78 <EachLength_Bench_PtrC+0x78>
       nop
       mov    %r15,%rax
       add    $0x4,%r15
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       cmp    %r14,%r15
       jb     68 <EachLength_Bench_PtrC+0x68>
       xor    %eax,%eax
       mov    %eax,%edi
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       mov    0x10(%rsp),%r14
       mov    0x18(%rsp),%r15
       add    $0x28,%rsp
       retq   
       mov    $0x85,%edx
       mov    $0x189,%ecx
       movabs $0x1b2663620d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; Unrolled2
       sub    $0x38,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       mov    %r13,0x10(%rsp)
       mov    %r14,0x18(%rsp)
       mov    %r15,0x20(%rsp)
       xor    %esi,%esi
       movabs $0x2ae7a8dfbf0,%rax
       00 00 
       mov    (%rax),%rax
       xor    %ecx,%ecx
       movslq %ecx,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    d9 <EachLength_Bench_Unrolled2+0xd9>
       lea    0x20(%rax,%rcx,4),%rdi
       mov    %rdi,%rax
       movabs $0x2ae7a8dfbf0,%rcx
       00 00 
       mov    (%rcx),%rcx
       movslq 0x18(%rcx),%r15
       mov    %rax,%r14
       mov    %r15,%rcx
       and    $0xfffffffe,%ecx
       movslq %ecx,%rcx
       mov    $0x4,%edx
       imul   %rdx,%rcx
       mov    %rax,%r13
       add    %rcx,%r13
       jmpq   9e <EachLength_Bench_Unrolled2+0x9e>
       lea    0x0(%rsp),%rsp
       nop
       mov    %r14,%rax
       add    $0x4,%r14
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       mov    %rsi,%rax
       mov    %r14,%rcx
       add    $0x4,%r14
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       cmp    %r13,%r14
       jb     78 <EachLength_Bench_Unrolled2+0x78>
       movslq (%r14),%rax
       mov    %r15,%rcx
       and    $0x1,%ecx
       imul   %ecx,%eax
       movslq %eax,%rax
       add    %rax,%rsi
       xor    %eax,%eax
       mov    %eax,%edi
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       mov    0x10(%rsp),%r13
       mov    0x18(%rsp),%r14
       mov    0x20(%rsp),%r15
       add    $0x38,%rsp
       retq   
       mov    $0xc0,%edx
       mov    $0x189,%ecx
       data16 xchg %ax,%ax
       movabs $0x2ae7a8120d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; Unrolled4
       sub    $0x38,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       mov    %r13,0x10(%rsp)
       mov    %r14,0x18(%rsp)
       mov    %r15,0x20(%rsp)
       xor    %esi,%esi
       movabs $0x254813fc310,%rax
       00 00 
       mov    (%rax),%rax
       xor    %ecx,%ecx
       movslq %ecx,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    131 <EachLength_Bench_Unrolled4+0x131>
       lea    0x20(%rax,%rcx,4),%rdi
       mov    %rdi,%r15
       mov    %r15,%rax
       movabs $0x254813fc310,%rcx
       00 00 
       mov    (%rcx),%rcx
       movslq 0x18(%rcx),%rcx
       and    $0xfffffffc,%ecx
       movslq %ecx,%rcx
       mov    $0x4,%edx
       imul   %rdx,%rcx
       mov    %rax,%r14
       add    %rcx,%r14
       mov    %r15,%r13
       jmpq   ca <EachLength_Bench_Unrolled4+0xca>
       lea    0x0(%rsp),%rsp
       nop
       mov    %r13,%rax
       add    $0x4,%r13
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       cmp    %r14,%r13
       jb     78 <EachLength_Bench_Unrolled4+0x78>
       movabs $0x254813fc310,%rax
       00 00 
       mov    (%rax),%rax
       movslq 0x18(%rax),%rax
       movslq %eax,%rax
       mov    $0x4,%ecx
       imul   %rcx,%rax
       mov    %r15,%r14
       add    %rax,%r14
       jmp    108 <EachLength_Bench_Unrolled4+0x108>
       lea    0x0(%rbp),%rbp
       mov    %r13,%rax
       add    $0x4,%r13
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       cmp    %r14,%r13
       jb     f8 <EachLength_Bench_Unrolled4+0xf8>
       xor    %eax,%eax
       mov    %eax,%edi
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       mov    0x10(%rsp),%r13
       mov    0x18(%rsp),%r14
       mov    0x20(%rsp),%r15
       add    $0x38,%rsp
       retq   
       mov    $0x118,%edx
       mov    $0x189,%ecx
       data16 xchg %ax,%ax
       movabs $0x254815920d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 64bit

; Unrolled8
       sub    $0x38,%rsp
       mov    %rsi,(%rsp)
       mov    %rdi,0x8(%rsp)
       mov    %r13,0x10(%rsp)
       mov    %r14,0x18(%rsp)
       mov    %r15,0x20(%rsp)
       xor    %esi,%esi
       movabs $0x17f2a2fb040,%rax
       00 00 
       mov    (%rax),%rax
       xor    %ecx,%ecx
       movslq %ecx,%rcx
       cmp    %ecx,0x18(%rax)
       jbe    189 <EachLength_Bench_Unrolled8+0x189>
       lea    0x20(%rax,%rcx,4),%rdi
       mov    %rdi,%r15
       mov    %r15,%rax
       movabs $0x17f2a2fb040,%rcx
       00 00 
       mov    (%rcx),%rcx
       movslq 0x18(%rcx),%rcx
       and    $0xfffffff8,%ecx
       movslq %ecx,%rcx
       mov    $0x4,%edx
       imul   %rdx,%rcx
       mov    %rax,%r14
       add    %rcx,%r14
       mov    %r15,%r13
       jmpq   122 <EachLength_Bench_Unrolled8+0x122>
       lea    0x0(%rsp),%rsp
       nop
       mov    %r13,%rax
       add    $0x4,%r13
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       mov    %rsi,%rax
       mov    %r13,%rcx
       add    $0x4,%r13
       movslq (%rcx),%rcx
       movslq %ecx,%rcx
       mov    %rax,%rsi
       add    %rcx,%rsi
       cmp    %r14,%r13
       jb     78 <EachLength_Bench_Unrolled8+0x78>
       movabs $0x17f2a2fb040,%rax
       00 00 
       mov    (%rax),%rax
       movslq 0x18(%rax),%rax
       movslq %eax,%rax
       mov    $0x4,%ecx
       imul   %rcx,%rax
       mov    %r15,%r14
       add    %rax,%r14
       jmp    160 <EachLength_Bench_Unrolled8+0x160>
       mov    %r13,%rax
       add    $0x4,%r13
       movslq (%rax),%rax
       movslq %eax,%rax
       add    %rax,%rsi
       cmp    %r14,%r13
       jb     150 <EachLength_Bench_Unrolled8+0x150>
       xor    %eax,%eax
       mov    %eax,%edi
       mov    %rsi,%rax
       mov    (%rsp),%rsi
       mov    0x8(%rsp),%rdi
       mov    0x10(%rsp),%r13
       mov    0x18(%rsp),%r14
       mov    0x20(%rsp),%r15
       add    $0x38,%rsp
       retq   
       mov    $0x170,%edx
       mov    $0x189,%ecx
       data16 xchg %ax,%ax
       movabs $0x17f2a4920d0,%r11
       00 00 
       callq  *%r11
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; ForEach
       push   %rbp
       mov    %esp,%ebp
       push   %rbx
       push   %rdi
       push   %rsi
       sub    $0x1c,%esp
       movl   $0x0,-0x18(%rbp)
       movl   $0x0,-0x14(%rbp)
       mov    0xed6f0(%rip),%esi        # ed70d <EachLength_Bench_ForEach+0xed70d>
       xor    %ebx,%ebx
       jmp    52 <EachLength_Bench_ForEach+0x52>
       lea    0x0(%rsp),%esp
       cmp    %ebx,0xc(%rsi)
       jbe    6a <EachLength_Bench_ForEach+0x6a>
       lea    0x10(%rsi,%rbx,4),%eax
       mov    (%rax),%edi
       cmp    $0xffffffff,%edi
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %edi,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       rex.XB mov 0xc(%r14),%eax
       cmp    %eax,%ebx
       jl     28 <EachLength_Bench_ForEach+0x28>
       mov    -0x18(%rbp),%eax
       mov    -0x14(%rbp),%edx
       lea    -0xc(%rbp),%esp
       lea    -0xc(%rbp),%esp
       pop    %rsi
       pop    %rdi
       pop    %rbx
       leaveq 
       retq   
       pushq  $0x4b
       pushq  $0x189
       callq  fffffffffffeff48 <EachLength_Bench_ForEach+0xfffffffffffeff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; For
       push   %rbp
       mov    %esp,%ebp
       push   %rdi
       sub    $0x14,%esp
       movl   $0x0,-0x10(%rbp)
       movl   $0x0,-0xc(%rbp)
       xor    %edi,%edi
       jmp    52 <EachLength_Bench_For+0x52>
       lea    0x0(%rsp),%esp
       mov    0x86f720(%rip),%eax        # 86f746 <EachLength_Bench_For+0x86f746>
       cmp    %edi,0xc(%rax)
       jbe    6e <EachLength_Bench_For+0x6e>
       lea    0x10(%rax,%rdi,4),%eax
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x10(%rbp),%rcx
       add    %eax,%ecx
       mov    -0xc(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x10(%rbp)
       mov    %eax,-0xc(%rbp)
       rex.RXB mov 0x86f720(%rip),%r8d        # 86f778 <EachLength_Bench_For+0x86f778>
       mov    0xc(%rax),%eax
       cmp    %eax,%edi
       jl     20 <EachLength_Bench_For+0x20>
       mov    -0x10(%rbp),%eax
       mov    -0xc(%rbp),%edx
       lea    -0x4(%rbp),%esp
       lea    -0x4(%rbp),%esp
       pop    %rdi
       leaveq 
       retq   
       pushq  $0x51
       pushq  $0x189
       callq  fffffffffc4fff48 <EachLength_Bench_For+0xfffffffffc4fff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; ForReverse
       push   %rbp
       mov    %esp,%ebp
       push   %rdi
       sub    $0x14,%esp
       movl   $0x0,-0x10(%rbp)
       movl   $0x0,-0xc(%rbp)
       mov    0x15e1500(%rip),%eax        # 15e151b <EachLength_Bench_ForReverse+0x15e151b>
       mov    0xc(%rax),%eax
       mov    %eax,%edi
       rex.WRXB jmp 5a <EachLength_Bench_ForReverse+0x5a>
       lea    0x0(%rsp),%esp
       nop
       mov    0x15e1500(%rip),%eax        # 15e152e <EachLength_Bench_ForReverse+0x15e152e>
       cmp    %edi,0xc(%rax)
       jbe    6d <EachLength_Bench_ForReverse+0x6d>
       lea    0x10(%rax,%rdi,4),%eax
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x10(%rbp),%rcx
       add    %eax,%ecx
       mov    -0xc(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x10(%rbp)
       mov    %eax,-0xc(%rbp)
       rex.WRXB test %r15,%r15
       jge    28 <EachLength_Bench_ForReverse+0x28>
       mov    -0x10(%rbp),%eax
       mov    -0xc(%rbp),%edx
       lea    -0x4(%rbp),%esp
       lea    -0x4(%rbp),%esp
       pop    %rdi
       leaveq 
       retq   
       pushq  $0x48
       pushq  $0x189
       callq  fffffffffc8fff48 <EachLength_Bench_ForReverse+0xfffffffffc8fff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; ForLength
       push   %rbp
       mov    %esp,%ebp
       push   %rdi
       push   %rsi
       sub    $0x10,%esp
       movl   $0x0,-0x10(%rbp)
       movl   $0x0,-0xc(%rbp)
       mov    0xc3cde0(%rip),%eax        # c3cdfc <EachLength_Bench_ForLength+0xc3cdfc>
       mov    0xc(%rax),%edi
       xor    %esi,%esi
       jmp    5a <EachLength_Bench_ForLength+0x5a>
       lea    0x0(%rsp),%esp
       nop
       mov    0xc3cde0(%rip),%eax        # c3ce0e <EachLength_Bench_ForLength+0xc3ce0e>
       cmp    %esi,0xc(%rax)
       jbe    6e <EachLength_Bench_ForLength+0x6e>
       lea    0x10(%rax,%rsi,4),%eax
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x10(%rbp),%rcx
       add    %eax,%ecx
       mov    -0xc(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x10(%rbp)
       mov    %eax,-0xc(%rbp)
       rex.RX cmp %edi,%r14d
       jl     28 <EachLength_Bench_ForLength+0x28>
       mov    -0x10(%rbp),%eax
       mov    -0xc(%rbp),%edx
       lea    -0x8(%rbp),%esp
       lea    -0x8(%rbp),%esp
       pop    %rsi
       pop    %rdi
       leaveq 
       retq   
       pushq  $0x49
       pushq  $0x189
       callq  ffffffffff9bff48 <EachLength_Bench_ForLength+0xffffffffff9bff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; PtrA
       push   %rbp
       mov    %esp,%ebp
       push   %rbx
       push   %rdi
       push   %rsi
       sub    $0x1c,%esp
       movl   $0x0,-0x18(%rbp)
       movl   $0x0,-0x14(%rbp)
       mov    0x131fe30(%rip),%eax        # 131fe4d <EachLength_Bench_PtrA+0x131fe4d>
       cmpl   $0x0,0xc(%rax)
       jbe    80 <EachLength_Bench_PtrA+0x80>
       mov    %eax,%edi
       add    $0x10,%edi
       mov    %edi,%ecx
       mov    %ecx,%eax
       mov    0x131fe30(%rip),%edx        # 131fe66 <EachLength_Bench_PtrA+0x131fe66>
       mov    0xc(%rdx),%edx
       shl    $0x2,%edx
       mov    %ecx,%esi
       add    %edx,%esi
       mov    %eax,%ebx
       jmp    69 <EachLength_Bench_PtrA+0x69>
       lea    0x0(%rsp),%esp
       mov    (%rbx),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %eax,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       add    $0x4,%ebx
       cmp    %esi,%ebx
       jb     48 <EachLength_Bench_PtrA+0x48>
       xor    %edi,%edi
       mov    -0x18(%rbp),%eax
       mov    -0x14(%rbp),%edx
       lea    -0xc(%rbp),%esp
       lea    -0xc(%rbp),%esp
       pop    %rsi
       pop    %rdi
       pop    %rbx
       leaveq 
       retq   
       pushq  $0x6b
       pushq  $0x189
       callq  fffffffffc67ff48 <EachLength_Bench_PtrA+0xfffffffffc67ff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; PtrB
       push   %rbp
       mov    %esp,%ebp
       push   %rbx
       push   %rdi
       push   %rsi
       sub    $0x1c,%esp
       movl   $0x0,-0x18(%rbp)
       movl   $0x0,-0x14(%rbp)
       mov    0x6d09c0(%rip),%eax        # 6d09dd <EachLength_Bench_PtrB+0x6d09dd>
       cmpl   $0x0,0xc(%rax)
       jbe    82 <EachLength_Bench_PtrB+0x82>
       mov    %eax,%edi
       add    $0x10,%edi
       mov    %edi,%ecx
       mov    %ecx,%eax
       mov    0x6d09c0(%rip),%edx        # 6d09f6 <EachLength_Bench_PtrB+0x6d09f6>
       mov    0xc(%rdx),%edx
       shl    $0x2,%edx
       mov    %ecx,%esi
       add    %edx,%esi
       mov    %eax,%ebx
       jmp    6b <EachLength_Bench_PtrB+0x6b>
       lea    0x0(%rsp),%esp
       mov    %ebx,%eax
       add    $0x4,%ebx
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %eax,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       cmp    %esi,%ebx
       jb     48 <EachLength_Bench_PtrB+0x48>
       xor    %edi,%edi
       mov    -0x18(%rbp),%eax
       mov    -0x14(%rbp),%edx
       lea    -0xc(%rbp),%esp
       lea    -0xc(%rbp),%esp
       pop    %rsi
       pop    %rdi
       pop    %rbx
       leaveq 
       retq   
       pushq  $0x6d
       pushq  $0x189
       callq  ffffffffffa5ff48 <EachLength_Bench_PtrB+0xffffffffffa5ff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; PtrC
       push   %rbp
       mov    %esp,%ebp
       push   %rbx
       push   %rdi
       push   %rsi
       sub    $0x1c,%esp
       movl   $0x0,-0x18(%rbp)
       movl   $0x0,-0x14(%rbp)
       mov    0x11a0d48(%rip),%eax        # 11a0d65 <EachLength_Bench_PtrC+0x11a0d65>
       cmpl   $0x0,0xc(%rax)
       jbe    82 <EachLength_Bench_PtrC+0x82>
       mov    %eax,%edi
       add    $0x10,%edi
       mov    %edi,%ecx
       mov    %ecx,%eax
       mov    %ecx,%esi
       mov    0x11a0d48(%rip),%ecx        # 11a0d80 <EachLength_Bench_PtrC+0x11a0d80>
       mov    0xc(%rcx),%ecx
       shl    $0x2,%ecx
       mov    %eax,%ebx
       add    %ecx,%ebx
       jmp    6b <EachLength_Bench_PtrC+0x6b>
       lea    0x0(%rsp),%esp
       mov    %esi,%eax
       add    $0x4,%esi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %eax,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       cmp    %ebx,%esi
       jb     48 <EachLength_Bench_PtrC+0x48>
       xor    %edi,%edi
       mov    -0x18(%rbp),%eax
       mov    -0x14(%rbp),%edx
       lea    -0xc(%rbp),%esp
       lea    -0xc(%rbp),%esp
       pop    %rsi
       pop    %rdi
       pop    %rbx
       leaveq 
       retq   
       pushq  $0x6d
       pushq  $0x189
       callq  ffffffffffa5ff48 <EachLength_Bench_PtrC+0xffffffffffa5ff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; Unrolled2
       push   %rbp
       mov    %esp,%ebp
       push   %rbx
       push   %rdi
       push   %rsi
       sub    $0x1c,%esp
       movl   $0x0,-0x18(%rbp)
       movl   $0x0,-0x14(%rbp)
       mov    0x51d8c8(%rip),%eax        # 51d8e5 <EachLength_Bench_Unrolled2+0x51d8e5>
       cmpl   $0x0,0xc(%rax)
       jbe    c4 <EachLength_Bench_Unrolled2+0xc4>
       add    $0x10,%eax
       mov    %eax,-0x1c(%rbp)
       mov    0x51d8c8(%rip),%ecx        # 51d8fd <EachLength_Bench_Unrolled2+0x51d8fd>
       mov    0xc(%rcx),%esi
       mov    %eax,%ebx
       mov    %esi,%ecx
       and    $0xfffffffe,%ecx
       shl    $0x2,%ecx
       mov    %eax,%edi
       add    %ecx,%edi
       jmp    88 <EachLength_Bench_Unrolled2+0x88>
       mov    %ebx,%eax
       add    $0x4,%ebx
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %eax,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x20(%rbp)
       mov    %ebx,%eax
       add    $0x4,%ebx
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x20(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       cmp    %edi,%ebx
       jb     48 <EachLength_Bench_Unrolled2+0x48>
       mov    (%rbx),%edx
       mov    %esi,%eax
       and    $0x1,%eax
       imul   %eax,%edx
       cmp    $0xffffffff,%edx
       setg   %cl
       movzbl %cl,%ecx
       mov    -0x18(%r13),%rax
       add    %edx,%eax
       mov    -0x14(%rbp),%edx
       adc    %ecx,%edx
       mov    %eax,-0x18(%rbp)
       mov    %edx,-0x14(%rbp)
       movl   $0x0,-0x1c(%rbp)
       lea    -0xc(%rbp),%esp
       lea    -0xc(%rbp),%esp
       pop    %rsi
       pop    %rdi
       pop    %rbx
       leaveq 
       retq   
       pushq  $0xb2
       pushq  $0x189
       callq  ffffffffff73ff48 <EachLength_Bench_Unrolled2+0xffffffffff73ff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; Unrolled4
       push   %rbp
       mov    %esp,%ebp
       push   %rbx
       push   %rdi
       push   %rsi
       sub    $0x2c,%esp
       movl   $0x0,-0x18(%rbp)
       movl   $0x0,-0x14(%rbp)
       mov    0xf4c2c0(%rip),%eax        # f4c2dd <EachLength_Bench_Unrolled4+0xf4c2dd>
       cmpl   $0x0,0xc(%rax)
       jbe    11f <EachLength_Bench_Unrolled4+0x11f>
       add    $0x10,%eax
       mov    %eax,-0x1c(%rbp)
       mov    %eax,%esi
       mov    0xf4c2c0(%rip),%ecx        # f4c2f7 <EachLength_Bench_Unrolled4+0xf4c2f7>
       mov    0xc(%rcx),%ecx
       and    $0xfffffffc,%ecx
       shl    $0x2,%ecx
       mov    %eax,%ebx
       add    %ecx,%ebx
       mov    %esi,%edi
       jmpq   ca <EachLength_Bench_Unrolled4+0xca>
       lea    0x0(%rsp),%esp
       nop
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %eax,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x28(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x28(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x24(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x24(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x20(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x20(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       cmp    %ebx,%edi
       jb     50 <EachLength_Bench_Unrolled4+0x50>
       mov    0xf4c2c0(%rip),%eax        # f4c394 <EachLength_Bench_Unrolled4+0xf4c394>
       mov    0xc(%rax),%eax
       shl    $0x2,%eax
       mov    %esi,%ebx
       add    %eax,%ebx
       jmp    103 <EachLength_Bench_Unrolled4+0x103>
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %eax,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       cmp    %ebx,%edi
       jb     e0 <EachLength_Bench_Unrolled4+0xe0>
       movl   $0x0,-0x1c(%rbp)
       mov    -0x18(%rbp),%eax
       mov    -0x14(%rbp),%edx
       lea    -0xc(%rbp),%esp
       lea    -0xc(%rbp),%esp
       pop    %rsi
       pop    %rdi
       pop    %rbx
       leaveq 
       retq   
       pushq  $0x10d
       pushq  $0x189
       callq  fffffffffc67ff48 <EachLength_Bench_Unrolled4+0xfffffffffc67ff48>
; Total bytes of code 0

Mono 5.10.0 (Visual Studio), 32bit

; Unrolled8
       push   %rbp
       mov    %esp,%ebp
       push   %rbx
       push   %rdi
       push   %rsi
       sub    $0x3c,%esp
       movl   $0x0,-0x18(%rbp)
       movl   $0x0,-0x14(%rbp)
       mov    0x132e740(%rip),%eax        # 132e75d <EachLength_Bench_Unrolled8+0x132e75d>
       cmpl   $0x0,0xc(%rax)
       jbe    197 <EachLength_Bench_Unrolled8+0x197>
       add    $0x10,%eax
       mov    %eax,-0x1c(%rbp)
       mov    %eax,%esi
       mov    0x132e740(%rip),%ecx        # 132e777 <EachLength_Bench_Unrolled8+0x132e777>
       mov    0xc(%rcx),%ecx
       and    $0xfffffff8,%ecx
       shl    $0x2,%ecx
       mov    %eax,%ebx
       add    %ecx,%ebx
       mov    %esi,%edi
       jmpq   13e <EachLength_Bench_Unrolled8+0x13e>
       lea    0x0(%rsp),%esp
       nop
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %eax,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x38(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x38(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x34(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x34(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x30(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x30(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x2c(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x2c(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x28(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x28(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x24(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x24(%rbp),%eax
       adc    %edx,%eax
       mov    %eax,-0x20(%rbp)
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX add %rax,%rcx
       mov    -0x20(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       cmp    %ebx,%edi
       jb     50 <EachLength_Bench_Unrolled8+0x50>
       mov    0x132e740(%rip),%eax        # 132e88c <EachLength_Bench_Unrolled8+0x132e88c>
       mov    0xc(%rax),%eax
       shl    $0x2,%eax
       mov    %esi,%ebx
       add    %eax,%ebx
       jmp    17b <EachLength_Bench_Unrolled8+0x17b>
       mov    %edi,%eax
       add    $0x4,%edi
       mov    (%rax),%eax
       cmp    $0xffffffff,%eax
       setg   %dl
       movzbl %dl,%edx
       rex.WX mov -0x18(%rbp),%rcx
       add    %eax,%ecx
       mov    -0x14(%rbp),%eax
       adc    %edx,%eax
       mov    %ecx,-0x18(%rbp)
       mov    %eax,-0x14(%rbp)
       cmp    %ebx,%edi
       jb     158 <EachLength_Bench_Unrolled8+0x158>
       movl   $0x0,-0x1c(%rbp)
       mov    -0x18(%rbp),%eax
       mov    -0x14(%rbp),%edx
       lea    -0xc(%rbp),%esp
       lea    -0xc(%rbp),%esp
       pop    %rsi
       pop    %rdi
       pop    %rbx
       leaveq 
       retq   
       pushq  $0x185
       pushq  $0x189
       callq  fffffffffcf5ff48 <EachLength_Bench_Unrolled8+0xfffffffffcf5ff48>
; Total bytes of code 0

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.ForEach()
       xor     eax,eax
       mov     rdx,qword ptr [13449A58h]
       xor     ecx,ecx
       mov     r8d,dword ptr [rdx+8]
       test    r8d,r8d
       jle     M00_L01
M00_L00:
       movsxd  r9,ecx
       mov     r9d,dword ptr [rdx+r9*4+10h]
       movsxd  r9,r9d
       add     rax,r9
       inc     ecx
       cmp     r8d,ecx
       jg      M00_L00
M00_L01:
       ret
; Total bytes of code 43

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.For()
       xor     eax,eax
       xor     edx,edx
       mov     rcx,qword ptr [134A9A58h]
       mov     r8d,dword ptr [rcx+8]
       test    r8d,r8d
       jle     M00_L01
M00_L00:
       mov     r9,rcx
       movsxd  r10,edx
       mov     r9d,dword ptr [r9+r10*4+10h]
       movsxd  r9,r9d
       add     rax,r9
       inc     edx
       cmp     r8d,edx
       jg      M00_L00
M00_L01:
       ret
; Total bytes of code 46

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.ForReverse()
       xor     eax,eax
       mov     rdx,qword ptr [13A79A58h]
       mov     ecx,dword ptr [rdx+8]
       lea     r8d,[rcx-1]
       test    r8d,r8d
       jl      M00_L01
M00_L00:
       mov     r9,rdx
       cmp     r8d,ecx
       jae     00007ffd`2e01868d
       movsxd  r10,r8d
       mov     r9d,dword ptr [r9+r10*4+10h]
       movsxd  r9,r9d
       add     rax,r9
       dec     r8d
       test    r8d,r8d
       jge     M00_L00
M00_L01:
       add     rsp,28h
; Total bytes of code 56

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.ForLength()
       xor     eax,eax
       mov     rdx,qword ptr [13589A58h]
       mov     ecx,dword ptr [rdx+8]
       xor     r8d,r8d
       test    ecx,ecx
       jle     M00_L01
M00_L00:
       mov     r9,rdx
       movsxd  r10,r8d
       mov     r9d,dword ptr [r9+r10*4+10h]
       movsxd  r9,r9d
       add     rax,r9
       inc     r8d
       cmp     r8d,ecx
       jl      M00_L00
M00_L01:
       ret
; Total bytes of code 46

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.PtrA()
       xor     eax,eax
       mov     rdx,qword ptr [13B29A58h]
       mov     ecx,dword ptr [rdx+8]
       cmp     ecx,0
       jbe     00007ffd`2e0086a5
       add     rdx,10h
       mov     qword ptr [rsp+20h],rdx
       mov     rdx,qword ptr [rsp+20h]
       movsxd  rcx,ecx
       lea     rcx,[rdx+rcx*4]
       cmp     rdx,rcx
       jae     M00_L01
M00_L00:
       mov     r8d,dword ptr [rdx]
       movsxd  r8,r8d
       add     rax,r8
       add     rdx,4
       cmp     rdx,rcx
       jb      M00_L00
M00_L01:
       xor     edx,edx
       mov     qword ptr [rsp+20h],rdx
       add     rsp,28h
; Total bytes of code 73

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.PtrB()
       xor     eax,eax
       mov     rdx,qword ptr [13419A58h]
       mov     ecx,dword ptr [rdx+8]
       cmp     ecx,0
       jbe     00007ffd`2e0186a7
       add     rdx,10h
       mov     qword ptr [rsp+20h],rdx
       mov     rdx,qword ptr [rsp+20h]
       movsxd  rcx,ecx
       lea     rcx,[rdx+rcx*4]
       cmp     rdx,rcx
       jae     M00_L01
M00_L00:
       lea     r8,[rdx+4]
       mov     edx,dword ptr [rdx]
       movsxd  rdx,edx
       add     rax,rdx
       cmp     r8,rcx
       mov     rdx,r8
       jb      M00_L00
M00_L01:
       xor     edx,edx
       mov     qword ptr [rsp+20h],rdx
       add     rsp,28h
; Total bytes of code 75

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.PtrC()
       xor     eax,eax
       mov     rdx,qword ptr [13849A58h]
       mov     ecx,dword ptr [rdx+8]
       cmp     ecx,0
       jbe     00007ffd`2e0086a7
       add     rdx,10h
       mov     qword ptr [rsp+20h],rdx
       mov     rdx,qword ptr [rsp+20h]
       movsxd  rcx,ecx
       lea     rcx,[rdx+rcx*4]
       cmp     rdx,rcx
       jae     M00_L01
M00_L00:
       lea     r8,[rdx+4]
       mov     edx,dword ptr [rdx]
       movsxd  rdx,edx
       add     rax,rdx
       cmp     r8,rcx
       mov     rdx,r8
       jb      M00_L00
M00_L01:
       xor     edx,edx
       mov     qword ptr [rsp+20h],rdx
       add     rsp,28h
; Total bytes of code 75

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.Unrolled2()
       xor     eax,eax
       mov     rdx,qword ptr [13949A58h]
       mov     ecx,dword ptr [rdx+8]
       cmp     ecx,0
       jbe     00007ffd`2e0286d1
       add     rdx,10h
       mov     qword ptr [rsp+20h],rdx
       mov     rdx,qword ptr [rsp+20h]
       mov     r8d,ecx
       and     r8d,0FFFFFFFEh
       movsxd  r8,r8d
       lea     r8,[rdx+r8*4]
       cmp     rdx,r8
       jae     00007ffd`2e0286cc
       lea     r9,[rdx+4]
       mov     edx,dword ptr [rdx]
       movsxd  rdx,edx
       add     rax,rdx
       mov     rdx,r9
       lea     r9,[rdx+4]
       mov     edx,dword ptr [rdx]
       movsxd  rdx,edx
       add     rax,rdx
       cmp     r9,r8
       jb      00007ffd`2e0286c7
       and     ecx,1
       imul    ecx,dword ptr [r9]
       movsxd  rdx,ecx
       add     rax,rdx
       xor     edx,edx
       mov     qword ptr [rsp+20h],rdx
       add     rsp,28h
; Total bytes of code 107

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.Unrolled4()
       xor     eax,eax
       mov     rdx,qword ptr [13AC9A58h]
       mov     ecx,dword ptr [rdx+8]
       cmp     ecx,0
       jbe     00007ffd`2e00870d
       add     rdx,10h
       mov     qword ptr [rsp+20h],rdx
       mov     rdx,qword ptr [rsp+20h]
       mov     r8d,ecx
       and     r8d,0FFFFFFFCh
       movsxd  r8,r8d
       lea     r8,[rdx+r8*4]
       mov     r9,rdx
       cmp     rdx,r8
       jae     00007ffd`2e008708
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       cmp     r10,r8
       jb      00007ffd`2e008703
       movsxd  r8,ecx
       lea     r8,[rdx+r8*4]
       cmp     r10,r8
       jae     M00_L01
M00_L00:
       mov     rdx,r10
       lea     r10,[rdx+4]
       mov     edx,dword ptr [rdx]
       movsxd  rdx,edx
       add     rax,rdx
       cmp     r10,r8
       jb      M00_L00
M00_L01:
       xor     edx,edx
       mov     qword ptr [rsp+20h],rdx
       add     rsp,28h
; Total bytes of code 167

.NET Framework 4.7.2 (CLR 4.0.30319.42000), 64bit RyuJIT-v4.7.3190.0

; ForEachLength.Bench.Unrolled8()
       xor     eax,eax
       mov     rdx,qword ptr [13E99A58h]
       mov     ecx,dword ptr [rdx+8]
       cmp     ecx,0
       jbe     00007ffd`2e038754
       add     rdx,10h
       mov     qword ptr [rsp+20h],rdx
       mov     rdx,qword ptr [rsp+20h]
       mov     r8d,ecx
       and     r8d,0FFFFFFF8h
       movsxd  r8,r8d
       lea     r8,[rdx+r8*4]
       mov     r9,rdx
       cmp     rdx,r8
       jae     00007ffd`2e03874f
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       mov     r9,r10
       lea     r10,[r9+4]
       mov     r9d,dword ptr [r9]
       movsxd  r9,r9d
       add     rax,r9
       cmp     r10,r8
       jb      00007ffd`2e038747
       movsxd  r8,ecx
       lea     r8,[rdx+r8*4]
       cmp     r10,r8
       jae     M00_L01
M00_L00:
       mov     rdx,r10
       lea     r10,[rdx+4]
       mov     edx,dword ptr [rdx]
       movsxd  rdx,edx
       add     rax,rdx
       cmp     r10,r8
       jb      M00_L00
M00_L01:
       xor     edx,edx
       mov     qword ptr [rsp+20h],rdx
       add     rsp,28h
; Total bytes of code 235
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment