void makeCodeLengths(int *len, int *freq, int alphaSize, int maxLen) {
  int nNodes, nHeap, n1, n2, i, j, k;
  int tooLong;
  int heap[258 + 2];
  int weight[258 * 2];
  int parent[258 * 2];
  for (i = 0; i < alphaSize; i++)
    weight[i + 1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
  while (1) {
    nNodes = alphaSize;
    nHeap = 0;
    heap[0] = 0;
    weight[0] = 0;
    parent[0] = -2;
    for (i = 1; i <= alphaSize; i++) {
      parent[i] = -1;
      nHeap++;
      heap[nHeap] = i;
      {
        int zz, tmp;
        zz = nHeap;
        tmp = heap[zz];
        while (weight[tmp] < weight[heap[zz >> 1]]) {
          heap[zz] = heap[zz >> 1];
          zz >>= 1;
        }
        heap[zz] = tmp;
      };
    }
    while (nHeap > 1) {
      n1 = heap[1];
      heap[1] = heap[nHeap];
      nHeap--;
      {
        int zz, yy, tmp;
        zz = 1;
        tmp = heap[zz];
        while (1) {
          yy = zz << 1;
          if (yy > nHeap)
            break;
          if (yy < nHeap && weight[heap[yy + 1]] < weight[heap[yy]])
            yy++;
          if (weight[tmp] < weight[heap[yy]])
            break;
          heap[zz] = heap[yy];
          zz = yy;
        }
        heap[zz] = tmp;
      };
      n2 = heap[1];
      heap[1] = heap[nHeap];
      nHeap--;
      {
        int zz, yy, tmp;
        zz = 1;
        tmp = heap[zz];
        while (1) {
          yy = zz << 1;
          if (yy > nHeap)
            break;
          if (yy < nHeap && weight[heap[yy + 1]] < weight[heap[yy]])
            yy++;
          if (weight[tmp] < weight[heap[yy]])
            break;
          heap[zz] = heap[yy];
          zz = yy;
        }
        heap[zz] = tmp;
      };
      nNodes++;
      parent[n1] = parent[n2] = nNodes;
      weight[nNodes] =
          (((weight[n1]) & 0xffffff00) + ((weight[n2]) & 0xffffff00)) |
          (1 + ((((weight[n1]) & 0x000000ff)) > (((weight[n2]) & 0x000000ff))
                    ? (((weight[n1]) & 0x000000ff))
                    : (((weight[n2]) & 0x000000ff))));
      parent[nNodes] = -1;
      nHeap++;
      heap[nHeap] = nNodes;
      {
        int zz, tmp;
        zz = nHeap;
        tmp = heap[zz];
        while (weight[tmp] < weight[heap[zz >> 1]]) {
          heap[zz] = heap[zz >> 1];
          zz >>= 1;
        }
        heap[zz] = tmp;
      };
    }
    tooLong = 0;
    for (i = 1; i <= alphaSize; i++) {
      j = 0;
      k = i;
      while (parent[k] >= 0) {
        k = parent[k];
        j++;
      }
      len[i - 1] = j;
      if (j > maxLen)
        tooLong = 1;
    }
    if (!tooLong)
      break;
    for (i = 1; i <= alphaSize; i++) {
      j = weight[i] >> 8;
      j = 1 + (j / 2);
      weight[i] = j << 8;
    }
  }
}


x86 assembly (clang, -O0):
<makeCodeLengths>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1430,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1185 <makeCodeLengths+0x85>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    114e <makeCodeLengths+0x4e>
mov    $0x1,%eax
mov    %eax,-0x149c(%rbp)
jmp    115f <makeCodeLengths+0x5f>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x149c(%rbp)
mov    -0x149c(%rbp),%ecx
shl    $0x8,%ecx
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
cltq
mov    %ecx,-0xc60(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1120 <makeCodeLengths+0x20>
jmp    118a <makeCodeLengths+0x8a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x450(%rbp)
movl   $0x0,-0xc60(%rbp)
movl   $0xfffffffe,-0x1470(%rbp)
ff ff ff
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1290 <makeCodeLengths+0x190>
movslq -0x2c(%rbp),%rax
movl   $0xffffffff,-0x1470(%rbp,%rax,4)
ff ff ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%ecx
movslq -0x20(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
mov    %eax,-0x1474(%rbp)
movslq -0x1474(%rbp),%rax
mov    -0x450(%rbp,%rax,4),%eax
mov    %eax,-0x1478(%rbp)
movslq -0x1478(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
mov    -0x1474(%rbp),%ecx
sar    $0x1,%ecx
movslq %ecx,%rcx
movslq -0x450(%rbp,%rcx,4),%rcx
ff
cmp    -0xc60(%rbp,%rcx,4),%eax
jge    126e <makeCodeLengths+0x16e>
mov    -0x1474(%rbp),%eax
sar    $0x1,%eax
cltq
mov    -0x450(%rbp,%rax,4),%ecx
movslq -0x1474(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x1474(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x1474(%rbp)
jmp    120b <makeCodeLengths+0x10b>
mov    -0x1478(%rbp),%ecx
movslq -0x1474(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11bc <makeCodeLengths+0xbc>
jmp    1295 <makeCodeLengths+0x195>
cmpl   $0x1,-0x20(%rbp)
jle    166f <makeCodeLengths+0x56f>
mov    -0x44c(%rbp),%eax
mov    %eax,-0x24(%rbp)
movslq -0x20(%rbp),%rax
mov    -0x450(%rbp,%rax,4),%eax
mov    %eax,-0x44c(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
movl   $0x1,-0x147c(%rbp)
movslq -0x147c(%rbp),%rax
mov    -0x450(%rbp,%rax,4),%eax
mov    %eax,-0x1484(%rbp)
mov    -0x147c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x1480(%rbp)
mov    -0x1480(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1303 <makeCodeLengths+0x203>
jmp    13b3 <makeCodeLengths+0x2b3>
mov    -0x1480(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1357 <makeCodeLengths+0x257>
mov    -0x1480(%rbp),%eax
add    $0x1,%eax
cltq
movslq -0x450(%rbp,%rax,4),%rax
ff
mov    -0xc60(%rbp,%rax,4),%eax
movslq -0x1480(%rbp),%rcx
movslq -0x450(%rbp,%rcx,4),%rcx
ff
cmp    -0xc60(%rbp,%rcx,4),%eax
jge    1357 <makeCodeLengths+0x257>
mov    -0x1480(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1480(%rbp)
movslq -0x1484(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
movslq -0x1480(%rbp),%rcx
movslq -0x450(%rbp,%rcx,4),%rcx
ff
cmp    -0xc60(%rbp,%rcx,4),%eax
jge    1386 <makeCodeLengths+0x286>
jmp    13b3 <makeCodeLengths+0x2b3>
movslq -0x1480(%rbp),%rax
mov    -0x450(%rbp,%rax,4),%ecx
movslq -0x147c(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x1480(%rbp),%eax
mov    %eax,-0x147c(%rbp)
jmp    12e0 <makeCodeLengths+0x1e0>
mov    -0x1484(%rbp),%ecx
movslq -0x147c(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x44c(%rbp),%eax
mov    %eax,-0x28(%rbp)
movslq -0x20(%rbp),%rax
mov    -0x450(%rbp,%rax,4),%eax
mov    %eax,-0x44c(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
movl   $0x1,-0x1488(%rbp)
movslq -0x1488(%rbp),%rax
mov    -0x450(%rbp,%rax,4),%eax
mov    %eax,-0x1490(%rbp)
mov    -0x1488(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x148c(%rbp)
mov    -0x148c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    142b <makeCodeLengths+0x32b>
jmp    14db <makeCodeLengths+0x3db>
mov    -0x148c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    147f <makeCodeLengths+0x37f>
mov    -0x148c(%rbp),%eax
add    $0x1,%eax
cltq
movslq -0x450(%rbp,%rax,4),%rax
ff
mov    -0xc60(%rbp,%rax,4),%eax
movslq -0x148c(%rbp),%rcx
movslq -0x450(%rbp,%rcx,4),%rcx
ff
cmp    -0xc60(%rbp,%rcx,4),%eax
jge    147f <makeCodeLengths+0x37f>
mov    -0x148c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x148c(%rbp)
movslq -0x1490(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
movslq -0x148c(%rbp),%rcx
movslq -0x450(%rbp,%rcx,4),%rcx
ff
cmp    -0xc60(%rbp,%rcx,4),%eax
jge    14ae <makeCodeLengths+0x3ae>
jmp    14db <makeCodeLengths+0x3db>
movslq -0x148c(%rbp),%rax
mov    -0x450(%rbp,%rax,4),%ecx
movslq -0x1488(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x148c(%rbp),%eax
mov    %eax,-0x1488(%rbp)
jmp    1408 <makeCodeLengths+0x308>
mov    -0x1490(%rbp),%ecx
movslq -0x1488(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%ecx
movslq -0x28(%rbp),%rax
mov    %ecx,-0x1470(%rbp,%rax,4)
movslq -0x24(%rbp),%rax
mov    %ecx,-0x1470(%rbp,%rax,4)
movslq -0x24(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
and    $0xffffff00,%eax
movslq -0x28(%rbp),%rcx
mov    -0xc60(%rbp,%rcx,4),%ecx
and    $0xffffff00,%ecx
add    %ecx,%eax
mov    %eax,-0x14a0(%rbp)
movslq -0x24(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
and    $0xff,%eax
movslq -0x28(%rbp),%rcx
mov    -0xc60(%rbp,%rcx,4),%ecx
and    $0xff,%ecx
cmp    %ecx,%eax
jle    157e <makeCodeLengths+0x47e>
movslq -0x24(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
and    $0xff,%eax
mov    %eax,-0x14a4(%rbp)
jmp    1594 <makeCodeLengths+0x494>
movslq -0x28(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
and    $0xff,%eax
mov    %eax,-0x14a4(%rbp)
mov    -0x14a0(%rbp),%ecx
mov    -0x14a4(%rbp),%eax
add    $0x1,%eax
or     %eax,%ecx
movslq -0x1c(%rbp),%rax
mov    %ecx,-0xc60(%rbp,%rax,4)
movslq -0x1c(%rbp),%rax
movl   $0xffffffff,-0x1470(%rbp,%rax,4)
ff ff ff ff
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
movslq -0x20(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
mov    %eax,-0x1494(%rbp)
movslq -0x1494(%rbp),%rax
mov    -0x450(%rbp,%rax,4),%eax
mov    %eax,-0x1498(%rbp)
movslq -0x1498(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
mov    -0x1494(%rbp),%ecx
sar    $0x1,%ecx
movslq %ecx,%rcx
movslq -0x450(%rbp,%rcx,4),%rcx
ff
cmp    -0xc60(%rbp,%rcx,4),%eax
jge    1656 <makeCodeLengths+0x556>
mov    -0x1494(%rbp),%eax
sar    $0x1,%eax
cltq
mov    -0x450(%rbp,%rax,4),%ecx
movslq -0x1494(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x1494(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x1494(%rbp)
jmp    15f3 <makeCodeLengths+0x4f3>
mov    -0x1498(%rbp),%ecx
movslq -0x1494(%rbp),%rax
mov    %ecx,-0x450(%rbp,%rax,4)
jmp    1295 <makeCodeLengths+0x195>
movl   $0x0,-0x38(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     16fd <makeCodeLengths+0x5fd>
movl   $0x0,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmpl   $0x0,-0x1470(%rbp,%rax,4)
jl     16c4 <makeCodeLengths+0x5c4>
movslq -0x34(%rbp),%rax
mov    -0x1470(%rbp,%rax,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1696 <makeCodeLengths+0x596>
mov    -0x30(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    16ea <makeCodeLengths+0x5ea>
movl   $0x1,-0x38(%rbp)
jmp    16ef <makeCodeLengths+0x5ef>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    167d <makeCodeLengths+0x57d>
cmpl   $0x0,-0x38(%rbp)
jne    170c <makeCodeLengths+0x60c>
jmp    1765 <makeCodeLengths+0x665>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1760 <makeCodeLengths+0x660>
movslq -0x2c(%rbp),%rax
mov    -0xc60(%rbp,%rax,4),%eax
sar    $0x8,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%ecx
shl    $0x8,%ecx
movslq -0x2c(%rbp),%rax
mov    %ecx,-0xc60(%rbp,%rax,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1713 <makeCodeLengths+0x613>
jmp    118a <makeCodeLengths+0x8a>
add    $0x1430,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<makeCodeLengths>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1488,%rsp
mov    %edx,%r13d
mov    %rdi,%r15
mov    %edx,%r14d
test   %edx,%edx
jle    12dd <makeCodeLengths+0x1cd>
cmp    $0x8,%r13d
jae    113f <makeCodeLengths+0x2f>
xor    %eax,%eax
jmp    12b3 <makeCodeLengths+0x1a3>
mov    %r14d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     183f <makeCodeLengths+0x72f>
mov    %rbp,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
pxor   %xmm0,%xmm0
movdqa 0xe8e(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rsi,%rdx,4),%xmm2
movdqu 0x10(%rsi,%rdx,4),%xmm3
movdqa %xmm2,%xmm4
pcmpeqd %xmm0,%xmm4
movdqa %xmm3,%xmm5
pcmpeqd %xmm0,%xmm5
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
movdqa %xmm4,%xmm6
pandn  %xmm2,%xmm6
pand   %xmm1,%xmm4
por    %xmm6,%xmm4
movdqa %xmm5,%xmm2
pandn  %xmm3,%xmm2
pand   %xmm1,%xmm5
por    %xmm2,%xmm5
movdqu %xmm4,0x464(%rsp,%rdx,4)
movdqu %xmm5,0x474(%rsp,%rdx,4)
movdqu 0x20(%rsi,%rdx,4),%xmm2
movdqu 0x30(%rsi,%rdx,4),%xmm3
movdqa %xmm2,%xmm4
pcmpeqd %xmm0,%xmm4
movdqa %xmm3,%xmm5
pcmpeqd %xmm0,%xmm5
pslld  $0x8,%xmm2
pslld  $0x8,%xmm3
movdqa %xmm4,%xmm6
pandn  %xmm2,%xmm6
pand   %xmm1,%xmm4
por    %xmm6,%xmm4
movdqa %xmm5,%xmm2
pandn  %xmm3,%xmm2
pand   %xmm1,%xmm5
por    %xmm2,%xmm5
movdqu %xmm4,0x484(%rsp,%rdx,4)
movdqu %xmm5,0x494(%rsp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1180 <makeCodeLengths+0x70>
test   $0x1,%bpl
je     12ae <makeCodeLengths+0x19e>
lea    0x0(,%rdx,4),%rdi
movdqu (%rsi,%rdx,4),%xmm0
movdqu 0x10(%rsi,%rdx,4),%xmm1
pxor   %xmm2,%xmm2
movdqa %xmm0,%xmm3
pcmpeqd %xmm2,%xmm3
pcmpeqd %xmm1,%xmm2
pslld  $0x8,%xmm0
pslld  $0x8,%xmm1
movdqa %xmm3,%xmm4
pandn  %xmm0,%xmm4
movdqa 0xd80(%rip),%xmm0
pand   %xmm0,%xmm3
por    %xmm4,%xmm3
movdqa %xmm2,%xmm4
pandn  %xmm1,%xmm4
pand   %xmm0,%xmm2
por    %xmm4,%xmm2
or     $0x4,%rdi
movdqu %xmm3,0x460(%rsp,%rdi,1)
movdqu %xmm2,0x470(%rsp,%rdi,1)
cmp    %r14,%rax
je     12dd <makeCodeLengths+0x1cd>
mov    $0x100,%ebp
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rax,4),%edx
mov    %edx,%edi
shl    $0x8,%edi
test   %edx,%edx
cmove  %ebp,%edi
mov    %edi,0x464(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    12c0 <makeCodeLengths+0x1b0>
movl   $0x0,0x50(%rsp)
movl   $0x0,0x460(%rsp)
movl   $0xfffffffe,0xc70(%rsp)
fe ff ff ff
test   %r13d,%r13d
jle    182d <makeCodeLengths+0x71d>
lea    0x0(,%r14,4),%rax
mov    %rax,0x40(%rsp)
lea    0x1(%r13),%r8d
movslq %r13d,%rax
mov    %rax,0x30(%rsp)
lea    -0x1(%r8),%r9
mov    %r9,%r10
and    $0xfffffffffffffffe,%r10
mov    %r9,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rsp)
add    $0x1,%rax
mov    %rax,0x10(%rsp)
mov    %ecx,0xc(%rsp)
mov    %r13,0x48(%rsp)
mov    %r8,0x38(%rsp)
mov    %r9,0x28(%rsp)
mov    %r10,0x20(%rsp)
jmp    1387 <makeCodeLengths+0x277>
nopw   0x0(%rax,%rax,1)
movl   $0x0,0x50(%rsp)
movl   $0x0,0x460(%rsp)
movl   $0xfffffffe,0xc70(%rsp)
fe ff ff ff
test   %r13d,%r13d
jle    182d <makeCodeLengths+0x71d>
lea    0xc74(%rsp),%rdi
mov    $0xff,%esi
mov    0x40(%rsp),%rdx
call   1030 <memset@plt>
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    13c1 <makeCodeLengths+0x2b1>
nopw   0x0(%rax,%rax,1)
mov    %ecx,%ebx
mov    %ebx,%edx
mov    %eax,0x50(%rsp,%rdx,4)
add    $0x1,%rax
cmp    %r14,%rcx
je     1410 <makeCodeLengths+0x300>
mov    %eax,0x54(%rsp,%rcx,4)
add    $0x1,%rcx
mov    0x460(%rsp,%rax,4),%edx
mov    %ecx,%esi
shr    %esi
movslq 0x50(%rsp,%rsi,4),%rdi
cmp    0x460(%rsp,%rdi,4),%edx
jge    13b0 <makeCodeLengths+0x2a0>
mov    %ecx,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %esi,%ebx
mov    %ebp,%esi
mov    %edi,0x50(%rsp,%rsi,4)
mov    %ebx,%esi
shr    %esi
movslq 0x50(%rsp,%rsi,4),%rdi
mov    %ebx,%ebp
cmp    0x460(%rsp,%rdi,4),%edx
jl     13f0 <makeCodeLengths+0x2e0>
jmp    13b2 <makeCodeLengths+0x2a2>
xchg   %ax,%ax
mov    %r14,%r12
mov    0x30(%rsp),%r10
cmp    $0x2,%r13d
movdqa 0xbec(%rip),%xmm4
movdqa 0xbd4(%rip),%xmm5
jge    1609 <makeCodeLengths+0x4f9>
mov    0x48(%rsp),%r13
test   %r13d,%r13d
mov    0xc(%rsp),%ecx
mov    0x38(%rsp),%r8
mov    0x28(%rsp),%r9
mov    0x20(%rsp),%r10
mov    $0x1,%r11d
jle    182d <makeCodeLengths+0x71d>
xor    %eax,%eax
mov    $0x1,%ebx
cmp    $0x2,%r8d
je     14ce <makeCodeLengths+0x3be>
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    $0xffffffff,%esi
mov    %ebx,%edi
nopw   0x0(%rax,%rax,1)
movslq %edi,%rdi
mov    0xc70(%rsp,%rdi,4),%edi
add    $0x1,%esi
test   %edi,%edi
jns    1480 <makeCodeLengths+0x370>
mov    %esi,-0x4(%r15,%rbx,4)
lea    0x1(%rbx),%ebp
mov    $0xffffffff,%edi
xchg   %ax,%ax
movslq %ebp,%rbp
mov    0xc70(%rsp,%rbp,4),%ebp
add    $0x1,%edi
test   %ebp,%ebp
jns    14a0 <makeCodeLengths+0x390>
cmp    %ecx,%esi
cmovg  %r11d,%eax
cmp    %ecx,%edi
cmovg  %r11d,%eax
mov    %edi,(%r15,%rbx,4)
add    $0x2,%rbx
add    $0x2,%rdx
cmp    %r10,%rdx
jne    1470 <makeCodeLengths+0x360>
test   $0x1,%r9b
je     14fc <makeCodeLengths+0x3ec>
mov    $0xffffffff,%edx
mov    %ebx,%esi
nopl   0x0(%rax,%rax,1)
movslq %esi,%rsi
mov    0xc70(%rsp,%rsi,4),%esi
add    $0x1,%edx
test   %esi,%esi
jns    14e0 <makeCodeLengths+0x3d0>
mov    %edx,-0x4(%r15,%rbx,4)
cmp    %ecx,%edx
cmovg  %r11d,%eax
test   %eax,%eax
je     182d <makeCodeLengths+0x71d>
test   %r13d,%r13d
jle    180f <makeCodeLengths+0x6ff>
mov    $0x1,%eax
cmp    $0x8,%r9
jb     15b0 <makeCodeLengths+0x4a0>
xor    %eax,%eax
mov    0x18(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu 0x464(%rsp,%rax,4),%xmm0
movdqu 0x474(%rsp,%rax,4),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x8,%xmm2
movdqa %xmm1,%xmm3
psrad  $0x8,%xmm3
psrld  $0x1f,%xmm0
paddd  %xmm2,%xmm0
pslld  $0x7,%xmm0
pand   %xmm4,%xmm0
psrld  $0x1f,%xmm1
paddd  %xmm3,%xmm1
pslld  $0x7,%xmm1
pand   %xmm4,%xmm1
paddd  %xmm5,%xmm0
paddd  %xmm5,%xmm1
movdqu %xmm0,0x464(%rsp,%rax,4)
movdqu %xmm1,0x474(%rsp,%rax,4)
add    $0x8,%rax
cmp    %rax,%rdx
jne    1530 <makeCodeLengths+0x420>
mov    0x10(%rsp),%rax
cmp    %rdx,%r9
je     1360 <makeCodeLengths+0x250>
nopl   0x0(%rax)
mov    0x460(%rsp,%rax,4),%esi
mov    %esi,%edx
sar    $0x8,%edx
shr    $0x1f,%esi
add    %edx,%esi
and    $0xfffffffe,%esi
shl    $0x7,%esi
add    $0x100,%esi
mov    %esi,0x460(%rsp,%rax,4)
add    $0x1,%rax
cmp    %rax,%r8
jne    15b0 <makeCodeLengths+0x4a0>
jmp    1360 <makeCodeLengths+0x250>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13d,%ebx
mov    %ebx,%eax
mov    %edi,0x50(%rsp,%rax,4)
mov    %rdi,%r10
cmp    $0x2,%r12
mov    %r13,%r12
jbe    1432 <makeCodeLengths+0x322>
movslq 0x54(%rsp),%r8
mov    0x50(%rsp,%r12,4),%r9d
mov    %r9d,0x54(%rsp)
lea    -0x1(%r12),%r13
mov    $0x1,%edi
mov    $0x1,%ecx
cmp    $0x3,%r12
jb     16c2 <makeCodeLengths+0x5b2>
movslq %r9d,%rcx
mov    0x460(%rsp,%rcx,4),%esi
mov    $0x1,%ebp
mov    $0x2,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ebx,%rdx
cmp    %rdx,%r13
jle    1690 <makeCodeLengths+0x580>
mov    %edx,%ecx
or     $0x1,%ecx
movslq %ecx,%rax
movslq 0x50(%rsp,%rax,4),%rax
mov    0x460(%rsp,%rax,4),%eax
movslq 0x50(%rsp,%rdx,4),%rdx
cmp    0x460(%rsp,%rdx,4),%eax
jl     167c <makeCodeLengths+0x56c>
mov    %ebx,%ecx
movslq %ecx,%rdx
jmp    1692 <makeCodeLengths+0x582>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebx,%ecx
movslq 0x50(%rsp,%rdx,4),%rdx
cmp    0x460(%rsp,%rdx,4),%esi
jl     16c0 <makeCodeLengths+0x5b0>
movslq %ebp,%rax
mov    %edx,0x50(%rsp,%rax,4)
lea    (%rcx,%rcx,1),%ebx
movslq %ebx,%rax
mov    %ecx,%ebp
cmp    %rax,%r12
jg     1650 <makeCodeLengths+0x540>
jmp    16c2 <makeCodeLengths+0x5b2>
cs nopw 0x0(%rax,%rax,1)
mov    %ebp,%ecx
movslq %ecx,%rax
mov    %r9d,0x50(%rsp,%rax,4)
movslq 0x54(%rsp),%r9
mov    0x50(%rsp,%r13,4),%r11d
mov    %r11d,0x54(%rsp)
cmp    $0x4,%r12
jl     1772 <makeCodeLengths+0x662>
movslq %r11d,%rax
lea    -0x2(%r12),%rsi
mov    0x460(%rsp,%rax,4),%ebx
mov    $0x1,%edx
mov    $0x2,%ebp
nopl   0x0(%rax)
movslq %ebp,%rcx
cmp    %rcx,%rsi
jle    1740 <makeCodeLengths+0x630>
mov    %ecx,%edi
or     $0x1,%edi
movslq %edi,%rax
movslq 0x50(%rsp,%rax,4),%rax
mov    0x460(%rsp,%rax,4),%eax
movslq 0x50(%rsp,%rcx,4),%rcx
cmp    0x460(%rsp,%rcx,4),%eax
jl     172c <makeCodeLengths+0x61c>
mov    %ebp,%edi
movslq %edi,%rcx
jmp    1742 <makeCodeLengths+0x632>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edi
movslq 0x50(%rsp,%rcx,4),%rcx
cmp    0x460(%rsp,%rcx,4),%ebx
jl     1770 <makeCodeLengths+0x660>
movslq %edx,%rax
mov    %ecx,0x50(%rsp,%rax,4)
lea    (%rdi,%rdi,1),%ebp
movslq %ebp,%rax
mov    %edi,%edx
cmp    %rax,%rsi
jge    1700 <makeCodeLengths+0x5f0>
jmp    1772 <makeCodeLengths+0x662>
cs nopw 0x0(%rax,%rax,1)
mov    %edx,%edi
movslq %edi,%rax
mov    %r11d,0x50(%rsp,%rax,4)
lea    0x1(%r10),%rdi
mov    %edi,0xc70(%rsp,%r9,4)
mov    %edi,0xc70(%rsp,%r8,4)
mov    0x460(%rsp,%r8,4),%eax
movzbl %al,%ecx
and    $0xffffff00,%eax
mov    0x460(%rsp,%r9,4),%esi
movzbl %sil,%edx
and    $0xffffff00,%esi
add    %eax,%esi
cmp    %edx,%ecx
cmova  %ecx,%edx
add    $0x1,%edx
or     %esi,%edx
mov    %edx,0x464(%rsp,%r10,4)
movl   $0xffffffff,0xc74(%rsp,%r10,4)
mov    %edi,0x50(%rsp,%r13,4)
mov    %r13d,%esi
sar    %esi
movslq 0x50(%rsp,%rsi,4),%rbp
cmp    0x460(%rsp,%rbp,4),%edx
jge    15f0 <makeCodeLengths+0x4e0>
mov    %r13d,%ecx
nop
mov    %esi,%ebx
mov    %ecx,%eax
mov    %ebp,0x50(%rsp,%rax,4)
sar    %esi
movslq 0x50(%rsp,%rsi,4),%rbp
mov    %ebx,%ecx
cmp    0x460(%rsp,%rbp,4),%edx
jl     17f0 <makeCodeLengths+0x6e0>
jmp    15f3 <makeCodeLengths+0x4e3>
movl   $0x0,0x50(%rsp)
movl   $0x0,0x460(%rsp)
movl   $0xfffffffe,0xc70(%rsp)
fe ff ff ff
add    $0x1488,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%bpl
jne    1243 <makeCodeLengths+0x133>
jmp    12ae <makeCodeLengths+0x19e>

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

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