int huffman_decode_create(short *table, unsigned char *length, int n,
                          int start_bits) {
  int i, j, k, last, freq[32], sum[32];
  memset(freq, 0, sizeof(freq));
  for (i = 0; i < n; ++i) {
    if ((k = length[i]) > 31)
      return ((6) + 338 * 256);
    ++freq[k];
  }
  if (freq[0] == n) {
    memset(table, 0, sizeof(table[0]) << start_bits);
    return (0);
  }
  if (freq[0] == n - 1) {
    if (freq[1] != 1)
      return ((6) + 349 * 256);
    for (i = 0; length[i] == 0;)
      ++i;
    i <<= 5;
    for (k = 1 << start_bits; --k >= 0;)
      *table++ = (short)i;
    return (0);
  }
  memcpy(sum, freq, sizeof(sum));
  k = 0;
  for (i = 32; --i != 0;) {
    if ((k += freq[i]) & 1)
      return ((6) + 365 * 256);
    k >>= 1;
  }
  if (k != 1)
    return ((6) + 369 * 256);
  k = 0;
  for (i = 1; i < 32; ++i)
    freq[i] = (k += freq[i]);
  last = freq[31];
  for (i = n; --i >= 0;) {
    if ((k = length[i]) != 0)
      table[--freq[k]] = (short)i;
  }
  k = i = (1 << start_bits) + (n << 1);
  for (n = 32; --n > start_bits;) {
    j = i;
    while (k > j)
      table[--i] = (short)-(k -= 2);
    for (k = sum[n]; --k >= 0;)
      table[--i] = table[--last];
    k = j;
  }
  j = i;
  i = 1 << start_bits;
  while (k > j)
    table[--i] = (short)-(k -= 2);
  for (; n > 0; --n) {
    for (k = sum[n]; --k >= 0;) {
      ((void)0);
      j = i - (1 << (start_bits - n));
      n |= table[--last] << 5;
      do
        table[--i] = (short)n;
      while (i != j);
      n &= 31;
    }
  }
  ((void)0);
  return (0);
}


