int boundary_offset(int width, int height, int depth, int id, int *offset) {
  int i, j;
  int n = 0;
  int area = width * height;
  int volume = area * depth;
  int cwidth = width - 1;
  int carea = area - width;
  int cvolume = volume - area;
  int start = 0;
  switch (id) {
  case 1:
    offset[0] = 0;
    n = 1;
    break;
  case 2:
    offset[0] = cwidth;
    n = 1;
    break;
  case 3:
    offset[0] = carea;
    n = 1;
    break;
  case 4:
    offset[0] = carea + cwidth;
    n = 1;
    break;
  case 5:
    offset[0] = cvolume;
    n = 1;
    break;
  case 6:
    offset[0] = cvolume + cwidth;
    n = 1;
    break;
  case 7:
    offset[0] = cvolume + carea;
    n = 1;
    break;
  case 8:
    offset[0] = volume - 1;
    n = 1;
    break;
  case 9:
    for (i = 1; i < cwidth; i++) {
      offset[n] = i;
      n++;
    }
    break;
  case 10:
    start = carea;
    for (i = 1; i < cwidth; i++) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 11:
    start = cvolume;
    for (i = 1; i < cwidth; i++) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 12:
    start = cvolume + carea;
    for (i = 1; i < cwidth; i++) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 13:
    for (i = width; i < carea; i += width) {
      offset[n] = i;
      n++;
    }
    break;
  case 14:
    start = cwidth;
    for (i = width; i < carea; i += width) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 15:
    start = cvolume;
    for (i = width; i < carea; i += width) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 16:
    start = cvolume + cwidth;
    for (i = width; i < carea; i += width) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 17:
    for (i = area; i < cvolume; i += area) {
      offset[n] = i;
      n++;
    }
    break;
  case 18:
    start = cwidth;
    for (i = area; i < cvolume; i += area) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 19:
    start = carea;
    for (i = area; i < cvolume; i += area) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 20:
    start = carea + cwidth;
    for (i = area; i < cvolume; i += area) {
      offset[n] = start + i;
      n++;
    }
    break;
  case 21:
    for (j = width; j < carea; j += width) {
      for (i = 1; i < cwidth; i++) {
        offset[n] = i + j;
        n++;
      }
    }
    break;
  case 22:
    start = cvolume;
    for (j = width; j < carea; j += width) {
      for (i = 1; i < cwidth; i++) {
        offset[n] = start + i + j;
        n++;
      }
    }
    break;
  case 23:
    for (j = area; j < cvolume; j += area) {
      for (i = width; i < carea; i += width) {
        offset[n] = i + j;
        n++;
      }
    }
    break;
  case 24:
    start = cwidth;
    for (j = area; j < cvolume; j += area) {
      for (i = width; i < carea; i += width) {
        offset[n] = start + i + j;
        n++;
      }
    }
    break;
  case 25:
    for (j = area; j < cvolume; j += area) {
      for (i = 1; i < cwidth; i++) {
        offset[n] = i + j;
        n++;
      }
    }
    break;
  case 26:
    start = carea;
    for (j = area; j < cvolume; j += area) {
      for (i = 1; i < cwidth; i++) {
        offset[n] = start + i + j;
        n++;
      }
    }
    break;
  default:
    break;
  }
  return n;
}


