#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
unsigned int bsrl(unsigned int);
int fls(unsigned int const);
void ordhuff(int ncodes, unsigned const vFreq[], unsigned vCode[],
             unsigned vBits[]) {
  int i;
  unsigned scale, sum, z;
  unsigned prevcode, prevbits, currbits, prevmask, comb;
  for (i = ncodes, sum = vFreq[0]; --i > 0;)
    sum += vFreq[i];
  scale = 0x3FFFFFFF / sum;
  for (i = ncodes; --i >= 0;)
    vBits[i] = -1 << fls(vFreq[i] * scale);
  prevcode = vCode[0] = 0;
  prevbits = vBits[0];
  for (i = 1; i < ncodes; ++i) {
    currbits = vBits[i];
    vCode[i] = (prevcode - (currbits & prevbits)) & currbits;
    prevcode = vCode[i];
    prevbits = currbits;
  }
  prevmask = comb = 0;
  for (i = ncodes; --i >= 0;) {
    int x;
    unsigned currmask = vBits[i], currcode = vCode[i];
    comb = (~prevmask | comb) & ~currcode & currmask;
    prevmask = currmask;
    for (x = comb; x < 0; x <<= 1, currmask <<= 1)
      currcode <<= 1;
    for (; x; x &= x - 1, currmask <<= 1)
      currcode += ((x - 1) ^ x) & currcode;
    vBits[i] = currmask, vCode[i] = currcode;
  }
  for (i = ncodes; --i >= 0;) {
    vCode[i] >>= z = bsrl(vBits[i]);
    vBits[i] = 32 - z;
  }
}


