void nibble_sort_anon(unsigned long *buf) {
  for (int i = 0; i < 1024; i++) {
    unsigned long val = buf[i], hist = 0, newval = 0;
    int count;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    hist += (1LU << ((val & 0xf) << 2));
    val >>= 4;
    if (!(hist & (hist - 1)))
      continue;
    hist >>= 4;
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x1111111111111111LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x2222222222222222LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x3333333333333333LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x4444444444444444LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x5555555555555555LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x6666666666666666LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x7777777777777777LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x8888888888888888LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0x9999999999999999LU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0xaaaaaaaaaaaaaaaaLU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0xbbbbbbbbbbbbbbbbLU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0xccccccccccccccccLU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0xddddddddddddddddLU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0xeeeeeeeeeeeeeeeeLU & ~(-1LU >> count));
    count = (hist & 0xf) << 2;
    hist >>= 4;
    newval = (newval >> count) | (0xffffffffffffffffLU & ~(-1LU >> count));
    buf[i] = newval;
  }
}


x86 assembly (clang, -O0):
<nibble_sort_anon>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x400,-0xc(%rbp)
jge    187e <nibble_sort_anon+0x77e>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rcx
and    $0xf,%rcx
shl    $0x2,%rcx
mov    $0x1,%eax
shl    %cl,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
jne    13da <nibble_sort_anon+0x2da>
jmp    1870 <nibble_sort_anon+0x770>
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x1111111111111111,%rdx
11 11 11
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x2222222222222222,%rdx
22 22 22
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x3333333333333333,%rdx
33 33 33
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x4444444444444444,%rdx
44 44 44
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x5555555555555555,%rdx
55 55 55
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x6666666666666666,%rdx
66 66 66
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x7777777777777777,%rdx
77 77 77
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x8888888888888888,%rdx
88 88 88
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0x9999999999999999,%rdx
99 99 99
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0xaaaaaaaaaaaaaaaa,%rdx
aa aa aa
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0xbbbbbbbbbbbbbbbb,%rdx
bb bb bb
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0xcccccccccccccccc,%rdx
cc cc cc
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0xdddddddddddddddd,%rdx
dd dd dd
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
movabs $0xeeeeeeeeeeeeeeee,%rdx
ee ee ee
and    %rdx,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0xf,%rax
shl    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
shr    %cl,%rax
mov    -0x2c(%rbp),%ecx
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
mov    %rdx,%rcx
xor    $0xffffffffffffffff,%rcx
and    $0xffffffffffffffff,%rcx
or     %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    110f <nibble_sort_anon+0xf>
pop    %rbp
ret

