void qtree_bitins(unsigned char a[], int nx, int ny, int b[], int n, int bit) {
  int i, j, k;
  int s00;
  int plane_val;
  plane_val = 1 << bit;
  k = 0;
  for (i = 0; i < nx - 1; i += 2) {
    s00 = n * i;
    for (j = 0; j < ny - 1; j += 2) {
      switch (a[k]) {
      case (0):
        break;
      case (1):
        b[s00 + n + 1] |= plane_val;
        break;
      case (2):
        b[s00 + n] |= plane_val;
        break;
      case (3):
        b[s00 + n + 1] |= plane_val;
        b[s00 + n] |= plane_val;
        break;
      case (4):
        b[s00 + 1] |= plane_val;
        break;
      case (5):
        b[s00 + n + 1] |= plane_val;
        b[s00 + 1] |= plane_val;
        break;
      case (6):
        b[s00 + n] |= plane_val;
        b[s00 + 1] |= plane_val;
        break;
      case (7):
        b[s00 + n + 1] |= plane_val;
        b[s00 + n] |= plane_val;
        b[s00 + 1] |= plane_val;
        break;
      case (8):
        b[s00] |= plane_val;
        break;
      case (9):
        b[s00 + n + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (10):
        b[s00 + n] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (11):
        b[s00 + n + 1] |= plane_val;
        b[s00 + n] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (12):
        b[s00 + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (13):
        b[s00 + n + 1] |= plane_val;
        b[s00 + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (14):
        b[s00 + n] |= plane_val;
        b[s00 + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (15):
        b[s00 + n + 1] |= plane_val;
        b[s00 + n] |= plane_val;
        b[s00 + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      }
      s00 += 2;
      k += 1;
    }
    if (j < ny) {
      switch (a[k]) {
      case (0):
        break;
      case (1):
        break;
      case (2):
        b[s00 + n] |= plane_val;
        break;
      case (3):
        b[s00 + n] |= plane_val;
        break;
      case (4):
        break;
      case (5):
        break;
      case (6):
        b[s00 + n] |= plane_val;
        break;
      case (7):
        b[s00 + n] |= plane_val;
        break;
      case (8):
        b[s00] |= plane_val;
        break;
      case (9):
        b[s00] |= plane_val;
        break;
      case (10):
        b[s00 + n] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (11):
        b[s00 + n] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (12):
        b[s00] |= plane_val;
        break;
      case (13):
        b[s00] |= plane_val;
        break;
      case (14):
        b[s00 + n] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (15):
        b[s00 + n] |= plane_val;
        b[s00] |= plane_val;
        break;
      }
      k += 1;
    }
  }
  if (i < nx) {
    s00 = n * i;
    for (j = 0; j < ny - 1; j += 2) {
      switch (a[k]) {
      case (0):
        break;
      case (1):
        break;
      case (2):
        break;
      case (3):
        break;
      case (4):
        b[s00 + 1] |= plane_val;
        break;
      case (5):
        b[s00 + 1] |= plane_val;
        break;
      case (6):
        b[s00 + 1] |= plane_val;
        break;
      case (7):
        b[s00 + 1] |= plane_val;
        break;
      case (8):
        b[s00] |= plane_val;
        break;
      case (9):
        b[s00] |= plane_val;
        break;
      case (10):
        b[s00] |= plane_val;
        break;
      case (11):
        b[s00] |= plane_val;
        break;
      case (12):
        b[s00 + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (13):
        b[s00 + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (14):
        b[s00 + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      case (15):
        b[s00 + 1] |= plane_val;
        b[s00] |= plane_val;
        break;
      }
      s00 += 2;
      k += 1;
    }
    if (j < ny) {
      switch (a[k]) {
      case (0):
        break;
      case (1):
        break;
      case (2):
        break;
      case (3):
        break;
      case (4):
        break;
      case (5):
        break;
      case (6):
        break;
      case (7):
        break;
      case (8):
        b[s00] |= plane_val;
        break;
      case (9):
        b[s00] |= plane_val;
        break;
      case (10):
        b[s00] |= plane_val;
        break;
      case (11):
        b[s00] |= plane_val;
        break;
      case (12):
        b[s00] |= plane_val;
        break;
      case (13):
        b[s00] |= plane_val;
        break;
      case (14):
        b[s00] |= plane_val;
        break;
      case (15):
        b[s00] |= plane_val;
        break;
      }
      k += 1;
    }
  }
}


x86 assembly (clang, -O0):
<qtree_bitins>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x20(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    168a <qtree_bitins+0x58a>
mov    -0x1c(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    14b1 <qtree_bitins+0x3b1>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x40(%rbp)
sub    $0xf,%rax
ja     1491 <qtree_bitins+0x391>
mov    -0x40(%rbp),%rax
lea    0xf33(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1491 <qtree_bitins+0x391>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    1157 <qtree_bitins+0x57>
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1677 <qtree_bitins+0x577>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x48(%rbp)
sub    $0xf,%rax
ja     166e <qtree_bitins+0x56e>
mov    -0x48(%rbp),%rax
lea    0xb9e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    166e <qtree_bitins+0x56e>
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
jmp    166e <qtree_bitins+0x56e>
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    166e <qtree_bitins+0x56e>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    167c <qtree_bitins+0x57c>
mov    -0x24(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x24(%rbp)
jmp    1135 <qtree_bitins+0x35>
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19a4 <qtree_bitins+0x8a4>
mov    -0x1c(%rbp),%eax
imul   -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1889 <qtree_bitins+0x789>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x50(%rbp)
sub    $0xf,%rax
ja     1869 <qtree_bitins+0x769>
mov    -0x50(%rbp),%rax
lea    0x963(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    1869 <qtree_bitins+0x769>
jmp    1869 <qtree_bitins+0x769>
jmp    1869 <qtree_bitins+0x769>
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1869 <qtree_bitins+0x769>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    16a7 <qtree_bitins+0x5a7>
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    199f <qtree_bitins+0x89f>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %rax,-0x58(%rbp)
sub    $0xf,%rax
ja     1996 <qtree_bitins+0x896>
mov    -0x58(%rbp),%rax
lea    0x746(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    1996 <qtree_bitins+0x896>
jmp    1996 <qtree_bitins+0x896>
jmp    1996 <qtree_bitins+0x896>
jmp    1996 <qtree_bitins+0x896>
jmp    1996 <qtree_bitins+0x896>
jmp    1996 <qtree_bitins+0x896>
jmp    1996 <qtree_bitins+0x896>
jmp    1996 <qtree_bitins+0x896>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1996 <qtree_bitins+0x896>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1996 <qtree_bitins+0x896>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1996 <qtree_bitins+0x896>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1996 <qtree_bitins+0x896>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1996 <qtree_bitins+0x896>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1996 <qtree_bitins+0x896>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
jmp    1996 <qtree_bitins+0x896>
mov    -0x34(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
or     (%rax,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19a4 <qtree_bitins+0x8a4>
pop    %rbp
ret

x86 assembly (clang, -O2):
<qtree_bitins>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,%r10
mov    $0x1,%eax
mov    %r9d,%ecx
shl    %cl,%eax
mov    %r8,-0x30(%rsp)
mov    %rdi,-0x28(%rsp)
xor    %r9d,%r9d
mov    $0x0,%r14d
mov    %rsi,-0x10(%rsp)
cmp    $0x2,%esi
jl     12d7 <qtree_bitins+0x1d7>
mov    -0x10(%rsp),%rcx
lea    -0x1(%rcx),%r8d
lea    -0x1(%rdx),%ebx
mov    -0x30(%rsp),%rcx
lea    (%rcx,%rcx,1),%r11d
movslq %ecx,%r13
lea    -0x2(%rdx),%ecx
shr    %ecx
add    $0x1,%ecx
mov    %ecx,-0x18(%rsp)
mov    %edx,%ecx
and    $0xfffffffe,%ecx
mov    %ecx,-0x1c(%rsp)
lea    (%r10,%r13,4),%rbp
add    $0x4,%rbp
xor    %r12d,%r12d
lea    0xe89(%rip),%rsi
xor    %r14d,%r14d
xor    %r9d,%r9d
mov    %rdx,-0x8(%rsp)
mov    %r11d,-0x14(%rsp)
jmp    11b3 <qtree_bitins+0xb3>
mov    -0x30(%rsp),%rcx
add    %r15d,%ecx
movslq %ecx,%rcx
or     %eax,(%r10,%rcx,4)
movslq %r15d,%rcx
or     %eax,(%r10,%rcx,4)
add    $0x1,%r9d
add    $0x2,%r14d
add    %r11d,%r12d
cmp    %r8d,%r14d
jge    12d7 <qtree_bitins+0x1d7>
cmp    $0x2,%edx
jl     1290 <qtree_bitins+0x190>
mov    %r8d,%edx
movslq %r12d,%r11
movslq %r9d,%rdi
add    -0x28(%rsp),%rdi
xor    %r15d,%r15d
nopl   (%rax)
movzbl (%rdi),%ecx
add    $0xff,%cl
cmp    $0xe,%cl
ja     124c <qtree_bitins+0x14c>
movzbl %cl,%ecx
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
jmp    *%rcx
lea    (%r11,%r13,1),%r8
add    $0x1,%r8
jmp    1248 <qtree_bitins+0x148>
lea    (%r11,%r13,1),%r8
or     %eax,0x0(%rbp,%r11,4)
jmp    1248 <qtree_bitins+0x148>
or     %eax,0x0(%rbp,%r11,4)
jmp    122b <qtree_bitins+0x12b>
or     %eax,0x0(%rbp,%r11,4)
jmp    1214 <qtree_bitins+0x114>
or     %eax,0x0(%rbp,%r11,4)
or     %eax,-0x4(%rbp,%r11,4)
or     %eax,0x4(%r10,%r11,4)
jmp    1245 <qtree_bitins+0x145>
lea    (%r11,%r13,1),%r8
jmp    1248 <qtree_bitins+0x148>
or     %eax,0x0(%rbp,%r11,4)
or     %eax,-0x4(%rbp,%r11,4)
mov    %r11,%r8
or     $0x1,%r8
jmp    1248 <qtree_bitins+0x148>
or     %eax,0x0(%rbp,%r11,4)
jmp    1245 <qtree_bitins+0x145>
or     %eax,0x0(%rbp,%r11,4)
or     %eax,-0x4(%rbp,%r11,4)
mov    %r11,%r8
or     %eax,(%r10,%r8,4)
add    $0x2,%r11
add    $0x2,%r15d
add    $0x1,%rdi
cmp    %ebx,%r15d
jl     11d0 <qtree_bitins+0xd0>
add    -0x18(%rsp),%r9d
add    %r12d,%r15d
mov    -0x1c(%rsp),%edi
mov    %edx,%r8d
mov    -0x8(%rsp),%rdx
mov    -0x14(%rsp),%r11d
cmp    %edx,%edi
jge    11a3 <qtree_bitins+0xa3>
jmp    12a3 <qtree_bitins+0x1a3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r14d,%r15d
imul   -0x30(%rsp),%r15d
xor    %edi,%edi
cmp    %edx,%edi
jge    11a3 <qtree_bitins+0xa3>
movslq %r9d,%rcx
mov    -0x28(%rsp),%rdi
mov    (%rdi,%rcx,1),%cl
add    $0xfe,%cl
cmp    $0xd,%cl
ja     119f <qtree_bitins+0x9f>
movzbl %cl,%ecx
lea    0xd78(%rip),%rdi
movslq (%rdi,%rcx,4),%rcx
add    %rdi,%rcx
jmp    *%rcx
add    -0x30(%rsp),%r15d
jmp    1198 <qtree_bitins+0x98>
cmp    -0x10(%rsp),%r14d
jge    13ad <qtree_bitins+0x2ad>
imul   -0x30(%rsp),%r14d
xor    %esi,%esi
cmp    $0x2,%edx
jl     138f <qtree_bitins+0x28f>
lea    -0x1(%rdx),%r12d
movslq %r14d,%r8
movslq %r9d,%rbx
lea    -0x2(%rdx),%ecx
shr    %ecx
lea    (%rbx,%rcx,1),%r9d
add    -0x28(%rsp),%rbx
mov    %r8,%rbp
shl    $0x20,%rbp
xor    %edi,%edi
movabs $0x200000000,%r11
lea    0xd4f(%rip),%r15
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx),%ecx
add    $0xfc,%cl
cmp    $0xb,%cl
ja     1373 <qtree_bitins+0x273>
lea    (%r8,%rdi,1),%rsi
movzbl %cl,%ecx
movslq (%r15,%rcx,4),%rcx
add    %r15,%rcx
jmp    *%rcx
mov    %rbp,%rsi
sar    $0x20,%rsi
or     $0x1,%rsi
jmp    136f <qtree_bitins+0x26f>
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rcx
sar    $0x1e,%rcx
or     $0x4,%rcx
or     %eax,(%r10,%rcx,1)
or     %eax,(%r10,%rsi,4)
add    $0x1,%rbx
add    $0x2,%rdi
add    %r11,%rbp
cmp    %r12d,%edi
jl     1330 <qtree_bitins+0x230>
add    $0x1,%r9d
mov    %edx,%esi
and    $0xfffffffe,%esi
add    %edi,%r14d
cmp    %edx,%esi
jge    13ad <qtree_bitins+0x2ad>
movslq %r9d,%rcx
mov    -0x28(%rsp),%rdx
mov    (%rdx,%rcx,1),%cl
and    $0xf8,%cl
cmp    $0x8,%cl
jne    13ad <qtree_bitins+0x2ad>
movslq %r14d,%rcx
or     %eax,(%r10,%rcx,4)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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