x86 assembly (clang, -O0):
<ordhuff>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jle    116e <ordhuff+0x4e>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1146 <ordhuff+0x26>
mov    $0x3fffffff,%eax
xor    %edx,%edx
divl   -0x2c(%rbp)
mov    %eax,-0x28(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jl     11c0 <ordhuff+0xa0>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
imul   -0x28(%rbp),%edi
call   1040 <fls@plt>
mov    %eax,%ecx
mov    $0xffffffff,%edx
shl    %cl,%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1181 <ordhuff+0x61>
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x0,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1236 <ordhuff+0x116>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x3c(%rbp),%eax
and    -0x38(%rbp),%eax
sub    %eax,%edx
and    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11e1 <ordhuff+0xc1>
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jl     1321 <ordhuff+0x201>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%eax
xor    $0xffffffff,%eax
or     -0x44(%rbp),%eax
mov    -0x50(%rbp),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
and    -0x4c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jge    12c5 <ordhuff+0x1a5>
mov    -0x50(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    129b <ordhuff+0x17b>
jmp    12ca <ordhuff+0x1aa>
cmpl   $0x0,-0x48(%rbp)
je     1300 <ordhuff+0x1e0>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
xor    -0x48(%rbp),%eax
and    -0x50(%rbp),%eax
add    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
and    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12ca <ordhuff+0x1aa>
mov    -0x4c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    124a <ordhuff+0x12a>
mov    -0x4(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jl     137e <ordhuff+0x25e>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
call   1030 <bsrl@plt>
mov    %eax,%ecx
mov    %ecx,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rdx
mov    %rdx,-0x58(%rbp)
mov    (%rax,%rdx,4),%edx
shr    %cl,%edx
mov    -0x58(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    $0x20,%edx
sub    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1327 <ordhuff+0x207>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ordhuff>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rcx,%r13
mov    %rsi,%r12
mov    (%rsi),%esi
mov    %edi,%r15d
cmp    $0x2,%edi
mov    %rdx,0x10(%rsp)
jl     12a1 <ordhuff+0x181>
xor    %ecx,%ecx
mov    %r15,%rax
sub    $0x2,%rax
mov    $0x0,%r10d
cmovae %rax,%r10
add    $0x1,%r10
mov    %r15,%rax
cmp    $0x8,%r10
jb     128c <ordhuff+0x16c>
sub    $0x2,%rax
mov    $0x0,%ebp
cmovae %rax,%rbp
mov    %r15d,%eax
sub    $0x2,%eax
cmovb  %ecx,%eax
lea    -0x1(%rdi),%ecx
cmp    %eax,%ecx
jb     1289 <ordhuff+0x169>
shr    $0x20,%rbp
jne    1289 <ordhuff+0x169>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
movd   %esi,%xmm0
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1439 <ordhuff+0x319>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
mov    $0xfffffff7,%ebp
add    %r15,%rbp
lea    -0x1(%r15),%rbx
pxor   %xmm1,%xmm1
mov    $0x1,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebx,%ecx
movdqu -0x1c(%r12,%rcx,4),%xmm2
movdqu -0xc(%r12,%rcx,4),%xmm3
pshufd $0x1b,%xmm3,%xmm3
paddd  %xmm0,%xmm3
pshufd $0x1b,%xmm2,%xmm2
paddd  %xmm1,%xmm2
mov    %ebp,%ecx
movdqu -0x1c(%r12,%rcx,4),%xmm1
movdqu -0xc(%r12,%rcx,4),%xmm0
pshufd $0x1b,%xmm0,%xmm0
paddd  %xmm3,%xmm0
pshufd $0x1b,%xmm1,%xmm1
paddd  %xmm2,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffff0,%rbp
add    $0xfffffffffffffff0,%rbx
add    $0xfffffffffffffffe,%rax
jne    11e0 <ordhuff+0xc0>
neg    %rsi
test   $0x1,%r9b
je     1262 <ordhuff+0x142>
add    %r15d,%esi
movdqu -0x1c(%r12,%rsi,4),%xmm2
movdqu -0xc(%r12,%rsi,4),%xmm3
pshufd $0x1b,%xmm3,%xmm3
paddd  %xmm3,%xmm0
pshufd $0x1b,%xmm2,%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
cmp    %r8,%r10
je     12a1 <ordhuff+0x181>
mov    %r15,%rax
sub    %r8,%rax
jmp    128c <ordhuff+0x16c>
mov    %r15,%rax
add    $0x1,%rax
lea    -0x2(%rax),%ecx
add    (%r12,%rcx,4),%esi
add    $0xffffffffffffffff,%rax
cmp    $0x2,%rax
ja     1290 <ordhuff+0x170>
mov    $0x3fffffff,%eax
xor    %edx,%edx
div    %esi
mov    %rdi,0x8(%rsp)
test   %edi,%edi
jle    12e8 <ordhuff+0x1c8>
mov    %eax,%ebp
lea    0x1(%r15),%rbx
nopl   0x0(%rax)
lea    -0x2(%rbx),%r14d
mov    (%r12,%r14,4),%edi
imul   %ebp,%edi
call   1040 <fls@plt>
mov    $0xffffffff,%edx
mov    %eax,%ecx
shl    %cl,%edx
mov    %edx,0x0(%r13,%r14,4)
add    $0xffffffffffffffff,%rbx
cmp    $0x1,%rbx
ja     12c0 <ordhuff+0x1a0>
mov    0x10(%rsp),%r14
movl   $0x0,(%r14)
mov    0x8(%rsp),%r11
cmp    $0x2,%r11d
jl     1375 <ordhuff+0x255>
mov    0x0(%r13),%eax
lea    -0x1(%r15),%rdx
cmp    $0x2,%r11d
jne    1316 <ordhuff+0x1f6>
xor    %ecx,%ecx
mov    $0x1,%esi
jmp    1361 <ordhuff+0x241>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xor    %ecx,%ecx
mov    $0x1,%esi
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rsi,4),%ebp
and    %ebp,%eax
sub    %eax,%ecx
and    %ebp,%ecx
mov    %ecx,(%r14,%rsi,4)
mov    0x4(%r13,%rsi,4),%eax
and    %eax,%ebp
sub    %ebp,%ecx
and    %eax,%ecx
mov    %ecx,0x4(%r14,%rsi,4)
lea    (%rdi,%rsi,1),%rbp
add    $0x2,%rbp
add    $0x2,%rsi
cmp    $0x1,%rbp
jne    1330 <ordhuff+0x210>
test   $0x1,%dl
je     1375 <ordhuff+0x255>
mov    0x0(%r13,%rsi,4),%edx
and    %edx,%eax
sub    %eax,%ecx
and    %edx,%ecx
mov    %ecx,(%r14,%rsi,4)
test   %r11d,%r11d
jle    142a <ordhuff+0x30a>
xor    %ecx,%ecx
mov    %r15,%r10
xor    %r9d,%r9d
jmp    13a2 <ordhuff+0x282>
nopl   0x0(%rax,%rax,1)
mov    %edx,0x0(%r13,%rdi,4)
mov    %ebp,(%r14,%rdi,4)
cmp    $0x1,%r10
mov    %r8,%r10
jle    13f5 <ordhuff+0x2d5>
mov    %r9d,%edx
lea    -0x1(%r10),%r8
mov    %r8d,%edi
mov    0x0(%r13,%rdi,4),%r9d
mov    (%r14,%rdi,4),%ebp
not    %edx
or     %ecx,%edx
mov    %ebp,%esi
not    %esi
and    %r9d,%edx
mov    %edx,%ecx
mov    %r9d,%edx
and    %esi,%ecx
mov    %ecx,%esi
jns    13da <ordhuff+0x2ba>
nopl   0x0(%rax,%rax,1)
add    %ebp,%ebp
add    %esi,%esi
add    %edx,%edx
test   %esi,%esi
js     13d0 <ordhuff+0x2b0>
test   %esi,%esi
je     1390 <ordhuff+0x270>
xchg   %ax,%ax
lea    -0x1(%rsi),%eax
mov    %eax,%ebx
xor    %esi,%ebx
and    %ebp,%ebx
add    %ebx,%ebp
add    %edx,%edx
and    %esi,%eax
mov    %eax,%esi
jne    13e0 <ordhuff+0x2c0>
jmp    1390 <ordhuff+0x270>
test   %r11d,%r11d
jle    142a <ordhuff+0x30a>
add    $0x1,%r15
xchg   %ax,%ax
lea    -0x2(%r15),%ebx
mov    0x0(%r13,%rbx,4),%edi
call   1030 <bsrl@plt>
mov    %eax,%ecx
shrl   %cl,(%r14,%rbx,4)
mov    $0x20,%ecx
sub    %eax,%ecx
mov    %ecx,0x0(%r13,%rbx,4)
add    $0xffffffffffffffff,%r15
cmp    $0x1,%r15
ja     1400 <ordhuff+0x2e0>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm1,%xmm1
mov    $0xffffffffffffffff,%rsi
test   $0x1,%r9b
jne    123f <ordhuff+0x11f>
jmp    1262 <ordhuff+0x142>

LLVM IR (-O0):
define void @ordhuff(i32 %0, i32* %1, i32* %2, i32* %3) {
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
store i32 %0, i32* %5
store i32* %1, i32** %6
store i32* %2, i32** %7
store i32* %3, i32** %8
%21 = load i32, i32* %5
store i32 %21, i32* %9
%22 = load i32*, i32** %6
%23 = getelementptr inbounds i32, i32* %22, i64 0
%24 = load i32, i32* %23
store i32 %24, i32* %11
br label %25
25: ; preds = %29, %4
%26 = load i32, i32* %9
%27 = add nsw i32 %26, -1
store i32 %27, i32* %9
%28 = icmp sgt i32 %27, 0
br i1 %28, label %29, label %37
29: ; preds = %25
%30 = load i32*, i32** %6
%31 = load i32, i32* %9
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %30, i64 %32
%34 = load i32, i32* %33
%35 = load i32, i32* %11
%36 = add i32 %35, %34
store i32 %36, i32* %11
br label %25
37: ; preds = %25
%38 = load i32, i32* %11
%39 = udiv i32 1073741823, %38
store i32 %39, i32* %10
%40 = load i32, i32* %5
store i32 %40, i32* %9
br label %41
41: ; preds = %45, %37
%42 = load i32, i32* %9
%43 = add nsw i32 %42, -1
store i32 %43, i32* %9
%44 = icmp sge i32 %43, 0
br i1 %44, label %45, label %59
45: ; preds = %41
%46 = load i32*, i32** %6
%47 = load i32, i32* %9
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %46, i64 %48
%50 = load i32, i32* %49
%51 = load i32, i32* %10
%52 = mul i32 %50, %51
%53 = call i32 @fls(i32 %52)
%54 = shl i32 -1, %53
%55 = load i32*, i32** %8
%56 = load i32, i32* %9
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
store i32 %54, i32* %58
br label %41
59: ; preds = %41
%60 = load i32*, i32** %7
%61 = getelementptr inbounds i32, i32* %60, i64 0
store i32 0, i32* %61
store i32 0, i32* %13
%62 = load i32*, i32** %8
%63 = getelementptr inbounds i32, i32* %62, i64 0
%64 = load i32, i32* %63
store i32 %64, i32* %14
store i32 1, i32* %9
br label %65
65: ; preds = %92, %59
%66 = load i32, i32* %9
%67 = load i32, i32* %5
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %95
69: ; preds = %65
%70 = load i32*, i32** %8
%71 = load i32, i32* %9
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i32, i32* %70, i64 %72
%74 = load i32, i32* %73
store i32 %74, i32* %15
%75 = load i32, i32* %13
%76 = load i32, i32* %15
%77 = load i32, i32* %14
%78 = and i32 %76, %77
%79 = sub i32 %75, %78
%80 = load i32, i32* %15
%81 = and i32 %79, %80
%82 = load i32*, i32** %7
%83 = load i32, i32* %9
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %82, i64 %84
store i32 %81, i32* %85
%86 = load i32*, i32** %7
%87 = load i32, i32* %9
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32, i32* %86, i64 %88
%90 = load i32, i32* %89
store i32 %90, i32* %13
%91 = load i32, i32* %15
store i32 %91, i32* %14
br label %92
92: ; preds = %69
%93 = load i32, i32* %9
%94 = add nsw i32 %93, 1
store i32 %94, i32* %9
br label %65
95: ; preds = %65
store i32 0, i32* %17
store i32 0, i32* %16
%96 = load i32, i32* %5
store i32 %96, i32* %9
br label %97
97: ; preds = %154, %95
%98 = load i32, i32* %9
%99 = add nsw i32 %98, -1
store i32 %99, i32* %9
%100 = icmp sge i32 %99, 0
br i1 %100, label %101, label %165
101: ; preds = %97
%102 = load i32*, i32** %8
%103 = load i32, i32* %9
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %102, i64 %104
%106 = load i32, i32* %105
store i32 %106, i32* %19
%107 = load i32*, i32** %7
%108 = load i32, i32* %9
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %107, i64 %109
%111 = load i32, i32* %110
store i32 %111, i32* %20
%112 = load i32, i32* %16
%113 = xor i32 %112, -1
%114 = load i32, i32* %17
%115 = or i32 %113, %114
%116 = load i32, i32* %20
%117 = xor i32 %116, -1
%118 = and i32 %115, %117
%119 = load i32, i32* %19
%120 = and i32 %118, %119
store i32 %120, i32* %17
%121 = load i32, i32* %19
store i32 %121, i32* %16
%122 = load i32, i32* %17
store i32 %122, i32* %18
br label %123
123: ; preds = %129, %101
%124 = load i32, i32* %18
%125 = icmp slt i32 %124, 0
br i1 %125, label %126, label %134
126: ; preds = %123
%127 = load i32, i32* %20
%128 = shl i32 %127, 1
store i32 %128, i32* %20
br label %129
129: ; preds = %126
%130 = load i32, i32* %18
%131 = shl i32 %130, 1
store i32 %131, i32* %18
%132 = load i32, i32* %19
%133 = shl i32 %132, 1
store i32 %133, i32* %19
br label %123
134: ; preds = %123
br label %135
135: ; preds = %147, %134
%136 = load i32, i32* %18
%137 = icmp ne i32 %136, 0
br i1 %137, label %138, label %154
138: ; preds = %135
%139 = load i32, i32* %18
%140 = sub nsw i32 %139, 1
%141 = load i32, i32* %18
%142 = xor i32 %140, %141
%143 = load i32, i32* %20
%144 = and i32 %142, %143
%145 = load i32, i32* %20
%146 = add i32 %145, %144
store i32 %146, i32* %20
br label %147
147: ; preds = %138
%148 = load i32, i32* %18
%149 = sub nsw i32 %148, 1
%150 = load i32, i32* %18
%151 = and i32 %150, %149
store i32 %151, i32* %18
%152 = load i32, i32* %19
%153 = shl i32 %152, 1
store i32 %153, i32* %19
br label %135
154: ; preds = %135
%155 = load i32, i32* %19
%156 = load i32*, i32** %8
%157 = load i32, i32* %9
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %156, i64 %158
store i32 %155, i32* %159
%160 = load i32, i32* %20
%161 = load i32*, i32** %7
%162 = load i32, i32* %9
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i32, i32* %161, i64 %163
store i32 %160, i32* %164
br label %97
165: ; preds = %97
%166 = load i32, i32* %5
store i32 %166, i32* %9
br label %167
167: ; preds = %171, %165
%168 = load i32, i32* %9
%169 = add nsw i32 %168, -1
store i32 %169, i32* %9
%170 = icmp sge i32 %169, 0
br i1 %170, label %171, label %190
171: ; preds = %167
%172 = load i32*, i32** %8
%173 = load i32, i32* %9
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i32, i32* %172, i64 %174
%176 = load i32, i32* %175
%177 = call i32 @bsrl(i32 %176)
store i32 %177, i32* %12
%178 = load i32*, i32** %7
%179 = load i32, i32* %9
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32, i32* %178, i64 %180
%182 = load i32, i32* %181
%183 = lshr i32 %182, %177
store i32 %183, i32* %181
%184 = load i32, i32* %12
%185 = sub i32 32, %184
%186 = load i32*, i32** %8
%187 = load i32, i32* %9
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %186, i64 %188
store i32 %185, i32* %189
br label %167
190: ; preds = %167
ret void
}

LLVM IR (-O2):
define void @ordhuff(i32 %0, i32* nocapture %1, i32* nocapture %2, i32* nocapture %3) {
%5 = load i32, i32* %1
%6 = icmp sgt i32 %0, 1
br i1 %6, label %7, label %112
7: ; preds = %4
%8 = zext i32 %0 to i64
%9 = add nuw nsw i64 %8, 1
%10 = call i64 @llvm.umin.i64(i64 %8, i64 2)
%11 = sub nsw i64 %9, %10
%12 = icmp ult i64 %11, 8
br i1 %12, label %100, label %13
13: ; preds = %7
%14 = call i64 @llvm.umin.i64(i64 %8, i64 2)
%15 = sub nsw i64 %8, %14
%16 = add i32 %0, -1
%17 = trunc i64 %15 to i32
%18 = icmp ult i32 %16, %17
%19 = icmp ugt i64 %15, 4294967295
%20 = or i1 %18, %19
br i1 %20, label %100, label %21
21: ; preds = %13
%22 = and i64 %11, -8
%23 = sub nsw i64 %8, %22
%24 = insertelement <4 x i32> <i32 poison, i32 0, i32 0, i32 0>, i32 %5, i64 0
%25 = add nsw i64 %22, -8
%26 = lshr exact i64 %25, 3
%27 = add nuw nsw i64 %26, 1
%28 = and i64 %27, 1
%29 = icmp eq i64 %25, 0
br i1 %29, label %72, label %30
30: ; preds = %21
%31 = and i64 %27, 4611686018427387902
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %67, %32 ]
%34 = phi <4 x i32> [ %24, %30 ], [ %65, %32 ]
%35 = phi <4 x i32> [ zeroinitializer, %30 ], [ %66, %32 ]
%36 = phi i64 [ 0, %30 ], [ %68, %32 ]
%37 = xor i64 %33, -1
%38 = add i64 %37, %8
%39 = and i64 %38, 4294967295
%40 = getelementptr inbounds i32, i32* %1, i64 %39
%41 = getelementptr inbounds i32, i32* %40, i64 -3
%42 = bitcast i32* %41 to <4 x i32>*
%43 = load <4 x i32>, <4 x i32>* %42
%44 = shufflevector <4 x i32> %43, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%45 = getelementptr inbounds i32, i32* %40, i64 -4
%46 = getelementptr inbounds i32, i32* %45, i64 -3
%47 = bitcast i32* %46 to <4 x i32>*
%48 = load <4 x i32>, <4 x i32>* %47
%49 = shufflevector <4 x i32> %48, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%50 = add <4 x i32> %44, %34
%51 = add <4 x i32> %49, %35
%52 = sub i64 4294967287, %33
%53 = add i64 %52, %8
%54 = and i64 %53, 4294967295
%55 = getelementptr inbounds i32, i32* %1, i64 %54
%56 = getelementptr inbounds i32, i32* %55, i64 -3
%57 = bitcast i32* %56 to <4 x i32>*
%58 = load <4 x i32>, <4 x i32>* %57
%59 = shufflevector <4 x i32> %58, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%60 = getelementptr inbounds i32, i32* %55, i64 -4
%61 = getelementptr inbounds i32, i32* %60, i64 -3
%62 = bitcast i32* %61 to <4 x i32>*
%63 = load <4 x i32>, <4 x i32>* %62
%64 = shufflevector <4 x i32> %63, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%65 = add <4 x i32> %59, %50
%66 = add <4 x i32> %64, %51
%67 = add nuw i64 %33, 16
%68 = add i64 %36, 2
%69 = icmp eq i64 %68, %31
br i1 %69, label %70, label %32
70: ; preds = %32
%71 = sub i64 -17, %33
br label %72
72: ; preds = %70, %21
%73 = phi <4 x i32> [ undef, %21 ], [ %65, %70 ]
%74 = phi <4 x i32> [ undef, %21 ], [ %66, %70 ]
%75 = phi i64 [ -1, %21 ], [ %71, %70 ]
%76 = phi <4 x i32> [ %24, %21 ], [ %65, %70 ]
%77 = phi <4 x i32> [ zeroinitializer, %21 ], [ %66, %70 ]
%78 = icmp eq i64 %28, 0
br i1 %78, label %94, label %79
79: ; preds = %72
%80 = add i64 %75, %8
%81 = and i64 %80, 4294967295
%82 = getelementptr inbounds i32, i32* %1, i64 %81
%83 = getelementptr inbounds i32, i32* %82, i64 -3
%84 = bitcast i32* %83 to <4 x i32>*
%85 = load <4 x i32>, <4 x i32>* %84
%86 = shufflevector <4 x i32> %85, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%87 = getelementptr inbounds i32, i32* %82, i64 -4
%88 = getelementptr inbounds i32, i32* %87, i64 -3
%89 = bitcast i32* %88 to <4 x i32>*
%90 = load <4 x i32>, <4 x i32>* %89
%91 = shufflevector <4 x i32> %90, <4 x i32> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%92 = add <4 x i32> %86, %76
%93 = add <4 x i32> %91, %77
br label %94
94: ; preds = %72, %79
%95 = phi <4 x i32> [ %73, %72 ], [ %92, %79 ]
%96 = phi <4 x i32> [ %74, %72 ], [ %93, %79 ]
%97 = add <4 x i32> %96, %95
%98 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %97)
%99 = icmp eq i64 %11, %22
br i1 %99, label %112, label %100
100: ; preds = %13, %7, %94
%101 = phi i64 [ %8, %13 ], [ %8, %7 ], [ %23, %94 ]
%102 = phi i32 [ %5, %13 ], [ %5, %7 ], [ %98, %94 ]
br label %103
103: ; preds = %100, %103
%104 = phi i64 [ %106, %103 ], [ %101, %100 ]
%105 = phi i32 [ %110, %103 ], [ %102, %100 ]
%106 = add nsw i64 %104, -1
%107 = and i64 %106, 4294967295
%108 = getelementptr inbounds i32, i32* %1, i64 %107
%109 = load i32, i32* %108
%110 = add i32 %109, %105
%111 = icmp ugt i64 %104, 2
br i1 %111, label %103, label %112
112: ; preds = %103, %94, %4
%113 = phi i32 [ %5, %4 ], [ %98, %94 ], [ %110, %103 ]
%114 = udiv i32 1073741823, %113
%115 = icmp sgt i32 %0, 0
br i1 %115, label %116, label %129
116: ; preds = %112
%117 = zext i32 %0 to i64
br label %118
118: ; preds = %116, %118
%119 = phi i64 [ %117, %116 ], [ %120, %118 ]
%120 = add nsw i64 %119, -1
%121 = and i64 %120, 4294967295
%122 = getelementptr inbounds i32, i32* %1, i64 %121
%123 = load i32, i32* %122
%124 = mul i32 %123, %114
%125 = tail call i32 @fls(i32 %124)
%126 = shl nsw i32 -1, %125
%127 = getelementptr inbounds i32, i32* %3, i64 %121
store i32 %126, i32* %127
%128 = icmp ugt i64 %119, 1
br i1 %128, label %118, label %129
129: ; preds = %118, %112
store i32 0, i32* %2
br i1 %6, label %130, label %150
130: ; preds = %129
%131 = load i32, i32* %3
%132 = zext i32 %0 to i64
%133 = add nsw i64 %132, -1
%134 = and i64 %133, 1
%135 = icmp eq i32 %0, 2
br i1 %135, label %138, label %136
136: ; preds = %130
%137 = and i64 %133, -2
br label %153
138: ; preds = %153, %130
%139 = phi i64 [ 1, %130 ], [ %171, %153 ]
%140 = phi i32 [ %131, %130 ], [ %166, %153 ]
%141 = phi i32 [ 0, %130 ], [ %169, %153 ]
%142 = icmp eq i64 %134, 0
br i1 %142, label %150, label %143
143: ; preds = %138
%144 = getelementptr inbounds i32, i32* %3, i64 %139
%145 = load i32, i32* %144
%146 = and i32 %145, %140
%147 = sub i32 %141, %146
%148 = and i32 %147, %145
%149 = getelementptr inbounds i32, i32* %2, i64 %139
store i32 %148, i32* %149
br label %150
150: ; preds = %143, %138, %129
br i1 %115, label %151, label %233
151: ; preds = %150
%152 = zext i32 %0 to i64
br label %177
153: ; preds = %153, %136
%154 = phi i64 [ 1, %136 ], [ %171, %153 ]
%155 = phi i32 [ %131, %136 ], [ %166, %153 ]
%156 = phi i32 [ 0, %136 ], [ %169, %153 ]
%157 = phi i64 [ 0, %136 ], [ %172, %153 ]
%158 = getelementptr inbounds i32, i32* %3, i64 %154
%159 = load i32, i32* %158
%160 = and i32 %159, %155
%161 = sub i32 %156, %160
%162 = and i32 %161, %159
%163 = getelementptr inbounds i32, i32* %2, i64 %154
store i32 %162, i32* %163
%164 = add nuw nsw i64 %154, 1
%165 = getelementptr inbounds i32, i32* %3, i64 %164
%166 = load i32, i32* %165
%167 = and i32 %166, %159
%168 = sub i32 %162, %167
%169 = and i32 %168, %166
%170 = getelementptr inbounds i32, i32* %2, i64 %164
store i32 %169, i32* %170
%171 = add nuw nsw i64 %154, 2
%172 = add i64 %157, 2
%173 = icmp eq i64 %172, %137
br i1 %173, label %138, label %153
174: ; preds = %217
br i1 %115, label %175, label %233
175: ; preds = %174
%176 = zext i32 %0 to i64
br label %221
177: ; preds = %151, %217
%178 = phi i64 [ %152, %151 ], [ %181, %217 ]
%179 = phi i32 [ 0, %151 ], [ %191, %217 ]
%180 = phi i32 [ 0, %151 ], [ %184, %217 ]
%181 = add nsw i64 %178, -1
%182 = and i64 %181, 4294967295
%183 = getelementptr inbounds i32, i32* %3, i64 %182
%184 = load i32, i32* %183
%185 = getelementptr inbounds i32, i32* %2, i64 %182
%186 = load i32, i32* %185
%187 = xor i32 %180, -1
%188 = or i32 %179, %187
%189 = xor i32 %186, -1
%190 = and i32 %184, %188
%191 = and i32 %190, %189
%192 = icmp slt i32 %191, 0
br i1 %192, label %198, label %193
193: ; preds = %198, %177
%194 = phi i32 [ %191, %177 ], [ %203, %198 ]
%195 = phi i32 [ %184, %177 ], [ %204, %198 ]
%196 = phi i32 [ %186, %177 ], [ %202, %198 ]
%197 = icmp eq i32 %194, 0
br i1 %197, label %217, label %206
198: ; preds = %177, %198
%199 = phi i32 [ %202, %198 ], [ %186, %177 ]
%200 = phi i32 [ %204, %198 ], [ %184, %177 ]
%201 = phi i32 [ %203, %198 ], [ %191, %177 ]
%202 = shl i32 %199, 1
%203 = shl i32 %201, 1
%204 = shl i32 %200, 1
%205 = icmp slt i32 %203, 0
br i1 %205, label %198, label %193
206: ; preds = %193, %206
%207 = phi i32 [ %213, %206 ], [ %196, %193 ]
%208 = phi i32 [ %215, %206 ], [ %195, %193 ]
%209 = phi i32 [ %214, %206 ], [ %194, %193 ]
%210 = add nsw i32 %209, -1
%211 = xor i32 %210, %209
%212 = and i32 %211, %207
%213 = add i32 %212, %207
%214 = and i32 %210, %209
%215 = shl i32 %208, 1
%216 = icmp eq i32 %214, 0
br i1 %216, label %217, label %206
217: ; preds = %206, %193
%218 = phi i32 [ %195, %193 ], [ %215, %206 ]
%219 = phi i32 [ %196, %193 ], [ %213, %206 ]
store i32 %218, i32* %183
store i32 %219, i32* %185
%220 = icmp sgt i64 %178, 1
br i1 %220, label %177, label %174
221: ; preds = %175, %221
%222 = phi i64 [ %176, %175 ], [ %223, %221 ]
%223 = add nsw i64 %222, -1
%224 = and i64 %223, 4294967295
%225 = getelementptr inbounds i32, i32* %3, i64 %224
%226 = load i32, i32* %225
%227 = tail call i32 @bsrl(i32 %226)
%228 = getelementptr inbounds i32, i32* %2, i64 %224
%229 = load i32, i32* %228
%230 = lshr i32 %229, %227
store i32 %230, i32* %228
%231 = sub i32 32, %227
store i32 %231, i32* %225
%232 = icmp ugt i64 %222, 1
br i1 %232, label %221, label %233
233: ; preds = %221, %150, %174
ret void
}