x86 assembly (clang, -O0):
<boundary_offset>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x4(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
imul   %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x4(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x19,%eax
ja     17dc <boundary_offset+0x6dc>
mov    -0x48(%rbp),%rax
lea    0xe87(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movl   $0x1,-0x24(%rbp)
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x24(%rbp)
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x34(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x24(%rbp)
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x34(%rbp),%ecx
add    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x24(%rbp)
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x38(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x24(%rbp)
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x38(%rbp),%ecx
add    -0x30(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x24(%rbp)
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x38(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x24(%rbp)
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x24(%rbp)
jmp    17e1 <boundary_offset+0x6e1>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    126f <boundary_offset+0x16f>
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    123e <boundary_offset+0x13e>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    12b5 <boundary_offset+0x1b5>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1281 <boundary_offset+0x181>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    12fb <boundary_offset+0x1fb>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12c7 <boundary_offset+0x1c7>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x38(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1344 <boundary_offset+0x244>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1310 <boundary_offset+0x210>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1380 <boundary_offset+0x280>
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    134f <boundary_offset+0x24f>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13c5 <boundary_offset+0x2c5>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1391 <boundary_offset+0x291>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    140a <boundary_offset+0x30a>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    13d6 <boundary_offset+0x2d6>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x38(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1452 <boundary_offset+0x352>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    141e <boundary_offset+0x31e>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    148e <boundary_offset+0x38e>
mov    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    145d <boundary_offset+0x35d>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    14d3 <boundary_offset+0x3d3>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    149f <boundary_offset+0x39f>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1518 <boundary_offset+0x418>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    14e4 <boundary_offset+0x3e4>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x34(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1560 <boundary_offset+0x460>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    152c <boundary_offset+0x42c>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x4(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    15c5 <boundary_offset+0x4c5>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    15b2 <boundary_offset+0x4b2>
mov    -0x1c(%rbp),%edx
add    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    157e <boundary_offset+0x47e>
jmp    15b7 <boundary_offset+0x4b7>
mov    -0x4(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    156b <boundary_offset+0x46b>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1633 <boundary_offset+0x533>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1620 <boundary_offset+0x520>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
add    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    15e9 <boundary_offset+0x4e9>
jmp    1625 <boundary_offset+0x525>
mov    -0x4(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    15d6 <boundary_offset+0x4d6>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1697 <boundary_offset+0x597>
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    1684 <boundary_offset+0x584>
mov    -0x1c(%rbp),%edx
add    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1650 <boundary_offset+0x550>
jmp    1689 <boundary_offset+0x589>
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    163e <boundary_offset+0x53e>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1704 <boundary_offset+0x604>
mov    -0x4(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    16f1 <boundary_offset+0x5f1>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
add    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x4(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    16ba <boundary_offset+0x5ba>
jmp    16f6 <boundary_offset+0x5f6>
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    16a8 <boundary_offset+0x5a8>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1769 <boundary_offset+0x669>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1756 <boundary_offset+0x656>
mov    -0x1c(%rbp),%edx
add    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1722 <boundary_offset+0x622>
jmp    175b <boundary_offset+0x65b>
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    170f <boundary_offset+0x60f>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    17d7 <boundary_offset+0x6d7>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    17c4 <boundary_offset+0x6c4>
mov    -0x3c(%rbp),%edx
add    -0x1c(%rbp),%edx
add    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    178d <boundary_offset+0x68d>
jmp    17c9 <boundary_offset+0x6c9>
mov    -0x28(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    177a <boundary_offset+0x67a>
jmp    17e1 <boundary_offset+0x6e1>
jmp    17e1 <boundary_offset+0x6e1>
mov    -0x24(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<boundary_offset>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
xor    %r10d,%r10d
add    $0xffffffff,%ecx
cmp    $0x19,%ecx
ja     2c51 <boundary_offset+0x1b51>
mov    %edx,%r9d
mov    %esi,%ebx
imul   %edi,%ebx
mov    %ebx,%eax
imul   %edx,%eax
lea    -0x1(%rdi),%r15d
mov    %ebx,%ebp
sub    %edi,%ebp
mov    %eax,%r11d
sub    %ebx,%r11d
lea    0x1f75(%rip),%rdx
movslq (%rdx,%rcx,4),%rcx
add    %rdx,%rcx
mov    %r11,%rdx
mov    %r11,-0x40(%rsp)
mov    %rbp,%rdx
mov    %rbp,-0x38(%rsp)
jmp    *%rcx
movl   $0x0,(%r8)
mov    $0x1,%r10d
jmp    2c51 <boundary_offset+0x1b51>
mov    %r15d,(%r8)
mov    $0x1,%r10d
jmp    2c51 <boundary_offset+0x1b51>
mov    %ebp,(%r8)
mov    $0x1,%r10d
jmp    2c51 <boundary_offset+0x1b51>
add    $0xffffffff,%ebx
mov    %ebx,(%r8)
mov    $0x1,%r10d
jmp    2c51 <boundary_offset+0x1b51>
add    %r15d,%r11d
jmp    119b <boundary_offset+0x9b>
add    %ebp,%r11d
mov    %r11d,(%r8)
mov    $0x1,%r10d
jmp    2c51 <boundary_offset+0x1b51>
add    $0xffffffff,%eax
mov    %eax,(%r8)
mov    $0x1,%r10d
jmp    2c51 <boundary_offset+0x1b51>
cmp    $0x3,%edi
jl     2c51 <boundary_offset+0x1b51>
add    $0xfffffffe,%edi
cmp    $0x8,%edi
jae    1e55 <boundary_offset+0xd55>
mov    $0x1,%esi
xor    %eax,%eax
jmp    2763 <boundary_offset+0x1663>
cmp    $0x3,%edi
jl     2c51 <boundary_offset+0x1b51>
add    $0xfffffffe,%edi
cmp    $0x8,%edi
jae    1e87 <boundary_offset+0xd87>
mov    $0x1,%ecx
xor    %eax,%eax
mov    -0x38(%rsp),%rbp
jmp    296f <boundary_offset+0x186f>
cmp    $0x3,%edi
jl     2c51 <boundary_offset+0x1b51>
add    $0xfffffffe,%edi
cmp    $0x8,%edi
jae    1f31 <boundary_offset+0xe31>
mov    $0x1,%ecx
xor    %eax,%eax
mov    -0x40(%rsp),%rbp
jmp    29c9 <boundary_offset+0x18c9>
cmp    $0x3,%edi
jl     2c51 <boundary_offset+0x1b51>
lea    -0x2(%rdi),%r10d
cmp    $0x8,%r10d
jae    1fdb <boundary_offset+0xedb>
mov    $0x1,%ebp
xor    %eax,%eax
jmp    2a33 <boundary_offset+0x1933>
cmp    %edi,%ebp
jle    2c51 <boundary_offset+0x1b51>
lea    (%rdi,%rdi,1),%eax
xor    %ecx,%ecx
mov    -0x38(%rsp),%rbx
cmp    %eax,%ebx
cmovg  %ebx,%eax
setg   %cl
lea    (%rcx,%rdi,2),%edx
sub    %edx,%eax
xor    %r10d,%r10d
xor    %edx,%edx
div    %edi
add    %ecx,%eax
cmp    $0x7,%eax
jae    208a <boundary_offset+0xf8a>
mov    %edi,%eax
jmp    2850 <boundary_offset+0x1750>
cmp    %edi,%ebp
jle    2c51 <boundary_offset+0x1b51>
lea    (%rdi,%rdi,1),%eax
xor    %ecx,%ecx
mov    -0x38(%rsp),%rbx
cmp    %eax,%ebx
cmovg  %ebx,%eax
setg   %cl
lea    (%rcx,%rdi,2),%edx
sub    %edx,%eax
xor    %r10d,%r10d
xor    %edx,%edx
div    %edi
add    %ecx,%eax
cmp    $0x7,%eax
jae    20f2 <boundary_offset+0xff2>
mov    %edi,%eax
jmp    2aa0 <boundary_offset+0x19a0>
cmp    %edi,%ebp
jle    2c51 <boundary_offset+0x1b51>
lea    (%rdi,%rdi,1),%eax
xor    %ecx,%ecx
mov    -0x38(%rsp),%rbx
cmp    %eax,%ebx
cmovg  %ebx,%eax
setg   %cl
lea    (%rcx,%rdi,2),%edx
sub    %edx,%eax
xor    %r10d,%r10d
xor    %edx,%edx
div    %edi
add    %ecx,%eax
cmp    $0x7,%eax
jae    21bf <boundary_offset+0x10bf>
mov    %edi,%eax
mov    -0x40(%rsp),%rdx
jmp    2af0 <boundary_offset+0x19f0>
cmp    %edi,%ebp
jle    2c51 <boundary_offset+0x1b51>
lea    (%rdi,%rdi,1),%eax
xor    %ecx,%ecx
mov    -0x38(%rsp),%rbx
cmp    %eax,%ebx
cmovg  %ebx,%eax
setg   %cl
lea    (%rcx,%rdi,2),%edx
sub    %edx,%eax
xor    %r10d,%r10d
xor    %edx,%edx
div    %edi
add    %ecx,%eax
cmp    $0x7,%eax
jae    2290 <boundary_offset+0x1190>
mov    %edi,%eax
jmp    2b38 <boundary_offset+0x1a38>
cmp    %r11d,%ebx
jge    2c51 <boundary_offset+0x1b51>
lea    (%rbx,%rbx,1),%ecx
mov    -0x40(%rsp),%rbp
cmp    %ecx,%ebp
mov    %ecx,%eax
cmovg  %ebp,%eax
xor    %esi,%esi
sub    %ecx,%eax
setne  %sil
sub    %esi,%eax
xor    %r10d,%r10d
xor    %edx,%edx
div    %ebx
add    %esi,%eax
cmp    $0x7,%eax
jae    2364 <boundary_offset+0x1264>
mov    %ebx,%eax
jmp    2920 <boundary_offset+0x1820>
cmp    %r11d,%ebx
jge    2c51 <boundary_offset+0x1b51>
lea    (%rbx,%rbx,1),%ecx
mov    -0x40(%rsp),%rbp
cmp    %ecx,%ebp
mov    %ecx,%eax
cmovg  %ebp,%eax
xor    %esi,%esi
sub    %ecx,%eax
setne  %sil
sub    %esi,%eax
xor    %r10d,%r10d
xor    %edx,%edx
div    %ebx
add    %esi,%eax
cmp    $0x7,%eax
jae    23cc <boundary_offset+0x12cc>
mov    %ebx,%eax
jmp    2ba0 <boundary_offset+0x1aa0>
cmp    %r11d,%ebx
jge    2c51 <boundary_offset+0x1b51>
lea    (%rbx,%rbx,1),%ecx
mov    -0x40(%rsp),%rbp
cmp    %ecx,%ebp
mov    %ecx,%eax
cmovg  %ebp,%eax
xor    %esi,%esi
sub    %ecx,%eax
setne  %sil
sub    %esi,%eax
xor    %r10d,%r10d
xor    %edx,%edx
div    %ebx
add    %esi,%eax
cmp    $0x7,%eax
jae    2499 <boundary_offset+0x1399>
mov    %ebx,%eax
mov    -0x38(%rsp),%rdx
jmp    2bf0 <boundary_offset+0x1af0>
cmp    %r11d,%ebx
jge    2c51 <boundary_offset+0x1b51>
mov    %rbx,%rsi
lea    -0x1(%rbx),%ecx
lea    (%rbx,%rbx,1),%edx
mov    -0x40(%rsp),%rbx
cmp    %edx,%ebx
mov    %edx,%eax
cmovg  %ebx,%eax
xor    %edi,%edi
sub    %edx,%eax
setne  %dil
sub    %edi,%eax
xor    %r10d,%r10d
xor    %edx,%edx
div    %esi
add    %edi,%eax
cmp    $0x7,%eax
jae    256a <boundary_offset+0x146a>
mov    %esi,%eax
jmp    2c40 <boundary_offset+0x1b40>
cmp    %edi,%ebp
jle    2c51 <boundary_offset+0x1b51>
lea    -0x3(%rdi),%r9d
lea    0x1(%r9),%r15
mov    %r15,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%r12
mov    %r12,%r13
shr    $0x3,%r13
add    $0x1,%r13
lea    0x1(%rdx),%ebx
mov    %r13,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x40(%rsp)
lea    0x30(%r8),%rax
mov    %rax,-0x30(%rsp)
mov    $0x1,%ecx
sub    %edi,%ecx
xor    %r10d,%r10d
movdqa 0x1b8a(%rip),%xmm0
movdqa 0x1b92(%rip),%xmm1
movdqa 0x1b9a(%rip),%xmm2
mov    %edi,%ebp
jmp    149c <boundary_offset+0x39c>
nopw   0x0(%rax,%rax,1)
add    %edi,%ebp
cmp    -0x38(%rsp),%ebp
jge    2c51 <boundary_offset+0x1b51>
cmp    $0x3,%edi
jl     1490 <boundary_offset+0x390>
movslq %r10d,%r10
mov    $0x1,%esi
cmp    $0x7,%r9d
jb     1580 <boundary_offset+0x480>
movd   %ebp,%xmm3
pshufd $0x0,%xmm3,%xmm3
test   %r12,%r12
je     1599 <boundary_offset+0x499>
lea    0x4(%rbp),%esi
movd   %esi,%xmm4
pshufd $0x0,%xmm4,%xmm5
mov    -0x30(%rsp),%rax
lea    (%rax,%r10,4),%r14
mov    -0x40(%rsp),%r11
xor    %esi,%esi
movdqa %xmm0,%xmm4
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm4,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm4,%xmm7
movdqu %xmm6,-0x30(%r14,%rsi,4)
movdqu %xmm7,-0x20(%r14,%rsi,4)
movdqa %xmm4,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm6,%xmm7
paddd  %xmm3,%xmm6
movdqu %xmm6,-0x10(%r14,%rsi,4)
movdqu %xmm7,(%r14,%rsi,4)
add    $0x10,%rsi
paddd  %xmm2,%xmm4
add    $0xfffffffffffffffe,%r11
jne    14f0 <boundary_offset+0x3f0>
test   $0x1,%r13b
je     1567 <boundary_offset+0x467>
add    %r10,%rsi
paddd  %xmm4,%xmm3
lea    0x4(%rbp),%eax
movd   %eax,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm4,%xmm5
movdqu %xmm3,(%r8,%rsi,4)
movdqu %xmm5,0x10(%r8,%rsi,4)
add    %rdx,%r10
mov    %ebx,%esi
cmp    %rdx,%r15
je     1490 <boundary_offset+0x390>
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rsi,%rbp,1),%eax
mov    %eax,(%r8,%r10,4)
add    $0x1,%r10
add    $0x1,%esi
mov    %ecx,%eax
add    %esi,%eax
jne    1580 <boundary_offset+0x480>
jmp    1490 <boundary_offset+0x390>
xor    %esi,%esi
movdqa %xmm0,%xmm4
test   $0x1,%r13b
jne    1543 <boundary_offset+0x443>
jmp    1567 <boundary_offset+0x467>
cmp    %edi,%ebp
jle    2c51 <boundary_offset+0x1b51>
lea    -0x3(%rdi),%r14d
lea    0x1(%r14),%rbx
mov    %rbx,%r11
and    $0xfffffffffffffff8,%r11
lea    -0x8(%r11),%r12
mov    %r12,%r13
shr    $0x3,%r13
add    $0x1,%r13
lea    0x1(%r11),%eax
mov    %eax,-0x30(%rsp)
mov    %r13,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0x28(%rsp)
lea    0x30(%r8),%rax
mov    %rax,-0x20(%rsp)
add    $0xffffffff,%r9d
imul   %r9d,%esi
add    $0x1,%esi
imul   %edi,%esi
xor    %r10d,%r10d
movdqa 0x19fd(%rip),%xmm0
movdqa 0x1a05(%rip),%xmm1
movdqa 0x1a0d(%rip),%xmm2
mov    %edi,%ecx
jmp    162e <boundary_offset+0x52e>
nopw   0x0(%rax,%rax,1)
add    %edi,%ecx
add    %edi,%esi
cmp    -0x38(%rsp),%ecx
jge    2c51 <boundary_offset+0x1b51>
cmp    $0x3,%edi
jl     1620 <boundary_offset+0x520>
movslq %r10d,%r10
mov    $0x1,%eax
cmp    $0x7,%r14d
jb     1715 <boundary_offset+0x615>
mov    -0x40(%rsp),%rax
lea    (%rcx,%rax,1),%r9d
movd   %r9d,%xmm3
pshufd $0x0,%xmm3,%xmm3
test   %r12,%r12
je     1735 <boundary_offset+0x635>
lea    0x4(%r9),%eax
movd   %eax,%xmm4
pshufd $0x0,%xmm4,%xmm5
mov    -0x20(%rsp),%rax
lea    (%rax,%r10,4),%rdx
mov    -0x28(%rsp),%rbp
xor    %eax,%eax
movdqa %xmm0,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm3,%xmm6
paddd  %xmm4,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm4,%xmm7
movdqu %xmm6,-0x30(%rdx,%rax,4)
movdqu %xmm7,-0x20(%rdx,%rax,4)
movdqa %xmm4,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm3,%xmm7
paddd  %xmm6,%xmm7
paddd  %xmm5,%xmm6
movdqu %xmm7,-0x10(%rdx,%rax,4)
movdqu %xmm6,(%rdx,%rax,4)
add    $0x10,%rax
paddd  %xmm2,%xmm4
add    $0xfffffffffffffffe,%rbp
jne    1690 <boundary_offset+0x590>
test   $0x1,%r13b
je     1705 <boundary_offset+0x605>
add    %r10,%rax
paddd  %xmm4,%xmm3
add    $0x4,%r9d
movd   %r9d,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm4,%xmm5
movdqu %xmm3,(%r8,%rax,4)
movdqu %xmm5,0x10(%r8,%rax,4)
add    %r11,%r10
mov    -0x30(%rsp),%eax
cmp    %r11,%rbx
je     1620 <boundary_offset+0x520>
mov    %r15d,%edx
sub    %eax,%edx
add    %esi,%eax
nopl   0x0(%rax)
mov    %eax,(%r8,%r10,4)
add    $0x1,%r10
add    $0x1,%eax
add    $0xffffffff,%edx
jne    1720 <boundary_offset+0x620>
jmp    1620 <boundary_offset+0x520>
xor    %eax,%eax
movdqa %xmm0,%xmm4
test   $0x1,%r13b
jne    16df <boundary_offset+0x5df>
jmp    1705 <boundary_offset+0x605>
cmp    %r11d,%ebx
jge    2c51 <boundary_offset+0x1b51>
lea    (%rdi,%rdi,1),%r9d
xor    %r13d,%r13d
mov    -0x38(%rsp),%rax
cmp    %r9d,%eax
cmovg  %eax,%r9d
setg   %r13b
lea    0x0(%r13,%rdi,2),%eax
sub    %eax,%r9d
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0x18b4(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0x18b3(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
lea    0x30(%r8),%rax
mov    %rax,-0x28(%rsp)
xor    %r10d,%r10d
mov    %ebx,%ebp
mov    %r9d,-0x30(%rsp)
mov    -0x38(%rsp),%rsi
jmp    17cf <boundary_offset+0x6cf>
nopl   (%rax)
mov    -0x40(%rsp),%rcx
add    %ebx,%ebp
cmp    %ecx,%ebp
jge    2c51 <boundary_offset+0x1b51>
cmp    %edi,%esi
jle    17c0 <boundary_offset+0x6c0>
movslq %r10d,%r10
mov    %r9d,%eax
xor    %edx,%edx
div    %edi
add    %r13d,%eax
cmp    $0x7,%eax
jae    17f1 <boundary_offset+0x6f1>
mov    %edi,%edx
mov    -0x40(%rsp),%rcx
jmp    1900 <boundary_offset+0x800>
add    $0x1,%rax
mov    %rax,%rdx
movabs $0x1fffffff8,%rcx
and    %rcx,%rdx
movd   %ebp,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    -0x8(%rdx),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     18aa <boundary_offset+0x7aa>
mov    %r11,%r15
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%r15
mov    -0x28(%rsp),%rcx
lea    (%rcx,%r10,4),%r14
xor    %r9d,%r9d
movdqa %xmm1,%xmm3
xor    %r12d,%r12d
nopl   0x0(%rax)
movdqa %xmm3,%xmm4
paddd  %xmm0,%xmm4
paddd  %xmm2,%xmm3
movdqa %xmm4,%xmm5
paddd  %xmm2,%xmm5
movdqu %xmm3,-0x30(%r14,%r9,4)
movdqu %xmm5,-0x20(%r14,%r9,4)
paddd  %xmm0,%xmm4
movdqa %xmm4,%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm2,%xmm4
movdqa %xmm3,%xmm5
paddd  %xmm2,%xmm5
movdqu %xmm4,-0x10(%r14,%r9,4)
movdqu %xmm5,(%r14,%r9,4)
add    $0x10,%r9
paddd  %xmm0,%xmm3
add    $0x2,%r12
cmp    %r15,%r12
jne    1850 <boundary_offset+0x750>
jmp    18b1 <boundary_offset+0x7b1>
xor    %r9d,%r9d
movdqa %xmm1,%xmm3
test   $0x1,%r11b
mov    -0x40(%rsp),%rcx
je     18dc <boundary_offset+0x7dc>
add    %r10,%r9
movdqa %xmm3,%xmm4
paddd  %xmm0,%xmm4
paddd  %xmm2,%xmm3
paddd  %xmm2,%xmm4
movdqu %xmm3,(%r8,%r9,4)
movdqu %xmm4,0x10(%r8,%r9,4)
add    %rdx,%r10
cmp    %rdx,%rax
jne    18ee <boundary_offset+0x7ee>
mov    -0x30(%rsp),%r9d
jmp    17c5 <boundary_offset+0x6c5>
imul   %edi,%edx
add    %edi,%edx
mov    -0x30(%rsp),%r9d
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%rbp,1),%eax
mov    %eax,(%r8,%r10,4)
add    $0x1,%r10
add    %edi,%edx
cmp    %esi,%edx
jl     1900 <boundary_offset+0x800>
jmp    17c5 <boundary_offset+0x6c5>
cmp    %r11d,%ebx
jge    2c51 <boundary_offset+0x1b51>
lea    (%rdi,%rdi,1),%r9d
xor    %r11d,%r11d
mov    -0x38(%rsp),%rax
cmp    %r9d,%eax
cmovg  %eax,%r9d
setg   %r11b
lea    (%r11,%rdi,2),%eax
sub    %eax,%r9d
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0x16e2(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0x16e1(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
lea    0x30(%r8),%rax
mov    %rax,-0x20(%rsp)
add    $0x1,%esi
imul   %edi,%esi
add    $0xffffffff,%esi
xor    %r10d,%r10d
mov    %ebx,%r14d
mov    %r9d,-0x30(%rsp)
mov    %r11,-0x28(%rsp)
jmp    19b3 <boundary_offset+0x8b3>
nopl   0x0(%rax)
mov    -0x40(%rsp),%rcx
add    %ebx,%r14d
add    %ebx,%esi
cmp    %ecx,%r14d
jge    2c51 <boundary_offset+0x1b51>
mov    -0x38(%rsp),%rbp
cmp    %edi,%ebp
jle    19a0 <boundary_offset+0x8a0>
movslq %r10d,%r10
mov    %r9d,%eax
xor    %edx,%edx
div    %edi
add    %r11d,%eax
cmp    $0x7,%eax
jae    19da <boundary_offset+0x8da>
mov    %edi,%edx
mov    -0x40(%rsp),%rcx
jmp    1af0 <boundary_offset+0x9f0>
lea    (%r14,%r15,1),%ecx
add    $0x1,%rax
mov    %rax,%rdx
movabs $0x1fffffff8,%rbp
and    %rbp,%rdx
movd   %ecx,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    -0x8(%rdx),%rcx
mov    %rcx,%r13
shr    $0x3,%r13
add    $0x1,%r13
test   %rcx,%rcx
je     1b06 <boundary_offset+0xa06>
mov    %r13,%r12
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
and    %rcx,%r12
mov    -0x20(%rsp),%rcx
lea    (%rcx,%r10,4),%r9
xor    %ebp,%ebp
movdqa %xmm1,%xmm3
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm2,%xmm4
paddd  %xmm3,%xmm4
paddd  %xmm0,%xmm3
movdqa %xmm2,%xmm5
paddd  %xmm3,%xmm5
movdqu %xmm4,-0x30(%r9,%rbp,4)
movdqu %xmm5,-0x20(%r9,%rbp,4)
paddd  %xmm0,%xmm3
movdqa %xmm2,%xmm4
paddd  %xmm3,%xmm4
paddd  %xmm0,%xmm3
movdqa %xmm2,%xmm5
paddd  %xmm3,%xmm5
movdqu %xmm4,-0x10(%r9,%rbp,4)
movdqu %xmm5,(%r9,%rbp,4)
add    $0x10,%rbp
paddd  %xmm0,%xmm3
add    $0x2,%r11
cmp    %r12,%r11
jne    1a40 <boundary_offset+0x940>
test   $0x1,%r13b
je     1abe <boundary_offset+0x9be>
add    %r10,%rbp
movdqa %xmm2,%xmm4
paddd  %xmm3,%xmm4
paddd  %xmm0,%xmm3
paddd  %xmm2,%xmm3
movdqu %xmm4,(%r8,%rbp,4)
movdqu %xmm3,0x10(%r8,%rbp,4)
add    %rdx,%r10
cmp    %rdx,%rax
mov    -0x40(%rsp),%rcx
mov    -0x38(%rsp),%rbp
mov    -0x30(%rsp),%r9d
mov    -0x28(%rsp),%r11
je     19a5 <boundary_offset+0x8a5>
imul   %edi,%edx
add    %edi,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%rdx,1),%eax
mov    %eax,(%r8,%r10,4)
add    $0x1,%r10
add    %edi,%edx
cmp    %ebp,%edx
jl     1af0 <boundary_offset+0x9f0>
jmp    19a5 <boundary_offset+0x8a5>
xor    %ebp,%ebp
movdqa %xmm1,%xmm3
test   $0x1,%r13b
jne    1a9e <boundary_offset+0x99e>
jmp    1abe <boundary_offset+0x9be>
cmp    %r11d,%ebx
jge    2c51 <boundary_offset+0x1b51>
mov    %rbx,%rsi
lea    -0x3(%rdi),%eax
lea    0x1(%rax),%r11
mov    %r11,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%r12
mov    %r12,%r13
shr    $0x3,%r13
add    $0x1,%r13
lea    0x1(%rdx),%ecx
mov    %ecx,-0x38(%rsp)
mov    %r13,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x30(%rsp)
lea    0x30(%r8),%rcx
mov    %rcx,-0x28(%rsp)
xor    %r10d,%r10d
movdqa 0x149c(%rip),%xmm0
movdqa 0x14a4(%rip),%xmm1
movdqa 0x14ac(%rip),%xmm2
jmp    1b8c <boundary_offset+0xa8c>
cs nopw 0x0(%rax,%rax,1)
add    %esi,%ebx
cmp    -0x40(%rsp),%ebx
jge    2c51 <boundary_offset+0x1b51>
cmp    $0x3,%edi
jl     1b80 <boundary_offset+0xa80>
movslq %r10d,%r10
mov    $0x1,%ecx
cmp    $0x7,%eax
jb     1c70 <boundary_offset+0xb70>
movd   %ebx,%xmm3
pshufd $0x0,%xmm3,%xmm3
test   %r12,%r12
je     1c88 <boundary_offset+0xb88>
lea    0x4(%rbx),%ecx
movd   %ecx,%xmm4
pshufd $0x0,%xmm4,%xmm5
mov    -0x28(%rsp),%rcx
lea    (%rcx,%r10,4),%rcx
mov    -0x30(%rsp),%r9
xor    %r14d,%r14d
movdqa %xmm0,%xmm4
cs nopw 0x0(%rax,%rax,1)
nop
movdqa %xmm4,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm4,%xmm7
movdqu %xmm6,-0x30(%rcx,%r14,4)
movdqu %xmm7,-0x20(%rcx,%r14,4)
movdqa %xmm4,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm6,%xmm7
paddd  %xmm3,%xmm6
movdqu %xmm6,-0x10(%rcx,%r14,4)
movdqu %xmm7,(%rcx,%r14,4)
add    $0x10,%r14
paddd  %xmm2,%xmm4
add    $0xfffffffffffffffe,%r9
jne    1be0 <boundary_offset+0xae0>
test   $0x1,%r13b
je     1c57 <boundary_offset+0xb57>
add    %r10,%r14
paddd  %xmm4,%xmm3
lea    0x4(%rbx),%ecx
movd   %ecx,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm4,%xmm5
movdqu %xmm3,(%r8,%r14,4)
movdqu %xmm5,0x10(%r8,%r14,4)
add    %rdx,%r10
mov    -0x38(%rsp),%ecx
cmp    %rdx,%r11
je     1b80 <boundary_offset+0xa80>
nopw   0x0(%rax,%rax,1)
lea    (%rbx,%rcx,1),%ebp
mov    %ebp,(%r8,%r10,4)
add    $0x1,%r10
add    $0x1,%ecx
cmp    %ecx,%r15d
jne    1c70 <boundary_offset+0xb70>
jmp    1b80 <boundary_offset+0xa80>
xor    %r14d,%r14d
movdqa %xmm0,%xmm4
test   $0x1,%r13b
jne    1c33 <boundary_offset+0xb33>
jmp    1c57 <boundary_offset+0xb57>
cmp    %r11d,%ebx
jge    2c51 <boundary_offset+0x1b51>
lea    -0x3(%rdi),%r13d
lea    0x1(%r13),%rdx
mov    %rdx,-0x30(%rsp)
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rax
mov    %rax,-0x28(%rsp)
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
lea    0x1(%rdx),%eax
mov    %eax,-0x14(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x20(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x8(%rsp)
lea    0x30(%r8),%rax
mov    %rax,-0x10(%rsp)
add    %esi,%esi
add    $0xffffffff,%esi
imul   %edi,%esi
xor    %r10d,%r10d
movdqa 0x1307(%rip),%xmm0
movdqa 0x130f(%rip),%xmm1
movdqa 0x1317(%rip),%xmm2
mov    %ebx,%r12d
jmp    1d23 <boundary_offset+0xc23>
xchg   %ax,%ax
mov    -0x40(%rsp),%rax
add    %ebx,%r12d
add    %ebx,%esi
cmp    %eax,%r12d
jge    2c51 <boundary_offset+0x1b51>
cmp    $0x3,%edi
jl     1d10 <boundary_offset+0xc10>
movslq %r10d,%r10
mov    $0x1,%ecx
cmp    $0x7,%r13d
jae    1d40 <boundary_offset+0xc40>
mov    -0x40(%rsp),%rax
jmp    1e21 <boundary_offset+0xd21>
mov    -0x38(%rsp),%rax
lea    (%r12,%rax,1),%r14d
movd   %r14d,%xmm3
pshufd $0x0,%xmm3,%xmm3
cmpq   $0x0,-0x28(%rsp)
je     1e45 <boundary_offset+0xd45>
lea    0x4(%r14),%ecx
movd   %ecx,%xmm4
pshufd $0x0,%xmm4,%xmm5
mov    -0x10(%rsp),%rax
lea    (%rax,%r10,4),%rcx
mov    -0x8(%rsp),%r11
xor    %r9d,%r9d
movdqa %xmm0,%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm3,%xmm6
paddd  %xmm4,%xmm6
movdqa %xmm5,%xmm7
paddd  %xmm4,%xmm7
movdqu %xmm6,-0x30(%rcx,%r9,4)
movdqu %xmm7,-0x20(%rcx,%r9,4)
movdqa %xmm4,%xmm6
paddd  %xmm1,%xmm6
movdqa %xmm3,%xmm7
paddd  %xmm6,%xmm7
paddd  %xmm5,%xmm6
movdqu %xmm7,-0x10(%rcx,%r9,4)
movdqu %xmm6,(%rcx,%r9,4)
add    $0x10,%r9
paddd  %xmm2,%xmm4
add    $0xfffffffffffffffe,%r11
jne    1d90 <boundary_offset+0xc90>
testb  $0x1,-0x20(%rsp)
je     1e0a <boundary_offset+0xd0a>
add    %r10,%r9
paddd  %xmm4,%xmm3
add    $0x4,%r14d
movd   %r14d,%xmm5
pshufd $0x0,%xmm5,%xmm5
paddd  %xmm4,%xmm5
movdqu %xmm3,(%r8,%r9,4)
movdqu %xmm5,0x10(%r8,%r9,4)
add    %rdx,%r10
mov    -0x14(%rsp),%ecx
cmp    %rdx,-0x30(%rsp)
mov    -0x40(%rsp),%rax
je     1d15 <boundary_offset+0xc15>
mov    %r15d,%ebp
sub    %ecx,%ebp
add    %esi,%ecx
nopl   0x0(%rax,%rax,1)
mov    %ecx,(%r8,%r10,4)
add    $0x1,%r10
add    $0x1,%ecx
add    $0xffffffff,%ebp
jne    1e30 <boundary_offset+0xd30>
jmp    1d15 <boundary_offset+0xc15>
xor    %r9d,%r9d
movdqa %xmm0,%xmm4
testb  $0x1,-0x20(%rsp)
jne    1de4 <boundary_offset+0xce4>
jmp    1e0a <boundary_offset+0xd0a>
mov    %edi,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    2636 <boundary_offset+0x1536>
movdqa 0x1180(%rip),%xmm0
xor    %esi,%esi
jmp    2714 <boundary_offset+0x1614>
mov    %edi,%eax
and    $0xfffffff8,%eax
mov    -0x38(%rsp),%rbp
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     2933 <boundary_offset+0x1833>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x4(%rbp),%edx
movd   %edx,%xmm1
pshufd $0x0,%xmm1,%xmm2
movdqa 0x1133(%rip),%xmm1
xor    %edx,%edx
movdqa 0x1139(%rip),%xmm3
movdqa 0x1141(%rip),%xmm4
movdqa %xmm1,%xmm5
paddd  %xmm0,%xmm5
movdqa %xmm2,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,(%r8,%rdx,4)
movdqu %xmm6,0x10(%r8,%rdx,4)
movdqa %xmm1,%xmm5
paddd  %xmm3,%xmm5
movdqa %xmm2,%xmm6
paddd  %xmm5,%xmm6
paddd  %xmm0,%xmm5
movdqu %xmm5,0x20(%r8,%rdx,4)
movdqu %xmm6,0x30(%r8,%rdx,4)
add    $0x10,%rdx
paddd  %xmm4,%xmm1
add    $0xfffffffffffffffe,%rsi
jne    1edf <boundary_offset+0xddf>
jmp    293d <boundary_offset+0x183d>
mov    %edi,%eax
and    $0xfffffff8,%eax
mov    -0x40(%rsp),%rbp
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     2991 <boundary_offset+0x1891>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x4(%rbp),%edx
movd   %edx,%xmm1
pshufd $0x0,%xmm1,%xmm2
movdqa 0x1089(%rip),%xmm1
xor    %edx,%edx
movdqa 0x108f(%rip),%xmm3
movdqa 0x1097(%rip),%xmm4
movdqa %xmm1,%xmm5
paddd  %xmm0,%xmm5
movdqa %xmm2,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,(%r8,%rdx,4)
movdqu %xmm6,0x10(%r8,%rdx,4)
movdqa %xmm1,%xmm5
paddd  %xmm3,%xmm5
movdqa %xmm2,%xmm6
paddd  %xmm5,%xmm6
paddd  %xmm0,%xmm5
movdqu %xmm5,0x20(%r8,%rdx,4)
movdqu %xmm6,0x30(%r8,%rdx,4)
add    $0x10,%rdx
paddd  %xmm4,%xmm1
add    $0xfffffffffffffffe,%rsi
jne    1f89 <boundary_offset+0xe89>
jmp    299b <boundary_offset+0x189b>
mov    -0x40(%rsp),%rbp
add    -0x38(%rsp),%ebp
mov    %r10d,%eax
and    $0xfffffff8,%eax
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     29f7 <boundary_offset+0x18f7>
mov    %rcx,%rbx
and    $0xfffffffffffffffe,%rbx
lea    0x4(%rbp),%edx
movd   %edx,%xmm1
pshufd $0x0,%xmm1,%xmm2
movdqa 0xfda(%rip),%xmm1
xor    %edx,%edx
movdqa 0xfe0(%rip),%xmm3
movdqa 0xfe8(%rip),%xmm4
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
movdqa %xmm2,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm5,(%r8,%rdx,4)
movdqu %xmm6,0x10(%r8,%rdx,4)
movdqa %xmm1,%xmm5
paddd  %xmm3,%xmm5
movdqa %xmm0,%xmm6
paddd  %xmm5,%xmm6
paddd  %xmm2,%xmm5
movdqu %xmm6,0x20(%r8,%rdx,4)
movdqu %xmm5,0x30(%r8,%rdx,4)
add    $0x10,%rdx
paddd  %xmm4,%xmm1
add    $0xfffffffffffffffe,%rbx
jne    2038 <boundary_offset+0xf38>
jmp    2a01 <boundary_offset+0x1901>
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xf8a(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0xf89(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
lea    -0x8(%r10),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    2794 <boundary_offset+0x1694>
xor    %esi,%esi
jmp    280d <boundary_offset+0x170d>
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xf22(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0xf21(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
movd   %r15d,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    -0x8(%r10),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2a64 <boundary_offset+0x1964>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
xor    %ebp,%ebp
movdqa %xmm1,%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm2,%xmm1
movdqa %xmm3,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm4,0x10(%r8,%rcx,4)
paddd  %xmm0,%xmm3
movdqa %xmm3,%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm2,%xmm3
movdqa %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm3,0x20(%r8,%rcx,4)
movdqu %xmm4,0x30(%r8,%rcx,4)
add    $0x10,%rcx
paddd  %xmm0,%xmm1
add    $0x2,%rbp
cmp    %rsi,%rbp
jne    2162 <boundary_offset+0x1062>
jmp    2a66 <boundary_offset+0x1966>
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xe55(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0xe54(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
mov    -0x40(%rsp),%rdx
movd   %edx,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    -0x8(%r10),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     2ab7 <boundary_offset+0x19b7>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
xor    %ebp,%ebp
movdqa %xmm1,%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm2,%xmm1
movdqa %xmm3,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm4,0x10(%r8,%rcx,4)
paddd  %xmm0,%xmm3
movdqa %xmm3,%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm2,%xmm3
movdqa %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm3,0x20(%r8,%rcx,4)
movdqu %xmm4,0x30(%r8,%rcx,4)
add    $0x10,%rcx
paddd  %xmm0,%xmm1
add    $0x2,%rbp
cmp    %rsi,%rbp
jne    2233 <boundary_offset+0x1133>
jmp    2ab9 <boundary_offset+0x19b9>
mov    -0x40(%rsp),%rcx
add    %r15d,%ecx
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
movd   %edi,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xd7c(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0xd7b(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
movd   %ecx,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    -0x8(%r10),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     2b06 <boundary_offset+0x1a06>
mov    %r11,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %ecx,%ecx
xor    %ebp,%ebp
movdqa %xmm2,%xmm3
paddd  %xmm1,%xmm3
paddd  %xmm0,%xmm1
movdqa %xmm2,%xmm4
paddd  %xmm1,%xmm4
movdqu %xmm3,(%r8,%rcx,4)
movdqu %xmm4,0x10(%r8,%rcx,4)
paddd  %xmm0,%xmm1
movdqa %xmm2,%xmm3
paddd  %xmm1,%xmm3
paddd  %xmm0,%xmm1
movdqa %xmm2,%xmm4
paddd  %xmm1,%xmm4
movdqu %xmm3,0x20(%r8,%rcx,4)
movdqu %xmm4,0x30(%r8,%rcx,4)
add    $0x10,%rcx
paddd  %xmm0,%xmm1
add    $0x2,%rbp
cmp    %rdx,%rbp
jne    2307 <boundary_offset+0x1207>
jmp    2b08 <boundary_offset+0x1a08>
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xcb0(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0xcaf(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
lea    -0x8(%r10),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    2863 <boundary_offset+0x1763>
xor    %esi,%esi
jmp    28dc <boundary_offset+0x17dc>
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xc48(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0xc47(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
movd   %r15d,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    -0x8(%r10),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     2b66 <boundary_offset+0x1a66>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
xor    %edi,%edi
movdqa %xmm1,%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm2,%xmm1
movdqa %xmm3,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm4,0x10(%r8,%rcx,4)
paddd  %xmm0,%xmm3
movdqa %xmm3,%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm2,%xmm3
movdqa %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm3,0x20(%r8,%rcx,4)
movdqu %xmm4,0x30(%r8,%rcx,4)
add    $0x10,%rcx
paddd  %xmm0,%xmm1
add    $0x2,%rdi
cmp    %rsi,%rdi
jne    243c <boundary_offset+0x133c>
jmp    2b68 <boundary_offset+0x1a68>
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
movd   %ebx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xb7b(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0xb7a(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
mov    -0x38(%rsp),%rdx
movd   %edx,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    -0x8(%r10),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     2bb7 <boundary_offset+0x1ab7>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
xor    %edi,%edi
movdqa %xmm1,%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm2,%xmm1
movdqa %xmm3,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm4,0x10(%r8,%rcx,4)
paddd  %xmm0,%xmm3
movdqa %xmm3,%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm2,%xmm3
movdqa %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu %xmm3,0x20(%r8,%rcx,4)
movdqu %xmm4,0x30(%r8,%rcx,4)
add    $0x10,%rcx
paddd  %xmm0,%xmm1
add    $0x2,%rdi
cmp    %rsi,%rdi
jne    250d <boundary_offset+0x140d>
jmp    2bb9 <boundary_offset+0x1ab9>
add    $0x1,%rax
mov    %rax,%r10
and    $0xfffffffffffffff8,%r10
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xaaa(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm2
movdqa 0xaa9(%rip),%xmm1
pmuludq %xmm0,%xmm1
pshufd $0xe8,%xmm1,%xmm1
punpckldq %xmm2,%xmm1
paddd  %xmm0,%xmm1
pslld  $0x2,%xmm0
movd   %ecx,%xmm2
pshufd $0x0,%xmm2,%xmm2
lea    -0x8(%r10),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     2c03 <boundary_offset+0x1b03>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
xor    %ebp,%ebp
movdqa %xmm2,%xmm3
paddd  %xmm1,%xmm3
paddd  %xmm0,%xmm1
movdqa %xmm2,%xmm4
paddd  %xmm1,%xmm4
movdqu %xmm3,(%r8,%rdx,4)
movdqu %xmm4,0x10(%r8,%rdx,4)
paddd  %xmm0,%xmm1
movdqa %xmm2,%xmm3
paddd  %xmm1,%xmm3
paddd  %xmm0,%xmm1
movdqa %xmm2,%xmm4
paddd  %xmm1,%xmm4
movdqu %xmm3,0x20(%r8,%rdx,4)
movdqu %xmm4,0x30(%r8,%rdx,4)
add    $0x10,%rdx
paddd  %xmm0,%xmm1
add    $0x2,%rbp
cmp    %rdi,%rbp
jne    25d9 <boundary_offset+0x14d9>
jmp    2c05 <boundary_offset+0x1b05>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
movdqa 0x9b1(%rip),%xmm0
xor    %esi,%esi
movdqa 0x9f6(%rip),%xmm8
movdqa 0x9ad(%rip),%xmm9
movdqa 0x9f4(%rip),%xmm10
movdqa 0x9ac(%rip),%xmm4
movdqa 0x9f4(%rip),%xmm5
movdqa 0x9fc(%rip),%xmm6
movdqa 0xa04(%rip),%xmm7
movdqa 0xa0c(%rip),%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%r8,%rsi,4)
movdqu %xmm2,0x10(%r8,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%r8,%rsi,4)
movdqu %xmm3,0x30(%r8,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%r8,%rsi,4)
movdqu %xmm3,0x50(%r8,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%r8,%rsi,4)
movdqu %xmm3,0x70(%r8,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdx
jne    2694 <boundary_offset+0x1594>
test   %rcx,%rcx
je     2757 <boundary_offset+0x1657>
lea    (%r8,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
movdqa 0x921(%rip),%xmm1
movdqa 0x8d9(%rip),%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm3,(%rdx,%rsi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    2737 <boundary_offset+0x1637>
cmp    %rdi,%rax
je     29ef <boundary_offset+0x18ef>
lea    0x1(%rax),%esi
lea    (%r8,%rax,4),%rcx
mov    %rdi,%rdx
sub    %rax,%rdx
mov    %esi,%eax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rsi,1),%ebp
mov    %ebp,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    2780 <boundary_offset+0x1680>
jmp    29ef <boundary_offset+0x18ef>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
xor    %ebp,%ebp
movdqu %xmm1,(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x10(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x20(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x30(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x40(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x50(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x60(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x70(%r8,%rsi,4)
add    $0x20,%rsi
paddd  %xmm0,%xmm1
add    $0x4,%rbp
cmp    %rdx,%rbp
jne    27a9 <boundary_offset+0x16a9>
test   %rcx,%rcx
je     283a <boundary_offset+0x173a>
lea    (%r8,%rsi,4),%rdx
add    $0x10,%rdx
xor    %esi,%esi
movdqu %xmm1,-0x10(%rdx)
paddd  %xmm0,%xmm1
movdqu %xmm1,(%rdx)
paddd  %xmm0,%xmm1
add    $0x1,%rsi
add    $0x20,%rdx
cmp    %rcx,%rsi
jne    281c <boundary_offset+0x171c>
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
mov    %r10d,%eax
imul   %edi,%eax
add    %edi,%eax
nopl   0x0(%rax,%rax,1)
mov    %eax,(%r8,%r10,4)
add    $0x1,%r10
add    %edi,%eax
cmp    %ebx,%eax
jl     2850 <boundary_offset+0x1750>
jmp    2c51 <boundary_offset+0x1b51>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdx
xor    %esi,%esi
xor    %edi,%edi
movdqu %xmm1,(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x10(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x20(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x30(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x40(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x50(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x60(%r8,%rsi,4)
paddd  %xmm0,%xmm1
movdqu %xmm1,0x70(%r8,%rsi,4)
add    $0x20,%rsi
paddd  %xmm0,%xmm1
add    $0x4,%rdi
cmp    %rdx,%rdi
jne    2878 <boundary_offset+0x1778>
test   %rcx,%rcx
je     2909 <boundary_offset+0x1809>
lea    (%r8,%rsi,4),%rdx
add    $0x10,%rdx
xor    %esi,%esi
movdqu %xmm1,-0x10(%rdx)
paddd  %xmm0,%xmm1
movdqu %xmm1,(%rdx)
paddd  %xmm0,%xmm1
add    $0x1,%rsi
add    $0x20,%rdx
cmp    %rcx,%rsi
jne    28eb <boundary_offset+0x17eb>
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
mov    %ebx,%eax
imul   %r10d,%eax
add    %ebx,%eax
nopw   0x0(%rax,%rax,1)
mov    %eax,(%r8,%r10,4)
add    $0x1,%r10
add    %ebx,%eax
cmp    %ebp,%eax
jl     2920 <boundary_offset+0x1820>
jmp    2c51 <boundary_offset+0x1b51>
movdqa 0x6c5(%rip),%xmm1
xor    %edx,%edx
test   $0x1,%cl
je     2963 <boundary_offset+0x1863>
paddd  %xmm1,%xmm0
lea    0x4(%rbp),%ecx
movd   %ecx,%xmm2
pshufd $0x0,%xmm2,%xmm2
paddd  %xmm1,%xmm2
movdqu %xmm0,(%r8,%rdx,4)
movdqu %xmm2,0x10(%r8,%rdx,4)
cmp    %rdi,%rax
je     29ef <boundary_offset+0x18ef>
lea    0x1(%rax),%ecx
lea    (%r8,%rax,4),%rdx
mov    %rdi,%rsi
sub    %rax,%rsi
add    %ebp,%ecx
xor    %eax,%eax
nopl   (%rax)
lea    (%rcx,%rax,1),%ebp
mov    %ebp,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    2980 <boundary_offset+0x1880>
jmp    29ef <boundary_offset+0x18ef>
movdqa 0x667(%rip),%xmm1
xor    %edx,%edx
test   $0x1,%cl
je     29c1 <boundary_offset+0x18c1>
paddd  %xmm1,%xmm0
lea    0x4(%rbp),%ecx
movd   %ecx,%xmm2
pshufd $0x0,%xmm2,%xmm2
paddd  %xmm1,%xmm2
movdqu %xmm0,(%r8,%rdx,4)
movdqu %xmm2,0x10(%r8,%rdx,4)
cmp    %rdi,%rax
je     29ef <boundary_offset+0x18ef>
lea    0x1(%rax),%ecx
lea    (%r8,%rax,4),%rdx
mov    %rdi,%rsi
sub    %rax,%rsi
add    %ebp,%ecx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rax,1),%ebp
mov    %ebp,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    29e0 <boundary_offset+0x18e0>
mov    %edi,%r10d
jmp    2c51 <boundary_offset+0x1b51>
movdqa 0x601(%rip),%xmm1
xor    %edx,%edx
test   $0x1,%cl
je     2a27 <boundary_offset+0x1927>
paddd  %xmm1,%xmm0
add    $0x4,%ebp
movd   %ebp,%xmm2
pshufd $0x0,%xmm2,%xmm2
paddd  %xmm1,%xmm2
movdqu %xmm0,(%r8,%rdx,4)
movdqu %xmm2,0x10(%r8,%rdx,4)
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
lea    0x1(%rax),%ebp
lea    (%r8,%rax,4),%rcx
mov    %r10,%rdx
sub    %rax,%rdx
imul   %esi,%r9d
add    $0xffffffff,%r9d
imul   %r9d,%edi
add    %ebp,%edi
xor    %eax,%eax
nopl   (%rax)
lea    (%rdi,%rax,1),%esi
mov    %esi,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdx
jne    2a50 <boundary_offset+0x1950>
jmp    2c51 <boundary_offset+0x1b51>
xor    %ecx,%ecx
test   $0x1,%dl
je     2a84 <boundary_offset+0x1984>
paddd  %xmm1,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm2,%xmm0
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm0,0x10(%r8,%rcx,4)
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
mov    %r10d,%eax
imul   %edi,%eax
add    %edi,%eax
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%r15,%rax,1),%ecx
mov    %ecx,(%r8,%r10,4)
add    $0x1,%r10
add    %edi,%eax
cmp    %ebx,%eax
jl     2aa0 <boundary_offset+0x19a0>
jmp    2c51 <boundary_offset+0x1b51>
xor    %ecx,%ecx
test   $0x1,%r9b
je     2ad8 <boundary_offset+0x19d8>
paddd  %xmm1,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm2,%xmm0
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm0,0x10(%r8,%rcx,4)
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
mov    %r10d,%eax
imul   %edi,%eax
add    %edi,%eax
nopl   0x0(%rax)
lea    (%rdx,%rax,1),%ecx
mov    %ecx,(%r8,%r10,4)
add    $0x1,%r10
add    %edi,%eax
cmp    %ebx,%eax
jl     2af0 <boundary_offset+0x19f0>
jmp    2c51 <boundary_offset+0x1b51>
xor    %ecx,%ecx
test   $0x1,%r11b
je     2b27 <boundary_offset+0x1a27>
paddd  %xmm1,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm2,%xmm0
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm0,0x10(%r8,%rcx,4)
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
mov    %r10d,%eax
imul   %edi,%eax
add    %edi,%eax
add    $0xffffffff,%r9d
imul   %r9d,%esi
add    $0x1,%esi
imul   %edi,%esi
add    $0xffffffff,%esi
nopl   0x0(%rax)
lea    (%rsi,%rax,1),%ecx
mov    %ecx,(%r8,%r10,4)
add    $0x1,%r10
add    %edi,%eax
cmp    %ebx,%eax
jl     2b50 <boundary_offset+0x1a50>
jmp    2c51 <boundary_offset+0x1b51>
xor    %ecx,%ecx
test   $0x1,%dl
je     2b86 <boundary_offset+0x1a86>
paddd  %xmm1,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm2,%xmm0
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm0,0x10(%r8,%rcx,4)
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
mov    %ebx,%eax
imul   %r10d,%eax
add    %ebx,%eax
nopw   0x0(%rax,%rax,1)
lea    (%r15,%rax,1),%ecx
mov    %ecx,(%r8,%r10,4)
add    $0x1,%r10
add    %ebx,%eax
cmp    %ebp,%eax
jl     2ba0 <boundary_offset+0x1aa0>
jmp    2c51 <boundary_offset+0x1b51>
xor    %ecx,%ecx
test   $0x1,%r9b
je     2bd8 <boundary_offset+0x1ad8>
paddd  %xmm1,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm2,%xmm0
movdqu %xmm1,(%r8,%rcx,4)
movdqu %xmm0,0x10(%r8,%rcx,4)
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
mov    %ebx,%eax
imul   %r10d,%eax
add    %ebx,%eax
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rdx,%rax,1),%ecx
mov    %ecx,(%r8,%r10,4)
add    $0x1,%r10
add    %ebx,%eax
cmp    %ebp,%eax
jl     2bf0 <boundary_offset+0x1af0>
jmp    2c51 <boundary_offset+0x1b51>
xor    %edx,%edx
test   $0x1,%r9b
je     2c24 <boundary_offset+0x1b24>
paddd  %xmm1,%xmm0
paddd  %xmm2,%xmm1
paddd  %xmm2,%xmm0
movdqu %xmm1,(%r8,%rdx,4)
movdqu %xmm0,0x10(%r8,%rdx,4)
cmp    %r10,%rax
je     2c51 <boundary_offset+0x1b51>
mov    %esi,%eax
imul   %r10d,%eax
add    %esi,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rax,1),%edx
mov    %edx,(%r8,%r10,4)
add    $0x1,%r10
add    %esi,%eax
cmp    %ebx,%eax
jl     2c40 <boundary_offset+0x1b40>
mov    %r10d,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @boundary_offset(i32 %0, i32 %1, i32 %2, i32 %3, i32* %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i32* %4, i32** %10
store i32 0, i32* %13
%20 = load i32, i32* %6
%21 = load i32, i32* %7
%22 = mul nsw i32 %20, %21
store i32 %22, i32* %14
%23 = load i32, i32* %14
%24 = load i32, i32* %8
%25 = mul nsw i32 %23, %24
store i32 %25, i32* %15
%26 = load i32, i32* %6
%27 = sub nsw i32 %26, 1
store i32 %27, i32* %16
%28 = load i32, i32* %14
%29 = load i32, i32* %6
%30 = sub nsw i32 %28, %29
store i32 %30, i32* %17
%31 = load i32, i32* %15
%32 = load i32, i32* %14
%33 = sub nsw i32 %31, %32
store i32 %33, i32* %18
store i32 0, i32* %19
%34 = load i32, i32* %9
switch i32 %34, label %519 [
i32 1, label %35
i32 2, label %38
i32 3, label %42
i32 4, label %46
i32 5, label %52
i32 6, label %56
i32 7, label %62
i32 8, label %68
i32 9, label %73
i32 10, label %90
i32 11, label %110
i32 12, label %130
i32 13, label %152
i32 14, label %171
i32 15, label %193
i32 16, label %215
i32 17, label %239
i32 18, label %258
i32 19, label %280
i32 20, label %302
i32 21, label %326
i32 22, label %356
i32 23, label %389
i32 24, label %421
i32 25, label %456
i32 26, label %486
]
35: ; preds = %5
%36 = load i32*, i32** %10
%37 = getelementptr inbounds i32, i32* %36, i64 0
store i32 0, i32* %37
store i32 1, i32* %13
br label %520
38: ; preds = %5
%39 = load i32, i32* %16
%40 = load i32*, i32** %10
%41 = getelementptr inbounds i32, i32* %40, i64 0
store i32 %39, i32* %41
store i32 1, i32* %13
br label %520
42: ; preds = %5
%43 = load i32, i32* %17
%44 = load i32*, i32** %10
%45 = getelementptr inbounds i32, i32* %44, i64 0
store i32 %43, i32* %45
store i32 1, i32* %13
br label %520
46: ; preds = %5
%47 = load i32, i32* %17
%48 = load i32, i32* %16
%49 = add nsw i32 %47, %48
%50 = load i32*, i32** %10
%51 = getelementptr inbounds i32, i32* %50, i64 0
store i32 %49, i32* %51
store i32 1, i32* %13
br label %520
52: ; preds = %5
%53 = load i32, i32* %18
%54 = load i32*, i32** %10
%55 = getelementptr inbounds i32, i32* %54, i64 0
store i32 %53, i32* %55
store i32 1, i32* %13
br label %520
56: ; preds = %5
%57 = load i32, i32* %18
%58 = load i32, i32* %16
%59 = add nsw i32 %57, %58
%60 = load i32*, i32** %10
%61 = getelementptr inbounds i32, i32* %60, i64 0
store i32 %59, i32* %61
store i32 1, i32* %13
br label %520
62: ; preds = %5
%63 = load i32, i32* %18
%64 = load i32, i32* %17
%65 = add nsw i32 %63, %64
%66 = load i32*, i32** %10
%67 = getelementptr inbounds i32, i32* %66, i64 0
store i32 %65, i32* %67
store i32 1, i32* %13
br label %520
68: ; preds = %5
%69 = load i32, i32* %15
%70 = sub nsw i32 %69, 1
%71 = load i32*, i32** %10
%72 = getelementptr inbounds i32, i32* %71, i64 0
store i32 %70, i32* %72
store i32 1, i32* %13
br label %520
73: ; preds = %5
store i32 1, i32* %11
br label %74
74: ; preds = %86, %73
%75 = load i32, i32* %11
%76 = load i32, i32* %16
%77 = icmp slt i32 %75, %76
br i1 %77, label %78, label %89
78: ; preds = %74
%79 = load i32, i32* %11
%80 = load i32*, i32** %10
%81 = load i32, i32* %13
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i32, i32* %80, i64 %82
store i32 %79, i32* %83
%84 = load i32, i32* %13
%85 = add nsw i32 %84, 1
store i32 %85, i32* %13
br label %86
86: ; preds = %78
%87 = load i32, i32* %11
%88 = add nsw i32 %87, 1
store i32 %88, i32* %11
br label %74
89: ; preds = %74
br label %520
90: ; preds = %5
%91 = load i32, i32* %17
store i32 %91, i32* %19
store i32 1, i32* %11
br label %92
92: ; preds = %106, %90
%93 = load i32, i32* %11
%94 = load i32, i32* %16
%95 = icmp slt i32 %93, %94
br i1 %95, label %96, label %109
96: ; preds = %92
%97 = load i32, i32* %19
%98 = load i32, i32* %11
%99 = add nsw i32 %97, %98
%100 = load i32*, i32** %10
%101 = load i32, i32* %13
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds i32, i32* %100, i64 %102
store i32 %99, i32* %103
%104 = load i32, i32* %13
%105 = add nsw i32 %104, 1
store i32 %105, i32* %13
br label %106
106: ; preds = %96
%107 = load i32, i32* %11
%108 = add nsw i32 %107, 1
store i32 %108, i32* %11
br label %92
109: ; preds = %92
br label %520
110: ; preds = %5
%111 = load i32, i32* %18
store i32 %111, i32* %19
store i32 1, i32* %11
br label %112
112: ; preds = %126, %110
%113 = load i32, i32* %11
%114 = load i32, i32* %16
%115 = icmp slt i32 %113, %114
br i1 %115, label %116, label %129
116: ; preds = %112
%117 = load i32, i32* %19
%118 = load i32, i32* %11
%119 = add nsw i32 %117, %118
%120 = load i32*, i32** %10
%121 = load i32, i32* %13
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %120, i64 %122
store i32 %119, i32* %123
%124 = load i32, i32* %13
%125 = add nsw i32 %124, 1
store i32 %125, i32* %13
br label %126
126: ; preds = %116
%127 = load i32, i32* %11
%128 = add nsw i32 %127, 1
store i32 %128, i32* %11
br label %112
129: ; preds = %112
br label %520
130: ; preds = %5
%131 = load i32, i32* %18
%132 = load i32, i32* %17
%133 = add nsw i32 %131, %132
store i32 %133, i32* %19
store i32 1, i32* %11
br label %134
134: ; preds = %148, %130
%135 = load i32, i32* %11
%136 = load i32, i32* %16
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %151
138: ; preds = %134
%139 = load i32, i32* %19
%140 = load i32, i32* %11
%141 = add nsw i32 %139, %140
%142 = load i32*, i32** %10
%143 = load i32, i32* %13
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i32, i32* %142, i64 %144
store i32 %141, i32* %145
%146 = load i32, i32* %13
%147 = add nsw i32 %146, 1
store i32 %147, i32* %13
br label %148
148: ; preds = %138
%149 = load i32, i32* %11
%150 = add nsw i32 %149, 1
store i32 %150, i32* %11
br label %134
151: ; preds = %134
br label %520
152: ; preds = %5
%153 = load i32, i32* %6
store i32 %153, i32* %11
br label %154
154: ; preds = %166, %152
%155 = load i32, i32* %11
%156 = load i32, i32* %17
%157 = icmp slt i32 %155, %156
br i1 %157, label %158, label %170
158: ; preds = %154
%159 = load i32, i32* %11
%160 = load i32*, i32** %10
%161 = load i32, i32* %13
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i32, i32* %160, i64 %162
store i32 %159, i32* %163
%164 = load i32, i32* %13
%165 = add nsw i32 %164, 1
store i32 %165, i32* %13
br label %166
166: ; preds = %158
%167 = load i32, i32* %6
%168 = load i32, i32* %11
%169 = add nsw i32 %168, %167
store i32 %169, i32* %11
br label %154
170: ; preds = %154
br label %520
171: ; preds = %5
%172 = load i32, i32* %16
store i32 %172, i32* %19
%173 = load i32, i32* %6
store i32 %173, i32* %11
br label %174
174: ; preds = %188, %171
%175 = load i32, i32* %11
%176 = load i32, i32* %17
%177 = icmp slt i32 %175, %176
br i1 %177, label %178, label %192
178: ; preds = %174
%179 = load i32, i32* %19
%180 = load i32, i32* %11
%181 = add nsw i32 %179, %180
%182 = load i32*, i32** %10
%183 = load i32, i32* %13
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i32, i32* %182, i64 %184
store i32 %181, i32* %185
%186 = load i32, i32* %13
%187 = add nsw i32 %186, 1
store i32 %187, i32* %13
br label %188
188: ; preds = %178
%189 = load i32, i32* %6
%190 = load i32, i32* %11
%191 = add nsw i32 %190, %189
store i32 %191, i32* %11
br label %174
192: ; preds = %174
br label %520
193: ; preds = %5
%194 = load i32, i32* %18
store i32 %194, i32* %19
%195 = load i32, i32* %6
store i32 %195, i32* %11
br label %196
196: ; preds = %210, %193
%197 = load i32, i32* %11
%198 = load i32, i32* %17
%199 = icmp slt i32 %197, %198
br i1 %199, label %200, label %214
200: ; preds = %196
%201 = load i32, i32* %19
%202 = load i32, i32* %11
%203 = add nsw i32 %201, %202
%204 = load i32*, i32** %10
%205 = load i32, i32* %13
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %204, i64 %206
store i32 %203, i32* %207
%208 = load i32, i32* %13
%209 = add nsw i32 %208, 1
store i32 %209, i32* %13
br label %210
210: ; preds = %200
%211 = load i32, i32* %6
%212 = load i32, i32* %11
%213 = add nsw i32 %212, %211
store i32 %213, i32* %11
br label %196
214: ; preds = %196
br label %520
215: ; preds = %5
%216 = load i32, i32* %18
%217 = load i32, i32* %16
%218 = add nsw i32 %216, %217
store i32 %218, i32* %19
%219 = load i32, i32* %6
store i32 %219, i32* %11
br label %220
220: ; preds = %234, %215
%221 = load i32, i32* %11
%222 = load i32, i32* %17
%223 = icmp slt i32 %221, %222
br i1 %223, label %224, label %238
224: ; preds = %220
%225 = load i32, i32* %19
%226 = load i32, i32* %11
%227 = add nsw i32 %225, %226
%228 = load i32*, i32** %10
%229 = load i32, i32* %13
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i32, i32* %228, i64 %230
store i32 %227, i32* %231
%232 = load i32, i32* %13
%233 = add nsw i32 %232, 1
store i32 %233, i32* %13
br label %234
234: ; preds = %224
%235 = load i32, i32* %6
%236 = load i32, i32* %11
%237 = add nsw i32 %236, %235
store i32 %237, i32* %11
br label %220
238: ; preds = %220
br label %520
239: ; preds = %5
%240 = load i32, i32* %14
store i32 %240, i32* %11
br label %241
241: ; preds = %253, %239
%242 = load i32, i32* %11
%243 = load i32, i32* %18
%244 = icmp slt i32 %242, %243
br i1 %244, label %245, label %257
245: ; preds = %241
%246 = load i32, i32* %11
%247 = load i32*, i32** %10
%248 = load i32, i32* %13
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %247, i64 %249
store i32 %246, i32* %250
%251 = load i32, i32* %13
%252 = add nsw i32 %251, 1
store i32 %252, i32* %13
br label %253
253: ; preds = %245
%254 = load i32, i32* %14
%255 = load i32, i32* %11
%256 = add nsw i32 %255, %254
store i32 %256, i32* %11
br label %241
257: ; preds = %241
br label %520
258: ; preds = %5
%259 = load i32, i32* %16
store i32 %259, i32* %19
%260 = load i32, i32* %14
store i32 %260, i32* %11
br label %261
261: ; preds = %275, %258
%262 = load i32, i32* %11
%263 = load i32, i32* %18
%264 = icmp slt i32 %262, %263
br i1 %264, label %265, label %279
265: ; preds = %261
%266 = load i32, i32* %19
%267 = load i32, i32* %11
%268 = add nsw i32 %266, %267
%269 = load i32*, i32** %10
%270 = load i32, i32* %13
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %269, i64 %271
store i32 %268, i32* %272
%273 = load i32, i32* %13
%274 = add nsw i32 %273, 1
store i32 %274, i32* %13
br label %275
275: ; preds = %265
%276 = load i32, i32* %14
%277 = load i32, i32* %11
%278 = add nsw i32 %277, %276
store i32 %278, i32* %11
br label %261
279: ; preds = %261
br label %520
280: ; preds = %5
%281 = load i32, i32* %17
store i32 %281, i32* %19
%282 = load i32, i32* %14
store i32 %282, i32* %11
br label %283
283: ; preds = %297, %280
%284 = load i32, i32* %11
%285 = load i32, i32* %18
%286 = icmp slt i32 %284, %285
br i1 %286, label %287, label %301
287: ; preds = %283
%288 = load i32, i32* %19
%289 = load i32, i32* %11
%290 = add nsw i32 %288, %289
%291 = load i32*, i32** %10
%292 = load i32, i32* %13
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds i32, i32* %291, i64 %293
store i32 %290, i32* %294
%295 = load i32, i32* %13
%296 = add nsw i32 %295, 1
store i32 %296, i32* %13
br label %297
297: ; preds = %287
%298 = load i32, i32* %14
%299 = load i32, i32* %11
%300 = add nsw i32 %299, %298
store i32 %300, i32* %11
br label %283
301: ; preds = %283
br label %520
302: ; preds = %5
%303 = load i32, i32* %17
%304 = load i32, i32* %16
%305 = add nsw i32 %303, %304
store i32 %305, i32* %19
%306 = load i32, i32* %14
store i32 %306, i32* %11
br label %307
307: ; preds = %321, %302
%308 = load i32, i32* %11
%309 = load i32, i32* %18
%310 = icmp slt i32 %308, %309
br i1 %310, label %311, label %325
311: ; preds = %307
%312 = load i32, i32* %19
%313 = load i32, i32* %11
%314 = add nsw i32 %312, %313
%315 = load i32*, i32** %10
%316 = load i32, i32* %13
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds i32, i32* %315, i64 %317
store i32 %314, i32* %318
%319 = load i32, i32* %13
%320 = add nsw i32 %319, 1
store i32 %320, i32* %13
br label %321
321: ; preds = %311
%322 = load i32, i32* %14
%323 = load i32, i32* %11
%324 = add nsw i32 %323, %322
store i32 %324, i32* %11
br label %307
325: ; preds = %307
br label %520
326: ; preds = %5
%327 = load i32, i32* %6
store i32 %327, i32* %12
br label %328
328: ; preds = %351, %326
%329 = load i32, i32* %12
%330 = load i32, i32* %17
%331 = icmp slt i32 %329, %330
br i1 %331, label %332, label %355
332: ; preds = %328
store i32 1, i32* %11
br label %333
333: ; preds = %347, %332
%334 = load i32, i32* %11
%335 = load i32, i32* %16
%336 = icmp slt i32 %334, %335
br i1 %336, label %337, label %350
337: ; preds = %333
%338 = load i32, i32* %11
%339 = load i32, i32* %12
%340 = add nsw i32 %338, %339
%341 = load i32*, i32** %10
%342 = load i32, i32* %13
%343 = sext i32 %342 to i64
%344 = getelementptr inbounds i32, i32* %341, i64 %343
store i32 %340, i32* %344
%345 = load i32, i32* %13
%346 = add nsw i32 %345, 1
store i32 %346, i32* %13
br label %347
347: ; preds = %337
%348 = load i32, i32* %11
%349 = add nsw i32 %348, 1
store i32 %349, i32* %11
br label %333
350: ; preds = %333
br label %351
351: ; preds = %350
%352 = load i32, i32* %6
%353 = load i32, i32* %12
%354 = add nsw i32 %353, %352
store i32 %354, i32* %12
br label %328
355: ; preds = %328
br label %520
356: ; preds = %5
%357 = load i32, i32* %18
store i32 %357, i32* %19
%358 = load i32, i32* %6
store i32 %358, i32* %12
br label %359
359: ; preds = %384, %356
%360 = load i32, i32* %12
%361 = load i32, i32* %17
%362 = icmp slt i32 %360, %361
br i1 %362, label %363, label %388
363: ; preds = %359
store i32 1, i32* %11
br label %364
364: ; preds = %380, %363
%365 = load i32, i32* %11
%366 = load i32, i32* %16
%367 = icmp slt i32 %365, %366
br i1 %367, label %368, label %383
368: ; preds = %364
%369 = load i32, i32* %19
%370 = load i32, i32* %11
%371 = add nsw i32 %369, %370
%372 = load i32, i32* %12
%373 = add nsw i32 %371, %372
%374 = load i32*, i32** %10
%375 = load i32, i32* %13
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds i32, i32* %374, i64 %376
store i32 %373, i32* %377
%378 = load i32, i32* %13
%379 = add nsw i32 %378, 1
store i32 %379, i32* %13
br label %380
380: ; preds = %368
%381 = load i32, i32* %11
%382 = add nsw i32 %381, 1
store i32 %382, i32* %11
br label %364
383: ; preds = %364
br label %384
384: ; preds = %383
%385 = load i32, i32* %6
%386 = load i32, i32* %12
%387 = add nsw i32 %386, %385
store i32 %387, i32* %12
br label %359
388: ; preds = %359
br label %520
389: ; preds = %5
%390 = load i32, i32* %14
store i32 %390, i32* %12
br label %391
391: ; preds = %416, %389
%392 = load i32, i32* %12
%393 = load i32, i32* %18
%394 = icmp slt i32 %392, %393
br i1 %394, label %395, label %420
395: ; preds = %391
%396 = load i32, i32* %6
store i32 %396, i32* %11
br label %397
397: ; preds = %411, %395
%398 = load i32, i32* %11
%399 = load i32, i32* %17
%400 = icmp slt i32 %398, %399
br i1 %400, label %401, label %415
401: ; preds = %397
%402 = load i32, i32* %11
%403 = load i32, i32* %12
%404 = add nsw i32 %402, %403
%405 = load i32*, i32** %10
%406 = load i32, i32* %13
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %405, i64 %407
store i32 %404, i32* %408
%409 = load i32, i32* %13
%410 = add nsw i32 %409, 1
store i32 %410, i32* %13
br label %411
411: ; preds = %401
%412 = load i32, i32* %6
%413 = load i32, i32* %11
%414 = add nsw i32 %413, %412
store i32 %414, i32* %11
br label %397
415: ; preds = %397
br label %416
416: ; preds = %415
%417 = load i32, i32* %14
%418 = load i32, i32* %12
%419 = add nsw i32 %418, %417
store i32 %419, i32* %12
br label %391
420: ; preds = %391
br label %520
421: ; preds = %5
%422 = load i32, i32* %16
store i32 %422, i32* %19
%423 = load i32, i32* %14
store i32 %423, i32* %12
br label %424
424: ; preds = %451, %421
%425 = load i32, i32* %12
%426 = load i32, i32* %18
%427 = icmp slt i32 %425, %426
br i1 %427, label %428, label %455
428: ; preds = %424
%429 = load i32, i32* %6
store i32 %429, i32* %11
br label %430
430: ; preds = %446, %428
%431 = load i32, i32* %11
%432 = load i32, i32* %17
%433 = icmp slt i32 %431, %432
br i1 %433, label %434, label %450
434: ; preds = %430
%435 = load i32, i32* %19
%436 = load i32, i32* %11
%437 = add nsw i32 %435, %436
%438 = load i32, i32* %12
%439 = add nsw i32 %437, %438
%440 = load i32*, i32** %10
%441 = load i32, i32* %13
%442 = sext i32 %441 to i64
%443 = getelementptr inbounds i32, i32* %440, i64 %442
store i32 %439, i32* %443
%444 = load i32, i32* %13
%445 = add nsw i32 %444, 1
store i32 %445, i32* %13
br label %446
446: ; preds = %434
%447 = load i32, i32* %6
%448 = load i32, i32* %11
%449 = add nsw i32 %448, %447
store i32 %449, i32* %11
br label %430
450: ; preds = %430
br label %451
451: ; preds = %450
%452 = load i32, i32* %14
%453 = load i32, i32* %12
%454 = add nsw i32 %453, %452
store i32 %454, i32* %12
br label %424
455: ; preds = %424
br label %520
456: ; preds = %5
%457 = load i32, i32* %14
store i32 %457, i32* %12
br label %458
458: ; preds = %481, %456
%459 = load i32, i32* %12
%460 = load i32, i32* %18
%461 = icmp slt i32 %459, %460
br i1 %461, label %462, label %485
462: ; preds = %458
store i32 1, i32* %11
br label %463
463: ; preds = %477, %462
%464 = load i32, i32* %11
%465 = load i32, i32* %16
%466 = icmp slt i32 %464, %465
br i1 %466, label %467, label %480
467: ; preds = %463
%468 = load i32, i32* %11
%469 = load i32, i32* %12
%470 = add nsw i32 %468, %469
%471 = load i32*, i32** %10
%472 = load i32, i32* %13
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds i32, i32* %471, i64 %473
store i32 %470, i32* %474
%475 = load i32, i32* %13
%476 = add nsw i32 %475, 1
store i32 %476, i32* %13
br label %477
477: ; preds = %467
%478 = load i32, i32* %11
%479 = add nsw i32 %478, 1
store i32 %479, i32* %11
br label %463
480: ; preds = %463
br label %481
481: ; preds = %480
%482 = load i32, i32* %14
%483 = load i32, i32* %12
%484 = add nsw i32 %483, %482
store i32 %484, i32* %12
br label %458
485: ; preds = %458
br label %520
486: ; preds = %5
%487 = load i32, i32* %17
store i32 %487, i32* %19
%488 = load i32, i32* %14
store i32 %488, i32* %12
br label %489
489: ; preds = %514, %486
%490 = load i32, i32* %12
%491 = load i32, i32* %18
%492 = icmp slt i32 %490, %491
br i1 %492, label %493, label %518
493: ; preds = %489
store i32 1, i32* %11
br label %494
494: ; preds = %510, %493
%495 = load i32, i32* %11
%496 = load i32, i32* %16
%497 = icmp slt i32 %495, %496
br i1 %497, label %498, label %513
498: ; preds = %494
%499 = load i32, i32* %19
%500 = load i32, i32* %11
%501 = add nsw i32 %499, %500
%502 = load i32, i32* %12
%503 = add nsw i32 %501, %502
%504 = load i32*, i32** %10
%505 = load i32, i32* %13
%506 = sext i32 %505 to i64
%507 = getelementptr inbounds i32, i32* %504, i64 %506
store i32 %503, i32* %507
%508 = load i32, i32* %13
%509 = add nsw i32 %508, 1
store i32 %509, i32* %13
br label %510
510: ; preds = %498
%511 = load i32, i32* %11
%512 = add nsw i32 %511, 1
store i32 %512, i32* %11
br label %494
513: ; preds = %494
br label %514
514: ; preds = %513
%515 = load i32, i32* %14
%516 = load i32, i32* %12
%517 = add nsw i32 %516, %515
store i32 %517, i32* %12
br label %489
518: ; preds = %489
br label %520
519: ; preds = %5
br label %520
520: ; preds = %519, %518, %485, %455, %420, %388, %355, %325, %301, %279, %257, %238, %214, %192, %170, %151, %129, %109, %89, %68, %62, %56, %52, %46, %42, %38, %35
%521 = load i32, i32* %13
ret i32 %521
}

LLVM IR (-O2):
define i32 @boundary_offset(i32 %0, i32 %1, i32 %2, i32 %3, i32* writeonly %4) {
%6 = mul i32 %1, %0
%7 = mul nsw i32 %6, %2
%8 = add i32 %0, -1
%9 = sub i32 %6, %0
%10 = sub i32 %7, %6
switch i32 %3, label %1665 [
i32 1, label %839
i32 2, label %840
i32 3, label %841
i32 4, label %842
i32 5, label %844
i32 6, label %845
i32 7, label %847
i32 8, label %849
i32 9, label %766
i32 10, label %700
i32 11, label %634
i32 12, label %874
i32 13, label %543
i32 14, label %463
i32 15, label %383
i32 16, label %972
i32 17, label %291
i32 18, label %210
i32 19, label %129
i32 20, label %1084
i32 21, label %109
i32 22, label %89
i32 23, label %70
i32 24, label %51
i32 25, label %31
i32 26, label %11
]
11: ; preds = %5
%12 = icmp slt i32 %6, %10
br i1 %12, label %13, label %1665
13: ; preds = %11
%14 = icmp sgt i32 %0, 2
%15 = add i32 %0, -3
%16 = zext i32 %15 to i64
%17 = add nuw nsw i64 %16, 1
%18 = and i64 %17, 8589934584
%19 = add nsw i64 %18, -8
%20 = lshr exact i64 %19, 3
%21 = add nuw nsw i64 %20, 1
%22 = icmp ult i32 %15, 7
%23 = and i64 %17, 8589934584
%24 = trunc i64 %23 to i32
%25 = or i32 %24, 1
%26 = and i64 %21, 1
%27 = icmp eq i64 %19, 0
%28 = and i64 %21, 4611686018427387902
%29 = icmp eq i64 %26, 0
%30 = icmp eq i64 %17, %23
br label %1567
31: ; preds = %5
%32 = icmp slt i32 %6, %10
br i1 %32, label %33, label %1665
33: ; preds = %31
%34 = icmp sgt i32 %0, 2
%35 = add i32 %0, -3
%36 = zext i32 %35 to i64
%37 = add nuw nsw i64 %36, 1
%38 = and i64 %37, 8589934584
%39 = add nsw i64 %38, -8
%40 = lshr exact i64 %39, 3
%41 = add nuw nsw i64 %40, 1
%42 = icmp ult i32 %35, 7
%43 = and i64 %37, 8589934584
%44 = trunc i64 %43 to i32
%45 = or i32 %44, 1
%46 = and i64 %41, 1
%47 = icmp eq i64 %39, 0
%48 = and i64 %41, 4611686018427387902
%49 = icmp eq i64 %46, 0
%50 = icmp eq i64 %37, %43
br label %1494
51: ; preds = %5
%52 = icmp slt i32 %6, %10
br i1 %52, label %53, label %1665
53: ; preds = %51
%54 = icmp sgt i32 %9, %0
%55 = shl i32 %0, 1
%56 = call i32 @llvm.smax.i32(i32 %9, i32 %55)
%57 = icmp slt i32 %55, %9
%58 = zext i1 %57 to i32
%59 = or i32 %55, %58
%60 = sub i32 %56, %59
%61 = insertelement <4 x i32> poison, i32 %0, i64 0
%62 = shufflevector <4 x i32> %61, <4 x i32> poison, <4 x i32> zeroinitializer
%63 = insertelement <4 x i32> poison, i32 %0, i64 0
%64 = shufflevector <4 x i32> %63, <4 x i32> poison, <4 x i32> zeroinitializer
%65 = mul <4 x i32> %64, <i32 0, i32 1, i32 2, i32 3>
%66 = add <4 x i32> %62, %65
%67 = shl i32 %0, 2
%68 = insertelement <4 x i32> poison, i32 %67, i64 0
%69 = shufflevector <4 x i32> %68, <4 x i32> poison, <4 x i32> zeroinitializer
br label %1407
70: ; preds = %5
%71 = icmp slt i32 %6, %10
br i1 %71, label %72, label %1665
72: ; preds = %70
%73 = icmp sgt i32 %9, %0
%74 = shl i32 %0, 1
%75 = call i32 @llvm.smax.i32(i32 %9, i32 %74)
%76 = icmp slt i32 %74, %9
%77 = zext i1 %76 to i32
%78 = or i32 %74, %77
%79 = sub i32 %75, %78
%80 = insertelement <4 x i32> poison, i32 %0, i64 0
%81 = shufflevector <4 x i32> %80, <4 x i32> poison, <4 x i32> zeroinitializer
%82 = insertelement <4 x i32> poison, i32 %0, i64 0
%83 = shufflevector <4 x i32> %82, <4 x i32> poison, <4 x i32> zeroinitializer
%84 = mul <4 x i32> %83, <i32 0, i32 1, i32 2, i32 3>
%85 = add <4 x i32> %81, %84
%86 = shl i32 %0, 2
%87 = insertelement <4 x i32> poison, i32 %86, i64 0
%88 = shufflevector <4 x i32> %87, <4 x i32> poison, <4 x i32> zeroinitializer
br label %1321
89: ; preds = %5
%90 = icmp sgt i32 %9, %0
br i1 %90, label %91, label %1665
91: ; preds = %89
%92 = icmp sgt i32 %0, 2
%93 = add i32 %0, -3
%94 = zext i32 %93 to i64
%95 = add nuw nsw i64 %94, 1
%96 = and i64 %95, 8589934584
%97 = add nsw i64 %96, -8
%98 = lshr exact i64 %97, 3
%99 = add nuw nsw i64 %98, 1
%100 = icmp ult i32 %93, 7
%101 = and i64 %95, 8589934584
%102 = trunc i64 %101 to i32
%103 = or i32 %102, 1
%104 = and i64 %99, 1
%105 = icmp eq i64 %97, 0
%106 = and i64 %99, 4611686018427387902
%107 = icmp eq i64 %104, 0
%108 = icmp eq i64 %95, %101
br label %1247
109: ; preds = %5
%110 = icmp sgt i32 %9, %0
br i1 %110, label %111, label %1665
111: ; preds = %109
%112 = icmp sgt i32 %0, 2
%113 = add i32 %0, -3
%114 = zext i32 %113 to i64
%115 = add nuw nsw i64 %114, 1
%116 = and i64 %115, 8589934584
%117 = add nsw i64 %116, -8
%118 = lshr exact i64 %117, 3
%119 = add nuw nsw i64 %118, 1
%120 = icmp ult i32 %113, 7
%121 = and i64 %115, 8589934584
%122 = trunc i64 %121 to i32
%123 = or i32 %122, 1
%124 = and i64 %119, 1
%125 = icmp eq i64 %117, 0
%126 = and i64 %119, 4611686018427387902
%127 = icmp eq i64 %124, 0
%128 = icmp eq i64 %115, %121
br label %1174
129: ; preds = %5
%130 = icmp slt i32 %6, %10
br i1 %130, label %131, label %1665
131: ; preds = %129
%132 = mul i32 %1, %0
%133 = shl i32 %132, 1
%134 = call i32 @llvm.smax.i32(i32 %10, i32 %133)
%135 = sub i32 %134, %133
%136 = icmp ne i32 %135, 0
%137 = zext i1 %136 to i32
%138 = sub i32 %135, %137
%139 = udiv i32 %138, %6
%140 = add i32 %139, %137
%141 = zext i32 %140 to i64
%142 = add nuw nsw i64 %141, 1
%143 = icmp ult i32 %140, 7
br i1 %143, label %207, label %144
144: ; preds = %131
%145 = and i64 %142, 8589934584
%146 = trunc i64 %145 to i32
%147 = mul i32 %6, %146
%148 = add i32 %6, %147
%149 = insertelement <4 x i32> poison, i32 %6, i64 0
%150 = shufflevector <4 x i32> %149, <4 x i32> poison, <4 x i32> zeroinitializer
%151 = insertelement <4 x i32> poison, i32 %6, i64 0
%152 = shufflevector <4 x i32> %151, <4 x i32> poison, <4 x i32> zeroinitializer
%153 = mul <4 x i32> %152, <i32 0, i32 1, i32 2, i32 3>
%154 = add <4 x i32> %150, %153
%155 = shl i32 %6, 2
%156 = insertelement <4 x i32> poison, i32 %155, i64 0
%157 = shufflevector <4 x i32> %156, <4 x i32> poison, <4 x i32> zeroinitializer
%158 = insertelement <4 x i32> poison, i32 %9, i64 0
%159 = shufflevector <4 x i32> %158, <4 x i32> poison, <4 x i32> zeroinitializer
%160 = insertelement <4 x i32> poison, i32 %9, i64 0
%161 = shufflevector <4 x i32> %160, <4 x i32> poison, <4 x i32> zeroinitializer
%162 = add nsw i64 %145, -8
%163 = lshr exact i64 %162, 3
%164 = add nuw nsw i64 %163, 1
%165 = and i64 %164, 1
%166 = icmp eq i64 %162, 0
br i1 %166, label %193, label %167
167: ; preds = %144
%168 = and i64 %164, 4611686018427387902
br label %169
169: ; preds = %169, %167
%170 = phi i64 [ 0, %167 ], [ %189, %169 ]
%171 = phi <4 x i32> [ %154, %167 ], [ %190, %169 ]
%172 = phi i64 [ 0, %167 ], [ %191, %169 ]
%173 = add <4 x i32> %171, %157
%174 = add nsw <4 x i32> %171, %159
%175 = add nsw <4 x i32> %173, %161
%176 = getelementptr inbounds i32, i32* %4, i64 %170
%177 = bitcast i32* %176 to <4 x i32>*
store <4 x i32> %174, <4 x i32>* %177
%178 = getelementptr inbounds i32, i32* %176, i64 4
%179 = bitcast i32* %178 to <4 x i32>*
store <4 x i32> %175, <4 x i32>* %179
%180 = or i64 %170, 8
%181 = add <4 x i32> %173, %157
%182 = add <4 x i32> %181, %157
%183 = add nsw <4 x i32> %181, %159
%184 = add nsw <4 x i32> %182, %161
%185 = getelementptr inbounds i32, i32* %4, i64 %180
%186 = bitcast i32* %185 to <4 x i32>*
store <4 x i32> %183, <4 x i32>* %186
%187 = getelementptr inbounds i32, i32* %185, i64 4
%188 = bitcast i32* %187 to <4 x i32>*
store <4 x i32> %184, <4 x i32>* %188
%189 = add nuw i64 %170, 16
%190 = add <4 x i32> %182, %157
%191 = add i64 %172, 2
%192 = icmp eq i64 %191, %168
br i1 %192, label %193, label %169
193: ; preds = %169, %144
%194 = phi i64 [ 0, %144 ], [ %189, %169 ]
%195 = phi <4 x i32> [ %154, %144 ], [ %190, %169 ]
%196 = icmp eq i64 %165, 0
br i1 %196, label %205, label %197
197: ; preds = %193
%198 = add <4 x i32> %195, %157
%199 = add nsw <4 x i32> %195, %159
%200 = add nsw <4 x i32> %198, %161
%201 = getelementptr inbounds i32, i32* %4, i64 %194
%202 = bitcast i32* %201 to <4 x i32>*
store <4 x i32> %199, <4 x i32>* %202
%203 = getelementptr inbounds i32, i32* %201, i64 4
%204 = bitcast i32* %203 to <4 x i32>*
store <4 x i32> %200, <4 x i32>* %204
br label %205
205: ; preds = %193, %197
%206 = icmp eq i64 %142, %145
br i1 %206, label %1659, label %207
207: ; preds = %131, %205
%208 = phi i64 [ 0, %131 ], [ %145, %205 ]
%209 = phi i32 [ %6, %131 ], [ %148, %205 ]
br label %1076
210: ; preds = %5
%211 = icmp slt i32 %6, %10
br i1 %211, label %212, label %1665
212: ; preds = %210
%213 = mul i32 %1, %0
%214 = shl i32 %213, 1
%215 = call i32 @llvm.smax.i32(i32 %10, i32 %214)
%216 = sub i32 %215, %214
%217 = icmp ne i32 %216, 0
%218 = zext i1 %217 to i32
%219 = sub i32 %216, %218
%220 = udiv i32 %219, %6
%221 = add i32 %220, %218
%222 = zext i32 %221 to i64
%223 = add nuw nsw i64 %222, 1
%224 = icmp ult i32 %221, 7
br i1 %224, label %288, label %225
225: ; preds = %212
%226 = and i64 %223, 8589934584
%227 = trunc i64 %226 to i32
%228 = mul i32 %6, %227
%229 = add i32 %6, %228
%230 = insertelement <4 x i32> poison, i32 %6, i64 0
%231 = shufflevector <4 x i32> %230, <4 x i32> poison, <4 x i32> zeroinitializer
%232 = insertelement <4 x i32> poison, i32 %6, i64 0
%233 = shufflevector <4 x i32> %232, <4 x i32> poison, <4 x i32> zeroinitializer
%234 = mul <4 x i32> %233, <i32 0, i32 1, i32 2, i32 3>
%235 = add <4 x i32> %231, %234
%236 = shl i32 %6, 2
%237 = insertelement <4 x i32> poison, i32 %236, i64 0
%238 = shufflevector <4 x i32> %237, <4 x i32> poison, <4 x i32> zeroinitializer
%239 = insertelement <4 x i32> poison, i32 %8, i64 0
%240 = shufflevector <4 x i32> %239, <4 x i32> poison, <4 x i32> zeroinitializer
%241 = insertelement <4 x i32> poison, i32 %8, i64 0
%242 = shufflevector <4 x i32> %241, <4 x i32> poison, <4 x i32> zeroinitializer
%243 = add nsw i64 %226, -8
%244 = lshr exact i64 %243, 3
%245 = add nuw nsw i64 %244, 1
%246 = and i64 %245, 1
%247 = icmp eq i64 %243, 0
br i1 %247, label %274, label %248
248: ; preds = %225
%249 = and i64 %245, 4611686018427387902
br label %250
250: ; preds = %250, %248
%251 = phi i64 [ 0, %248 ], [ %270, %250 ]
%252 = phi <4 x i32> [ %235, %248 ], [ %271, %250 ]
%253 = phi i64 [ 0, %248 ], [ %272, %250 ]
%254 = add <4 x i32> %252, %238
%255 = add nsw <4 x i32> %252, %240
%256 = add nsw <4 x i32> %254, %242
%257 = getelementptr inbounds i32, i32* %4, i64 %251
%258 = bitcast i32* %257 to <4 x i32>*
store <4 x i32> %255, <4 x i32>* %258
%259 = getelementptr inbounds i32, i32* %257, i64 4
%260 = bitcast i32* %259 to <4 x i32>*
store <4 x i32> %256, <4 x i32>* %260
%261 = or i64 %251, 8
%262 = add <4 x i32> %254, %238
%263 = add <4 x i32> %262, %238
%264 = add nsw <4 x i32> %262, %240
%265 = add nsw <4 x i32> %263, %242
%266 = getelementptr inbounds i32, i32* %4, i64 %261
%267 = bitcast i32* %266 to <4 x i32>*
store <4 x i32> %264, <4 x i32>* %267
%268 = getelementptr inbounds i32, i32* %266, i64 4
%269 = bitcast i32* %268 to <4 x i32>*
store <4 x i32> %265, <4 x i32>* %269
%270 = add nuw i64 %251, 16
%271 = add <4 x i32> %263, %238
%272 = add i64 %253, 2
%273 = icmp eq i64 %272, %249
br i1 %273, label %274, label %250
274: ; preds = %250, %225
%275 = phi i64 [ 0, %225 ], [ %270, %250 ]
%276 = phi <4 x i32> [ %235, %225 ], [ %271, %250 ]
%277 = icmp eq i64 %246, 0
br i1 %277, label %286, label %278
278: ; preds = %274
%279 = add <4 x i32> %276, %238
%280 = add nsw <4 x i32> %276, %240
%281 = add nsw <4 x i32> %279, %242
%282 = getelementptr inbounds i32, i32* %4, i64 %275
%283 = bitcast i32* %282 to <4 x i32>*
store <4 x i32> %280, <4 x i32>* %283
%284 = getelementptr inbounds i32, i32* %282, i64 4
%285 = bitcast i32* %284 to <4 x i32>*
store <4 x i32> %281, <4 x i32>* %285
br label %286
286: ; preds = %274, %278
%287 = icmp eq i64 %223, %226
br i1 %287, label %1656, label %288
288: ; preds = %212, %286
%289 = phi i64 [ 0, %212 ], [ %226, %286 ]
%290 = phi i32 [ %6, %212 ], [ %229, %286 ]
br label %1068
291: ; preds = %5
%292 = icmp slt i32 %6, %10
br i1 %292, label %293, label %1665
293: ; preds = %291
%294 = mul i32 %1, %0
%295 = shl i32 %294, 1
%296 = call i32 @llvm.smax.i32(i32 %10, i32 %295)
%297 = sub i32 %296, %295
%298 = icmp ne i32 %297, 0
%299 = zext i1 %298 to i32
%300 = sub i32 %297, %299
%301 = udiv i32 %300, %6
%302 = add i32 %301, %299
%303 = zext i32 %302 to i64
%304 = add nuw nsw i64 %303, 1
%305 = icmp ult i32 %302, 7
br i1 %305, label %380, label %306
306: ; preds = %293
%307 = and i64 %304, 8589934584
%308 = trunc i64 %307 to i32
%309 = mul i32 %6, %308
%310 = add i32 %6, %309
%311 = insertelement <4 x i32> poison, i32 %6, i64 0
%312 = shufflevector <4 x i32> %311, <4 x i32> poison, <4 x i32> zeroinitializer
%313 = insertelement <4 x i32> poison, i32 %6, i64 0
%314 = shufflevector <4 x i32> %313, <4 x i32> poison, <4 x i32> zeroinitializer
%315 = mul <4 x i32> %314, <i32 0, i32 1, i32 2, i32 3>
%316 = add <4 x i32> %312, %315
%317 = shl i32 %6, 2
%318 = insertelement <4 x i32> poison, i32 %317, i64 0
%319 = shufflevector <4 x i32> %318, <4 x i32> poison, <4 x i32> zeroinitializer
%320 = add nsw i64 %307, -8
%321 = lshr exact i64 %320, 3
%322 = add nuw nsw i64 %321, 1
%323 = and i64 %322, 3
%324 = icmp ult i64 %320, 24
br i1 %324, label %361, label %325
325: ; preds = %306
%326 = and i64 %322, 4611686018427387900
br label %327
327: ; preds = %327, %325
%328 = phi i64 [ 0, %325 ], [ %357, %327 ]
%329 = phi <4 x i32> [ %316, %325 ], [ %358, %327 ]
%330 = phi i64 [ 0, %325 ], [ %359, %327 ]
%331 = add <4 x i32> %329, %319
%332 = getelementptr inbounds i32, i32* %4, i64 %328
%333 = bitcast i32* %332 to <4 x i32>*
store <4 x i32> %329, <4 x i32>* %333
%334 = getelementptr inbounds i32, i32* %332, i64 4
%335 = bitcast i32* %334 to <4 x i32>*
store <4 x i32> %331, <4 x i32>* %335
%336 = or i64 %328, 8
%337 = add <4 x i32> %331, %319
%338 = add <4 x i32> %337, %319
%339 = getelementptr inbounds i32, i32* %4, i64 %336
%340 = bitcast i32* %339 to <4 x i32>*
store <4 x i32> %337, <4 x i32>* %340
%341 = getelementptr inbounds i32, i32* %339, i64 4
%342 = bitcast i32* %341 to <4 x i32>*
store <4 x i32> %338, <4 x i32>* %342
%343 = or i64 %328, 16
%344 = add <4 x i32> %338, %319
%345 = add <4 x i32> %344, %319
%346 = getelementptr inbounds i32, i32* %4, i64 %343
%347 = bitcast i32* %346 to <4 x i32>*
store <4 x i32> %344, <4 x i32>* %347
%348 = getelementptr inbounds i32, i32* %346, i64 4
%349 = bitcast i32* %348 to <4 x i32>*
store <4 x i32> %345, <4 x i32>* %349
%350 = or i64 %328, 24
%351 = add <4 x i32> %345, %319
%352 = add <4 x i32> %351, %319
%353 = getelementptr inbounds i32, i32* %4, i64 %350
%354 = bitcast i32* %353 to <4 x i32>*
store <4 x i32> %351, <4 x i32>* %354
%355 = getelementptr inbounds i32, i32* %353, i64 4
%356 = bitcast i32* %355 to <4 x i32>*
store <4 x i32> %352, <4 x i32>* %356
%357 = add nuw i64 %328, 32
%358 = add <4 x i32> %352, %319
%359 = add i64 %330, 4
%360 = icmp eq i64 %359, %326
br i1 %360, label %361, label %327
361: ; preds = %327, %306
%362 = phi i64 [ 0, %306 ], [ %357, %327 ]
%363 = phi <4 x i32> [ %316, %306 ], [ %358, %327 ]
%364 = icmp eq i64 %323, 0
br i1 %364, label %378, label %365
365: ; preds = %361, %365
%366 = phi i64 [ %374, %365 ], [ %362, %361 ]
%367 = phi <4 x i32> [ %375, %365 ], [ %363, %361 ]
%368 = phi i64 [ %376, %365 ], [ 0, %361 ]
%369 = add <4 x i32> %367, %319
%370 = getelementptr inbounds i32, i32* %4, i64 %366
%371 = bitcast i32* %370 to <4 x i32>*
store <4 x i32> %367, <4 x i32>* %371
%372 = getelementptr inbounds i32, i32* %370, i64 4
%373 = bitcast i32* %372 to <4 x i32>*
store <4 x i32> %369, <4 x i32>* %373
%374 = add nuw i64 %366, 8
%375 = add <4 x i32> %369, %319
%376 = add i64 %368, 1
%377 = icmp eq i64 %376, %323
br i1 %377, label %378, label %365
378: ; preds = %365, %361
%379 = icmp eq i64 %304, %307
br i1 %379, label %1653, label %380
380: ; preds = %293, %378
%381 = phi i64 [ 0, %293 ], [ %307, %378 ]
%382 = phi i32 [ %6, %293 ], [ %310, %378 ]
br label %1061
383: ; preds = %5
%384 = icmp sgt i32 %9, %0
br i1 %384, label %385, label %1665
385: ; preds = %383
%386 = shl i32 %0, 1
%387 = call i32 @llvm.smax.i32(i32 %9, i32 %386)
%388 = icmp slt i32 %386, %9
%389 = zext i1 %388 to i32
%390 = or i32 %386, %389
%391 = sub i32 %387, %390
%392 = udiv i32 %391, %0
%393 = add i32 %392, %389
%394 = zext i32 %393 to i64
%395 = add nuw nsw i64 %394, 1
%396 = icmp ult i32 %393, 7
br i1 %396, label %460, label %397
397: ; preds = %385
%398 = and i64 %395, 8589934584
%399 = trunc i64 %398 to i32
%400 = mul i32 %399, %0
%401 = add i32 %400, %0
%402 = insertelement <4 x i32> poison, i32 %0, i64 0
%403 = shufflevector <4 x i32> %402, <4 x i32> poison, <4 x i32> zeroinitializer
%404 = insertelement <4 x i32> poison, i32 %0, i64 0
%405 = shufflevector <4 x i32> %404, <4 x i32> poison, <4 x i32> zeroinitializer
%406 = mul <4 x i32> %405, <i32 0, i32 1, i32 2, i32 3>
%407 = add <4 x i32> %403, %406
%408 = shl i32 %0, 2
%409 = insertelement <4 x i32> poison, i32 %408, i64 0
%410 = shufflevector <4 x i32> %409, <4 x i32> poison, <4 x i32> zeroinitializer
%411 = insertelement <4 x i32> poison, i32 %10, i64 0
%412 = shufflevector <4 x i32> %411, <4 x i32> poison, <4 x i32> zeroinitializer
%413 = insertelement <4 x i32> poison, i32 %10, i64 0
%414 = shufflevector <4 x i32> %413, <4 x i32> poison, <4 x i32> zeroinitializer
%415 = add nsw i64 %398, -8
%416 = lshr exact i64 %415, 3
%417 = add nuw nsw i64 %416, 1
%418 = and i64 %417, 1
%419 = icmp eq i64 %415, 0
br i1 %419, label %446, label %420
420: ; preds = %397
%421 = and i64 %417, 4611686018427387902
br label %422
422: ; preds = %422, %420
%423 = phi i64 [ 0, %420 ], [ %442, %422 ]
%424 = phi <4 x i32> [ %407, %420 ], [ %443, %422 ]
%425 = phi i64 [ 0, %420 ], [ %444, %422 ]
%426 = add <4 x i32> %424, %410
%427 = add nsw <4 x i32> %424, %412
%428 = add nsw <4 x i32> %426, %414
%429 = getelementptr inbounds i32, i32* %4, i64 %423
%430 = bitcast i32* %429 to <4 x i32>*
store <4 x i32> %427, <4 x i32>* %430
%431 = getelementptr inbounds i32, i32* %429, i64 4
%432 = bitcast i32* %431 to <4 x i32>*
store <4 x i32> %428, <4 x i32>* %432
%433 = or i64 %423, 8
%434 = add <4 x i32> %426, %410
%435 = add <4 x i32> %434, %410
%436 = add nsw <4 x i32> %434, %412
%437 = add nsw <4 x i32> %435, %414
%438 = getelementptr inbounds i32, i32* %4, i64 %433
%439 = bitcast i32* %438 to <4 x i32>*
store <4 x i32> %436, <4 x i32>* %439
%440 = getelementptr inbounds i32, i32* %438, i64 4
%441 = bitcast i32* %440 to <4 x i32>*
store <4 x i32> %437, <4 x i32>* %441
%442 = add nuw i64 %423, 16
%443 = add <4 x i32> %435, %410
%444 = add i64 %425, 2
%445 = icmp eq i64 %444, %421
br i1 %445, label %446, label %422
446: ; preds = %422, %397
%447 = phi i64 [ 0, %397 ], [ %442, %422 ]
%448 = phi <4 x i32> [ %407, %397 ], [ %443, %422 ]
%449 = icmp eq i64 %418, 0
br i1 %449, label %458, label %450
450: ; preds = %446
%451 = add <4 x i32> %448, %410
%452 = add nsw <4 x i32> %448, %412
%453 = add nsw <4 x i32> %451, %414
%454 = getelementptr inbounds i32, i32* %4, i64 %447
%455 = bitcast i32* %454 to <4 x i32>*
store <4 x i32> %452, <4 x i32>* %455
%456 = getelementptr inbounds i32, i32* %454, i64 4
%457 = bitcast i32* %456 to <4 x i32>*
store <4 x i32> %453, <4 x i32>* %457
br label %458
458: ; preds = %446, %450
%459 = icmp eq i64 %395, %398
br i1 %459, label %1647, label %460
460: ; preds = %385, %458
%461 = phi i64 [ 0, %385 ], [ %398, %458 ]
%462 = phi i32 [ %0, %385 ], [ %401, %458 ]
br label %964
463: ; preds = %5
%464 = icmp sgt i32 %9, %0
br i1 %464, label %465, label %1665
465: ; preds = %463
%466 = shl i32 %0, 1
%467 = call i32 @llvm.smax.i32(i32 %9, i32 %466)
%468 = icmp slt i32 %466, %9
%469 = zext i1 %468 to i32
%470 = or i32 %466, %469
%471 = sub i32 %467, %470
%472 = udiv i32 %471, %0
%473 = add i32 %472, %469
%474 = zext i32 %473 to i64
%475 = add nuw nsw i64 %474, 1
%476 = icmp ult i32 %473, 7
br i1 %476, label %540, label %477
477: ; preds = %465
%478 = and i64 %475, 8589934584
%479 = trunc i64 %478 to i32
%480 = mul i32 %479, %0
%481 = add i32 %480, %0
%482 = insertelement <4 x i32> poison, i32 %0, i64 0
%483 = shufflevector <4 x i32> %482, <4 x i32> poison, <4 x i32> zeroinitializer
%484 = insertelement <4 x i32> poison, i32 %0, i64 0
%485 = shufflevector <4 x i32> %484, <4 x i32> poison, <4 x i32> zeroinitializer
%486 = mul <4 x i32> %485, <i32 0, i32 1, i32 2, i32 3>
%487 = add <4 x i32> %483, %486
%488 = shl i32 %0, 2
%489 = insertelement <4 x i32> poison, i32 %488, i64 0
%490 = shufflevector <4 x i32> %489, <4 x i32> poison, <4 x i32> zeroinitializer
%491 = insertelement <4 x i32> poison, i32 %8, i64 0
%492 = shufflevector <4 x i32> %491, <4 x i32> poison, <4 x i32> zeroinitializer
%493 = insertelement <4 x i32> poison, i32 %8, i64 0
%494 = shufflevector <4 x i32> %493, <4 x i32> poison, <4 x i32> zeroinitializer
%495 = add nsw i64 %478, -8
%496 = lshr exact i64 %495, 3
%497 = add nuw nsw i64 %496, 1
%498 = and i64 %497, 1
%499 = icmp eq i64 %495, 0
br i1 %499, label %526, label %500
500: ; preds = %477
%501 = and i64 %497, 4611686018427387902
br label %502
502: ; preds = %502, %500
%503 = phi i64 [ 0, %500 ], [ %522, %502 ]
%504 = phi <4 x i32> [ %487, %500 ], [ %523, %502 ]
%505 = phi i64 [ 0, %500 ], [ %524, %502 ]
%506 = add <4 x i32> %504, %490
%507 = add nsw <4 x i32> %504, %492
%508 = add nsw <4 x i32> %506, %494
%509 = getelementptr inbounds i32, i32* %4, i64 %503
%510 = bitcast i32* %509 to <4 x i32>*
store <4 x i32> %507, <4 x i32>* %510
%511 = getelementptr inbounds i32, i32* %509, i64 4
%512 = bitcast i32* %511 to <4 x i32>*
store <4 x i32> %508, <4 x i32>* %512
%513 = or i64 %503, 8
%514 = add <4 x i32> %506, %490
%515 = add <4 x i32> %514, %490
%516 = add nsw <4 x i32> %514, %492
%517 = add nsw <4 x i32> %515, %494
%518 = getelementptr inbounds i32, i32* %4, i64 %513
%519 = bitcast i32* %518 to <4 x i32>*
store <4 x i32> %516, <4 x i32>* %519
%520 = getelementptr inbounds i32, i32* %518, i64 4
%521 = bitcast i32* %520 to <4 x i32>*
store <4 x i32> %517, <4 x i32>* %521
%522 = add nuw i64 %503, 16
%523 = add <4 x i32> %515, %490
%524 = add i64 %505, 2
%525 = icmp eq i64 %524, %501
br i1 %525, label %526, label %502
526: ; preds = %502, %477
%527 = phi i64 [ 0, %477 ], [ %522, %502 ]
%528 = phi <4 x i32> [ %487, %477 ], [ %523, %502 ]
%529 = icmp eq i64 %498, 0
br i1 %529, label %538, label %530
530: ; preds = %526
%531 = add <4 x i32> %528, %490
%532 = add nsw <4 x i32> %528, %492
%533 = add nsw <4 x i32> %531, %494
%534 = getelementptr inbounds i32, i32* %4, i64 %527
%535 = bitcast i32* %534 to <4 x i32>*
store <4 x i32> %532, <4 x i32>* %535
%536 = getelementptr inbounds i32, i32* %534, i64 4
%537 = bitcast i32* %536 to <4 x i32>*
store <4 x i32> %533, <4 x i32>* %537
br label %538
538: ; preds = %526, %530
%539 = icmp eq i64 %475, %478
br i1 %539, label %1644, label %540
540: ; preds = %465, %538
%541 = phi i64 [ 0, %465 ], [ %478, %538 ]
%542 = phi i32 [ %0, %465 ], [ %481, %538 ]
br label %956
543: ; preds = %5
%544 = icmp sgt i32 %9, %0
br i1 %544, label %545, label %1665
545: ; preds = %543
%546 = shl i32 %0, 1
%547 = call i32 @llvm.smax.i32(i32 %9, i32 %546)
%548 = icmp slt i32 %546, %9
%549 = zext i1 %548 to i32
%550 = or i32 %546, %549
%551 = sub i32 %547, %550
%552 = udiv i32 %551, %0
%553 = add i32 %552, %549
%554 = zext i32 %553 to i64
%555 = add nuw nsw i64 %554, 1
%556 = icmp ult i32 %553, 7
br i1 %556, label %631, label %557
557: ; preds = %545
%558 = and i64 %555, 8589934584
%559 = trunc i64 %558 to i32
%560 = mul i32 %559, %0
%561 = add i32 %560, %0
%562 = insertelement <4 x i32> poison, i32 %0, i64 0
%563 = shufflevector <4 x i32> %562, <4 x i32> poison, <4 x i32> zeroinitializer
%564 = insertelement <4 x i32> poison, i32 %0, i64 0
%565 = shufflevector <4 x i32> %564, <4 x i32> poison, <4 x i32> zeroinitializer
%566 = mul <4 x i32> %565, <i32 0, i32 1, i32 2, i32 3>
%567 = add <4 x i32> %563, %566
%568 = shl i32 %0, 2
%569 = insertelement <4 x i32> poison, i32 %568, i64 0
%570 = shufflevector <4 x i32> %569, <4 x i32> poison, <4 x i32> zeroinitializer
%571 = add nsw i64 %558, -8
%572 = lshr exact i64 %571, 3
%573 = add nuw nsw i64 %572, 1
%574 = and i64 %573, 3
%575 = icmp ult i64 %571, 24
br i1 %575, label %612, label %576
576: ; preds = %557
%577 = and i64 %573, 4611686018427387900
br label %578
578: ; preds = %578, %576
%579 = phi i64 [ 0, %576 ], [ %608, %578 ]
%580 = phi <4 x i32> [ %567, %576 ], [ %609, %578 ]
%581 = phi i64 [ 0, %576 ], [ %610, %578 ]
%582 = add <4 x i32> %580, %570
%583 = getelementptr inbounds i32, i32* %4, i64 %579
%584 = bitcast i32* %583 to <4 x i32>*
store <4 x i32> %580, <4 x i32>* %584
%585 = getelementptr inbounds i32, i32* %583, i64 4
%586 = bitcast i32* %585 to <4 x i32>*
store <4 x i32> %582, <4 x i32>* %586
%587 = or i64 %579, 8
%588 = add <4 x i32> %582, %570
%589 = add <4 x i32> %588, %570
%590 = getelementptr inbounds i32, i32* %4, i64 %587
%591 = bitcast i32* %590 to <4 x i32>*
store <4 x i32> %588, <4 x i32>* %591
%592 = getelementptr inbounds i32, i32* %590, i64 4
%593 = bitcast i32* %592 to <4 x i32>*
store <4 x i32> %589, <4 x i32>* %593
%594 = or i64 %579, 16
%595 = add <4 x i32> %589, %570
%596 = add <4 x i32> %595, %570
%597 = getelementptr inbounds i32, i32* %4, i64 %594
%598 = bitcast i32* %597 to <4 x i32>*
store <4 x i32> %595, <4 x i32>* %598
%599 = getelementptr inbounds i32, i32* %597, i64 4
%600 = bitcast i32* %599 to <4 x i32>*
store <4 x i32> %596, <4 x i32>* %600
%601 = or i64 %579, 24
%602 = add <4 x i32> %596, %570
%603 = add <4 x i32> %602, %570
%604 = getelementptr inbounds i32, i32* %4, i64 %601
%605 = bitcast i32* %604 to <4 x i32>*
store <4 x i32> %602, <4 x i32>* %605
%606 = getelementptr inbounds i32, i32* %604, i64 4
%607 = bitcast i32* %606 to <4 x i32>*
store <4 x i32> %603, <4 x i32>* %607
%608 = add nuw i64 %579, 32
%609 = add <4 x i32> %603, %570
%610 = add i64 %581, 4
%611 = icmp eq i64 %610, %577
br i1 %611, label %612, label %578
612: ; preds = %578, %557
%613 = phi i64 [ 0, %557 ], [ %608, %578 ]
%614 = phi <4 x i32> [ %567, %557 ], [ %609, %578 ]
%615 = icmp eq i64 %574, 0
br i1 %615, label %629, label %616
616: ; preds = %612, %616
%617 = phi i64 [ %625, %616 ], [ %613, %612 ]
%618 = phi <4 x i32> [ %626, %616 ], [ %614, %612 ]
%619 = phi i64 [ %627, %616 ], [ 0, %612 ]
%620 = add <4 x i32> %618, %570
%621 = getelementptr inbounds i32, i32* %4, i64 %617
%622 = bitcast i32* %621 to <4 x i32>*
store <4 x i32> %618, <4 x i32>* %622
%623 = getelementptr inbounds i32, i32* %621, i64 4
%624 = bitcast i32* %623 to <4 x i32>*
store <4 x i32> %620, <4 x i32>* %624
%625 = add nuw i64 %617, 8
%626 = add <4 x i32> %620, %570
%627 = add i64 %619, 1
%628 = icmp eq i64 %627, %574
br i1 %628, label %629, label %616
629: ; preds = %616, %612
%630 = icmp eq i64 %555, %558
br i1 %630, label %1641, label %631
631: ; preds = %545, %629
%632 = phi i64 [ 0, %545 ], [ %558, %629 ]
%633 = phi i32 [ %0, %545 ], [ %561, %629 ]
br label %949
634: ; preds = %5
%635 = icmp sgt i32 %0, 2
br i1 %635, label %636, label %1665
636: ; preds = %634
%637 = add nsw i32 %0, -2
%638 = zext i32 %637 to i64
%639 = icmp ult i32 %637, 8
br i1 %639, label %697, label %640
640: ; preds = %636
%641 = and i64 %638, 4294967288
%642 = trunc i64 %641 to i32
%643 = or i32 %642, 1
%644 = insertelement <4 x i32> poison, i32 %10, i64 0
%645 = shufflevector <4 x i32> %644, <4 x i32> poison, <4 x i32> zeroinitializer
%646 = add nsw i64 %641, -8
%647 = lshr exact i64 %646, 3
%648 = add nuw nsw i64 %647, 1
%649 = and i64 %648, 1
%650 = icmp eq i64 %646, 0
br i1 %650, label %681, label %651
651: ; preds = %640
%652 = and i64 %648, 4611686018427387902
%653 = add i32 %10, 4
%654 = insertelement <4 x i32> poison, i32 %653, i64 0
%655 = shufflevector <4 x i32> %654, <4 x i32> poison, <4 x i32> zeroinitializer
%656 = add i32 %10, 4
%657 = insertelement <4 x i32> poison, i32 %656, i64 0
%658 = shufflevector <4 x i32> %657, <4 x i32> poison, <4 x i32> zeroinitializer
br label %659
659: ; preds = %659, %651
%660 = phi i64 [ 0, %651 ], [ %677, %659 ]
%661 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %651 ], [ %678, %659 ]
%662 = phi i64 [ 0, %651 ], [ %679, %659 ]
%663 = add nsw <4 x i32> %661, %645
%664 = add <4 x i32> %655, %661
%665 = getelementptr inbounds i32, i32* %4, i64 %660
%666 = bitcast i32* %665 to <4 x i32>*
store <4 x i32> %663, <4 x i32>* %666
%667 = getelementptr inbounds i32, i32* %665, i64 4
%668 = bitcast i32* %667 to <4 x i32>*
store <4 x i32> %664, <4 x i32>* %668
%669 = or i64 %660, 8
%670 = add <4 x i32> %661, <i32 8, i32 8, i32 8, i32 8>
%671 = add nsw <4 x i32> %670, %645
%672 = add <4 x i32> %658, %670
%673 = getelementptr inbounds i32, i32* %4, i64 %669
%674 = bitcast i32* %673 to <4 x i32>*
store <4 x i32> %671, <4 x i32>* %674
%675 = getelementptr inbounds i32, i32* %673, i64 4
%676 = bitcast i32* %675 to <4 x i32>*
store <4 x i32> %672, <4 x i32>* %676
%677 = add nuw i64 %660, 16
%678 = add <4 x i32> %661, <i32 16, i32 16, i32 16, i32 16>
%679 = add i64 %662, 2
%680 = icmp eq i64 %679, %652
br i1 %680, label %681, label %659
681: ; preds = %659, %640
%682 = phi i64 [ 0, %640 ], [ %677, %659 ]
%683 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %640 ], [ %678, %659 ]
%684 = icmp eq i64 %649, 0
br i1 %684, label %695, label %685
685: ; preds = %681
%686 = add nsw <4 x i32> %683, %645
%687 = add i32 %10, 4
%688 = insertelement <4 x i32> poison, i32 %687, i64 0
%689 = shufflevector <4 x i32> %688, <4 x i32> poison, <4 x i32> zeroinitializer
%690 = add <4 x i32> %689, %683
%691 = getelementptr inbounds i32, i32* %4, i64 %682
%692 = bitcast i32* %691 to <4 x i32>*
store <4 x i32> %686, <4 x i32>* %692
%693 = getelementptr inbounds i32, i32* %691, i64 4
%694 = bitcast i32* %693 to <4 x i32>*
store <4 x i32> %690, <4 x i32>* %694
br label %695
695: ; preds = %681, %685
%696 = icmp eq i64 %641, %638
br i1 %696, label %1665, label %697
697: ; preds = %636, %695
%698 = phi i64 [ 0, %636 ], [ %641, %695 ]
%699 = phi i32 [ 1, %636 ], [ %643, %695 ]
br label %866
700: ; preds = %5
%701 = icmp sgt i32 %0, 2
br i1 %701, label %702, label %1665
702: ; preds = %700
%703 = add nsw i32 %0, -2
%704 = zext i32 %703 to i64
%705 = icmp ult i32 %703, 8
br i1 %705, label %763, label %706
706: ; preds = %702
%707 = and i64 %704, 4294967288
%708 = trunc i64 %707 to i32
%709 = or i32 %708, 1
%710 = insertelement <4 x i32> poison, i32 %9, i64 0
%711 = shufflevector <4 x i32> %710, <4 x i32> poison, <4 x i32> zeroinitializer
%712 = add nsw i64 %707, -8
%713 = lshr exact i64 %712, 3
%714 = add nuw nsw i64 %713, 1
%715 = and i64 %714, 1
%716 = icmp eq i64 %712, 0
br i1 %716, label %747, label %717
717: ; preds = %706
%718 = and i64 %714, 4611686018427387902
%719 = add i32 %9, 4
%720 = insertelement <4 x i32> poison, i32 %719, i64 0
%721 = shufflevector <4 x i32> %720, <4 x i32> poison, <4 x i32> zeroinitializer
%722 = add i32 %9, 4
%723 = insertelement <4 x i32> poison, i32 %722, i64 0
%724 = shufflevector <4 x i32> %723, <4 x i32> poison, <4 x i32> zeroinitializer
br label %725
725: ; preds = %725, %717
%726 = phi i64 [ 0, %717 ], [ %743, %725 ]
%727 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %717 ], [ %744, %725 ]
%728 = phi i64 [ 0, %717 ], [ %745, %725 ]
%729 = add nsw <4 x i32> %727, %711
%730 = add <4 x i32> %721, %727
%731 = getelementptr inbounds i32, i32* %4, i64 %726
%732 = bitcast i32* %731 to <4 x i32>*
store <4 x i32> %729, <4 x i32>* %732
%733 = getelementptr inbounds i32, i32* %731, i64 4
%734 = bitcast i32* %733 to <4 x i32>*
store <4 x i32> %730, <4 x i32>* %734
%735 = or i64 %726, 8
%736 = add <4 x i32> %727, <i32 8, i32 8, i32 8, i32 8>
%737 = add nsw <4 x i32> %736, %711
%738 = add <4 x i32> %724, %736
%739 = getelementptr inbounds i32, i32* %4, i64 %735
%740 = bitcast i32* %739 to <4 x i32>*
store <4 x i32> %737, <4 x i32>* %740
%741 = getelementptr inbounds i32, i32* %739, i64 4
%742 = bitcast i32* %741 to <4 x i32>*
store <4 x i32> %738, <4 x i32>* %742
%743 = add nuw i64 %726, 16
%744 = add <4 x i32> %727, <i32 16, i32 16, i32 16, i32 16>
%745 = add i64 %728, 2
%746 = icmp eq i64 %745, %718
br i1 %746, label %747, label %725
747: ; preds = %725, %706
%748 = phi i64 [ 0, %706 ], [ %743, %725 ]
%749 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %706 ], [ %744, %725 ]
%750 = icmp eq i64 %715, 0
br i1 %750, label %761, label %751
751: ; preds = %747
%752 = add nsw <4 x i32> %749, %711
%753 = add i32 %9, 4
%754 = insertelement <4 x i32> poison, i32 %753, i64 0
%755 = shufflevector <4 x i32> %754, <4 x i32> poison, <4 x i32> zeroinitializer
%756 = add <4 x i32> %755, %749
%757 = getelementptr inbounds i32, i32* %4, i64 %748
%758 = bitcast i32* %757 to <4 x i32>*
store <4 x i32> %752, <4 x i32>* %758
%759 = getelementptr inbounds i32, i32* %757, i64 4
%760 = bitcast i32* %759 to <4 x i32>*
store <4 x i32> %756, <4 x i32>* %760
br label %761
761: ; preds = %747, %751
%762 = icmp eq i64 %707, %704
br i1 %762, label %1665, label %763
763: ; preds = %702, %761
%764 = phi i64 [ 0, %702 ], [ %707, %761 ]
%765 = phi i32 [ 1, %702 ], [ %709, %761 ]
br label %858
766: ; preds = %5
%767 = icmp sgt i32 %0, 2
br i1 %767, label %768, label %1665
768: ; preds = %766
%769 = add nsw i32 %0, -2
%770 = zext i32 %769 to i64
%771 = icmp ult i32 %769, 8
br i1 %771, label %836, label %772
772: ; preds = %768
%773 = and i64 %770, 4294967288
%774 = trunc i64 %773 to i32
%775 = or i32 %774, 1
%776 = add nsw i64 %773, -8
%777 = lshr exact i64 %776, 3
%778 = add nuw nsw i64 %777, 1
%779 = and i64 %778, 3
%780 = icmp ult i64 %776, 24
br i1 %780, label %817, label %781
781: ; preds = %772
%782 = and i64 %778, 4611686018427387900
br label %783
783: ; preds = %783, %781
%784 = phi i64 [ 0, %781 ], [ %813, %783 ]
%785 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %781 ], [ %814, %783 ]
%786 = phi i64 [ 0, %781 ], [ %815, %783 ]
%787 = add <4 x i32> %785, <i32 4, i32 4, i32 4, i32 4>
%788 = getelementptr inbounds i32, i32* %4, i64 %784
%789 = bitcast i32* %788 to <4 x i32>*
store <4 x i32> %785, <4 x i32>* %789
%790 = getelementptr inbounds i32, i32* %788, i64 4
%791 = bitcast i32* %790 to <4 x i32>*
store <4 x i32> %787, <4 x i32>* %791
%792 = or i64 %784, 8
%793 = add <4 x i32> %785, <i32 8, i32 8, i32 8, i32 8>
%794 = add <4 x i32> %785, <i32 12, i32 12, i32 12, i32 12>
%795 = getelementptr inbounds i32, i32* %4, i64 %792
%796 = bitcast i32* %795 to <4 x i32>*
store <4 x i32> %793, <4 x i32>* %796
%797 = getelementptr inbounds i32, i32* %795, i64 4
%798 = bitcast i32* %797 to <4 x i32>*
store <4 x i32> %794, <4 x i32>* %798
%799 = or i64 %784, 16
%800 = add <4 x i32> %785, <i32 16, i32 16, i32 16, i32 16>
%801 = add <4 x i32> %785, <i32 20, i32 20, i32 20, i32 20>
%802 = getelementptr inbounds i32, i32* %4, i64 %799
%803 = bitcast i32* %802 to <4 x i32>*
store <4 x i32> %800, <4 x i32>* %803
%804 = getelementptr inbounds i32, i32* %802, i64 4
%805 = bitcast i32* %804 to <4 x i32>*
store <4 x i32> %801, <4 x i32>* %805
%806 = or i64 %784, 24
%807 = add <4 x i32> %785, <i32 24, i32 24, i32 24, i32 24>
%808 = add <4 x i32> %785, <i32 28, i32 28, i32 28, i32 28>
%809 = getelementptr inbounds i32, i32* %4, i64 %806
%810 = bitcast i32* %809 to <4 x i32>*
store <4 x i32> %807, <4 x i32>* %810
%811 = getelementptr inbounds i32, i32* %809, i64 4
%812 = bitcast i32* %811 to <4 x i32>*
store <4 x i32> %808, <4 x i32>* %812
%813 = add nuw i64 %784, 32
%814 = add <4 x i32> %785, <i32 32, i32 32, i32 32, i32 32>
%815 = add i64 %786, 4
%816 = icmp eq i64 %815, %782
br i1 %816, label %817, label %783
817: ; preds = %783, %772
%818 = phi i64 [ 0, %772 ], [ %813, %783 ]
%819 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %772 ], [ %814, %783 ]
%820 = icmp eq i64 %779, 0
br i1 %820, label %834, label %821
821: ; preds = %817, %821
%822 = phi i64 [ %830, %821 ], [ %818, %817 ]
%823 = phi <4 x i32> [ %831, %821 ], [ %819, %817 ]
%824 = phi i64 [ %832, %821 ], [ 0, %817 ]
%825 = add <4 x i32> %823, <i32 4, i32 4, i32 4, i32 4>
%826 = getelementptr inbounds i32, i32* %4, i64 %822
%827 = bitcast i32* %826 to <4 x i32>*
store <4 x i32> %823, <4 x i32>* %827
%828 = getelementptr inbounds i32, i32* %826, i64 4
%829 = bitcast i32* %828 to <4 x i32>*
store <4 x i32> %825, <4 x i32>* %829
%830 = add nuw i64 %822, 8
%831 = add <4 x i32> %823, <i32 8, i32 8, i32 8, i32 8>
%832 = add i64 %824, 1
%833 = icmp eq i64 %832, %779
br i1 %833, label %834, label %821
834: ; preds = %821, %817
%835 = icmp eq i64 %773, %770
br i1 %835, label %1665, label %836
836: ; preds = %768, %834
%837 = phi i64 [ 0, %768 ], [ %773, %834 ]
%838 = phi i32 [ 1, %768 ], [ %775, %834 ]
br label %851
839: ; preds = %5
store i32 0, i32* %4
br label %1665
840: ; preds = %5
store i32 %8, i32* %4
br label %1665
841: ; preds = %5
store i32 %9, i32* %4
br label %1665
842: ; preds = %5
%843 = add i32 %6, -1
store i32 %843, i32* %4
br label %1665
844: ; preds = %5
store i32 %10, i32* %4
br label %1665
845: ; preds = %5
%846 = add nsw i32 %10, %8
store i32 %846, i32* %4
br label %1665
847: ; preds = %5
%848 = add nsw i32 %10, %9
store i32 %848, i32* %4
br label %1665
849: ; preds = %5
%850 = add nsw i32 %7, -1
store i32 %850, i32* %4
br label %1665
851: ; preds = %836, %851
%852 = phi i64 [ %855, %851 ], [ %837, %836 ]
%853 = phi i32 [ %856, %851 ], [ %838, %836 ]
%854 = getelementptr inbounds i32, i32* %4, i64 %852
store i32 %853, i32* %854
%855 = add nuw nsw i64 %852, 1
%856 = add nuw nsw i32 %853, 1
%857 = icmp eq i64 %855, %770
br i1 %857, label %1665, label %851
858: ; preds = %763, %858
%859 = phi i64 [ %863, %858 ], [ %764, %763 ]
%860 = phi i32 [ %864, %858 ], [ %765, %763 ]
%861 = add nsw i32 %860, %9
%862 = getelementptr inbounds i32, i32* %4, i64 %859
store i32 %861, i32* %862
%863 = add nuw nsw i64 %859, 1
%864 = add nuw nsw i32 %860, 1
%865 = icmp eq i64 %863, %704
br i1 %865, label %1665, label %858
866: ; preds = %697, %866
%867 = phi i64 [ %871, %866 ], [ %698, %697 ]
%868 = phi i32 [ %872, %866 ], [ %699, %697 ]
%869 = add nsw i32 %868, %10
%870 = getelementptr inbounds i32, i32* %4, i64 %867
store i32 %869, i32* %870
%871 = add nuw nsw i64 %867, 1
%872 = add nuw nsw i32 %868, 1
%873 = icmp eq i64 %871, %638
br i1 %873, label %1665, label %866
874: ; preds = %5
%875 = add nsw i32 %10, %9
%876 = icmp sgt i32 %0, 2
br i1 %876, label %877, label %1665
877: ; preds = %874
%878 = add nsw i32 %0, -2
%879 = zext i32 %878 to i64
%880 = icmp ult i32 %878, 8
br i1 %880, label %938, label %881
881: ; preds = %877
%882 = and i64 %879, 4294967288
%883 = trunc i64 %882 to i32
%884 = or i32 %883, 1
%885 = insertelement <4 x i32> poison, i32 %875, i64 0
%886 = shufflevector <4 x i32> %885, <4 x i32> poison, <4 x i32> zeroinitializer
%887 = add nsw i64 %882, -8
%888 = lshr exact i64 %887, 3
%889 = add nuw nsw i64 %888, 1
%890 = and i64 %889, 1
%891 = icmp eq i64 %887, 0
br i1 %891, label %922, label %892
892: ; preds = %881
%893 = and i64 %889, 4611686018427387902
%894 = add i32 %875, 4
%895 = insertelement <4 x i32> poison, i32 %894, i64 0
%896 = shufflevector <4 x i32> %895, <4 x i32> poison, <4 x i32> zeroinitializer
%897 = add i32 %875, 4
%898 = insertelement <4 x i32> poison, i32 %897, i64 0
%899 = shufflevector <4 x i32> %898, <4 x i32> poison, <4 x i32> zeroinitializer
br label %900
900: ; preds = %900, %892
%901 = phi i64 [ 0, %892 ], [ %918, %900 ]
%902 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %892 ], [ %919, %900 ]
%903 = phi i64 [ 0, %892 ], [ %920, %900 ]
%904 = add nsw <4 x i32> %886, %902
%905 = add <4 x i32> %896, %902
%906 = getelementptr inbounds i32, i32* %4, i64 %901
%907 = bitcast i32* %906 to <4 x i32>*
store <4 x i32> %904, <4 x i32>* %907
%908 = getelementptr inbounds i32, i32* %906, i64 4
%909 = bitcast i32* %908 to <4 x i32>*
store <4 x i32> %905, <4 x i32>* %909
%910 = or i64 %901, 8
%911 = add <4 x i32> %902, <i32 8, i32 8, i32 8, i32 8>
%912 = add nsw <4 x i32> %886, %911
%913 = add <4 x i32> %899, %911
%914 = getelementptr inbounds i32, i32* %4, i64 %910
%915 = bitcast i32* %914 to <4 x i32>*
store <4 x i32> %912, <4 x i32>* %915
%916 = getelementptr inbounds i32, i32* %914, i64 4
%917 = bitcast i32* %916 to <4 x i32>*
store <4 x i32> %913, <4 x i32>* %917
%918 = add nuw i64 %901, 16
%919 = add <4 x i32> %902, <i32 16, i32 16, i32 16, i32 16>
%920 = add i64 %903, 2
%921 = icmp eq i64 %920, %893
br i1 %921, label %922, label %900
922: ; preds = %900, %881
%923 = phi i64 [ 0, %881 ], [ %918, %900 ]
%924 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %881 ], [ %919, %900 ]
%925 = icmp eq i64 %890, 0
br i1 %925, label %936, label %926
926: ; preds = %922
%927 = add nsw <4 x i32> %886, %924
%928 = add i32 %875, 4
%929 = insertelement <4 x i32> poison, i32 %928, i64 0
%930 = shufflevector <4 x i32> %929, <4 x i32> poison, <4 x i32> zeroinitializer
%931 = add <4 x i32> %930, %924
%932 = getelementptr inbounds i32, i32* %4, i64 %923
%933 = bitcast i32* %932 to <4 x i32>*
store <4 x i32> %927, <4 x i32>* %933
%934 = getelementptr inbounds i32, i32* %932, i64 4
%935 = bitcast i32* %934 to <4 x i32>*
store <4 x i32> %931, <4 x i32>* %935
br label %936
936: ; preds = %922, %926
%937 = icmp eq i64 %882, %879
br i1 %937, label %1665, label %938
938: ; preds = %877, %936
%939 = phi i64 [ 0, %877 ], [ %882, %936 ]
%940 = phi i32 [ 1, %877 ], [ %884, %936 ]
br label %941
941: ; preds = %938, %941
%942 = phi i64 [ %946, %941 ], [ %939, %938 ]
%943 = phi i32 [ %947, %941 ], [ %940, %938 ]
%944 = add nsw i32 %875, %943
%945 = getelementptr inbounds i32, i32* %4, i64 %942
store i32 %944, i32* %945
%946 = add nuw nsw i64 %942, 1
%947 = add nuw nsw i32 %943, 1
%948 = icmp eq i64 %946, %879
br i1 %948, label %1665, label %941
949: ; preds = %631, %949
%950 = phi i64 [ %953, %949 ], [ %632, %631 ]
%951 = phi i32 [ %954, %949 ], [ %633, %631 ]
%952 = getelementptr inbounds i32, i32* %4, i64 %950
store i32 %951, i32* %952
%953 = add nuw nsw i64 %950, 1
%954 = add nsw i32 %951, %0
%955 = icmp slt i32 %954, %9
br i1 %955, label %949, label %1641
956: ; preds = %540, %956
%957 = phi i64 [ %961, %956 ], [ %541, %540 ]
%958 = phi i32 [ %962, %956 ], [ %542, %540 ]
%959 = add nsw i32 %958, %8
%960 = getelementptr inbounds i32, i32* %4, i64 %957
store i32 %959, i32* %960
%961 = add nuw nsw i64 %957, 1
%962 = add nsw i32 %958, %0
%963 = icmp slt i32 %962, %9
br i1 %963, label %956, label %1644
964: ; preds = %460, %964
%965 = phi i64 [ %969, %964 ], [ %461, %460 ]
%966 = phi i32 [ %970, %964 ], [ %462, %460 ]
%967 = add nsw i32 %966, %10
%968 = getelementptr inbounds i32, i32* %4, i64 %965
store i32 %967, i32* %968
%969 = add nuw nsw i64 %965, 1
%970 = add nsw i32 %966, %0
%971 = icmp slt i32 %970, %9
br i1 %971, label %964, label %1647
972: ; preds = %5
%973 = add nsw i32 %10, %8
%974 = icmp sgt i32 %9, %0
br i1 %974, label %975, label %1665
975: ; preds = %972
%976 = shl i32 %0, 1
%977 = call i32 @llvm.smax.i32(i32 %9, i32 %976)
%978 = icmp slt i32 %976, %9
%979 = zext i1 %978 to i32
%980 = or i32 %976, %979
%981 = sub i32 %977, %980
%982 = udiv i32 %981, %0
%983 = add i32 %982, %979
%984 = zext i32 %983 to i64
%985 = add nuw nsw i64 %984, 1
%986 = icmp ult i32 %983, 7
br i1 %986, label %1050, label %987
987: ; preds = %975
%988 = and i64 %985, 8589934584
%989 = trunc i64 %988 to i32
%990 = mul i32 %989, %0
%991 = add i32 %990, %0
%992 = insertelement <4 x i32> poison, i32 %0, i64 0
%993 = shufflevector <4 x i32> %992, <4 x i32> poison, <4 x i32> zeroinitializer
%994 = insertelement <4 x i32> poison, i32 %0, i64 0
%995 = shufflevector <4 x i32> %994, <4 x i32> poison, <4 x i32> zeroinitializer
%996 = mul <4 x i32> %995, <i32 0, i32 1, i32 2, i32 3>
%997 = add <4 x i32> %993, %996
%998 = shl i32 %0, 2
%999 = insertelement <4 x i32> poison, i32 %998, i64 0
%1000 = shufflevector <4 x i32> %999, <4 x i32> poison, <4 x i32> zeroinitializer
%1001 = insertelement <4 x i32> poison, i32 %973, i64 0
%1002 = shufflevector <4 x i32> %1001, <4 x i32> poison, <4 x i32> zeroinitializer
%1003 = insertelement <4 x i32> poison, i32 %973, i64 0
%1004 = shufflevector <4 x i32> %1003, <4 x i32> poison, <4 x i32> zeroinitializer
%1005 = add nsw i64 %988, -8
%1006 = lshr exact i64 %1005, 3
%1007 = add nuw nsw i64 %1006, 1
%1008 = and i64 %1007, 1
%1009 = icmp eq i64 %1005, 0
br i1 %1009, label %1036, label %1010
1010: ; preds = %987
%1011 = and i64 %1007, 4611686018427387902
br label %1012
1012: ; preds = %1012, %1010
%1013 = phi i64 [ 0, %1010 ], [ %1032, %1012 ]
%1014 = phi <4 x i32> [ %997, %1010 ], [ %1033, %1012 ]
%1015 = phi i64 [ 0, %1010 ], [ %1034, %1012 ]
%1016 = add <4 x i32> %1014, %1000
%1017 = add nsw <4 x i32> %1002, %1014
%1018 = add nsw <4 x i32> %1004, %1016
%1019 = getelementptr inbounds i32, i32* %4, i64 %1013
%1020 = bitcast i32* %1019 to <4 x i32>*
store <4 x i32> %1017, <4 x i32>* %1020
%1021 = getelementptr inbounds i32, i32* %1019, i64 4
%1022 = bitcast i32* %1021 to <4 x i32>*
store <4 x i32> %1018, <4 x i32>* %1022
%1023 = or i64 %1013, 8
%1024 = add <4 x i32> %1016, %1000
%1025 = add <4 x i32> %1024, %1000
%1026 = add nsw <4 x i32> %1002, %1024
%1027 = add nsw <4 x i32> %1004, %1025
%1028 = getelementptr inbounds i32, i32* %4, i64 %1023
%1029 = bitcast i32* %1028 to <4 x i32>*
store <4 x i32> %1026, <4 x i32>* %1029
%1030 = getelementptr inbounds i32, i32* %1028, i64 4
%1031 = bitcast i32* %1030 to <4 x i32>*
store <4 x i32> %1027, <4 x i32>* %1031
%1032 = add nuw i64 %1013, 16
%1033 = add <4 x i32> %1025, %1000
%1034 = add i64 %1015, 2
%1035 = icmp eq i64 %1034, %1011
br i1 %1035, label %1036, label %1012
1036: ; preds = %1012, %987
%1037 = phi i64 [ 0, %987 ], [ %1032, %1012 ]
%1038 = phi <4 x i32> [ %997, %987 ], [ %1033, %1012 ]
%1039 = icmp eq i64 %1008, 0
br i1 %1039, label %1048, label %1040
1040: ; preds = %1036
%1041 = add <4 x i32> %1038, %1000
%1042 = add nsw <4 x i32> %1002, %1038
%1043 = add nsw <4 x i32> %1004, %1041
%1044 = getelementptr inbounds i32, i32* %4, i64 %1037
%1045 = bitcast i32* %1044 to <4 x i32>*
store <4 x i32> %1042, <4 x i32>* %1045
%1046 = getelementptr inbounds i32, i32* %1044, i64 4
%1047 = bitcast i32* %1046 to <4 x i32>*
store <4 x i32> %1043, <4 x i32>* %1047
br label %1048
1048: ; preds = %1036, %1040
%1049 = icmp eq i64 %985, %988
br i1 %1049, label %1650, label %1050
1050: ; preds = %975, %1048
%1051 = phi i64 [ 0, %975 ], [ %988, %1048 ]
%1052 = phi i32 [ %0, %975 ], [ %991, %1048 ]
br label %1053
1053: ; preds = %1050, %1053
%1054 = phi i64 [ %1058, %1053 ], [ %1051, %1050 ]
%1055 = phi i32 [ %1059, %1053 ], [ %1052, %1050 ]
%1056 = add nsw i32 %973, %1055
%1057 = getelementptr inbounds i32, i32* %4, i64 %1054
store i32 %1056, i32* %1057
%1058 = add nuw nsw i64 %1054, 1
%1059 = add nsw i32 %1055, %0
%1060 = icmp slt i32 %1059, %9
br i1 %1060, label %1053, label %1650
1061: ; preds = %380, %1061
%1062 = phi i64 [ %1065, %1061 ], [ %381, %380 ]
%1063 = phi i32 [ %1066, %1061 ], [ %382, %380 ]
%1064 = getelementptr inbounds i32, i32* %4, i64 %1062
store i32 %1063, i32* %1064
%1065 = add nuw nsw i64 %1062, 1
%1066 = add nsw i32 %1063, %6
%1067 = icmp slt i32 %1066, %10
br i1 %1067, label %1061, label %1653
1068: ; preds = %288, %1068
%1069 = phi i64 [ %1073, %1068 ], [ %289, %288 ]
%1070 = phi i32 [ %1074, %1068 ], [ %290, %288 ]
%1071 = add nsw i32 %1070, %8
%1072 = getelementptr inbounds i32, i32* %4, i64 %1069
store i32 %1071, i32* %1072
%1073 = add nuw nsw i64 %1069, 1
%1074 = add nsw i32 %1070, %6
%1075 = icmp slt i32 %1074, %10
br i1 %1075, label %1068, label %1656
1076: ; preds = %207, %1076
%1077 = phi i64 [ %1081, %1076 ], [ %208, %207 ]
%1078 = phi i32 [ %1082, %1076 ], [ %209, %207 ]
%1079 = add nsw i32 %1078, %9
%1080 = getelementptr inbounds i32, i32* %4, i64 %1077
store i32 %1079, i32* %1080
%1081 = add nuw nsw i64 %1077, 1
%1082 = add nsw i32 %1078, %6
%1083 = icmp slt i32 %1082, %10
br i1 %1083, label %1076, label %1659
1084: ; preds = %5
%1085 = add i32 %6, -1
%1086 = icmp slt i32 %6, %10
br i1 %1086, label %1087, label %1665
1087: ; preds = %1084
%1088 = mul i32 %1, %0
%1089 = shl i32 %1088, 1
%1090 = call i32 @llvm.smax.i32(i32 %10, i32 %1089)
%1091 = sub i32 %1090, %1089
%1092 = icmp ne i32 %1091, 0
%1093 = zext i1 %1092 to i32
%1094 = sub i32 %1091, %1093
%1095 = udiv i32 %1094, %6
%1096 = add i32 %1095, %1093
%1097 = zext i32 %1096 to i64
%1098 = add nuw nsw i64 %1097, 1
%1099 = icmp ult i32 %1096, 7
br i1 %1099, label %1163, label %1100
1100: ; preds = %1087
%1101 = and i64 %1098, 8589934584
%1102 = trunc i64 %1101 to i32
%1103 = mul i32 %6, %1102
%1104 = add i32 %6, %1103
%1105 = insertelement <4 x i32> poison, i32 %6, i64 0
%1106 = shufflevector <4 x i32> %1105, <4 x i32> poison, <4 x i32> zeroinitializer
%1107 = insertelement <4 x i32> poison, i32 %6, i64 0
%1108 = shufflevector <4 x i32> %1107, <4 x i32> poison, <4 x i32> zeroinitializer
%1109 = mul <4 x i32> %1108, <i32 0, i32 1, i32 2, i32 3>
%1110 = add <4 x i32> %1106, %1109
%1111 = shl i32 %6, 2
%1112 = insertelement <4 x i32> poison, i32 %1111, i64 0
%1113 = shufflevector <4 x i32> %1112, <4 x i32> poison, <4 x i32> zeroinitializer
%1114 = insertelement <4 x i32> poison, i32 %1085, i64 0
%1115 = shufflevector <4 x i32> %1114, <4 x i32> poison, <4 x i32> zeroinitializer
%1116 = insertelement <4 x i32> poison, i32 %1085, i64 0
%1117 = shufflevector <4 x i32> %1116, <4 x i32> poison, <4 x i32> zeroinitializer
%1118 = add nsw i64 %1101, -8
%1119 = lshr exact i64 %1118, 3
%1120 = add nuw nsw i64 %1119, 1
%1121 = and i64 %1120, 1
%1122 = icmp eq i64 %1118, 0
br i1 %1122, label %1149, label %1123
1123: ; preds = %1100
%1124 = and i64 %1120, 4611686018427387902
br label %1125
1125: ; preds = %1125, %1123
%1126 = phi i64 [ 0, %1123 ], [ %1145, %1125 ]
%1127 = phi <4 x i32> [ %1110, %1123 ], [ %1146, %1125 ]
%1128 = phi i64 [ 0, %1123 ], [ %1147, %1125 ]
%1129 = add <4 x i32> %1127, %1113
%1130 = add nsw <4 x i32> %1115, %1127
%1131 = add nsw <4 x i32> %1117, %1129
%1132 = getelementptr inbounds i32, i32* %4, i64 %1126
%1133 = bitcast i32* %1132 to <4 x i32>*
store <4 x i32> %1130, <4 x i32>* %1133
%1134 = getelementptr inbounds i32, i32* %1132, i64 4
%1135 = bitcast i32* %1134 to <4 x i32>*
store <4 x i32> %1131, <4 x i32>* %1135
%1136 = or i64 %1126, 8
%1137 = add <4 x i32> %1129, %1113
%1138 = add <4 x i32> %1137, %1113
%1139 = add nsw <4 x i32> %1115, %1137
%1140 = add nsw <4 x i32> %1117, %1138
%1141 = getelementptr inbounds i32, i32* %4, i64 %1136
%1142 = bitcast i32* %1141 to <4 x i32>*
store <4 x i32> %1139, <4 x i32>* %1142
%1143 = getelementptr inbounds i32, i32* %1141, i64 4
%1144 = bitcast i32* %1143 to <4 x i32>*
store <4 x i32> %1140, <4 x i32>* %1144
%1145 = add nuw i64 %1126, 16
%1146 = add <4 x i32> %1138, %1113
%1147 = add i64 %1128, 2
%1148 = icmp eq i64 %1147, %1124
br i1 %1148, label %1149, label %1125
1149: ; preds = %1125, %1100
%1150 = phi i64 [ 0, %1100 ], [ %1145, %1125 ]
%1151 = phi <4 x i32> [ %1110, %1100 ], [ %1146, %1125 ]
%1152 = icmp eq i64 %1121, 0
br i1 %1152, label %1161, label %1153
1153: ; preds = %1149
%1154 = add <4 x i32> %1151, %1113
%1155 = add nsw <4 x i32> %1115, %1151
%1156 = add nsw <4 x i32> %1117, %1154
%1157 = getelementptr inbounds i32, i32* %4, i64 %1150
%1158 = bitcast i32* %1157 to <4 x i32>*
store <4 x i32> %1155, <4 x i32>* %1158
%1159 = getelementptr inbounds i32, i32* %1157, i64 4
%1160 = bitcast i32* %1159 to <4 x i32>*
store <4 x i32> %1156, <4 x i32>* %1160
br label %1161
1161: ; preds = %1149, %1153
%1162 = icmp eq i64 %1098, %1101
br i1 %1162, label %1662, label %1163
1163: ; preds = %1087, %1161
%1164 = phi i64 [ 0, %1087 ], [ %1101, %1161 ]
%1165 = phi i32 [ %6, %1087 ], [ %1104, %1161 ]
br label %1166
1166: ; preds = %1163, %1166
%1167 = phi i64 [ %1171, %1166 ], [ %1164, %1163 ]
%1168 = phi i32 [ %1172, %1166 ], [ %1165, %1163 ]
%1169 = add nsw i32 %1085, %1168
%1170 = getelementptr inbounds i32, i32* %4, i64 %1167
store i32 %1169, i32* %1170
%1171 = add nuw nsw i64 %1167, 1
%1172 = add nsw i32 %1168, %6
%1173 = icmp slt i32 %1172, %10
br i1 %1173, label %1166, label %1662
1174: ; preds = %111, %1243
%1175 = phi i32 [ %0, %111 ], [ %1245, %1243 ]
%1176 = phi i32 [ 0, %111 ], [ %1244, %1243 ]
br i1 %112, label %1177, label %1243
1177: ; preds = %1174
%1178 = sext i32 %1176 to i64
br i1 %120, label %1229, label %1179
1179: ; preds = %1177
%1180 = add nsw i64 %121, %1178
%1181 = insertelement <4 x i32> poison, i32 %1175, i64 0
%1182 = shufflevector <4 x i32> %1181, <4 x i32> poison, <4 x i32> zeroinitializer
br i1 %125, label %1214, label %1183
1183: ; preds = %1179
%1184 = add i32 %1175, 4
%1185 = insertelement <4 x i32> poison, i32 %1184, i64 0
%1186 = shufflevector <4 x i32> %1185, <4 x i32> poison, <4 x i32> zeroinitializer
%1187 = add i32 %1175, 4
%1188 = insertelement <4 x i32> poison, i32 %1187, i64 0
%1189 = shufflevector <4 x i32> %1188, <4 x i32> poison, <4 x i32> zeroinitializer
br label %1190
1190: ; preds = %1190, %1183
%1191 = phi i64 [ 0, %1183 ], [ %1210, %1190 ]
%1192 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1183 ], [ %1211, %1190 ]
%1193 = phi i64 [ 0, %1183 ], [ %1212, %1190 ]
%1194 = add i64 %1191, %1178
%1195 = add nsw <4 x i32> %1192, %1182
%1196 = add <4 x i32> %1186, %1192
%1197 = getelementptr inbounds i32, i32* %4, i64 %1194
%1198 = bitcast i32* %1197 to <4 x i32>*
store <4 x i32> %1195, <4 x i32>* %1198
%1199 = getelementptr inbounds i32, i32* %1197, i64 4
%1200 = bitcast i32* %1199 to <4 x i32>*
store <4 x i32> %1196, <4 x i32>* %1200
%1201 = or i64 %1191, 8
%1202 = add <4 x i32> %1192, <i32 8, i32 8, i32 8, i32 8>
%1203 = add i64 %1201, %1178
%1204 = add nsw <4 x i32> %1202, %1182
%1205 = add <4 x i32> %1189, %1202
%1206 = getelementptr inbounds i32, i32* %4, i64 %1203
%1207 = bitcast i32* %1206 to <4 x i32>*
store <4 x i32> %1204, <4 x i32>* %1207
%1208 = getelementptr inbounds i32, i32* %1206, i64 4
%1209 = bitcast i32* %1208 to <4 x i32>*
store <4 x i32> %1205, <4 x i32>* %1209
%1210 = add nuw i64 %1191, 16
%1211 = add <4 x i32> %1192, <i32 16, i32 16, i32 16, i32 16>
%1212 = add i64 %1193, 2
%1213 = icmp eq i64 %1212, %126
br i1 %1213, label %1214, label %1190
1214: ; preds = %1190, %1179
%1215 = phi i64 [ 0, %1179 ], [ %1210, %1190 ]
%1216 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1179 ], [ %1211, %1190 ]
br i1 %127, label %1228, label %1217
1217: ; preds = %1214
%1218 = add i64 %1215, %1178
%1219 = add nsw <4 x i32> %1216, %1182
%1220 = add i32 %1175, 4
%1221 = insertelement <4 x i32> poison, i32 %1220, i64 0
%1222 = shufflevector <4 x i32> %1221, <4 x i32> poison, <4 x i32> zeroinitializer
%1223 = add <4 x i32> %1222, %1216
%1224 = getelementptr inbounds i32, i32* %4, i64 %1218
%1225 = bitcast i32* %1224 to <4 x i32>*
store <4 x i32> %1219, <4 x i32>* %1225
%1226 = getelementptr inbounds i32, i32* %1224, i64 4
%1227 = bitcast i32* %1226 to <4 x i32>*
store <4 x i32> %1223, <4 x i32>* %1227
br label %1228
1228: ; preds = %1214, %1217
br i1 %128, label %1240, label %1229
1229: ; preds = %1177, %1228
%1230 = phi i64 [ %1178, %1177 ], [ %1180, %1228 ]
%1231 = phi i32 [ 1, %1177 ], [ %123, %1228 ]
br label %1232
1232: ; preds = %1229, %1232
%1233 = phi i64 [ %1237, %1232 ], [ %1230, %1229 ]
%1234 = phi i32 [ %1238, %1232 ], [ %1231, %1229 ]
%1235 = add nsw i32 %1234, %1175
%1236 = getelementptr inbounds i32, i32* %4, i64 %1233
store i32 %1235, i32* %1236
%1237 = add nsw i64 %1233, 1
%1238 = add nuw nsw i32 %1234, 1
%1239 = icmp eq i32 %1238, %8
br i1 %1239, label %1240, label %1232
1240: ; preds = %1232, %1228
%1241 = phi i64 [ %1180, %1228 ], [ %1237, %1232 ]
%1242 = trunc i64 %1241 to i32
br label %1243
1243: ; preds = %1240, %1174
%1244 = phi i32 [ %1176, %1174 ], [ %1242, %1240 ]
%1245 = add nsw i32 %1175, %0
%1246 = icmp slt i32 %1245, %9
br i1 %1246, label %1174, label %1665
1247: ; preds = %91, %1317
%1248 = phi i32 [ %0, %91 ], [ %1319, %1317 ]
%1249 = phi i32 [ 0, %91 ], [ %1318, %1317 ]
br i1 %92, label %1250, label %1317
1250: ; preds = %1247
%1251 = add i32 %1248, %10
%1252 = sext i32 %1249 to i64
br i1 %100, label %1303, label %1253
1253: ; preds = %1250
%1254 = add nsw i64 %101, %1252
%1255 = insertelement <4 x i32> poison, i32 %1251, i64 0
%1256 = shufflevector <4 x i32> %1255, <4 x i32> poison, <4 x i32> zeroinitializer
br i1 %105, label %1288, label %1257
1257: ; preds = %1253
%1258 = add i32 %1251, 4
%1259 = insertelement <4 x i32> poison, i32 %1258, i64 0
%1260 = shufflevector <4 x i32> %1259, <4 x i32> poison, <4 x i32> zeroinitializer
%1261 = add i32 %1251, 4
%1262 = insertelement <4 x i32> poison, i32 %1261, i64 0
%1263 = shufflevector <4 x i32> %1262, <4 x i32> poison, <4 x i32> zeroinitializer
br label %1264
1264: ; preds = %1264, %1257
%1265 = phi i64 [ 0, %1257 ], [ %1284, %1264 ]
%1266 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1257 ], [ %1285, %1264 ]
%1267 = phi i64 [ 0, %1257 ], [ %1286, %1264 ]
%1268 = add i64 %1265, %1252
%1269 = add <4 x i32> %1256, %1266
%1270 = add <4 x i32> %1260, %1266
%1271 = getelementptr inbounds i32, i32* %4, i64 %1268
%1272 = bitcast i32* %1271 to <4 x i32>*
store <4 x i32> %1269, <4 x i32>* %1272
%1273 = getelementptr inbounds i32, i32* %1271, i64 4
%1274 = bitcast i32* %1273 to <4 x i32>*
store <4 x i32> %1270, <4 x i32>* %1274
%1275 = or i64 %1265, 8
%1276 = add <4 x i32> %1266, <i32 8, i32 8, i32 8, i32 8>
%1277 = add i64 %1275, %1252
%1278 = add <4 x i32> %1256, %1276
%1279 = add <4 x i32> %1263, %1276
%1280 = getelementptr inbounds i32, i32* %4, i64 %1277
%1281 = bitcast i32* %1280 to <4 x i32>*
store <4 x i32> %1278, <4 x i32>* %1281
%1282 = getelementptr inbounds i32, i32* %1280, i64 4
%1283 = bitcast i32* %1282 to <4 x i32>*
store <4 x i32> %1279, <4 x i32>* %1283
%1284 = add nuw i64 %1265, 16
%1285 = add <4 x i32> %1266, <i32 16, i32 16, i32 16, i32 16>
%1286 = add i64 %1267, 2
%1287 = icmp eq i64 %1286, %106
br i1 %1287, label %1288, label %1264
1288: ; preds = %1264, %1253
%1289 = phi i64 [ 0, %1253 ], [ %1284, %1264 ]
%1290 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1253 ], [ %1285, %1264 ]
br i1 %107, label %1302, label %1291
1291: ; preds = %1288
%1292 = add i64 %1289, %1252
%1293 = add <4 x i32> %1256, %1290
%1294 = add i32 %1251, 4
%1295 = insertelement <4 x i32> poison, i32 %1294, i64 0
%1296 = shufflevector <4 x i32> %1295, <4 x i32> poison, <4 x i32> zeroinitializer
%1297 = add <4 x i32> %1296, %1290
%1298 = getelementptr inbounds i32, i32* %4, i64 %1292
%1299 = bitcast i32* %1298 to <4 x i32>*
store <4 x i32> %1293, <4 x i32>* %1299
%1300 = getelementptr inbounds i32, i32* %1298, i64 4
%1301 = bitcast i32* %1300 to <4 x i32>*
store <4 x i32> %1297, <4 x i32>* %1301
br label %1302
1302: ; preds = %1288, %1291
br i1 %108, label %1314, label %1303
1303: ; preds = %1250, %1302
%1304 = phi i64 [ %1252, %1250 ], [ %1254, %1302 ]
%1305 = phi i32 [ 1, %1250 ], [ %103, %1302 ]
br label %1306
1306: ; preds = %1303, %1306
%1307 = phi i64 [ %1311, %1306 ], [ %1304, %1303 ]
%1308 = phi i32 [ %1312, %1306 ], [ %1305, %1303 ]
%1309 = add i32 %1251, %1308
%1310 = getelementptr inbounds i32, i32* %4, i64 %1307
store i32 %1309, i32* %1310
%1311 = add nsw i64 %1307, 1
%1312 = add nuw nsw i32 %1308, 1
%1313 = icmp eq i32 %1312, %8
br i1 %1313, label %1314, label %1306
1314: ; preds = %1306, %1302
%1315 = phi i64 [ %1254, %1302 ], [ %1311, %1306 ]
%1316 = trunc i64 %1315 to i32
br label %1317
1317: ; preds = %1314, %1247
%1318 = phi i32 [ %1249, %1247 ], [ %1316, %1314 ]
%1319 = add nsw i32 %1248, %0
%1320 = icmp slt i32 %1319, %9
br i1 %1320, label %1247, label %1665
1321: ; preds = %72, %1403
%1322 = phi i32 [ %6, %72 ], [ %1405, %1403 ]
%1323 = phi i32 [ 0, %72 ], [ %1404, %1403 ]
br i1 %73, label %1324, label %1403
1324: ; preds = %1321
%1325 = sext i32 %1323 to i64
%1326 = udiv i32 %79, %0
%1327 = add i32 %1326, %77
%1328 = zext i32 %1327 to i64
%1329 = add nuw nsw i64 %1328, 1
%1330 = icmp ult i32 %1327, 7
br i1 %1330, label %1389, label %1331
1331: ; preds = %1324
%1332 = and i64 %1329, 8589934584
%1333 = add nsw i64 %1332, %1325
%1334 = trunc i64 %1332 to i32
%1335 = mul i32 %1334, %0
%1336 = add i32 %1335, %0
%1337 = insertelement <4 x i32> poison, i32 %1322, i64 0
%1338 = shufflevector <4 x i32> %1337, <4 x i32> poison, <4 x i32> zeroinitializer
%1339 = insertelement <4 x i32> poison, i32 %1322, i64 0
%1340 = shufflevector <4 x i32> %1339, <4 x i32> poison, <4 x i32> zeroinitializer
%1341 = add nsw i64 %1332, -8
%1342 = lshr exact i64 %1341, 3
%1343 = add nuw nsw i64 %1342, 1
%1344 = and i64 %1343, 1
%1345 = icmp eq i64 %1341, 0
br i1 %1345, label %1374, label %1346
1346: ; preds = %1331
%1347 = and i64 %1343, 4611686018427387902
br label %1348
1348: ; preds = %1348, %1346
%1349 = phi i64 [ 0, %1346 ], [ %1370, %1348 ]
%1350 = phi <4 x i32> [ %85, %1346 ], [ %1371, %1348 ]
%1351 = phi i64 [ 0, %1346 ], [ %1372, %1348 ]
%1352 = add i64 %1349, %1325
%1353 = add <4 x i32> %1350, %88
%1354 = add nsw <4 x i32> %1350, %1338
%1355 = add nsw <4 x i32> %1353, %1340
%1356 = getelementptr inbounds i32, i32* %4, i64 %1352
%1357 = bitcast i32* %1356 to <4 x i32>*
store <4 x i32> %1354, <4 x i32>* %1357
%1358 = getelementptr inbounds i32, i32* %1356, i64 4
%1359 = bitcast i32* %1358 to <4 x i32>*
store <4 x i32> %1355, <4 x i32>* %1359
%1360 = or i64 %1349, 8
%1361 = add <4 x i32> %1353, %88
%1362 = add i64 %1360, %1325
%1363 = add <4 x i32> %1361, %88
%1364 = add nsw <4 x i32> %1361, %1338
%1365 = add nsw <4 x i32> %1363, %1340
%1366 = getelementptr inbounds i32, i32* %4, i64 %1362
%1367 = bitcast i32* %1366 to <4 x i32>*
store <4 x i32> %1364, <4 x i32>* %1367
%1368 = getelementptr inbounds i32, i32* %1366, i64 4
%1369 = bitcast i32* %1368 to <4 x i32>*
store <4 x i32> %1365, <4 x i32>* %1369
%1370 = add nuw i64 %1349, 16
%1371 = add <4 x i32> %1363, %88
%1372 = add i64 %1351, 2
%1373 = icmp eq i64 %1372, %1347
br i1 %1373, label %1374, label %1348
1374: ; preds = %1348, %1331
%1375 = phi i64 [ 0, %1331 ], [ %1370, %1348 ]
%1376 = phi <4 x i32> [ %85, %1331 ], [ %1371, %1348 ]
%1377 = icmp eq i64 %1344, 0
br i1 %1377, label %1387, label %1378
1378: ; preds = %1374
%1379 = add i64 %1375, %1325
%1380 = add <4 x i32> %1376, %88
%1381 = add nsw <4 x i32> %1376, %1338
%1382 = add nsw <4 x i32> %1380, %1340
%1383 = getelementptr inbounds i32, i32* %4, i64 %1379
%1384 = bitcast i32* %1383 to <4 x i32>*
store <4 x i32> %1381, <4 x i32>* %1384
%1385 = getelementptr inbounds i32, i32* %1383, i64 4
%1386 = bitcast i32* %1385 to <4 x i32>*
store <4 x i32> %1382, <4 x i32>* %1386
br label %1387
1387: ; preds = %1374, %1378
%1388 = icmp eq i64 %1329, %1332
br i1 %1388, label %1400, label %1389
1389: ; preds = %1324, %1387
%1390 = phi i64 [ %1325, %1324 ], [ %1333, %1387 ]
%1391 = phi i32 [ %0, %1324 ], [ %1336, %1387 ]
br label %1392
1392: ; preds = %1389, %1392
%1393 = phi i64 [ %1397, %1392 ], [ %1390, %1389 ]
%1394 = phi i32 [ %1398, %1392 ], [ %1391, %1389 ]
%1395 = add nsw i32 %1394, %1322
%1396 = getelementptr inbounds i32, i32* %4, i64 %1393
store i32 %1395, i32* %1396
%1397 = add nsw i64 %1393, 1
%1398 = add nsw i32 %1394, %0
%1399 = icmp slt i32 %1398, %9
br i1 %1399, label %1392, label %1400
1400: ; preds = %1392, %1387
%1401 = phi i64 [ %1333, %1387 ], [ %1397, %1392 ]
%1402 = trunc i64 %1401 to i32
br label %1403
1403: ; preds = %1400, %1321
%1404 = phi i32 [ %1323, %1321 ], [ %1402, %1400 ]
%1405 = add nsw i32 %1322, %6
%1406 = icmp slt i32 %1405, %10
br i1 %1406, label %1321, label %1665
1407: ; preds = %53, %1490
%1408 = phi i32 [ %6, %53 ], [ %1492, %1490 ]
%1409 = phi i32 [ 0, %53 ], [ %1491, %1490 ]
br i1 %54, label %1410, label %1490
1410: ; preds = %1407
%1411 = add i32 %1408, %8
%1412 = sext i32 %1409 to i64
%1413 = udiv i32 %60, %0
%1414 = add i32 %1413, %58
%1415 = zext i32 %1414 to i64
%1416 = add nuw nsw i64 %1415, 1
%1417 = icmp ult i32 %1414, 7
br i1 %1417, label %1476, label %1418
1418: ; preds = %1410
%1419 = and i64 %1416, 8589934584
%1420 = add nsw i64 %1419, %1412
%1421 = trunc i64 %1419 to i32
%1422 = mul i32 %1421, %0
%1423 = add i32 %1422, %0
%1424 = insertelement <4 x i32> poison, i32 %1411, i64 0
%1425 = shufflevector <4 x i32> %1424, <4 x i32> poison, <4 x i32> zeroinitializer
%1426 = insertelement <4 x i32> poison, i32 %1411, i64 0
%1427 = shufflevector <4 x i32> %1426, <4 x i32> poison, <4 x i32> zeroinitializer
%1428 = add nsw i64 %1419, -8
%1429 = lshr exact i64 %1428, 3
%1430 = add nuw nsw i64 %1429, 1
%1431 = and i64 %1430, 1
%1432 = icmp eq i64 %1428, 0
br i1 %1432, label %1461, label %1433
1433: ; preds = %1418
%1434 = and i64 %1430, 4611686018427387902
br label %1435
1435: ; preds = %1435, %1433
%1436 = phi i64 [ 0, %1433 ], [ %1457, %1435 ]
%1437 = phi <4 x i32> [ %66, %1433 ], [ %1458, %1435 ]
%1438 = phi i64 [ 0, %1433 ], [ %1459, %1435 ]
%1439 = add i64 %1436, %1412
%1440 = add <4 x i32> %1437, %69
%1441 = add <4 x i32> %1425, %1437
%1442 = add <4 x i32> %1427, %1440
%1443 = getelementptr inbounds i32, i32* %4, i64 %1439
%1444 = bitcast i32* %1443 to <4 x i32>*
store <4 x i32> %1441, <4 x i32>* %1444
%1445 = getelementptr inbounds i32, i32* %1443, i64 4
%1446 = bitcast i32* %1445 to <4 x i32>*
store <4 x i32> %1442, <4 x i32>* %1446
%1447 = or i64 %1436, 8
%1448 = add <4 x i32> %1440, %69
%1449 = add i64 %1447, %1412
%1450 = add <4 x i32> %1448, %69
%1451 = add <4 x i32> %1425, %1448
%1452 = add <4 x i32> %1427, %1450
%1453 = getelementptr inbounds i32, i32* %4, i64 %1449
%1454 = bitcast i32* %1453 to <4 x i32>*
store <4 x i32> %1451, <4 x i32>* %1454
%1455 = getelementptr inbounds i32, i32* %1453, i64 4
%1456 = bitcast i32* %1455 to <4 x i32>*
store <4 x i32> %1452, <4 x i32>* %1456
%1457 = add nuw i64 %1436, 16
%1458 = add <4 x i32> %1450, %69
%1459 = add i64 %1438, 2
%1460 = icmp eq i64 %1459, %1434
br i1 %1460, label %1461, label %1435
1461: ; preds = %1435, %1418
%1462 = phi i64 [ 0, %1418 ], [ %1457, %1435 ]
%1463 = phi <4 x i32> [ %66, %1418 ], [ %1458, %1435 ]
%1464 = icmp eq i64 %1431, 0
br i1 %1464, label %1474, label %1465
1465: ; preds = %1461
%1466 = add i64 %1462, %1412
%1467 = add <4 x i32> %1463, %69
%1468 = add <4 x i32> %1425, %1463
%1469 = add <4 x i32> %1427, %1467
%1470 = getelementptr inbounds i32, i32* %4, i64 %1466
%1471 = bitcast i32* %1470 to <4 x i32>*
store <4 x i32> %1468, <4 x i32>* %1471
%1472 = getelementptr inbounds i32, i32* %1470, i64 4
%1473 = bitcast i32* %1472 to <4 x i32>*
store <4 x i32> %1469, <4 x i32>* %1473
br label %1474
1474: ; preds = %1461, %1465
%1475 = icmp eq i64 %1416, %1419
br i1 %1475, label %1487, label %1476
1476: ; preds = %1410, %1474
%1477 = phi i64 [ %1412, %1410 ], [ %1420, %1474 ]
%1478 = phi i32 [ %0, %1410 ], [ %1423, %1474 ]
br label %1479
1479: ; preds = %1476, %1479
%1480 = phi i64 [ %1484, %1479 ], [ %1477, %1476 ]
%1481 = phi i32 [ %1485, %1479 ], [ %1478, %1476 ]
%1482 = add i32 %1411, %1481
%1483 = getelementptr inbounds i32, i32* %4, i64 %1480
store i32 %1482, i32* %1483
%1484 = add nsw i64 %1480, 1
%1485 = add nsw i32 %1481, %0
%1486 = icmp slt i32 %1485, %9
br i1 %1486, label %1479, label %1487
1487: ; preds = %1479, %1474
%1488 = phi i64 [ %1420, %1474 ], [ %1484, %1479 ]
%1489 = trunc i64 %1488 to i32
br label %1490
1490: ; preds = %1487, %1407
%1491 = phi i32 [ %1409, %1407 ], [ %1489, %1487 ]
%1492 = add nsw i32 %1408, %6
%1493 = icmp slt i32 %1492, %10
br i1 %1493, label %1407, label %1665
1494: ; preds = %33, %1563
%1495 = phi i32 [ %6, %33 ], [ %1565, %1563 ]
%1496 = phi i32 [ 0, %33 ], [ %1564, %1563 ]
br i1 %34, label %1497, label %1563
1497: ; preds = %1494
%1498 = sext i32 %1496 to i64
br i1 %42, label %1549, label %1499
1499: ; preds = %1497
%1500 = add nsw i64 %43, %1498
%1501 = insertelement <4 x i32> poison, i32 %1495, i64 0
%1502 = shufflevector <4 x i32> %1501, <4 x i32> poison, <4 x i32> zeroinitializer
br i1 %47, label %1534, label %1503
1503: ; preds = %1499
%1504 = add i32 %1495, 4
%1505 = insertelement <4 x i32> poison, i32 %1504, i64 0
%1506 = shufflevector <4 x i32> %1505, <4 x i32> poison, <4 x i32> zeroinitializer
%1507 = add i32 %1495, 4
%1508 = insertelement <4 x i32> poison, i32 %1507, i64 0
%1509 = shufflevector <4 x i32> %1508, <4 x i32> poison, <4 x i32> zeroinitializer
br label %1510
1510: ; preds = %1510, %1503
%1511 = phi i64 [ 0, %1503 ], [ %1530, %1510 ]
%1512 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1503 ], [ %1531, %1510 ]
%1513 = phi i64 [ 0, %1503 ], [ %1532, %1510 ]
%1514 = add i64 %1511, %1498
%1515 = add nsw <4 x i32> %1512, %1502
%1516 = add <4 x i32> %1506, %1512
%1517 = getelementptr inbounds i32, i32* %4, i64 %1514
%1518 = bitcast i32* %1517 to <4 x i32>*
store <4 x i32> %1515, <4 x i32>* %1518
%1519 = getelementptr inbounds i32, i32* %1517, i64 4
%1520 = bitcast i32* %1519 to <4 x i32>*
store <4 x i32> %1516, <4 x i32>* %1520
%1521 = or i64 %1511, 8
%1522 = add <4 x i32> %1512, <i32 8, i32 8, i32 8, i32 8>
%1523 = add i64 %1521, %1498
%1524 = add nsw <4 x i32> %1522, %1502
%1525 = add <4 x i32> %1509, %1522
%1526 = getelementptr inbounds i32, i32* %4, i64 %1523
%1527 = bitcast i32* %1526 to <4 x i32>*
store <4 x i32> %1524, <4 x i32>* %1527
%1528 = getelementptr inbounds i32, i32* %1526, i64 4
%1529 = bitcast i32* %1528 to <4 x i32>*
store <4 x i32> %1525, <4 x i32>* %1529
%1530 = add nuw i64 %1511, 16
%1531 = add <4 x i32> %1512, <i32 16, i32 16, i32 16, i32 16>
%1532 = add i64 %1513, 2
%1533 = icmp eq i64 %1532, %48
br i1 %1533, label %1534, label %1510
1534: ; preds = %1510, %1499
%1535 = phi i64 [ 0, %1499 ], [ %1530, %1510 ]
%1536 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1499 ], [ %1531, %1510 ]
br i1 %49, label %1548, label %1537
1537: ; preds = %1534
%1538 = add i64 %1535, %1498
%1539 = add nsw <4 x i32> %1536, %1502
%1540 = add i32 %1495, 4
%1541 = insertelement <4 x i32> poison, i32 %1540, i64 0
%1542 = shufflevector <4 x i32> %1541, <4 x i32> poison, <4 x i32> zeroinitializer
%1543 = add <4 x i32> %1542, %1536
%1544 = getelementptr inbounds i32, i32* %4, i64 %1538
%1545 = bitcast i32* %1544 to <4 x i32>*
store <4 x i32> %1539, <4 x i32>* %1545
%1546 = getelementptr inbounds i32, i32* %1544, i64 4
%1547 = bitcast i32* %1546 to <4 x i32>*
store <4 x i32> %1543, <4 x i32>* %1547
br label %1548
1548: ; preds = %1534, %1537
br i1 %50, label %1560, label %1549
1549: ; preds = %1497, %1548
%1550 = phi i64 [ %1498, %1497 ], [ %1500, %1548 ]
%1551 = phi i32 [ 1, %1497 ], [ %45, %1548 ]
br label %1552
1552: ; preds = %1549, %1552
%1553 = phi i64 [ %1557, %1552 ], [ %1550, %1549 ]
%1554 = phi i32 [ %1558, %1552 ], [ %1551, %1549 ]
%1555 = add nsw i32 %1554, %1495
%1556 = getelementptr inbounds i32, i32* %4, i64 %1553
store i32 %1555, i32* %1556
%1557 = add nsw i64 %1553, 1
%1558 = add nuw nsw i32 %1554, 1
%1559 = icmp eq i32 %1558, %8
br i1 %1559, label %1560, label %1552
1560: ; preds = %1552, %1548
%1561 = phi i64 [ %1500, %1548 ], [ %1557, %1552 ]
%1562 = trunc i64 %1561 to i32
br label %1563
1563: ; preds = %1560, %1494
%1564 = phi i32 [ %1496, %1494 ], [ %1562, %1560 ]
%1565 = add nsw i32 %1495, %6
%1566 = icmp slt i32 %1565, %10
br i1 %1566, label %1494, label %1665
1567: ; preds = %13, %1637
%1568 = phi i32 [ %6, %13 ], [ %1639, %1637 ]
%1569 = phi i32 [ 0, %13 ], [ %1638, %1637 ]
br i1 %14, label %1570, label %1637
1570: ; preds = %1567
%1571 = add i32 %1568, %9
%1572 = sext i32 %1569 to i64
br i1 %22, label %1623, label %1573
1573: ; preds = %1570
%1574 = add nsw i64 %23, %1572
%1575 = insertelement <4 x i32> poison, i32 %1571, i64 0
%1576 = shufflevector <4 x i32> %1575, <4 x i32> poison, <4 x i32> zeroinitializer
br i1 %27, label %1608, label %1577
1577: ; preds = %1573
%1578 = add i32 %1571, 4
%1579 = insertelement <4 x i32> poison, i32 %1578, i64 0
%1580 = shufflevector <4 x i32> %1579, <4 x i32> poison, <4 x i32> zeroinitializer
%1581 = add i32 %1571, 4
%1582 = insertelement <4 x i32> poison, i32 %1581, i64 0
%1583 = shufflevector <4 x i32> %1582, <4 x i32> poison, <4 x i32> zeroinitializer
br label %1584
1584: ; preds = %1584, %1577
%1585 = phi i64 [ 0, %1577 ], [ %1604, %1584 ]
%1586 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1577 ], [ %1605, %1584 ]
%1587 = phi i64 [ 0, %1577 ], [ %1606, %1584 ]
%1588 = add i64 %1585, %1572
%1589 = add <4 x i32> %1576, %1586
%1590 = add <4 x i32> %1580, %1586
%1591 = getelementptr inbounds i32, i32* %4, i64 %1588
%1592 = bitcast i32* %1591 to <4 x i32>*
store <4 x i32> %1589, <4 x i32>* %1592
%1593 = getelementptr inbounds i32, i32* %1591, i64 4
%1594 = bitcast i32* %1593 to <4 x i32>*
store <4 x i32> %1590, <4 x i32>* %1594
%1595 = or i64 %1585, 8
%1596 = add <4 x i32> %1586, <i32 8, i32 8, i32 8, i32 8>
%1597 = add i64 %1595, %1572
%1598 = add <4 x i32> %1576, %1596
%1599 = add <4 x i32> %1583, %1596
%1600 = getelementptr inbounds i32, i32* %4, i64 %1597
%1601 = bitcast i32* %1600 to <4 x i32>*
store <4 x i32> %1598, <4 x i32>* %1601
%1602 = getelementptr inbounds i32, i32* %1600, i64 4
%1603 = bitcast i32* %1602 to <4 x i32>*
store <4 x i32> %1599, <4 x i32>* %1603
%1604 = add nuw i64 %1585, 16
%1605 = add <4 x i32> %1586, <i32 16, i32 16, i32 16, i32 16>
%1606 = add i64 %1587, 2
%1607 = icmp eq i64 %1606, %28
br i1 %1607, label %1608, label %1584
1608: ; preds = %1584, %1573
%1609 = phi i64 [ 0, %1573 ], [ %1604, %1584 ]
%1610 = phi <4 x i32> [ <i32 1, i32 2, i32 3, i32 4>, %1573 ], [ %1605, %1584 ]
br i1 %29, label %1622, label %1611
1611: ; preds = %1608
%1612 = add i64 %1609, %1572
%1613 = add <4 x i32> %1576, %1610
%1614 = add i32 %1571, 4
%1615 = insertelement <4 x i32> poison, i32 %1614, i64 0
%1616 = shufflevector <4 x i32> %1615, <4 x i32> poison, <4 x i32> zeroinitializer
%1617 = add <4 x i32> %1616, %1610
%1618 = getelementptr inbounds i32, i32* %4, i64 %1612
%1619 = bitcast i32* %1618 to <4 x i32>*
store <4 x i32> %1613, <4 x i32>* %1619
%1620 = getelementptr inbounds i32, i32* %1618, i64 4
%1621 = bitcast i32* %1620 to <4 x i32>*
store <4 x i32> %1617, <4 x i32>* %1621
br label %1622
1622: ; preds = %1608, %1611
br i1 %30, label %1634, label %1623
1623: ; preds = %1570, %1622
%1624 = phi i64 [ %1572, %1570 ], [ %1574, %1622 ]
%1625 = phi i32 [ 1, %1570 ], [ %25, %1622 ]
br label %1626
1626: ; preds = %1623, %1626
%1627 = phi i64 [ %1631, %1626 ], [ %1624, %1623 ]
%1628 = phi i32 [ %1632, %1626 ], [ %1625, %1623 ]
%1629 = add i32 %1571, %1628
%1630 = getelementptr inbounds i32, i32* %4, i64 %1627
store i32 %1629, i32* %1630
%1631 = add nsw i64 %1627, 1
%1632 = add nuw nsw i32 %1628, 1
%1633 = icmp eq i32 %1632, %8
br i1 %1633, label %1634, label %1626
1634: ; preds = %1626, %1622
%1635 = phi i64 [ %1574, %1622 ], [ %1631, %1626 ]
%1636 = trunc i64 %1635 to i32
br label %1637
1637: ; preds = %1634, %1567
%1638 = phi i32 [ %1569, %1567 ], [ %1636, %1634 ]
%1639 = add nsw i32 %1568, %6
%1640 = icmp slt i32 %1639, %10
br i1 %1640, label %1567, label %1665
1641: ; preds = %949, %629
%1642 = phi i64 [ %558, %629 ], [ %953, %949 ]
%1643 = trunc i64 %1642 to i32
br label %1665
1644: ; preds = %956, %538
%1645 = phi i64 [ %478, %538 ], [ %961, %956 ]
%1646 = trunc i64 %1645 to i32
br label %1665
1647: ; preds = %964, %458
%1648 = phi i64 [ %398, %458 ], [ %969, %964 ]
%1649 = trunc i64 %1648 to i32
br label %1665
1650: ; preds = %1053, %1048
%1651 = phi i64 [ %988, %1048 ], [ %1058, %1053 ]
%1652 = trunc i64 %1651 to i32
br label %1665
1653: ; preds = %1061, %378
%1654 = phi i64 [ %307, %378 ], [ %1065, %1061 ]
%1655 = trunc i64 %1654 to i32
br label %1665
1656: ; preds = %1068, %286
%1657 = phi i64 [ %226, %286 ], [ %1073, %1068 ]
%1658 = trunc i64 %1657 to i32
br label %1665
1659: ; preds = %1076, %205
%1660 = phi i64 [ %145, %205 ], [ %1081, %1076 ]
%1661 = trunc i64 %1660 to i32
br label %1665
1662: ; preds = %1166, %1161
%1663 = phi i64 [ %1101, %1161 ], [ %1171, %1166 ]
%1664 = trunc i64 %1663 to i32
br label %1665
1665: ; preds = %1637, %1563, %1490, %1403, %1317, %1243, %941, %866, %858, %851, %936, %695, %761, %834, %1662, %1659, %1656, %1653, %1650, %1647, %1644, %1641, %11, %31, %51, %70, %89, %109, %1084, %129, %210, %291, %972, %383, %463, %543, %874, %634, %700, %766, %5, %849, %847, %845, %844, %842, %841, %840, %839
%1666 = phi i32 [ 0, %5 ], [ 1, %849 ], [ 1, %847 ], [ 1, %845 ], [ 1, %844 ], [ 1, %842 ], [ 1, %841 ], [ 1, %840 ], [ 1, %839 ], [ 0, %766 ], [ 0, %700 ], [ 0, %634 ], [ 0, %874 ], [ 0, %543 ], [ 0, %463 ], [ 0, %383 ], [ 0, %972 ], [ 0, %291 ], [ 0, %210 ], [ 0, %129 ], [ 0, %1084 ], [ 0, %109 ], [ 0, %89 ], [ 0, %70 ], [ 0, %51 ], [ 0, %31 ], [ 0, %11 ], [ %1643, %1641 ], [ %1646, %1644 ], [ %1649, %1647 ], [ %1652, %1650 ], [ %1655, %1653 ], [ %1658, %1656 ], [ %1661, %1659 ], [ %1664, %1662 ], [ %769, %834 ], [ %703, %761 ], [ %637, %695 ], [ %878, %936 ], [ %769, %851 ], [ %703, %858 ], [ %637, %866 ], [ %878, %941 ], [ %1244, %1243 ], [ %1318, %1317 ], [ %1404, %1403 ], [ %1491, %1490 ], [ %1564, %1563 ], [ %1638, %1637 ]
ret i32 %1666
}