x86 assembly (clang, -O2):
<nibble_sort_anon>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movabs $0x2222222222222220,%r8
22 22 22
movabs $0x1111111111111110,%r9
11 11 11
xor    %r10d,%r10d
jmp    1141 <nibble_sort_anon+0x41>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r10
cmp    $0x400,%r10
je     14e6 <nibble_sort_anon+0x3e6>
mov    (%rdi,%r10,8),%rax
lea    0x0(,%rax,4),%ecx
mov    $0x1,%r14d
shl    %cl,%r14
mov    %eax,%ecx
shr    $0x2,%cl
and    $0x3c,%cl
mov    $0x1,%r11d
shl    %cl,%r11
mov    %rax,%rcx
shr    $0x6,%rcx
and    $0x3c,%cl
mov    $0x1,%r15d
shl    %cl,%r15
mov    %rax,%rcx
shr    $0xa,%rcx
and    $0x3c,%cl
mov    $0x1,%r12d
shl    %cl,%r12
mov    %rax,%rcx
shr    $0xe,%rcx
and    $0x3c,%cl
mov    $0x1,%r13d
shl    %cl,%r13
mov    %rax,%rcx
shr    $0x12,%rcx
and    $0x3c,%cl
mov    $0x1,%esi
shl    %cl,%rsi
mov    %rax,%rcx
shr    $0x16,%rcx
and    $0x3c,%cl
mov    $0x1,%ebx
shl    %cl,%rbx
mov    %rax,%rcx
shr    $0x1a,%rcx
and    $0x3c,%cl
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rax,%rcx
shr    $0x1e,%rcx
and    $0x3c,%cl
mov    $0x1,%ebp
shl    %cl,%rbp
add    %r14,%r11
mov    %rax,%rcx
shr    $0x22,%rcx
and    $0x3c,%cl
mov    $0x1,%r14d
shl    %cl,%r14
add    %r11,%r15
add    %r15,%r12
mov    %rax,%rcx
shr    $0x26,%rcx
and    $0x3c,%cl
mov    $0x1,%r11d
shl    %cl,%r11
add    %r12,%r13
add    %r13,%rsi
mov    %rax,%rcx
shr    $0x2a,%rcx
and    $0x3c,%cl
mov    $0x1,%r15d
shl    %cl,%r15
add    %rsi,%rbx
add    %rbx,%rdx
mov    %rax,%rcx
shr    $0x2e,%rcx
and    $0x3c,%cl
mov    $0x1,%esi
shl    %cl,%rsi
add    %rdx,%rbp
add    %rbp,%r14
mov    %rax,%rcx
shr    $0x32,%rcx
and    $0x3c,%cl
mov    $0x1,%edx
shl    %cl,%rdx
add    %r14,%r11
add    %r11,%r15
mov    %rax,%rcx
shr    $0x36,%rcx
and    $0x3c,%cl
mov    $0x1,%ebp
shl    %cl,%rbp
add    %r15,%rsi
add    %rsi,%rdx
shr    $0x3a,%rax
and    $0x3c,%al
mov    $0x1,%esi
mov    %eax,%ecx
shl    %cl,%rsi
add    %rdx,%rbp
lea    (%rsi,%rbp,1),%rax
lea    (%rsi,%rbp,1),%rcx
add    $0xffffffffffffffff,%rcx
test   %rcx,%rax
je     1130 <nibble_sort_anon+0x30>
mov    %eax,%ecx
shr    $0x2,%cl
and    $0x3c,%cl
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
not    %rdx
and    %r9,%rdx
mov    %eax,%ecx
shr    $0x6,%ecx
and    $0x3c,%cl
mov    %r8,%rsi
shl    %cl,%rsi
or     %rdx,%rsi
shr    %cl,%rsi
xor    %r8,%rsi
mov    %eax,%ecx
shr    $0xa,%ecx
and    $0x3c,%cl
shr    %cl,%rsi
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
not    %rdx
movabs $0x3333333333333330,%rcx
33 33 33
and    %rcx,%rdx
or     %rsi,%rdx
mov    %eax,%ecx
shr    $0xe,%ecx
and    $0x3c,%cl
shr    %cl,%rdx
mov    $0xffffffffffffffff,%rsi
shr    %cl,%rsi
not    %rsi
movabs $0x4444444444444440,%rcx
44 44 44
and    %rcx,%rsi
or     %rdx,%rsi
mov    %eax,%ecx
shr    $0x12,%ecx
and    $0x3c,%cl
shr    %cl,%rsi
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
not    %rdx
movabs $0x5555555555555550,%rcx
55 55 55
and    %rcx,%rdx
or     %rsi,%rdx
mov    %eax,%ecx
shr    $0x16,%ecx
and    $0x3c,%cl
shr    %cl,%rdx
mov    $0xffffffffffffffff,%rsi
shr    %cl,%rsi
not    %rsi
movabs $0x6666666666666660,%rcx
66 66 66
and    %rcx,%rsi
or     %rdx,%rsi
mov    %eax,%ecx
shr    $0x1a,%ecx
and    $0x3c,%cl
shr    %cl,%rsi
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
not    %rdx
movabs $0x7777777777777770,%rcx
77 77 77
and    %rcx,%rdx
or     %rsi,%rdx
mov    %rax,%rcx
shr    $0x1e,%rcx
and    $0x3c,%cl
shr    %cl,%rdx
mov    $0xffffffffffffffff,%rsi
shr    %cl,%rsi
not    %rsi
movabs $0x8888888888888880,%rcx
88 88 88
and    %rcx,%rsi
or     %rdx,%rsi
mov    %rax,%rcx
shr    $0x22,%rcx
and    $0x3c,%cl
shr    %cl,%rsi
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
not    %rdx
movabs $0x9999999999999990,%rcx
99 99 99
and    %rcx,%rdx
or     %rsi,%rdx
mov    %rax,%rcx
shr    $0x26,%rcx
and    $0x3c,%cl
shr    %cl,%rdx
mov    $0xffffffffffffffff,%rsi
shr    %cl,%rsi
not    %rsi
movabs $0xaaaaaaaaaaaaaaa0,%rcx
aa aa aa
and    %rcx,%rsi
or     %rdx,%rsi
mov    %rax,%rcx
shr    $0x2a,%rcx
and    $0x3c,%cl
shr    %cl,%rsi
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
not    %rdx
movabs $0xbbbbbbbbbbbbbbb0,%rcx
bb bb bb
and    %rcx,%rdx
or     %rsi,%rdx
mov    %rax,%rcx
shr    $0x2e,%rcx
and    $0x3c,%cl
shr    %cl,%rdx
mov    $0xffffffffffffffff,%rsi
shr    %cl,%rsi
not    %rsi
movabs $0xccccccccccccccc0,%rcx
cc cc cc
and    %rcx,%rsi
or     %rdx,%rsi
mov    %rax,%rcx
shr    $0x32,%rcx
and    $0x3c,%cl
shr    %cl,%rsi
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
not    %rdx
movabs $0xddddddddddddddd0,%rcx
dd dd dd
and    %rcx,%rdx
or     %rsi,%rdx
mov    %rax,%rcx
shr    $0x36,%rcx
and    $0x3c,%cl
shr    %cl,%rdx
mov    $0xffffffffffffffff,%rsi
shr    %cl,%rsi
not    %rsi
movabs $0xeeeeeeeeeeeeeee0,%rcx
ee ee ee
and    %rcx,%rsi
or     %rdx,%rsi
shr    $0x3a,%rax
and    $0x3c,%al
mov    %eax,%ecx
shr    %cl,%rsi
mov    $0xffffffffffffffff,%rdx
shr    %cl,%rdx
not    %rdx
or     %rsi,%rdx
mov    %rdx,(%rdi,%r10,8)
jmp    1130 <nibble_sort_anon+0x30>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @nibble_sort_anon(i64* %0) {
%2 = alloca i64*
%3 = alloca i32
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
%7 = alloca i32
store i64* %0, i64** %2
store i32 0, i32* %3
br label %8
8: ; preds = %399, %1
%9 = load i32, i32* %3
%10 = icmp slt i32 %9, 1024
br i1 %10, label %11, label %402
11: ; preds = %8
%12 = load i64*, i64** %2
%13 = load i32, i32* %3
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i64, i64* %12, i64 %14
%16 = load i64, i64* %15
store i64 %16, i64* %4
store i64 0, i64* %5
store i64 0, i64* %6
%17 = load i64, i64* %4
%18 = and i64 %17, 15
%19 = shl i64 %18, 2
%20 = shl i64 1, %19
%21 = load i64, i64* %5
%22 = add i64 %21, %20
store i64 %22, i64* %5
%23 = load i64, i64* %4
%24 = lshr i64 %23, 4
store i64 %24, i64* %4
%25 = load i64, i64* %4
%26 = and i64 %25, 15
%27 = shl i64 %26, 2
%28 = shl i64 1, %27
%29 = load i64, i64* %5
%30 = add i64 %29, %28
store i64 %30, i64* %5
%31 = load i64, i64* %4
%32 = lshr i64 %31, 4
store i64 %32, i64* %4
%33 = load i64, i64* %4
%34 = and i64 %33, 15
%35 = shl i64 %34, 2
%36 = shl i64 1, %35
%37 = load i64, i64* %5
%38 = add i64 %37, %36
store i64 %38, i64* %5
%39 = load i64, i64* %4
%40 = lshr i64 %39, 4
store i64 %40, i64* %4
%41 = load i64, i64* %4
%42 = and i64 %41, 15
%43 = shl i64 %42, 2
%44 = shl i64 1, %43
%45 = load i64, i64* %5
%46 = add i64 %45, %44
store i64 %46, i64* %5
%47 = load i64, i64* %4
%48 = lshr i64 %47, 4
store i64 %48, i64* %4
%49 = load i64, i64* %4
%50 = and i64 %49, 15
%51 = shl i64 %50, 2
%52 = shl i64 1, %51
%53 = load i64, i64* %5
%54 = add i64 %53, %52
store i64 %54, i64* %5
%55 = load i64, i64* %4
%56 = lshr i64 %55, 4
store i64 %56, i64* %4
%57 = load i64, i64* %4
%58 = and i64 %57, 15
%59 = shl i64 %58, 2
%60 = shl i64 1, %59
%61 = load i64, i64* %5
%62 = add i64 %61, %60
store i64 %62, i64* %5
%63 = load i64, i64* %4
%64 = lshr i64 %63, 4
store i64 %64, i64* %4
%65 = load i64, i64* %4
%66 = and i64 %65, 15
%67 = shl i64 %66, 2
%68 = shl i64 1, %67
%69 = load i64, i64* %5
%70 = add i64 %69, %68
store i64 %70, i64* %5
%71 = load i64, i64* %4
%72 = lshr i64 %71, 4
store i64 %72, i64* %4
%73 = load i64, i64* %4
%74 = and i64 %73, 15
%75 = shl i64 %74, 2
%76 = shl i64 1, %75
%77 = load i64, i64* %5
%78 = add i64 %77, %76
store i64 %78, i64* %5
%79 = load i64, i64* %4
%80 = lshr i64 %79, 4
store i64 %80, i64* %4
%81 = load i64, i64* %4
%82 = and i64 %81, 15
%83 = shl i64 %82, 2
%84 = shl i64 1, %83
%85 = load i64, i64* %5
%86 = add i64 %85, %84
store i64 %86, i64* %5
%87 = load i64, i64* %4
%88 = lshr i64 %87, 4
store i64 %88, i64* %4
%89 = load i64, i64* %4
%90 = and i64 %89, 15
%91 = shl i64 %90, 2
%92 = shl i64 1, %91
%93 = load i64, i64* %5
%94 = add i64 %93, %92
store i64 %94, i64* %5
%95 = load i64, i64* %4
%96 = lshr i64 %95, 4
store i64 %96, i64* %4
%97 = load i64, i64* %4
%98 = and i64 %97, 15
%99 = shl i64 %98, 2
%100 = shl i64 1, %99
%101 = load i64, i64* %5
%102 = add i64 %101, %100
store i64 %102, i64* %5
%103 = load i64, i64* %4
%104 = lshr i64 %103, 4
store i64 %104, i64* %4
%105 = load i64, i64* %4
%106 = and i64 %105, 15
%107 = shl i64 %106, 2
%108 = shl i64 1, %107
%109 = load i64, i64* %5
%110 = add i64 %109, %108
store i64 %110, i64* %5
%111 = load i64, i64* %4
%112 = lshr i64 %111, 4
store i64 %112, i64* %4
%113 = load i64, i64* %4
%114 = and i64 %113, 15
%115 = shl i64 %114, 2
%116 = shl i64 1, %115
%117 = load i64, i64* %5
%118 = add i64 %117, %116
store i64 %118, i64* %5
%119 = load i64, i64* %4
%120 = lshr i64 %119, 4
store i64 %120, i64* %4
%121 = load i64, i64* %4
%122 = and i64 %121, 15
%123 = shl i64 %122, 2
%124 = shl i64 1, %123
%125 = load i64, i64* %5
%126 = add i64 %125, %124
store i64 %126, i64* %5
%127 = load i64, i64* %4
%128 = lshr i64 %127, 4
store i64 %128, i64* %4
%129 = load i64, i64* %4
%130 = and i64 %129, 15
%131 = shl i64 %130, 2
%132 = shl i64 1, %131
%133 = load i64, i64* %5
%134 = add i64 %133, %132
store i64 %134, i64* %5
%135 = load i64, i64* %4
%136 = lshr i64 %135, 4
store i64 %136, i64* %4
%137 = load i64, i64* %4
%138 = and i64 %137, 15
%139 = shl i64 %138, 2
%140 = shl i64 1, %139
%141 = load i64, i64* %5
%142 = add i64 %141, %140
store i64 %142, i64* %5
%143 = load i64, i64* %4
%144 = lshr i64 %143, 4
store i64 %144, i64* %4
%145 = load i64, i64* %5
%146 = load i64, i64* %5
%147 = sub i64 %146, 1
%148 = and i64 %145, %147
%149 = icmp ne i64 %148, 0
br i1 %149, label %151, label %150
150: ; preds = %11
br label %399
151: ; preds = %11
%152 = load i64, i64* %5
%153 = lshr i64 %152, 4
store i64 %153, i64* %5
%154 = load i64, i64* %5
%155 = and i64 %154, 15
%156 = shl i64 %155, 2
%157 = trunc i64 %156 to i32
store i32 %157, i32* %7
%158 = load i64, i64* %5
%159 = lshr i64 %158, 4
store i64 %159, i64* %5
%160 = load i64, i64* %6
%161 = load i32, i32* %7
%162 = zext i32 %161 to i64
%163 = lshr i64 %160, %162
%164 = load i32, i32* %7
%165 = zext i32 %164 to i64
%166 = lshr i64 -1, %165
%167 = xor i64 %166, -1
%168 = and i64 1229782938247303441, %167
%169 = or i64 %163, %168
store i64 %169, i64* %6
%170 = load i64, i64* %5
%171 = and i64 %170, 15
%172 = shl i64 %171, 2
%173 = trunc i64 %172 to i32
store i32 %173, i32* %7
%174 = load i64, i64* %5
%175 = lshr i64 %174, 4
store i64 %175, i64* %5
%176 = load i64, i64* %6
%177 = load i32, i32* %7
%178 = zext i32 %177 to i64
%179 = lshr i64 %176, %178
%180 = load i32, i32* %7
%181 = zext i32 %180 to i64
%182 = lshr i64 -1, %181
%183 = xor i64 %182, -1
%184 = and i64 2459565876494606882, %183
%185 = or i64 %179, %184
store i64 %185, i64* %6
%186 = load i64, i64* %5
%187 = and i64 %186, 15
%188 = shl i64 %187, 2
%189 = trunc i64 %188 to i32
store i32 %189, i32* %7
%190 = load i64, i64* %5
%191 = lshr i64 %190, 4
store i64 %191, i64* %5
%192 = load i64, i64* %6
%193 = load i32, i32* %7
%194 = zext i32 %193 to i64
%195 = lshr i64 %192, %194
%196 = load i32, i32* %7
%197 = zext i32 %196 to i64
%198 = lshr i64 -1, %197
%199 = xor i64 %198, -1
%200 = and i64 3689348814741910323, %199
%201 = or i64 %195, %200
store i64 %201, i64* %6
%202 = load i64, i64* %5
%203 = and i64 %202, 15
%204 = shl i64 %203, 2
%205 = trunc i64 %204 to i32
store i32 %205, i32* %7
%206 = load i64, i64* %5
%207 = lshr i64 %206, 4
store i64 %207, i64* %5
%208 = load i64, i64* %6
%209 = load i32, i32* %7
%210 = zext i32 %209 to i64
%211 = lshr i64 %208, %210
%212 = load i32, i32* %7
%213 = zext i32 %212 to i64
%214 = lshr i64 -1, %213
%215 = xor i64 %214, -1
%216 = and i64 4919131752989213764, %215
%217 = or i64 %211, %216
store i64 %217, i64* %6
%218 = load i64, i64* %5
%219 = and i64 %218, 15
%220 = shl i64 %219, 2
%221 = trunc i64 %220 to i32
store i32 %221, i32* %7
%222 = load i64, i64* %5
%223 = lshr i64 %222, 4
store i64 %223, i64* %5
%224 = load i64, i64* %6
%225 = load i32, i32* %7
%226 = zext i32 %225 to i64
%227 = lshr i64 %224, %226
%228 = load i32, i32* %7
%229 = zext i32 %228 to i64
%230 = lshr i64 -1, %229
%231 = xor i64 %230, -1
%232 = and i64 6148914691236517205, %231
%233 = or i64 %227, %232
store i64 %233, i64* %6
%234 = load i64, i64* %5
%235 = and i64 %234, 15
%236 = shl i64 %235, 2
%237 = trunc i64 %236 to i32
store i32 %237, i32* %7
%238 = load i64, i64* %5
%239 = lshr i64 %238, 4
store i64 %239, i64* %5
%240 = load i64, i64* %6
%241 = load i32, i32* %7
%242 = zext i32 %241 to i64
%243 = lshr i64 %240, %242
%244 = load i32, i32* %7
%245 = zext i32 %244 to i64
%246 = lshr i64 -1, %245
%247 = xor i64 %246, -1
%248 = and i64 7378697629483820646, %247
%249 = or i64 %243, %248
store i64 %249, i64* %6
%250 = load i64, i64* %5
%251 = and i64 %250, 15
%252 = shl i64 %251, 2
%253 = trunc i64 %252 to i32
store i32 %253, i32* %7
%254 = load i64, i64* %5
%255 = lshr i64 %254, 4
store i64 %255, i64* %5
%256 = load i64, i64* %6
%257 = load i32, i32* %7
%258 = zext i32 %257 to i64
%259 = lshr i64 %256, %258
%260 = load i32, i32* %7
%261 = zext i32 %260 to i64
%262 = lshr i64 -1, %261
%263 = xor i64 %262, -1
%264 = and i64 8608480567731124087, %263
%265 = or i64 %259, %264
store i64 %265, i64* %6
%266 = load i64, i64* %5
%267 = and i64 %266, 15
%268 = shl i64 %267, 2
%269 = trunc i64 %268 to i32
store i32 %269, i32* %7
%270 = load i64, i64* %5
%271 = lshr i64 %270, 4
store i64 %271, i64* %5
%272 = load i64, i64* %6
%273 = load i32, i32* %7
%274 = zext i32 %273 to i64
%275 = lshr i64 %272, %274
%276 = load i32, i32* %7
%277 = zext i32 %276 to i64
%278 = lshr i64 -1, %277
%279 = xor i64 %278, -1
%280 = and i64 -8608480567731124088, %279
%281 = or i64 %275, %280
store i64 %281, i64* %6
%282 = load i64, i64* %5
%283 = and i64 %282, 15
%284 = shl i64 %283, 2
%285 = trunc i64 %284 to i32
store i32 %285, i32* %7
%286 = load i64, i64* %5
%287 = lshr i64 %286, 4
store i64 %287, i64* %5
%288 = load i64, i64* %6
%289 = load i32, i32* %7
%290 = zext i32 %289 to i64
%291 = lshr i64 %288, %290
%292 = load i32, i32* %7
%293 = zext i32 %292 to i64
%294 = lshr i64 -1, %293
%295 = xor i64 %294, -1
%296 = and i64 -7378697629483820647, %295
%297 = or i64 %291, %296
store i64 %297, i64* %6
%298 = load i64, i64* %5
%299 = and i64 %298, 15
%300 = shl i64 %299, 2
%301 = trunc i64 %300 to i32
store i32 %301, i32* %7
%302 = load i64, i64* %5
%303 = lshr i64 %302, 4
store i64 %303, i64* %5
%304 = load i64, i64* %6
%305 = load i32, i32* %7
%306 = zext i32 %305 to i64
%307 = lshr i64 %304, %306
%308 = load i32, i32* %7
%309 = zext i32 %308 to i64
%310 = lshr i64 -1, %309
%311 = xor i64 %310, -1
%312 = and i64 -6148914691236517206, %311
%313 = or i64 %307, %312
store i64 %313, i64* %6
%314 = load i64, i64* %5
%315 = and i64 %314, 15
%316 = shl i64 %315, 2
%317 = trunc i64 %316 to i32
store i32 %317, i32* %7
%318 = load i64, i64* %5
%319 = lshr i64 %318, 4
store i64 %319, i64* %5
%320 = load i64, i64* %6
%321 = load i32, i32* %7
%322 = zext i32 %321 to i64
%323 = lshr i64 %320, %322
%324 = load i32, i32* %7
%325 = zext i32 %324 to i64
%326 = lshr i64 -1, %325
%327 = xor i64 %326, -1
%328 = and i64 -4919131752989213765, %327
%329 = or i64 %323, %328
store i64 %329, i64* %6
%330 = load i64, i64* %5
%331 = and i64 %330, 15
%332 = shl i64 %331, 2
%333 = trunc i64 %332 to i32
store i32 %333, i32* %7
%334 = load i64, i64* %5
%335 = lshr i64 %334, 4
store i64 %335, i64* %5
%336 = load i64, i64* %6
%337 = load i32, i32* %7
%338 = zext i32 %337 to i64
%339 = lshr i64 %336, %338
%340 = load i32, i32* %7
%341 = zext i32 %340 to i64
%342 = lshr i64 -1, %341
%343 = xor i64 %342, -1
%344 = and i64 -3689348814741910324, %343
%345 = or i64 %339, %344
store i64 %345, i64* %6
%346 = load i64, i64* %5
%347 = and i64 %346, 15
%348 = shl i64 %347, 2
%349 = trunc i64 %348 to i32
store i32 %349, i32* %7
%350 = load i64, i64* %5
%351 = lshr i64 %350, 4
store i64 %351, i64* %5
%352 = load i64, i64* %6
%353 = load i32, i32* %7
%354 = zext i32 %353 to i64
%355 = lshr i64 %352, %354
%356 = load i32, i32* %7
%357 = zext i32 %356 to i64
%358 = lshr i64 -1, %357
%359 = xor i64 %358, -1
%360 = and i64 -2459565876494606883, %359
%361 = or i64 %355, %360
store i64 %361, i64* %6
%362 = load i64, i64* %5
%363 = and i64 %362, 15
%364 = shl i64 %363, 2
%365 = trunc i64 %364 to i32
store i32 %365, i32* %7
%366 = load i64, i64* %5
%367 = lshr i64 %366, 4
store i64 %367, i64* %5
%368 = load i64, i64* %6
%369 = load i32, i32* %7
%370 = zext i32 %369 to i64
%371 = lshr i64 %368, %370
%372 = load i32, i32* %7
%373 = zext i32 %372 to i64
%374 = lshr i64 -1, %373
%375 = xor i64 %374, -1
%376 = and i64 -1229782938247303442, %375
%377 = or i64 %371, %376
store i64 %377, i64* %6
%378 = load i64, i64* %5
%379 = and i64 %378, 15
%380 = shl i64 %379, 2
%381 = trunc i64 %380 to i32
store i32 %381, i32* %7
%382 = load i64, i64* %5
%383 = lshr i64 %382, 4
store i64 %383, i64* %5
%384 = load i64, i64* %6
%385 = load i32, i32* %7
%386 = zext i32 %385 to i64
%387 = lshr i64 %384, %386
%388 = load i32, i32* %7
%389 = zext i32 %388 to i64
%390 = lshr i64 -1, %389
%391 = xor i64 %390, -1
%392 = and i64 -1, %391
%393 = or i64 %387, %392
store i64 %393, i64* %6
%394 = load i64, i64* %6
%395 = load i64*, i64** %2
%396 = load i32, i32* %3
%397 = sext i32 %396 to i64
%398 = getelementptr inbounds i64, i64* %395, i64 %397
store i64 %394, i64* %398
br label %399
399: ; preds = %151, %150
%400 = load i32, i32* %3
%401 = add nsw i32 %400, 1
store i32 %401, i32* %3
br label %8
402: ; preds = %8
ret void
}