x86 assembly (clang, -O0):
<huffman_decode_create>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
lea    -0xb0(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1030 <memset@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11a6 <huffman_decode_create+0x86>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x1f,%eax
jle    1183 <huffman_decode_create+0x63>
movl   $0x15206,-0x4(%rbp)
jmp    1566 <huffman_decode_create+0x446>
movslq -0x2c(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0xb0(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1153 <huffman_decode_create+0x33>
mov    -0xb0(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    11d9 <huffman_decode_create+0xb9>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%eax
mov    %eax,%ecx
mov    $0x2,%edx
shl    %cl,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
movl   $0x0,-0x4(%rbp)
jmp    1566 <huffman_decode_create+0x446>
mov    -0xb0(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    1281 <huffman_decode_create+0x161>
cmpl   $0x1,-0xac(%rbp)
je     1206 <huffman_decode_create+0xe6>
movl   $0x15d06,-0x4(%rbp)
jmp    1566 <huffman_decode_create+0x446>
movl   $0x0,-0x24(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    1230 <huffman_decode_create+0x110>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    120d <huffman_decode_create+0xed>
mov    -0x24(%rbp),%eax
shl    $0x5,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x0,%eax
jl     1275 <huffman_decode_create+0x155>
mov    -0x24(%rbp),%eax
mov    %ax,%cx
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cx,(%rax)
jmp    1246 <huffman_decode_create+0x126>
movl   $0x0,-0x4(%rbp)
jmp    1566 <huffman_decode_create+0x446>
lea    -0x130(%rbp),%rdi
lea    -0xb0(%rbp),%rsi
mov    $0x80,%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x2c(%rbp)
movl   $0x20,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
je     12f0 <huffman_decode_create+0x1d0>
movslq -0x24(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
and    $0x1,%eax
cmp    $0x0,%eax
je     12e2 <huffman_decode_create+0x1c2>
movl   $0x16d06,-0x4(%rbp)
jmp    1566 <huffman_decode_create+0x446>
mov    -0x2c(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12a7 <huffman_decode_create+0x187>
cmpl   $0x1,-0x2c(%rbp)
je     1306 <huffman_decode_create+0x1e6>
movl   $0x17106,-0x4(%rbp)
jmp    1566 <huffman_decode_create+0x446>
movl   $0x0,-0x2c(%rbp)
movl   $0x1,-0x24(%rbp)
cmpl   $0x20,-0x24(%rbp)
jge    1348 <huffman_decode_create+0x228>
movslq -0x24(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%ecx
add    -0x2c(%rbp),%ecx
mov    %ecx,-0x2c(%rbp)
movslq -0x24(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1314 <huffman_decode_create+0x1f4>
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jl     13a9 <huffman_decode_create+0x289>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x0,%eax
je     13a4 <huffman_decode_create+0x284>
mov    -0x24(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rsi
mov    -0xb0(%rbp,%rsi,4),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0xb0(%rbp,%rsi,4)
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1354 <huffman_decode_create+0x234>
mov    -0x20(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    %eax,-0x2c(%rbp)
movl   $0x20,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    -0x20(%rbp),%eax
jle    146d <huffman_decode_create+0x34d>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jle    1415 <huffman_decode_create+0x2f5>
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
mov    %ecx,-0x2c(%rbp)
xor    %eax,%eax
sub    %ecx,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    13e0 <huffman_decode_create+0x2c0>
movslq -0x1c(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x0,%eax
jl     1462 <huffman_decode_create+0x342>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1423 <huffman_decode_create+0x303>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    13c8 <huffman_decode_create+0x2a8>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jle    14b5 <huffman_decode_create+0x395>
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
mov    %ecx,-0x2c(%rbp)
xor    %eax,%eax
sub    %ecx,%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1480 <huffman_decode_create+0x360>
jmp    14ba <huffman_decode_create+0x39a>
cmpl   $0x0,-0x1c(%rbp)
jle    155f <huffman_decode_create+0x43f>
movslq -0x1c(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x0,%eax
jl     154c <huffman_decode_create+0x42c>
mov    -0x24(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
shl    $0x5,%eax
or     -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
movslq %ecx,%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    1518 <huffman_decode_create+0x3f8>
mov    -0x1c(%rbp),%eax
and    $0x1f,%eax
mov    %eax,-0x1c(%rbp)
jmp    14d2 <huffman_decode_create+0x3b2>
jmp    1551 <huffman_decode_create+0x431>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    14ba <huffman_decode_create+0x39a>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<huffman_decode_create>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %ecx,%r8d
pxor   %xmm0,%xmm0
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x60(%rsp)
movdqa %xmm0,0x70(%rsp)
movdqa %xmm0,0x80(%rsp)
movdqa %xmm0,0x90(%rsp)
test   %edx,%edx
jle    1235 <huffman_decode_create+0x125>
mov    %edx,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movzbl (%rsi,%rcx,1),%ebp
cmp    $0x1f,%rbp
ja     1258 <huffman_decode_create+0x148>
addl   $0x1,0x20(%rsp,%rbp,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1170 <huffman_decode_create+0x60>
mov    0x20(%rsp),%eax
cmp    %edx,%eax
je     123f <huffman_decode_create+0x12f>
lea    -0x1(%rdx),%ecx
cmp    %ecx,%eax
jne    1262 <huffman_decode_create+0x152>
mov    $0x15d06,%ebp
cmpl   $0x1,0x24(%rsp)
jne    19d1 <huffman_decode_create+0x8c1>
mov    $0xffe0,%ax
nopw   0x0(%rax,%rax,1)
add    $0x20,%eax
cmpb   $0x0,(%rsi)
lea    0x1(%rsi),%rsi
je     11c0 <huffman_decode_create+0xb0>
cmp    $0x1f,%r8d
je     19cf <huffman_decode_create+0x8bf>
mov    $0x1,%esi
mov    $0x1,%edx
mov    %r8d,%ecx
shl    %cl,%edx
test   %edx,%edx
cmovle %edx,%esi
mov    %edx,%ecx
sub    %esi,%ecx
cmp    $0xf,%ecx
jb     19b2 <huffman_decode_create+0x8a2>
add    $0x1,%rcx
mov    %rcx,%r8
and    $0xfffffffffffffff0,%r8
movd   %eax,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x10(%r8),%rsi
mov    %rsi,%rbp
shr    $0x4,%rbp
add    $0x1,%rbp
mov    %ebp,%ebx
and    $0x7,%ebx
cmp    $0x70,%rsi
jae    18e3 <huffman_decode_create+0x7d3>
xor    %esi,%esi
jmp    1975 <huffman_decode_create+0x865>
xor    %eax,%eax
cmp    %edx,%eax
jne    1198 <huffman_decode_create+0x88>
mov    $0x2,%edx
mov    %r8d,%ecx
shl    %cl,%rdx
xor    %ebp,%ebp
xor    %esi,%esi
call   1030 <memset@plt>
jmp    19d1 <huffman_decode_create+0x8c1>
mov    $0x15206,%ebp
jmp    19d1 <huffman_decode_create+0x8c1>
movaps 0x90(%rsp),%xmm0
movaps %xmm0,0x120(%rsp)
movaps 0x80(%rsp),%xmm0
movaps %xmm0,0x110(%rsp)
movaps 0x70(%rsp),%xmm0
movaps %xmm0,0x100(%rsp)
movaps 0x60(%rsp),%xmm0
movaps %xmm0,0xf0(%rsp)
movdqa 0x20(%rsp),%xmm0
movdqa 0x30(%rsp),%xmm1
movdqa 0x40(%rsp),%xmm2
movdqa 0x50(%rsp),%xmm3
movdqa %xmm3,0xe0(%rsp)
movdqa %xmm2,0xd0(%rsp)
movdqa %xmm1,0xc0(%rsp)
movdqa %xmm0,0xb0(%rsp)
xor    %eax,%eax
mov    $0x1e,%ecx
mov    $0x16d06,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    0x24(%rsp,%rcx,4),%eax
test   $0x1,%al
jne    19d1 <huffman_decode_create+0x8c1>
sar    %eax
test   %rcx,%rcx
je     1317 <huffman_decode_create+0x207>
add    0x20(%rsp,%rcx,4),%eax
test   $0x1,%al
jne    19d1 <huffman_decode_create+0x8c1>
sar    %eax
add    $0xfffffffffffffffe,%rcx
jmp    12f0 <huffman_decode_create+0x1e0>
mov    $0x17106,%ebp
cmp    $0x1,%eax
jne    19d1 <huffman_decode_create+0x8c1>
xor    %eax,%eax
mov    $0x4,%ecx
nopl   0x0(%rax)
add    0x14(%rsp,%rcx,4),%eax
mov    %eax,0x14(%rsp,%rcx,4)
add    0x18(%rsp,%rcx,4),%eax
mov    %eax,0x18(%rsp,%rcx,4)
add    0x1c(%rsp,%rcx,4),%eax
mov    %eax,0x1c(%rsp,%rcx,4)
cmp    $0x20,%rcx
je     135c <huffman_decode_create+0x24c>
add    0x20(%rsp,%rcx,4),%eax
mov    %eax,0x20(%rsp,%rcx,4)
add    $0x4,%rcx
jmp    1330 <huffman_decode_create+0x220>
mov    0x9c(%rsp),%r14d
test   %edx,%edx
mov    %r8d,0x14(%rsp)
jle    139d <huffman_decode_create+0x28d>
mov    %edx,%eax
test   $0x1,%al
je     1394 <huffman_decode_create+0x284>
add    $0xffffffffffffffff,%rax
mov    %eax,%ecx
movzbl (%rsi,%rcx,1),%ecx
test   %rcx,%rcx
je     1394 <huffman_decode_create+0x284>
movslq 0x20(%rsp,%rcx,4),%rbp
lea    -0x1(%rbp),%rbx
mov    %ebx,0x20(%rsp,%rcx,4)
mov    %ax,-0x2(%rdi,%rbp,2)
cmp    $0x1,%edx
jne    19e5 <huffman_decode_create+0x8d5>
mov    $0x1,%r13d
mov    %r8d,%ecx
shl    %cl,%r13d
mov    $0x1f,%ebx
cmp    $0x1e,%r8d
jg     1738 <huffman_decode_create+0x628>
lea    0x0(%r13,%rdx,2),%ecx
movslq %r8d,%r9
lea    -0x2(%rdi),%r11
lea    -0x10(%rdi),%rax
mov    %rax,0x18(%rsp)
mov    $0x1f,%ebx
movdqa 0xc26(%rip),%xmm3
movdqa 0xc2e(%rip),%xmm0
movdqa 0xc36(%rip),%xmm1
movdqa 0xc3e(%rip),%xmm2
mov    %ecx,%edx
mov    %r9,0x8(%rsp)
jmp    1410 <huffman_decode_create+0x300>
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rbx
mov    %r15d,%ecx
cmp    %r9,%rbx
jle    166f <huffman_decode_create+0x55f>
mov    %edx,%r15d
cmp    %edx,%ecx
jle    14e4 <huffman_decode_create+0x3d4>
movslq %r15d,%rdx
mov    %r15d,%r10d
not    %r10d
add    %ecx,%r10d
cmp    $0x1e,%r10d
jb     14c0 <huffman_decode_create+0x3b0>
shr    %r10d
add    $0x1,%r10d
mov    %r10d,%r9d
and    $0xfffffff0,%r9d
movd   %ecx,%xmm4
sub    %r9d,%ecx
sub    %r9d,%ecx
pshuflw $0x0,%xmm4,%xmm4
pshufd $0x0,%xmm4,%xmm4
paddw  %xmm3,%xmm4
mov    0x18(%rsp),%rax
lea    (%rax,%rdx,2),%rax
sub    %r9,%rdx
mov    %r9,%rsi
neg    %rsi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm5
psubw  %xmm4,%xmm5
movdqa %xmm1,%xmm6
psubw  %xmm4,%xmm6
pshufd $0x4e,%xmm5,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
movdqu %xmm5,(%rax,%rbp,2)
pshufd $0x4e,%xmm6,%xmm5
pshuflw $0x1b,%xmm5,%xmm5
pshufhw $0x1b,%xmm5,%xmm5
movdqu %xmm5,-0x10(%rax,%rbp,2)
paddw  %xmm2,%xmm4
add    $0xfffffffffffffff0,%rbp
cmp    %rbp,%rsi
jne    1470 <huffman_decode_create+0x360>
cmp    %r10,%r9
mov    0x8(%rsp),%r9
je     14e4 <huffman_decode_create+0x3d4>
mov    $0x2,%eax
sub    %ecx,%eax
nopw   0x0(%rax,%rax,1)
add    $0xfffffffe,%ecx
mov    %ax,-0x2(%rdi,%rdx,2)
add    $0xffffffffffffffff,%rdx
add    $0x2,%eax
cmp    %r15d,%ecx
jg     14d0 <huffman_decode_create+0x3c0>
mov    0xb0(%rsp,%rbx,4),%ecx
test   %ecx,%ecx
jle    1400 <huffman_decode_create+0x2f0>
movslq %r14d,%r14
movslq %edx,%rdx
lea    -0x1(%rcx),%r12d
cmp    $0xf,%r12d
jb     1640 <huffman_decode_create+0x530>
lea    (%r11,%rdx,2),%rbp
lea    (%r12,%r12,1),%rax
mov    %rbp,%rsi
sub    %rax,%rsi
cmp    %rbp,%rsi
ja     1640 <huffman_decode_create+0x530>
lea    (%r11,%r14,2),%rbp
mov    %rbp,%rsi
sub    %rax,%rsi
cmp    %rbp,%rsi
ja     1640 <huffman_decode_create+0x530>
mov    %rdx,%rax
sub    %r12,%rax
lea    (%r11,%rax,2),%rax
lea    (%rdi,%r14,2),%rsi
cmp    %rsi,%rax
jae    155b <huffman_decode_create+0x44b>
lea    (%rdi,%rdx,2),%rax
mov    %r14,%rsi
sub    %r12,%rsi
lea    (%r11,%rsi,2),%rsi
cmp    %rax,%rsi
jb     1640 <huffman_decode_create+0x530>
add    $0x1,%r12
mov    %r12,%rbp
movabs $0x1fffffff0,%rax
and    %rax,%rbp
lea    -0x10(%rbp),%rsi
mov    %rsi,%rax
shr    $0x4,%rax
add    $0x1,%rax
test   %rsi,%rsi
je     15ff <huffman_decode_create+0x4ef>
mov    %rbp,0xa8(%rsp)
movabs $0x1ffffffffffffff8,%rsi
ff ff 1f
add    $0x6,%rsi
and    %rax,%rsi
mov    0x18(%rsp),%r9
lea    (%r9,%rdx,2),%rbp
lea    (%r9,%r14,2),%r9
xor    %r10d,%r10d
movups -0x10(%r9,%r10,2),%xmm4
movups (%r9,%r10,2),%xmm5
movups %xmm5,0x0(%rbp,%r10,2)
movups %xmm4,-0x10(%rbp,%r10,2)
movdqu -0x30(%r9,%r10,2),%xmm4
movdqu -0x20(%r9,%r10,2),%xmm5
movdqu %xmm5,-0x20(%rbp,%r10,2)
movdqu %xmm4,-0x30(%rbp,%r10,2)
add    $0xffffffffffffffe0,%r10
add    $0xfffffffffffffffe,%rsi
jne    15b0 <huffman_decode_create+0x4a0>
neg    %r10
mov    0x8(%rsp),%r9
mov    0xa8(%rsp),%rbp
jmp    1602 <huffman_decode_create+0x4f2>
xor    %r10d,%r10d
test   $0x1,%al
je     162a <huffman_decode_create+0x51a>
not    %r10
lea    (%r10,%r14,1),%rax
movdqu -0x1e(%rdi,%rax,2),%xmm4
movdqu -0xe(%rdi,%rax,2),%xmm5
add    %rdx,%r10
movdqu %xmm5,-0xe(%rdi,%r10,2)
movdqu %xmm4,-0x1e(%rdi,%r10,2)
sub    %rbp,%rdx
sub    %rbp,%r14
cmp    %rbp,%r12
je     1400 <huffman_decode_create+0x2f0>
sub    %ebp,%ecx
nopl   0x0(%rax,%rax,1)
add    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzwl (%r11,%r14,2),%eax
add    $0xffffffffffffffff,%r14
mov    %ax,(%r11,%rdx,2)
add    $0xffffffffffffffff,%rdx
add    $0xffffffff,%ecx
cmp    $0x1,%ecx
ja     1650 <huffman_decode_create+0x540>
jmp    1400 <huffman_decode_create+0x2f0>
cmp    %edx,%r15d
jle    1730 <huffman_decode_create+0x620>
movslq %r13d,%r13
mov    %edx,%eax
not    %eax
add    %r15d,%eax
cmp    $0x1e,%eax
jb     1712 <huffman_decode_create+0x602>
shr    %eax
add    $0x1,%eax
mov    %eax,%r9d
and    $0xfffffff0,%r9d
movd   %r15d,%xmm3
sub    %r9d,%r15d
sub    %r9d,%r15d
pshuflw $0x0,%xmm3,%xmm3
pshufd $0x0,%xmm3,%xmm3
paddw  0x94c(%rip),%xmm3
lea    (%rdi,%r13,2),%rsi
add    $0xfffffffffffffff0,%rsi
sub    %r9,%r13
mov    %r9,%rcx
neg    %rcx
xor    %ebp,%ebp
movdqa %xmm0,%xmm4
psubw  %xmm3,%xmm4
movdqa %xmm1,%xmm5
psubw  %xmm3,%xmm5
pshufd $0x4e,%xmm4,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
movdqu %xmm4,(%rsi,%rbp,2)
pshufd $0x4e,%xmm5,%xmm4
pshuflw $0x1b,%xmm4,%xmm4
pshufhw $0x1b,%xmm4,%xmm4
movdqu %xmm4,-0x10(%rsi,%rbp,2)
paddw  %xmm2,%xmm3
add    $0xfffffffffffffff0,%rbp
cmp    %rbp,%rcx
jne    16c7 <huffman_decode_create+0x5b7>
cmp    %rax,%r9
je     1730 <huffman_decode_create+0x620>
mov    $0x2,%eax
sub    %r15d,%eax
add    $0xfffffffe,%r15d
mov    %ax,-0x2(%rdi,%r13,2)
add    $0xffffffffffffffff,%r13
add    $0x2,%eax
cmp    %edx,%r15d
jg     171a <huffman_decode_create+0x60a>
test   %ebx,%ebx
jle    19cf <huffman_decode_create+0x8bf>
lea    -0x10(%rdi),%rax
mov    %rax,0x8(%rsp)
jmp    1760 <huffman_decode_create+0x650>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebx,%esi
lea    -0x1(%rsi),%ebx
xor    %ebp,%ebp
cmp    $0x1,%esi
jle    19d1 <huffman_decode_create+0x8c1>
mov    %ebx,%eax
mov    0xb0(%rsp,%rax,4),%r12d
test   %r12d,%r12d
jle    1750 <huffman_decode_create+0x640>
mov    %ebx,%esi
and    $0x1f,%esi
movslq %r14d,%r14
mov    %rsi,0x18(%rsp)
jmp    1794 <huffman_decode_create+0x684>
xchg   %ax,%ax
add    $0xffffffffffffffff,%r14
lea    -0x1(%r12),%eax
mov    %esi,%ebx
cmp    $0x1,%r12d
mov    %eax,%r12d
jle    1752 <huffman_decode_create+0x642>
mov    %r13d,%eax
mov    %r8d,%ecx
sub    %ebx,%ecx
mov    $0xffffffff,%r13d
shl    %cl,%r13d
add    %eax,%r13d
movzwl -0x2(%rdi,%r14,2),%ecx
shl    $0x5,%ecx
or     %ebx,%ecx
movslq %eax,%rbx
movslq %r13d,%rdx
mov    %rbx,%r15
sub    %rdx,%r15
cmp    $0x10,%r15
jb     18d0 <huffman_decode_create+0x7c0>
mov    %r15,%r10
and    $0xfffffffffffffff0,%r10
movd   %ecx,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x10(%r10),%rsi
mov    %rsi,%rax
shr    $0x4,%rax
add    $0x1,%rax
mov    %eax,%r11d
and    $0x3,%r11d
cmp    $0x30,%rsi
jae    1810 <huffman_decode_create+0x700>
xor    %r9d,%r9d
test   %r11,%r11
jne    187e <huffman_decode_create+0x76e>
jmp    18b7 <huffman_decode_create+0x7a7>
nopw   0x0(%rax,%rax,1)
movabs $0x1ffffffffffffff8,%rsi
ff ff 1f
add    $0x4,%rsi
and    %rsi,%rax
mov    0x8(%rsp),%rsi
lea    (%rsi,%rbx,2),%r8
xor    %r9d,%r9d
nopl   (%rax)
movdqu %xmm0,(%r8,%r9,2)
movdqu %xmm0,-0x10(%r8,%r9,2)
movdqu %xmm0,-0x20(%r8,%r9,2)
movdqu %xmm0,-0x30(%r8,%r9,2)
movdqu %xmm0,-0x40(%r8,%r9,2)
movdqu %xmm0,-0x50(%r8,%r9,2)
movdqu %xmm0,-0x60(%r8,%r9,2)
movdqu %xmm0,-0x70(%r8,%r9,2)
add    $0xffffffffffffffc0,%r9
add    $0xfffffffffffffffc,%rax
jne    1830 <huffman_decode_create+0x720>
neg    %r9
mov    0x14(%rsp),%r8d
test   %r11,%r11
je     18b7 <huffman_decode_create+0x7a7>
mov    %rbx,%rax
sub    %r9,%rax
mov    0x8(%rsp),%rsi
lea    (%rsi,%rax,2),%rax
shl    $0x5,%r11
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu %xmm0,(%rax,%rsi,1)
movdqu %xmm0,-0x10(%rax,%rsi,1)
add    $0xffffffffffffffe0,%rsi
mov    %r11,%rbp
add    %rsi,%rbp
jne    18a0 <huffman_decode_create+0x790>
cmp    %r10,%r15
mov    0x18(%rsp),%rsi
je     1780 <huffman_decode_create+0x670>
sub    %r10,%rbx
nopl   0x0(%rax,%rax,1)
mov    %cx,-0x2(%rdi,%rbx,2)
add    $0xffffffffffffffff,%rbx
cmp    %rbx,%rdx
jne    18d0 <huffman_decode_create+0x7c0>
jmp    1780 <huffman_decode_create+0x670>
and    $0xfffffffffffffff8,%rbp
xor    %esi,%esi
nopl   0x0(%rax)
movdqu %xmm0,(%rdi,%rsi,2)
movdqu %xmm0,0x10(%rdi,%rsi,2)
movdqu %xmm0,0x20(%rdi,%rsi,2)
movdqu %xmm0,0x30(%rdi,%rsi,2)
movdqu %xmm0,0x40(%rdi,%rsi,2)
movdqu %xmm0,0x50(%rdi,%rsi,2)
movdqu %xmm0,0x60(%rdi,%rsi,2)
movdqu %xmm0,0x70(%rdi,%rsi,2)
movdqu %xmm0,0x80(%rdi,%rsi,2)
movdqu %xmm0,0x90(%rdi,%rsi,2)
movdqu %xmm0,0xa0(%rdi,%rsi,2)
movdqu %xmm0,0xb0(%rdi,%rsi,2)
movdqu %xmm0,0xc0(%rdi,%rsi,2)
movdqu %xmm0,0xd0(%rdi,%rsi,2)
movdqu %xmm0,0xe0(%rdi,%rsi,2)
movdqu %xmm0,0xf0(%rdi,%rsi,2)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffff8,%rbp
jne    18f0 <huffman_decode_create+0x7e0>
test   %rbx,%rbx
je     19a4 <huffman_decode_create+0x894>
lea    (%rdi,%rsi,2),%rsi
add    $0x10,%rsi
shl    $0x5,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rsi,%rbp,1)
movdqu %xmm0,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    1990 <huffman_decode_create+0x880>
xor    %ebp,%ebp
cmp    %r8,%rcx
je     19d1 <huffman_decode_create+0x8c1>
sub    %r8d,%edx
lea    (%rdi,%r8,2),%rdi
add    $0x1,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ax,(%rdi)
add    $0x2,%rdi
add    $0xffffffff,%edx
cmp    $0x1,%edx
jg     19c0 <huffman_decode_create+0x8b0>
xor    %ebp,%ebp
mov    %ebp,%eax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0xfffffffffffffffe,%rax
jmp    1a05 <huffman_decode_create+0x8f5>
nopl   0x0(%rax,%rax,1)
lea    -0x2(%rax),%rcx
add    $0x1,%rax
cmp    $0x1,%rax
mov    %rcx,%rax
jbe    139d <huffman_decode_create+0x28d>
lea    0x1(%rax),%ecx
movzbl (%rsi,%rcx,1),%ecx
test   %rcx,%rcx
je     1a2d <huffman_decode_create+0x91d>
lea    0x1(%rax),%r8d
movslq 0x20(%rsp,%rcx,4),%rbx
lea    -0x1(%rbx),%rbp
mov    %ebp,0x20(%rsp,%rcx,4)
mov    %r8w,-0x2(%rdi,%rbx,2)
mov    0x14(%rsp),%r8d
mov    %eax,%ecx
movzbl (%rsi,%rcx,1),%ecx
test   %rcx,%rcx
je     19f0 <huffman_decode_create+0x8e0>
movslq 0x20(%rsp,%rcx,4),%rbp
lea    -0x1(%rbp),%rbx
mov    %ebx,0x20(%rsp,%rcx,4)
mov    %ax,-0x2(%rdi,%rbp,2)
jmp    19f0 <huffman_decode_create+0x8e0>

LLVM IR (-O0):
define i32 @huffman_decode_create(i16* %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i16*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca [32 x i32]
%15 = alloca [32 x i32]
store i16* %0, i16** %6
store i8* %1, i8** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
%16 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 0
%17 = bitcast i32* %16 to i8*
store i32 0, i32* %10
br label %18
18: ; preds = %37, %4
%19 = load i32, i32* %10
%20 = load i32, i32* %8
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %40
22: ; preds = %18
%23 = load i8*, i8** %7
%24 = load i32, i32* %10
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = zext i8 %27 to i32
store i32 %28, i32* %12
%29 = icmp sgt i32 %28, 31
br i1 %29, label %30, label %31
30: ; preds = %22
store i32 86534, i32* %5
br label %278
31: ; preds = %22
%32 = load i32, i32* %12
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %33
%35 = load i32, i32* %34
%36 = add nsw i32 %35, 1
store i32 %36, i32* %34
br label %37
37: ; preds = %31
%38 = load i32, i32* %10
%39 = add nsw i32 %38, 1
store i32 %39, i32* %10
br label %18
40: ; preds = %18
%41 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 0
%42 = load i32, i32* %41
%43 = load i32, i32* %8
%44 = icmp eq i32 %42, %43
br i1 %44, label %45, label %51
45: ; preds = %40
%46 = load i16*, i16** %6
%47 = bitcast i16* %46 to i8*
%48 = load i32, i32* %9
%49 = zext i32 %48 to i64
%50 = shl i64 2, %49
store i32 0, i32* %5
br label %278
51: ; preds = %40
%52 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 0
%53 = load i32, i32* %52
%54 = load i32, i32* %8
%55 = sub nsw i32 %54, 1
%56 = icmp eq i32 %53, %55
br i1 %56, label %57, label %89
57: ; preds = %51
%58 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 1
%59 = load i32, i32* %58
%60 = icmp ne i32 %59, 1
br i1 %60, label %61, label %62
61: ; preds = %57
store i32 89350, i32* %5
br label %278
62: ; preds = %57
store i32 0, i32* %10
br label %63
63: ; preds = %71, %62
%64 = load i8*, i8** %7
%65 = load i32, i32* %10
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i8, i8* %64, i64 %66
%68 = load i8, i8* %67
%69 = zext i8 %68 to i32
%70 = icmp eq i32 %69, 0
br i1 %70, label %71, label %74
71: ; preds = %63
%72 = load i32, i32* %10
%73 = add nsw i32 %72, 1
store i32 %73, i32* %10
br label %63
74: ; preds = %63
%75 = load i32, i32* %10
%76 = shl i32 %75, 5
store i32 %76, i32* %10
%77 = load i32, i32* %9
%78 = shl i32 1, %77
store i32 %78, i32* %12
br label %79
79: ; preds = %83, %74
%80 = load i32, i32* %12
%81 = add nsw i32 %80, -1
store i32 %81, i32* %12
%82 = icmp sge i32 %81, 0
br i1 %82, label %83, label %88
83: ; preds = %79
%84 = load i32, i32* %10
%85 = trunc i32 %84 to i16
%86 = load i16*, i16** %6
%87 = getelementptr inbounds i16, i16* %86, i32 1
store i16* %87, i16** %6
store i16 %85, i16* %86
br label %79
88: ; preds = %79
store i32 0, i32* %5
br label %278
89: ; preds = %51
%90 = getelementptr inbounds [32 x i32], [32 x i32]* %15, i64 0, i64 0
%91 = bitcast i32* %90 to i8*
%92 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 0
%93 = bitcast i32* %92 to i8*
store i32 0, i32* %12
store i32 32, i32* %10
br label %94
94: ; preds = %108, %89
%95 = load i32, i32* %10
%96 = add nsw i32 %95, -1
store i32 %96, i32* %10
%97 = icmp ne i32 %96, 0
br i1 %97, label %98, label %111
98: ; preds = %94
%99 = load i32, i32* %10
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %100
%102 = load i32, i32* %101
%103 = load i32, i32* %12
%104 = add nsw i32 %103, %102
store i32 %104, i32* %12
%105 = and i32 %104, 1
%106 = icmp ne i32 %105, 0
br i1 %106, label %107, label %108
107: ; preds = %98
store i32 93446, i32* %5
br label %278
108: ; preds = %98
%109 = load i32, i32* %12
%110 = ashr i32 %109, 1
store i32 %110, i32* %12
br label %94
111: ; preds = %94
%112 = load i32, i32* %12
%113 = icmp ne i32 %112, 1
br i1 %113, label %114, label %115
114: ; preds = %111
store i32 94470, i32* %5
br label %278
115: ; preds = %111
store i32 0, i32* %12
store i32 1, i32* %10
br label %116
116: ; preds = %129, %115
%117 = load i32, i32* %10
%118 = icmp slt i32 %117, 32
br i1 %118, label %119, label %132
119: ; preds = %116
%120 = load i32, i32* %10
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %121
%123 = load i32, i32* %122
%124 = load i32, i32* %12
%125 = add nsw i32 %124, %123
store i32 %125, i32* %12
%126 = load i32, i32* %10
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %127
store i32 %125, i32* %128
br label %129
129: ; preds = %119
%130 = load i32, i32* %10
%131 = add nsw i32 %130, 1
store i32 %131, i32* %10
br label %116
132: ; preds = %116
%133 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 31
%134 = load i32, i32* %133
store i32 %134, i32* %13
%135 = load i32, i32* %8
store i32 %135, i32* %10
br label %136
136: ; preds = %159, %132
%137 = load i32, i32* %10
%138 = add nsw i32 %137, -1
store i32 %138, i32* %10
%139 = icmp sge i32 %138, 0
br i1 %139, label %140, label %160
140: ; preds = %136
%141 = load i8*, i8** %7
%142 = load i32, i32* %10
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds i8, i8* %141, i64 %143
%145 = load i8, i8* %144
%146 = zext i8 %145 to i32
store i32 %146, i32* %12
%147 = icmp ne i32 %146, 0
br i1 %147, label %148, label %159
148: ; preds = %140
%149 = load i32, i32* %10
%150 = trunc i32 %149 to i16
%151 = load i16*, i16** %6
%152 = load i32, i32* %12
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %153
%155 = load i32, i32* %154
%156 = add nsw i32 %155, -1
store i32 %156, i32* %154
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i16, i16* %151, i64 %157
store i16 %150, i16* %158
br label %159
159: ; preds = %148, %140
br label %136
160: ; preds = %136
%161 = load i32, i32* %9
%162 = shl i32 1, %161
%163 = load i32, i32* %8
%164 = shl i32 %163, 1
%165 = add nsw i32 %162, %164
store i32 %165, i32* %10
store i32 %165, i32* %12
store i32 32, i32* %8
br label %166
166: ; preds = %208, %160
%167 = load i32, i32* %8
%168 = add nsw i32 %167, -1
store i32 %168, i32* %8
%169 = load i32, i32* %9
%170 = icmp sgt i32 %168, %169
br i1 %170, label %171, label %210
171: ; preds = %166
%172 = load i32, i32* %10
store i32 %172, i32* %11
br label %173
173: ; preds = %177, %171
%174 = load i32, i32* %12
%175 = load i32, i32* %11
%176 = icmp sgt i32 %174, %175
br i1 %176, label %177, label %187
177: ; preds = %173
%178 = load i32, i32* %12
%179 = sub nsw i32 %178, 2
store i32 %179, i32* %12
%180 = sub nsw i32 0, %179
%181 = trunc i32 %180 to i16
%182 = load i16*, i16** %6
%183 = load i32, i32* %10
%184 = add nsw i32 %183, -1
store i32 %184, i32* %10
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i16, i16* %182, i64 %185
store i16 %181, i16* %186
br label %173
187: ; preds = %173
%188 = load i32, i32* %8
%189 = sext i32 %188 to i64
%190 = getelementptr inbounds [32 x i32], [32 x i32]* %15, i64 0, i64 %189
%191 = load i32, i32* %190
store i32 %191, i32* %12
br label %192
192: ; preds = %196, %187
%193 = load i32, i32* %12
%194 = add nsw i32 %193, -1
store i32 %194, i32* %12
%195 = icmp sge i32 %194, 0
br i1 %195, label %196, label %208
196: ; preds = %192
%197 = load i16*, i16** %6
%198 = load i32, i32* %13
%199 = add nsw i32 %198, -1
store i32 %199, i32* %13
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i16, i16* %197, i64 %200
%202 = load i16, i16* %201
%203 = load i16*, i16** %6
%204 = load i32, i32* %10
%205 = add nsw i32 %204, -1
store i32 %205, i32* %10
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i16, i16* %203, i64 %206
store i16 %202, i16* %207
br label %192
208: ; preds = %192
%209 = load i32, i32* %11
store i32 %209, i32* %12
br label %166
210: ; preds = %166
%211 = load i32, i32* %10
store i32 %211, i32* %11
%212 = load i32, i32* %9
%213 = shl i32 1, %212
store i32 %213, i32* %10
br label %214
214: ; preds = %218, %210
%215 = load i32, i32* %12
%216 = load i32, i32* %11
%217 = icmp sgt i32 %215, %216
br i1 %217, label %218, label %228
218: ; preds = %214
%219 = load i32, i32* %12
%220 = sub nsw i32 %219, 2
store i32 %220, i32* %12
%221 = sub nsw i32 0, %220
%222 = trunc i32 %221 to i16
%223 = load i16*, i16** %6
%224 = load i32, i32* %10
%225 = add nsw i32 %224, -1
store i32 %225, i32* %10
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds i16, i16* %223, i64 %226
store i16 %222, i16* %227
br label %214
228: ; preds = %214
br label %229
229: ; preds = %274, %228
%230 = load i32, i32* %8
%231 = icmp sgt i32 %230, 0
br i1 %231, label %232, label %277
232: ; preds = %229
%233 = load i32, i32* %8
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds [32 x i32], [32 x i32]* %15, i64 0, i64 %234
%236 = load i32, i32* %235
store i32 %236, i32* %12
br label %237
237: ; preds = %270, %232
%238 = load i32, i32* %12
%239 = add nsw i32 %238, -1
store i32 %239, i32* %12
%240 = icmp sge i32 %239, 0
br i1 %240, label %241, label %273
241: ; preds = %237
%242 = load i32, i32* %10
%243 = load i32, i32* %9
%244 = load i32, i32* %8
%245 = sub nsw i32 %243, %244
%246 = shl i32 1, %245
%247 = sub nsw i32 %242, %246
store i32 %247, i32* %11
%248 = load i16*, i16** %6
%249 = load i32, i32* %13
%250 = add nsw i32 %249, -1
store i32 %250, i32* %13
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds i16, i16* %248, i64 %251
%253 = load i16, i16* %252
%254 = sext i16 %253 to i32
%255 = shl i32 %254, 5
%256 = load i32, i32* %8
%257 = or i32 %256, %255
store i32 %257, i32* %8
br label %258
258: ; preds = %266, %241
%259 = load i32, i32* %8
%260 = trunc i32 %259 to i16
%261 = load i16*, i16** %6
%262 = load i32, i32* %10
%263 = add nsw i32 %262, -1
store i32 %263, i32* %10
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i16, i16* %261, i64 %264
store i16 %260, i16* %265
br label %266
266: ; preds = %258
%267 = load i32, i32* %10
%268 = load i32, i32* %11
%269 = icmp ne i32 %267, %268
br i1 %269, label %258, label %270
270: ; preds = %266
%271 = load i32, i32* %8
%272 = and i32 %271, 31
store i32 %272, i32* %8
br label %237
273: ; preds = %237
br label %274
274: ; preds = %273
%275 = load i32, i32* %8
%276 = add nsw i32 %275, -1
store i32 %276, i32* %8
br label %229
277: ; preds = %229
store i32 0, i32* %5
br label %278
278: ; preds = %277, %114, %107, %88, %61, %45, %30
%279 = load i32, i32* %5
ret i32 %279
}

LLVM IR (-O2):
define i32 @huffman_decode_create(i16* nocapture %0, i8* nocapture %1, i32 %2, i32 %3) {
%5 = alloca [32 x i32]
%6 = alloca [32 x i32]
%7 = bitcast [32 x i32]* %5 to i8*
%8 = bitcast [32 x i32]* %6 to i8*
%9 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%10 = icmp sgt i32 %2, 0
br i1 %10, label %11, label %27
11: ; preds = %4
%12 = zext i32 %2 to i64
br label %13
13: ; preds = %11, %18
%14 = phi i64 [ 0, %11 ], [ %23, %18 ]
%15 = getelementptr inbounds i8, i8* %1, i64 %14
%16 = load i8, i8* %15
%17 = icmp ugt i8 %16, 31
br i1 %17, label %636, label %18
18: ; preds = %13
%19 = zext i8 %16 to i64
%20 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %19
%21 = load i32, i32* %20
%22 = add nsw i32 %21, 1
store i32 %22, i32* %20
%23 = add nuw nsw i64 %14, 1
%24 = icmp eq i64 %23, %12
br i1 %24, label %25, label %13
25: ; preds = %18
%26 = load i32, i32* %9
br label %27
27: ; preds = %25, %4
%28 = phi i32 [ %26, %25 ], [ 0, %4 ]
%29 = icmp eq i32 %28, %2
br i1 %29, label %30, label %34
30: ; preds = %27
%31 = bitcast i16* %0 to i8*
%32 = zext i32 %3 to i64
%33 = shl i64 2, %32
tail call void @llvm.memset.p0i8.i64(i8* align 2 %31, i8 0, i64 %33, i1 false)
br label %636
34: ; preds = %27
%35 = add nsw i32 %2, -1
%36 = icmp eq i32 %28, %35
br i1 %36, label %37, label %143
37: ; preds = %34
%38 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%39 = load i32, i32* %38
%40 = icmp eq i32 %39, 1
br i1 %40, label %41, label %636
41: ; preds = %37, %41
%42 = phi i64 [ %46, %41 ], [ 0, %37 ]
%43 = getelementptr inbounds i8, i8* %1, i64 %42
%44 = load i8, i8* %43
%45 = icmp eq i8 %44, 0
%46 = add nuw i64 %42, 1
br i1 %45, label %41, label %47
47: ; preds = %41
%48 = icmp eq i32 %3, 31
br i1 %48, label %636, label %49
49: ; preds = %47
%50 = shl i32 1, %3
%51 = trunc i64 %42 to i16
%52 = shl i16 %51, 5
%53 = call i32 @llvm.smin.i32(i32 %50, i32 1)
%54 = sub i32 %50, %53
%55 = zext i32 %54 to i64
%56 = add nuw nsw i64 %55, 1
%57 = icmp ult i32 %54, 15
br i1 %57, label %134, label %58
58: ; preds = %49
%59 = and i64 %56, 8589934576
%60 = trunc i64 %59 to i32
%61 = sub i32 %50, %60
%62 = getelementptr i16, i16* %0, i64 %59
%63 = insertelement <8 x i16> poison, i16 %52, i64 0
%64 = shufflevector <8 x i16> %63, <8 x i16> poison, <8 x i32> zeroinitializer
%65 = insertelement <8 x i16> poison, i16 %52, i64 0
%66 = shufflevector <8 x i16> %65, <8 x i16> poison, <8 x i32> zeroinitializer
%67 = add nsw i64 %59, -16
%68 = lshr exact i64 %67, 4
%69 = add nuw nsw i64 %68, 1
%70 = and i64 %69, 7
%71 = icmp ult i64 %67, 112
br i1 %71, label %119, label %72
72: ; preds = %58
%73 = and i64 %69, 2305843009213693944
br label %74
74: ; preds = %74, %72
%75 = phi i64 [ 0, %72 ], [ %116, %74 ]
%76 = phi i64 [ 0, %72 ], [ %117, %74 ]
%77 = getelementptr i16, i16* %0, i64 %75
%78 = bitcast i16* %77 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %78
%79 = getelementptr i16, i16* %77, i64 8
%80 = bitcast i16* %79 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %80
%81 = or i64 %75, 16
%82 = getelementptr i16, i16* %0, i64 %81
%83 = bitcast i16* %82 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %83
%84 = getelementptr i16, i16* %82, i64 8
%85 = bitcast i16* %84 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %85
%86 = or i64 %75, 32
%87 = getelementptr i16, i16* %0, i64 %86
%88 = bitcast i16* %87 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %88
%89 = getelementptr i16, i16* %87, i64 8
%90 = bitcast i16* %89 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %90
%91 = or i64 %75, 48
%92 = getelementptr i16, i16* %0, i64 %91
%93 = bitcast i16* %92 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %93
%94 = getelementptr i16, i16* %92, i64 8
%95 = bitcast i16* %94 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %95
%96 = or i64 %75, 64
%97 = getelementptr i16, i16* %0, i64 %96
%98 = bitcast i16* %97 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %98
%99 = getelementptr i16, i16* %97, i64 8
%100 = bitcast i16* %99 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %100
%101 = or i64 %75, 80
%102 = getelementptr i16, i16* %0, i64 %101
%103 = bitcast i16* %102 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %103
%104 = getelementptr i16, i16* %102, i64 8
%105 = bitcast i16* %104 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %105
%106 = or i64 %75, 96
%107 = getelementptr i16, i16* %0, i64 %106
%108 = bitcast i16* %107 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %108
%109 = getelementptr i16, i16* %107, i64 8
%110 = bitcast i16* %109 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %110
%111 = or i64 %75, 112
%112 = getelementptr i16, i16* %0, i64 %111
%113 = bitcast i16* %112 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %113
%114 = getelementptr i16, i16* %112, i64 8
%115 = bitcast i16* %114 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %115
%116 = add nuw i64 %75, 128
%117 = add i64 %76, 8
%118 = icmp eq i64 %117, %73
br i1 %118, label %119, label %74
119: ; preds = %74, %58
%120 = phi i64 [ 0, %58 ], [ %116, %74 ]
%121 = icmp eq i64 %70, 0
br i1 %121, label %132, label %122
122: ; preds = %119, %122
%123 = phi i64 [ %129, %122 ], [ %120, %119 ]
%124 = phi i64 [ %130, %122 ], [ 0, %119 ]
%125 = getelementptr i16, i16* %0, i64 %123
%126 = bitcast i16* %125 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %126
%127 = getelementptr i16, i16* %125, i64 8
%128 = bitcast i16* %127 to <8 x i16>*
store <8 x i16> %66, <8 x i16>* %128
%129 = add nuw i64 %123, 16
%130 = add i64 %124, 1
%131 = icmp eq i64 %130, %70
br i1 %131, label %132, label %122
132: ; preds = %122, %119
%133 = icmp eq i64 %56, %59
br i1 %133, label %636, label %134
134: ; preds = %49, %132
%135 = phi i32 [ %50, %49 ], [ %61, %132 ]
%136 = phi i16* [ %0, %49 ], [ %62, %132 ]
br label %137
137: ; preds = %134, %137
%138 = phi i32 [ %140, %137 ], [ %135, %134 ]
%139 = phi i16* [ %141, %137 ], [ %136, %134 ]
%140 = add nsw i32 %138, -1
%141 = getelementptr inbounds i16, i16* %139, i64 1
store i16 %52, i16* %139
%142 = icmp sgt i32 %138, 1
br i1 %142, label %137, label %636
143: ; preds = %34
br label %156
144: ; preds = %156
%145 = add nsw i64 %157, -1
%146 = icmp eq i64 %145, 0
br i1 %146, label %165, label %147
147: ; preds = %144
%148 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %145
%149 = load i32, i32* %148
%150 = add nsw i32 %149, %164
%151 = and i32 %150, 1
%152 = icmp eq i32 %151, 0
br i1 %152, label %153, label %636
153: ; preds = %147
%154 = ashr i32 %150, 1
%155 = add nsw i64 %157, -2
br label %156
156: ; preds = %153, %143
%157 = phi i64 [ 31, %143 ], [ %155, %153 ]
%158 = phi i32 [ 0, %143 ], [ %154, %153 ]
%159 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %157
%160 = load i32, i32* %159
%161 = add nsw i32 %160, %158
%162 = and i32 %161, 1
%163 = icmp eq i32 %162, 0
%164 = ashr i32 %161, 1
br i1 %163, label %144, label %636
165: ; preds = %144
%166 = icmp eq i32 %164, 1
br i1 %166, label %167, label %636
167: ; preds = %165, %183
%168 = phi i64 [ %187, %183 ], [ 1, %165 ]
%169 = phi i32 [ %186, %183 ], [ 0, %165 ]
%170 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %168
%171 = load i32, i32* %170
%172 = add nsw i32 %171, %169
store i32 %172, i32* %170
%173 = add nuw nsw i64 %168, 1
%174 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %173
%175 = load i32, i32* %174
%176 = add nsw i32 %175, %172
store i32 %176, i32* %174
%177 = add nuw nsw i64 %168, 2
%178 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %177
%179 = load i32, i32* %178
%180 = add nsw i32 %179, %176
store i32 %180, i32* %178
%181 = add nuw nsw i64 %168, 3
%182 = icmp eq i64 %181, 32
br i1 %182, label %188, label %183
183: ; preds = %167
%184 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %181
%185 = load i32, i32* %184
%186 = add nsw i32 %185, %180
store i32 %186, i32* %184
%187 = add nuw nsw i64 %168, 4
br label %167
188: ; preds = %167
%189 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 31
%190 = load i32, i32* %189
br i1 %10, label %191, label %243
191: ; preds = %188
%192 = zext i32 %2 to i64
%193 = and i64 %192, 1
%194 = icmp eq i64 %193, 0
br i1 %194, label %209, label %195
195: ; preds = %191
%196 = add nsw i64 %192, -1
%197 = and i64 %196, 4294967295
%198 = getelementptr inbounds i8, i8* %1, i64 %197
%199 = load i8, i8* %198
%200 = icmp eq i8 %199, 0
br i1 %200, label %209, label %201
201: ; preds = %195
%202 = trunc i64 %196 to i16
%203 = zext i8 %199 to i64
%204 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %203
%205 = load i32, i32* %204
%206 = add nsw i32 %205, -1
store i32 %206, i32* %204
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i16, i16* %0, i64 %207
store i16 %202, i16* %208
br label %209
209: ; preds = %195, %201, %191
%210 = phi i64 [ %192, %191 ], [ %196, %201 ], [ %196, %195 ]
%211 = icmp eq i32 %2, 1
br i1 %211, label %243, label %212
212: ; preds = %209, %241
%213 = phi i64 [ %228, %241 ], [ %210, %209 ]
%214 = add nsw i64 %213, -1
%215 = and i64 %214, 4294967295
%216 = getelementptr inbounds i8, i8* %1, i64 %215
%217 = load i8, i8* %216
%218 = icmp eq i8 %217, 0
br i1 %218, label %227, label %219
219: ; preds = %212
%220 = trunc i64 %214 to i16
%221 = zext i8 %217 to i64
%222 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %221
%223 = load i32, i32* %222
%224 = add nsw i32 %223, -1
store i32 %224, i32* %222
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds i16, i16* %0, i64 %225
store i16 %220, i16* %226
br label %227
227: ; preds = %219, %212
%228 = add nsw i64 %213, -2
%229 = and i64 %228, 4294967295
%230 = getelementptr inbounds i8, i8* %1, i64 %229
%231 = load i8, i8* %230
%232 = icmp eq i8 %231, 0
br i1 %232, label %241, label %233
233: ; preds = %227
%234 = trunc i64 %228 to i16
%235 = zext i8 %231 to i64
%236 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %235
%237 = load i32, i32* %236
%238 = add nsw i32 %237, -1
store i32 %238, i32* %236
%239 = sext i32 %238 to i64
%240 = getelementptr inbounds i16, i16* %0, i64 %239
store i16 %234, i16* %240
br label %241
241: ; preds = %233, %227
%242 = icmp ugt i64 %214, 1
br i1 %242, label %212, label %243
243: ; preds = %209, %241, %188
%244 = shl nuw i32 1, %3
%245 = shl i32 %2, 1
%246 = add nsw i32 %244, %245
%247 = icmp slt i32 %3, 31
br i1 %247, label %248, label %504
248: ; preds = %243
%249 = sext i32 %3 to i64
%250 = getelementptr i16, i16* %0, i64 -1
%251 = getelementptr i16, i16* %0, i64 -1
%252 = getelementptr i16, i16* %0, i64 -1
%253 = getelementptr i16, i16* %0, i64 -1
br label %264
254: ; preds = %487, %481
%255 = phi i64 [ %407, %481 ], [ %492, %487 ]
%256 = phi i64 [ %406, %481 ], [ %495, %487 ]
%257 = trunc i64 %256 to i32
%258 = trunc i64 %255 to i32
br label %259
259: ; preds = %254, %367
%260 = phi i32 [ %368, %367 ], [ %257, %254 ]
%261 = phi i32 [ %266, %367 ], [ %258, %254 ]
%262 = add nsw i64 %265, -1
%263 = icmp sgt i64 %262, %249
br i1 %263, label %264, label %311
264: ; preds = %248, %259
%265 = phi i64 [ 31, %248 ], [ %262, %259 ]
%266 = phi i32 [ %190, %248 ], [ %261, %259 ]
%267 = phi i32 [ %246, %248 ], [ %268, %259 ]
%268 = phi i32 [ %246, %248 ], [ %260, %259 ]
%269 = icmp sgt i32 %267, %268
br i1 %269, label %270, label %367
270: ; preds = %264
%271 = sext i32 %268 to i64
%272 = xor i32 %268, -1
%273 = add i32 %267, %272
%274 = lshr i32 %273, 1
%275 = add nuw i32 %274, 1
%276 = zext i32 %275 to i64
%277 = icmp ult i32 %273, 30
br i1 %277, label %308, label %278
278: ; preds = %270
%279 = and i64 %276, 4294967280
%280 = sub nsw i64 %271, %279
%281 = trunc i64 %279 to i32
%282 = mul i32 %281, -2
%283 = add i32 %267, %282
%284 = trunc i32 %267 to i16
%285 = insertelement <8 x i16> poison, i16 %284, i64 0
%286 = shufflevector <8 x i16> %285, <8 x i16> poison, <8 x i32> zeroinitializer
%287 = add <8 x i16> %286, <i16 0, i16 -2, i16 -4, i16 -6, i16 -8, i16 -10, i16 -12, i16 -14>
br label %288
288: ; preds = %288, %278
%289 = phi i64 [ 0, %278 ], [ %303, %288 ]
%290 = phi <8 x i16> [ %287, %278 ], [ %304, %288 ]
%291 = sub <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %290
%292 = sub <8 x i16> <i16 18, i16 18, i16 18, i16 18, i16 18, i16 18, i16 18, i16 18>, %290
%293 = xor i64 %289, -1
%294 = add i64 %293, %271
%295 = getelementptr inbounds i16, i16* %0, i64 %294
%296 = shufflevector <8 x i16> %291, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%297 = getelementptr inbounds i16, i16* %295, i64 -7
%298 = bitcast i16* %297 to <8 x i16>*
store <8 x i16> %296, <8 x i16>* %298
%299 = shufflevector <8 x i16> %292, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%300 = getelementptr inbounds i16, i16* %295, i64 -8
%301 = getelementptr inbounds i16, i16* %300, i64 -7
%302 = bitcast i16* %301 to <8 x i16>*
store <8 x i16> %299, <8 x i16>* %302
%303 = add nuw i64 %289, 16
%304 = add <8 x i16> %290, <i16 -32, i16 -32, i16 -32, i16 -32, i16 -32, i16 -32, i16 -32, i16 -32>
%305 = icmp eq i64 %303, %279
br i1 %305, label %306, label %288
306: ; preds = %288
%307 = icmp eq i64 %279, %276
br i1 %307, label %364, label %308
308: ; preds = %270, %306
%309 = phi i64 [ %271, %270 ], [ %280, %306 ]
%310 = phi i32 [ %267, %270 ], [ %283, %306 ]
br label %355
311: ; preds = %259
%312 = trunc i64 %262 to i32
%313 = icmp sgt i32 %268, %260
br i1 %313, label %314, label %501
314: ; preds = %311
%315 = sext i32 %244 to i64
%316 = xor i32 %260, -1
%317 = add i32 %268, %316
%318 = lshr i32 %317, 1
%319 = add nuw i32 %318, 1
%320 = zext i32 %319 to i64
%321 = icmp ult i32 %317, 30
br i1 %321, label %352, label %322
322: ; preds = %314
%323 = and i64 %320, 4294967280
%324 = sub nsw i64 %315, %323
%325 = trunc i64 %323 to i32
%326 = mul i32 %325, -2
%327 = add i32 %268, %326
%328 = trunc i32 %268 to i16
%329 = insertelement <8 x i16> poison, i16 %328, i64 0
%330 = shufflevector <8 x i16> %329, <8 x i16> poison, <8 x i32> zeroinitializer
%331 = add <8 x i16> %330, <i16 0, i16 -2, i16 -4, i16 -6, i16 -8, i16 -10, i16 -12, i16 -14>
br label %332
332: ; preds = %332, %322
%333 = phi i64 [ 0, %322 ], [ %347, %332 ]
%334 = phi <8 x i16> [ %331, %322 ], [ %348, %332 ]
%335 = sub <8 x i16> <i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2, i16 2>, %334
%336 = sub <8 x i16> <i16 18, i16 18, i16 18, i16 18, i16 18, i16 18, i16 18, i16 18>, %334
%337 = xor i64 %333, -1
%338 = add i64 %337, %315
%339 = getelementptr inbounds i16, i16* %0, i64 %338
%340 = shufflevector <8 x i16> %335, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%341 = getelementptr inbounds i16, i16* %339, i64 -7
%342 = bitcast i16* %341 to <8 x i16>*
store <8 x i16> %340, <8 x i16>* %342
%343 = shufflevector <8 x i16> %336, <8 x i16> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%344 = getelementptr inbounds i16, i16* %339, i64 -8
%345 = getelementptr inbounds i16, i16* %344, i64 -7
%346 = bitcast i16* %345 to <8 x i16>*
store <8 x i16> %343, <8 x i16>* %346
%347 = add nuw i64 %333, 16
%348 = add <8 x i16> %334, <i16 -32, i16 -32, i16 -32, i16 -32, i16 -32, i16 -32, i16 -32, i16 -32>
%349 = icmp eq i64 %347, %323
br i1 %349, label %350, label %332
350: ; preds = %332
%351 = icmp eq i64 %323, %320
br i1 %351, label %498, label %352
352: ; preds = %314, %350
%353 = phi i64 [ %315, %314 ], [ %324, %350 ]
%354 = phi i32 [ %268, %314 ], [ %327, %350 ]
br label %508
355: ; preds = %308, %355
%356 = phi i64 [ %361, %355 ], [ %309, %308 ]
%357 = phi i32 [ %358, %355 ], [ %310, %308 ]
%358 = add nsw i32 %357, -2
%359 = trunc i32 %357 to i16
%360 = sub i16 2, %359
%361 = add nsw i64 %356, -1
%362 = getelementptr inbounds i16, i16* %0, i64 %361
store i16 %360, i16* %362
%363 = icmp sgt i32 %358, %268
br i1 %363, label %355, label %364
364: ; preds = %355, %306
%365 = phi i64 [ %280, %306 ], [ %361, %355 ]
%366 = trunc i64 %365 to i32
br label %367
367: ; preds = %364, %264
%368 = phi i32 [ %268, %264 ], [ %366, %364 ]
%369 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %265
%370 = load i32, i32* %369
%371 = icmp sgt i32 %370, 0
br i1 %371, label %372, label %259
372: ; preds = %367
%373 = sext i32 %266 to i64
%374 = sext i32 %368 to i64
%375 = add i32 %370, -1
%376 = zext i32 %375 to i64
%377 = add nuw nsw i64 %376, 1
%378 = icmp ult i32 %375, 15
br i1 %378, label %483, label %379
379: ; preds = %372
%380 = add i32 %370, -1
%381 = getelementptr i16, i16* %250, i64 %374
%382 = zext i32 %380 to i64
%383 = sub nsw i64 0, %382
%384 = getelementptr i16, i16* %381, i64 %383
%385 = icmp ugt i16* %384, %381
%386 = getelementptr i16, i16* %251, i64 %373
%387 = zext i32 %380 to i64
%388 = sub nsw i64 0, %387
%389 = getelementptr i16, i16* %386, i64 %388
%390 = icmp ugt i16* %389, %386
%391 = or i1 %385, %390
br i1 %391, label %483, label %392
392: ; preds = %379
%393 = add i32 %370, -1
%394 = zext i32 %393 to i64
%395 = sub nsw i64 %374, %394
%396 = getelementptr i16, i16* %252, i64 %395
%397 = getelementptr i16, i16* %0, i64 %374
%398 = sub nsw i64 %373, %394
%399 = getelementptr i16, i16* %253, i64 %398
%400 = getelementptr i16, i16* %0, i64 %373
%401 = icmp ult i16* %396, %400
%402 = icmp ult i16* %399, %397
%403 = and i1 %401, %402
br i1 %403, label %483, label %404
404: ; preds = %392
%405 = and i64 %377, 8589934576
%406 = sub nsw i64 %374, %405
%407 = sub nsw i64 %373, %405
%408 = trunc i64 %405 to i32
%409 = sub i32 %370, %408
%410 = add nsw i64 %405, -16
%411 = lshr exact i64 %410, 4
%412 = add nuw nsw i64 %411, 1
%413 = and i64 %412, 1
%414 = icmp eq i64 %410, 0
br i1 %414, label %459, label %415
415: ; preds = %404
%416 = and i64 %412, 2305843009213693950
br label %417
417: ; preds = %417, %415
%418 = phi i64 [ 0, %415 ], [ %456, %417 ]
%419 = phi i64 [ 0, %415 ], [ %457, %417 ]
%420 = xor i64 %418, -1
%421 = add i64 %420, %373
%422 = getelementptr inbounds i16, i16* %0, i64 %421
%423 = getelementptr inbounds i16, i16* %422, i64 -7
%424 = bitcast i16* %423 to <8 x i16>*
%425 = load <8 x i16>, <8 x i16>* %424
%426 = getelementptr inbounds i16, i16* %422, i64 -8
%427 = getelementptr inbounds i16, i16* %426, i64 -7
%428 = bitcast i16* %427 to <8 x i16>*
%429 = load <8 x i16>, <8 x i16>* %428
%430 = xor i64 %418, -1
%431 = add i64 %430, %374
%432 = getelementptr inbounds i16, i16* %0, i64 %431
%433 = getelementptr inbounds i16, i16* %432, i64 -7
%434 = bitcast i16* %433 to <8 x i16>*
store <8 x i16> %425, <8 x i16>* %434
%435 = getelementptr inbounds i16, i16* %432, i64 -8
%436 = getelementptr inbounds i16, i16* %435, i64 -7
%437 = bitcast i16* %436 to <8 x i16>*
store <8 x i16> %429, <8 x i16>* %437
%438 = sub nuw nsw i64 -17, %418
%439 = add i64 %438, %373
%440 = getelementptr inbounds i16, i16* %0, i64 %439
%441 = getelementptr inbounds i16, i16* %440, i64 -7
%442 = bitcast i16* %441 to <8 x i16>*
%443 = load <8 x i16>, <8 x i16>* %442
%444 = getelementptr inbounds i16, i16* %440, i64 -8
%445 = getelementptr inbounds i16, i16* %444, i64 -7
%446 = bitcast i16* %445 to <8 x i16>*
%447 = load <8 x i16>, <8 x i16>* %446
%448 = sub nuw nsw i64 -17, %418
%449 = add i64 %448, %374
%450 = getelementptr inbounds i16, i16* %0, i64 %449
%451 = getelementptr inbounds i16, i16* %450, i64 -7
%452 = bitcast i16* %451 to <8 x i16>*
store <8 x i16> %443, <8 x i16>* %452
%453 = getelementptr inbounds i16, i16* %450, i64 -8
%454 = getelementptr inbounds i16, i16* %453, i64 -7
%455 = bitcast i16* %454 to <8 x i16>*
store <8 x i16> %447, <8 x i16>* %455
%456 = add nuw i64 %418, 32
%457 = add i64 %419, 2
%458 = icmp eq i64 %457, %416
br i1 %458, label %459, label %417
459: ; preds = %417, %404
%460 = phi i64 [ 0, %404 ], [ %456, %417 ]
%461 = icmp eq i64 %413, 0
br i1 %461, label %481, label %462
462: ; preds = %459
%463 = xor i64 %460, -1
%464 = add i64 %463, %373
%465 = getelementptr inbounds i16, i16* %0, i64 %464
%466 = getelementptr inbounds i16, i16* %465, i64 -7
%467 = bitcast i16* %466 to <8 x i16>*
%468 = load <8 x i16>, <8 x i16>* %467
%469 = getelementptr inbounds i16, i16* %465, i64 -8
%470 = getelementptr inbounds i16, i16* %469, i64 -7
%471 = bitcast i16* %470 to <8 x i16>*
%472 = load <8 x i16>, <8 x i16>* %471
%473 = xor i64 %460, -1
%474 = add i64 %473, %374
%475 = getelementptr inbounds i16, i16* %0, i64 %474
%476 = getelementptr inbounds i16, i16* %475, i64 -7
%477 = bitcast i16* %476 to <8 x i16>*
store <8 x i16> %468, <8 x i16>* %477
%478 = getelementptr inbounds i16, i16* %475, i64 -8
%479 = getelementptr inbounds i16, i16* %478, i64 -7
%480 = bitcast i16* %479 to <8 x i16>*
store <8 x i16> %472, <8 x i16>* %480
br label %481
481: ; preds = %459, %462
%482 = icmp eq i64 %377, %405
br i1 %482, label %254, label %483
483: ; preds = %392, %379, %372, %481
%484 = phi i64 [ %374, %392 ], [ %374, %379 ], [ %374, %372 ], [ %406, %481 ]
%485 = phi i64 [ %373, %392 ], [ %373, %379 ], [ %373, %372 ], [ %407, %481 ]
%486 = phi i32 [ %370, %392 ], [ %370, %379 ], [ %370, %372 ], [ %409, %481 ]
br label %487
487: ; preds = %483, %487
%488 = phi i64 [ %495, %487 ], [ %484, %483 ]
%489 = phi i64 [ %492, %487 ], [ %485, %483 ]
%490 = phi i32 [ %491, %487 ], [ %486, %483 ]
%491 = add nsw i32 %490, -1
%492 = add nsw i64 %489, -1
%493 = getelementptr inbounds i16, i16* %0, i64 %492
%494 = load i16, i16* %493
%495 = add nsw i64 %488, -1
%496 = getelementptr inbounds i16, i16* %0, i64 %495
store i16 %494, i16* %496
%497 = icmp ugt i32 %490, 1
br i1 %497, label %487, label %254
498: ; preds = %508, %350
%499 = phi i64 [ %324, %350 ], [ %514, %508 ]
%500 = trunc i64 %499 to i32
br label %501
501: ; preds = %498, %311
%502 = phi i32 [ %244, %311 ], [ %500, %498 ]
%503 = icmp sgt i32 %312, 0
br i1 %503, label %504, label %636
504: ; preds = %243, %501
%505 = phi i32 [ %190, %243 ], [ %261, %501 ]
%506 = phi i32 [ %244, %243 ], [ %502, %501 ]
%507 = phi i32 [ 31, %243 ], [ %312, %501 ]
br label %517
508: ; preds = %352, %508
%509 = phi i64 [ %514, %508 ], [ %353, %352 ]
%510 = phi i32 [ %511, %508 ], [ %354, %352 ]
%511 = add nsw i32 %510, -2
%512 = trunc i32 %510 to i16
%513 = sub i16 2, %512
%514 = add nsw i64 %509, -1
%515 = getelementptr inbounds i16, i16* %0, i64 %514
store i16 %513, i16* %515
%516 = icmp sgt i32 %511, %260
br i1 %516, label %508, label %498
517: ; preds = %504, %630
%518 = phi i32 [ %633, %630 ], [ %505, %504 ]
%519 = phi i32 [ %632, %630 ], [ %506, %504 ]
%520 = phi i32 [ %634, %630 ], [ %507, %504 ]
%521 = zext i32 %520 to i64
%522 = getelementptr inbounds [32 x i32], [32 x i32]* %6, i64 0, i64 %521
%523 = load i32, i32* %522
%524 = icmp sgt i32 %523, 0
br i1 %524, label %525, label %630
525: ; preds = %517
%526 = and i32 %520, 31
%527 = sext i32 %518 to i64
br label %528
528: ; preds = %525, %625
%529 = phi i64 [ %527, %525 ], [ %536, %625 ]
%530 = phi i32 [ %523, %525 ], [ %626, %625 ]
%531 = phi i32 [ %519, %525 ], [ %535, %625 ]
%532 = phi i32 [ %520, %525 ], [ %526, %625 ]
%533 = sub nsw i32 %3, %532
%534 = shl nsw i32 -1, %533
%535 = add i32 %534, %531
%536 = add nsw i64 %529, -1
%537 = getelementptr inbounds i16, i16* %0, i64 %536
%538 = load i16, i16* %537
%539 = sext i16 %538 to i32
%540 = shl nsw i32 %539, 5
%541 = or i32 %540, %532
%542 = trunc i32 %541 to i16
%543 = sext i32 %531 to i64
%544 = sext i32 %535 to i64
%545 = sub nsw i64 %543, %544
%546 = icmp ult i64 %545, 16
br i1 %546, label %618, label %547
547: ; preds = %528
%548 = and i64 %545, -16
%549 = sub nsw i64 %543, %548
%550 = insertelement <8 x i16> poison, i16 %542, i64 0
%551 = shufflevector <8 x i16> %550, <8 x i16> poison, <8 x i32> zeroinitializer
%552 = insertelement <8 x i16> poison, i16 %542, i64 0
%553 = shufflevector <8 x i16> %552, <8 x i16> poison, <8 x i32> zeroinitializer
%554 = add nsw i64 %548, -16
%555 = lshr exact i64 %554, 4
%556 = add nuw nsw i64 %555, 1
%557 = and i64 %556, 3
%558 = icmp ult i64 %554, 48
br i1 %558, label %599, label %559
559: ; preds = %547
%560 = and i64 %556, 2305843009213693948
br label %561
561: ; preds = %561, %559
%562 = phi i64 [ 0, %559 ], [ %596, %561 ]
%563 = phi i64 [ 0, %559 ], [ %597, %561 ]
%564 = xor i64 %562, -1
%565 = add i64 %564, %543
%566 = getelementptr inbounds i16, i16* %0, i64 %565
%567 = getelementptr inbounds i16, i16* %566, i64 -7
%568 = bitcast i16* %567 to <8 x i16>*
store <8 x i16> %551, <8 x i16>* %568
%569 = getelementptr inbounds i16, i16* %566, i64 -8
%570 = getelementptr inbounds i16, i16* %569, i64 -7
%571 = bitcast i16* %570 to <8 x i16>*
store <8 x i16> %553, <8 x i16>* %571
%572 = sub nuw nsw i64 -17, %562
%573 = add i64 %572, %543
%574 = getelementptr inbounds i16, i16* %0, i64 %573
%575 = getelementptr inbounds i16, i16* %574, i64 -7
%576 = bitcast i16* %575 to <8 x i16>*
store <8 x i16> %551, <8 x i16>* %576
%577 = getelementptr inbounds i16, i16* %574, i64 -8
%578 = getelementptr inbounds i16, i16* %577, i64 -7
%579 = bitcast i16* %578 to <8 x i16>*
store <8 x i16> %553, <8 x i16>* %579
%580 = sub nuw nsw i64 -33, %562
%581 = add i64 %580, %543
%582 = getelementptr inbounds i16, i16* %0, i64 %581
%583 = getelementptr inbounds i16, i16* %582, i64 -7
%584 = bitcast i16* %583 to <8 x i16>*
store <8 x i16> %551, <8 x i16>* %584
%585 = getelementptr inbounds i16, i16* %582, i64 -8
%586 = getelementptr inbounds i16, i16* %585, i64 -7
%587 = bitcast i16* %586 to <8 x i16>*
store <8 x i16> %553, <8 x i16>* %587
%588 = sub nuw nsw i64 -49, %562
%589 = add i64 %588, %543
%590 = getelementptr inbounds i16, i16* %0, i64 %589
%591 = getelementptr inbounds i16, i16* %590, i64 -7
%592 = bitcast i16* %591 to <8 x i16>*
store <8 x i16> %551, <8 x i16>* %592
%593 = getelementptr inbounds i16, i16* %590, i64 -8
%594 = getelementptr inbounds i16, i16* %593, i64 -7
%595 = bitcast i16* %594 to <8 x i16>*
store <8 x i16> %553, <8 x i16>* %595
%596 = add nuw i64 %562, 64
%597 = add i64 %563, 4
%598 = icmp eq i64 %597, %560
br i1 %598, label %599, label %561
599: ; preds = %561, %547
%600 = phi i64 [ 0, %547 ], [ %596, %561 ]
%601 = icmp eq i64 %557, 0
br i1 %601, label %616, label %602
602: ; preds = %599, %602
%603 = phi i64 [ %613, %602 ], [ %600, %599 ]
%604 = phi i64 [ %614, %602 ], [ 0, %599 ]
%605 = xor i64 %603, -1
%606 = add i64 %605, %543
%607 = getelementptr inbounds i16, i16* %0, i64 %606
%608 = getelementptr inbounds i16, i16* %607, i64 -7
%609 = bitcast i16* %608 to <8 x i16>*
store <8 x i16> %551, <8 x i16>* %609
%610 = getelementptr inbounds i16, i16* %607, i64 -8
%611 = getelementptr inbounds i16, i16* %610, i64 -7
%612 = bitcast i16* %611 to <8 x i16>*
store <8 x i16> %553, <8 x i16>* %612
%613 = add nuw i64 %603, 16
%614 = add i64 %604, 1
%615 = icmp eq i64 %614, %557
br i1 %615, label %616, label %602
616: ; preds = %602, %599
%617 = icmp eq i64 %545, %548
br i1 %617, label %625, label %618
618: ; preds = %528, %616
%619 = phi i64 [ %543, %528 ], [ %549, %616 ]
br label %620
620: ; preds = %618, %620
%621 = phi i64 [ %622, %620 ], [ %619, %618 ]
%622 = add nsw i64 %621, -1
%623 = getelementptr inbounds i16, i16* %0, i64 %622
store i16 %542, i16* %623
%624 = icmp eq i64 %622, %544
br i1 %624, label %625, label %620
625: ; preds = %620, %616
%626 = add nsw i32 %530, -1
%627 = icmp sgt i32 %530, 1
br i1 %627, label %528, label %628
628: ; preds = %625
%629 = trunc i64 %536 to i32
br label %630
630: ; preds = %628, %517
%631 = phi i32 [ %520, %517 ], [ %526, %628 ]
%632 = phi i32 [ %519, %517 ], [ %535, %628 ]
%633 = phi i32 [ %518, %517 ], [ %629, %628 ]
%634 = add nsw i32 %631, -1
%635 = icmp sgt i32 %631, 1
br i1 %635, label %517, label %636
636: ; preds = %13, %156, %147, %630, %137, %132, %501, %47, %165, %37, %30
%637 = phi i32 [ 0, %30 ], [ 89350, %37 ], [ 94470, %165 ], [ 0, %47 ], [ 0, %501 ], [ 0, %132 ], [ 0, %137 ], [ 0, %630 ], [ 93446, %147 ], [ 93446, %156 ], [ 86534, %13 ]
ret i32 %637
}