LLVM IR (-O2):
define void @nibble_sort_anon(i64* nocapture %0) {
br label %3
2: ; preds = %175
ret void
3: ; preds = %1, %175
%4 = phi i64 [ 0, %1 ], [ %176, %175 ]
%5 = getelementptr inbounds i64, i64* %0, i64 %4
%6 = load i64, i64* %5
%7 = shl i64 %6, 2
%8 = and i64 %7, 60
%9 = shl nuw nsw i64 1, %8
%10 = lshr i64 %6, 2
%11 = and i64 %10, 60
%12 = shl nuw nsw i64 1, %11
%13 = add nuw nsw i64 %9, %12
%14 = lshr i64 %6, 6
%15 = and i64 %14, 60
%16 = shl nuw nsw i64 1, %15
%17 = add nuw nsw i64 %13, %16
%18 = lshr i64 %6, 10
%19 = and i64 %18, 60
%20 = shl nuw nsw i64 1, %19
%21 = add nuw nsw i64 %17, %20
%22 = lshr i64 %6, 14
%23 = and i64 %22, 60
%24 = shl nuw nsw i64 1, %23
%25 = add nuw nsw i64 %21, %24
%26 = lshr i64 %6, 18
%27 = and i64 %26, 60
%28 = shl nuw nsw i64 1, %27
%29 = add nuw nsw i64 %25, %28
%30 = lshr i64 %6, 22
%31 = and i64 %30, 60
%32 = shl nuw nsw i64 1, %31
%33 = add nuw nsw i64 %29, %32
%34 = lshr i64 %6, 26
%35 = and i64 %34, 60
%36 = shl nuw nsw i64 1, %35
%37 = add nuw i64 %33, %36
%38 = lshr i64 %6, 30
%39 = and i64 %38, 60
%40 = shl nuw nsw i64 1, %39
%41 = add nuw i64 %37, %40
%42 = lshr i64 %6, 34
%43 = and i64 %42, 60
%44 = shl nuw nsw i64 1, %43
%45 = add nuw i64 %41, %44
%46 = lshr i64 %6, 38
%47 = and i64 %46, 60
%48 = shl nuw nsw i64 1, %47
%49 = add nuw i64 %45, %48
%50 = lshr i64 %6, 42
%51 = and i64 %50, 60
%52 = shl nuw nsw i64 1, %51
%53 = add nuw i64 %49, %52
%54 = lshr i64 %6, 46
%55 = and i64 %54, 60
%56 = shl nuw nsw i64 1, %55
%57 = add nuw i64 %53, %56
%58 = lshr i64 %6, 50
%59 = and i64 %58, 60
%60 = shl nuw nsw i64 1, %59
%61 = add nuw i64 %57, %60
%62 = lshr i64 %6, 54
%63 = and i64 %62, 60
%64 = shl nuw nsw i64 1, %63
%65 = add nuw i64 %61, %64
%66 = lshr i64 %6, 58
%67 = and i64 %66, 60
%68 = shl nuw nsw i64 1, %67
%69 = add i64 %65, %68
%70 = tail call i64 @llvm.ctpop.i64(i64 %69)
%71 = icmp ult i64 %70, 2
br i1 %71, label %175, label %72
72: ; preds = %3
%73 = lshr i64 %69, 2
%74 = and i64 %73, 60
%75 = lshr i64 -1, %74
%76 = and i64 %75, 1229782938247303440
%77 = xor i64 %76, 1229782938247303440
%78 = lshr i64 %69, 6
%79 = and i64 %78, 60
%80 = lshr i64 %77, %79
%81 = lshr i64 -1, %79
%82 = and i64 %81, 2459565876494606880
%83 = or i64 %80, %82
%84 = xor i64 %83, 2459565876494606880
%85 = lshr i64 %69, 10
%86 = and i64 %85, 60
%87 = lshr i64 %84, %86
%88 = lshr i64 -1, %86
%89 = and i64 %88, 3689348814741910320
%90 = xor i64 %89, 3689348814741910320
%91 = or i64 %87, %90
%92 = lshr i64 %69, 14
%93 = and i64 %92, 60
%94 = lshr i64 %91, %93
%95 = lshr i64 -1, %93
%96 = and i64 %95, 4919131752989213760
%97 = xor i64 %96, 4919131752989213760
%98 = or i64 %94, %97
%99 = lshr i64 %69, 18
%100 = and i64 %99, 60
%101 = lshr i64 %98, %100
%102 = lshr i64 -1, %100
%103 = and i64 %102, 6148914691236517200
%104 = xor i64 %103, 6148914691236517200
%105 = or i64 %101, %104
%106 = lshr i64 %69, 22
%107 = and i64 %106, 60
%108 = lshr i64 %105, %107
%109 = lshr i64 -1, %107
%110 = and i64 %109, 7378697629483820640
%111 = xor i64 %110, 7378697629483820640
%112 = or i64 %108, %111
%113 = lshr i64 %69, 26
%114 = and i64 %113, 60
%115 = lshr i64 %112, %114
%116 = lshr i64 -1, %114
%117 = and i64 %116, 8608480567731124080
%118 = xor i64 %117, 8608480567731124080
%119 = or i64 %115, %118
%120 = lshr i64 %69, 30
%121 = and i64 %120, 60
%122 = lshr i64 %119, %121
%123 = lshr i64 -1, %121
%124 = and i64 %123, -8608480567731124096
%125 = xor i64 %124, -8608480567731124096
%126 = or i64 %122, %125
%127 = lshr i64 %69, 34
%128 = and i64 %127, 60
%129 = lshr i64 %126, %128
%130 = lshr i64 -1, %128
%131 = and i64 %130, -7378697629483820656
%132 = xor i64 %131, -7378697629483820656
%133 = or i64 %129, %132
%134 = lshr i64 %69, 38
%135 = and i64 %134, 60
%136 = lshr i64 %133, %135
%137 = lshr i64 -1, %135
%138 = and i64 %137, -6148914691236517216
%139 = xor i64 %138, -6148914691236517216
%140 = or i64 %136, %139
%141 = lshr i64 %69, 42
%142 = and i64 %141, 60
%143 = lshr i64 %140, %142
%144 = lshr i64 -1, %142
%145 = and i64 %144, -4919131752989213776
%146 = xor i64 %145, -4919131752989213776
%147 = or i64 %143, %146
%148 = lshr i64 %69, 46
%149 = and i64 %148, 60
%150 = lshr i64 %147, %149
%151 = lshr i64 -1, %149
%152 = and i64 %151, -3689348814741910336
%153 = xor i64 %152, -3689348814741910336
%154 = or i64 %150, %153
%155 = lshr i64 %69, 50
%156 = and i64 %155, 60
%157 = lshr i64 %154, %156
%158 = lshr i64 -1, %156
%159 = and i64 %158, -2459565876494606896
%160 = xor i64 %159, -2459565876494606896
%161 = or i64 %157, %160
%162 = lshr i64 %69, 54
%163 = and i64 %162, 60
%164 = lshr i64 %161, %163
%165 = lshr i64 -1, %163
%166 = and i64 %165, -1229782938247303456
%167 = xor i64 %166, -1229782938247303456
%168 = or i64 %164, %167
%169 = lshr i64 %69, 58
%170 = and i64 %169, 60
%171 = lshr i64 %168, %170
%172 = lshr i64 -1, %170
%173 = xor i64 %172, -1
%174 = or i64 %171, %173
store i64 %174, i64* %5
br label %175
175: ; preds = %3, %72
%176 = add nuw nsw i64 %4, 1
%177 = icmp eq i64 %176, 1024
br i1 %177, label %2, label %3
}