void sortints(int *x, int n) {
  int i, j;
  int a, d, ba, dc, s, nn;
  int tmp1, v, v1, v2, v3;
  int *x0, *xa, *xb, *xc, *xd, *xh, *xl;
  struct {
    int *addr;
    int len;
  } stack[40];
  int top;
  top = 0;
  if (n > 1) {
    stack[top].addr = x;
    stack[top].len = n;
    ++top;
  }
  while (top > 0) {
    --top;
    x0 = stack[top].addr;
    nn = stack[top].len;
    if (nn < 10) {
      for (i = 1; i < nn; ++i) {
        tmp1 = x0[i];
        for (j = i; x0[j - 1] > tmp1;) {
          x0[j] = x0[j - 1];
          if (--j == 0)
            break;
        }
        x0[j] = tmp1;
      }
      continue;
    }
    if (nn < 320)
      v = ((x0[0]) <= (x0[nn / 2])
               ? ((x0[nn / 2]) <= (x0[nn - 1]) ? (x0[nn / 2])
                  : (x0[nn - 1]) <= (x0[0])    ? (x0[0])
                                               : (x0[nn - 1]))
               : ((x0[0]) <= (x0[nn - 1])        ? (x0[0])
                  : (x0[nn - 1]) <= (x0[nn / 2]) ? (x0[nn / 2])
                                                 : (x0[nn - 1])));
    else {
      v1 = ((x0[0]) <= (x0[1]) ? ((x0[1]) <= (x0[2])   ? (x0[1])
                                  : (x0[2]) <= (x0[0]) ? (x0[0])
                                                       : (x0[2]))
                               : ((x0[0]) <= (x0[2])   ? (x0[0])
                                  : (x0[2]) <= (x0[1]) ? (x0[1])
                                                       : (x0[2])));
      v2 = ((x0[nn / 2 - 1]) <= (x0[nn / 2])
                ? ((x0[nn / 2]) <= (x0[nn / 2 + 1])       ? (x0[nn / 2])
                   : (x0[nn / 2 + 1]) <= (x0[nn / 2 - 1]) ? (x0[nn / 2 - 1])
                                                          : (x0[nn / 2 + 1]))
                : ((x0[nn / 2 - 1]) <= (x0[nn / 2 + 1]) ? (x0[nn / 2 - 1])
                   : (x0[nn / 2 + 1]) <= (x0[nn / 2])   ? (x0[nn / 2])
                                                        : (x0[nn / 2 + 1])));
      v3 = ((x0[nn - 3]) <= (x0[nn - 2])
                ? ((x0[nn - 2]) <= (x0[nn - 1])   ? (x0[nn - 2])
                   : (x0[nn - 1]) <= (x0[nn - 3]) ? (x0[nn - 3])
                                                  : (x0[nn - 1]))
                : ((x0[nn - 3]) <= (x0[nn - 1])   ? (x0[nn - 3])
                   : (x0[nn - 1]) <= (x0[nn - 2]) ? (x0[nn - 2])
                                                  : (x0[nn - 1])));
      v = ((v1) <= (v2) ? ((v2) <= (v3)   ? (v2)
                           : (v3) <= (v1) ? (v1)
                                          : (v3))
                        : ((v1) <= (v3)   ? (v1)
                           : (v3) <= (v2) ? (v2)
                                          : (v3)));
    }
    xa = xb = x0;
    xc = xd = x0 + (nn - 1);
    for (;;) {
      while (xb <= xc && *xb <= v) {
        if (*xb == v) {
          *xb = *xa;
          *xa = v;
          ++xa;
        }
        ++xb;
      }
      while (xc >= xb && *xc >= v) {
        if (*xc == v) {
          *xc = *xd;
          *xd = v;
          --xd;
        }
        --xc;
      }
      if (xb > xc)
        break;
      tmp1 = *xb;
      *xb = *xc;
      *xc = tmp1;
      ;
      ++xb;
      --xc;
    }
    a = xa - x0;
    ba = xb - xa;
    if (ba > a)
      s = a;
    else
      s = ba;
    for (xl = x0, xh = xb - s; s > 0; --s) {
      *xl = *xh;
      *xh = v;
      ++xl;
      ++xh;
    }
    d = xd - x0;
    dc = xd - xc;
    if (dc > nn - 1 - d)
      s = nn - 1 - d;
    else
      s = dc;
    for (xl = xb, xh = x0 + (nn - s); s > 0; --s) {
      *xh = *xl;
      *xl = v;
      ++xl;
      ++xh;
    }
    if (ba > dc) {
      if (ba > 1) {
        stack[top].addr = x0;
        stack[top].len = ba;
        ++top;
      }
      if (dc > 1) {
        stack[top].addr = x0 + (nn - dc);
        stack[top].len = dc;
        ++top;
      }
    } else {
      if (dc > 1) {
        stack[top].addr = x0 + (nn - dc);
        stack[top].len = dc;
        ++top;
      }
      if (ba > 1) {
        stack[top].addr = x0;
        stack[top].len = ba;
        ++top;
      }
    }
  }
}


x86 assembly (clang, -O0):
<sortints>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3a0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x304(%rbp)
cmpl   $0x1,-0xc(%rbp)
jle    116c <sortints+0x6c>
mov    -0x8(%rbp),%rcx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0xc(%rbp),%ecx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x304(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x304(%rbp)
jmp    1171 <sortints+0x71>
cmpl   $0x0,-0x304(%rbp)
jle    1edc <sortints+0xddc>
mov    -0x304(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x304(%rbp)
movslq -0x304(%rbp),%rcx
lea    -0x300(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
movslq -0x304(%rbp),%rcx
lea    -0x300(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0xa,-0x2c(%rbp)
jge    1266 <sortints+0x166>
movl   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1261 <sortints+0x161>
mov    -0x48(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x30(%rbp),%eax
jle    1245 <sortints+0x145>
mov    -0x48(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x48(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
cmp    $0x0,%eax
jne    1240 <sortints+0x140>
jmp    1245 <sortints+0x145>
jmp    11f5 <sortints+0xf5>
mov    -0x30(%rbp),%edx
mov    -0x48(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11d5 <sortints+0xd5>
jmp    1171 <sortints+0x71>
cmpl   $0x140,-0x2c(%rbp)
jge    143f <sortints+0x33f>
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x308(%rbp)
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x308(%rbp),%eax
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     136d <sortints+0x26d>
mov    -0x48(%rbp),%rax
mov    %rax,-0x310(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x310(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     130d <sortints+0x20d>
mov    -0x48(%rbp),%rax
mov    %rax,-0x320(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x320(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x314(%rbp)
jmp    135c <sortints+0x25c>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
cmp    (%rcx),%eax
jg     133a <sortints+0x23a>
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x324(%rbp)
jmp    1350 <sortints+0x250>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x324(%rbp)
mov    -0x324(%rbp),%eax
mov    %eax,-0x314(%rbp)
mov    -0x314(%rbp),%eax
mov    %eax,-0x328(%rbp)
jmp    1431 <sortints+0x331>
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     139a <sortints+0x29a>
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x32c(%rbp)
jmp    1425 <sortints+0x325>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x330(%rbp)
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x330(%rbp),%eax
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1403 <sortints+0x303>
mov    -0x48(%rbp),%rax
mov    %rax,-0x340(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x340(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x334(%rbp)
jmp    1419 <sortints+0x319>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x334(%rbp)
mov    -0x334(%rbp),%eax
mov    %eax,-0x32c(%rbp)
mov    -0x32c(%rbp),%eax
mov    %eax,-0x328(%rbp)
mov    -0x328(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1a91 <sortints+0x991>
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    -0x48(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     14c6 <sortints+0x3c6>
mov    -0x48(%rbp),%rax
mov    0x4(%rax),%eax
mov    -0x48(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     1478 <sortints+0x378>
mov    -0x48(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x344(%rbp)
jmp    14b5 <sortints+0x3b5>
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%eax
mov    -0x48(%rbp),%rcx
cmp    (%rcx),%eax
jg     149c <sortints+0x39c>
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x348(%rbp)
jmp    14a9 <sortints+0x3a9>
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x348(%rbp)
mov    -0x348(%rbp),%eax
mov    %eax,-0x344(%rbp)
mov    -0x344(%rbp),%eax
mov    %eax,-0x34c(%rbp)
jmp    1535 <sortints+0x435>
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    -0x48(%rbp),%rcx
cmp    0x8(%rcx),%eax
jg     14ea <sortints+0x3ea>
mov    -0x48(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x350(%rbp)
jmp    1529 <sortints+0x429>
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%eax
mov    -0x48(%rbp),%rcx
cmp    0x4(%rcx),%eax
jg     1510 <sortints+0x410>
mov    -0x48(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x354(%rbp)
jmp    151d <sortints+0x41d>
mov    -0x48(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x354(%rbp)
mov    -0x354(%rbp),%eax
mov    %eax,-0x350(%rbp)
mov    -0x350(%rbp),%eax
mov    %eax,-0x34c(%rbp)
mov    -0x34c(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x360(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x360(%rbp),%rax
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x358(%rbp)
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x358(%rbp),%eax
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     16e2 <sortints+0x5e2>
mov    -0x48(%rbp),%rax
mov    %rax,-0x370(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x370(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x364(%rbp)
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x364(%rbp),%eax
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1610 <sortints+0x510>
mov    -0x48(%rbp),%rax
mov    %rax,-0x380(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x380(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x374(%rbp)
jmp    16d1 <sortints+0x5d1>
mov    -0x48(%rbp),%rax
mov    %rax,-0x390(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x390(%rbp),%rax
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x384(%rbp)
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x384(%rbp),%eax
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1697 <sortints+0x597>
mov    -0x48(%rbp),%rax
mov    %rax,-0x3a0(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3a0(%rbp),%rax
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x394(%rbp)
jmp    16c5 <sortints+0x5c5>
mov    -0x48(%rbp),%rax
mov    %rax,-0x3a8(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3a8(%rbp),%rax
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x394(%rbp)
mov    -0x394(%rbp),%eax
mov    %eax,-0x374(%rbp)
mov    -0x374(%rbp),%eax
mov    %eax,-0x3ac(%rbp)
jmp    1830 <sortints+0x730>
mov    -0x48(%rbp),%rax
mov    %rax,-0x3b8(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3b8(%rbp),%rax
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3b0(%rbp)
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x3b0(%rbp),%eax
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1769 <sortints+0x669>
mov    -0x48(%rbp),%rax
mov    %rax,-0x3c8(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3c8(%rbp),%rax
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3bc(%rbp)
jmp    1824 <sortints+0x724>
mov    -0x48(%rbp),%rax
mov    %rax,-0x3d8(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3d8(%rbp),%rax
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3cc(%rbp)
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x3cc(%rbp),%eax
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     17ea <sortints+0x6ea>
mov    -0x48(%rbp),%rax
mov    %rax,-0x3e8(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3e8(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3dc(%rbp)
jmp    1818 <sortints+0x718>
mov    -0x48(%rbp),%rax
mov    %rax,-0x3f0(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3f0(%rbp),%rax
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3dc(%rbp)
mov    -0x3dc(%rbp),%eax
mov    %eax,-0x3bc(%rbp)
mov    -0x3bc(%rbp),%eax
mov    %eax,-0x3ac(%rbp)
mov    -0x3ac(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1914 <sortints+0x814>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     18a0 <sortints+0x7a0>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3f4(%rbp)
jmp    1903 <sortints+0x803>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x3,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     18e1 <sortints+0x7e1>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3f8(%rbp)
jmp    18f7 <sortints+0x7f7>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3f8(%rbp)
mov    -0x3f8(%rbp),%eax
mov    %eax,-0x3f4(%rbp)
mov    -0x3f4(%rbp),%eax
mov    %eax,-0x3fc(%rbp)
jmp    19c4 <sortints+0x8c4>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1955 <sortints+0x855>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x400(%rbp)
jmp    19b8 <sortints+0x8b8>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1996 <sortints+0x896>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x404(%rbp)
jmp    19ac <sortints+0x8ac>
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x404(%rbp)
mov    -0x404(%rbp),%eax
mov    %eax,-0x400(%rbp)
mov    -0x400(%rbp),%eax
mov    %eax,-0x3fc(%rbp)
mov    -0x3fc(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1a33 <sortints+0x933>
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     19f3 <sortints+0x8f3>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x408(%rbp)
jmp    1a22 <sortints+0x922>
mov    -0x40(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1a0d <sortints+0x90d>
mov    -0x38(%rbp),%eax
mov    %eax,-0x40c(%rbp)
jmp    1a16 <sortints+0x916>
mov    -0x40(%rbp),%eax
mov    %eax,-0x40c(%rbp)
mov    -0x40c(%rbp),%eax
mov    %eax,-0x408(%rbp)
mov    -0x408(%rbp),%eax
mov    %eax,-0x410(%rbp)
jmp    1a88 <sortints+0x988>
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1a4d <sortints+0x94d>
mov    -0x38(%rbp),%eax
mov    %eax,-0x414(%rbp)
jmp    1a7c <sortints+0x97c>
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     1a67 <sortints+0x967>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x418(%rbp)
jmp    1a70 <sortints+0x970>
mov    -0x40(%rbp),%eax
mov    %eax,-0x418(%rbp)
mov    -0x418(%rbp),%eax
mov    %eax,-0x414(%rbp)
mov    -0x414(%rbp),%eax
mov    %eax,-0x410(%rbp)
mov    -0x410(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    %rax,-0x60(%rbp)
jmp    1abe <sortints+0x9be>
mov    -0x58(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp),%rcx
mov    %al,-0x419(%rbp)
ja     1ae6 <sortints+0x9e6>
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
cmp    -0x34(%rbp),%eax
setle  %al
mov    %al,-0x419(%rbp)
mov    -0x419(%rbp),%al
test   $0x1,%al
jne    1af9 <sortints+0x9f9>
jmp    1b3a <sortints+0xa3a>
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
cmp    -0x34(%rbp),%eax
jne    1b29 <sortints+0xa29>
mov    -0x50(%rbp),%rax
mov    (%rax),%ecx
mov    -0x58(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x50(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x50(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x50(%rbp)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
jmp    1abe <sortints+0x9be>
jmp    1b3f <sortints+0xa3f>
mov    -0x60(%rbp),%rcx
xor    %eax,%eax
cmp    -0x58(%rbp),%rcx
mov    %al,-0x41a(%rbp)
jb     1b67 <sortints+0xa67>
mov    -0x60(%rbp),%rax
mov    (%rax),%eax
cmp    -0x34(%rbp),%eax
setge  %al
mov    %al,-0x41a(%rbp)
mov    -0x41a(%rbp),%al
test   $0x1,%al
jne    1b7a <sortints+0xa7a>
jmp    1bbb <sortints+0xabb>
mov    -0x60(%rbp),%rax
mov    (%rax),%eax
cmp    -0x34(%rbp),%eax
jne    1baa <sortints+0xaaa>
mov    -0x68(%rbp),%rax
mov    (%rax),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x68(%rbp)
mov    -0x60(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x60(%rbp)
jmp    1b3f <sortints+0xa3f>
mov    -0x58(%rbp),%rax
cmp    -0x60(%rbp),%rax
jbe    1bce <sortints+0xace>
jmp    1c09 <sortints+0xb09>
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%ecx
mov    -0x58(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x58(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x58(%rbp)
mov    -0x60(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x60(%rbp)
jmp    1ab9 <sortints+0x9b9>
mov    -0x50(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x18(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x18(%rbp),%eax
jle    1c44 <sortints+0xb44>
mov    -0x18(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    1c4a <sortints+0xb4a>
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1caf <sortints+0xbaf>
mov    -0x70(%rbp),%rax
mov    (%rax),%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1c6a <sortints+0xb6a>
mov    -0x68(%rbp),%rax
mov    -0x48(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x1c(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x60(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jle    1cf8 <sortints+0xbf8>
mov    -0x2c(%rbp),%eax
sub    $0x1,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
jmp    1cfe <sortints+0xbfe>
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x70(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    1d63 <sortints+0xc63>
mov    -0x78(%rbp),%rax
mov    (%rax),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x78(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x70(%rbp)
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1d1e <sortints+0xc1e>
mov    -0x20(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    1e23 <sortints+0xd23>
cmpl   $0x1,-0x20(%rbp)
jle    1dbf <sortints+0xcbf>
mov    -0x48(%rbp),%rcx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%ecx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x304(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x304(%rbp)
cmpl   $0x1,-0x24(%rbp)
jle    1e1e <sortints+0xd1e>
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
sub    -0x24(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x304(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x304(%rbp)
jmp    1ed7 <sortints+0xdd7>
cmpl   $0x1,-0x24(%rbp)
jle    1e82 <sortints+0xd82>
mov    -0x48(%rbp),%rcx
mov    -0x2c(%rbp),%eax
sub    -0x24(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x24(%rbp),%ecx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x304(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x304(%rbp)
cmpl   $0x1,-0x20(%rbp)
jle    1ed2 <sortints+0xdd2>
mov    -0x48(%rbp),%rcx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%ecx
movslq -0x304(%rbp),%rdx
lea    -0x300(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x304(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x304(%rbp)
jmp    1ed7 <sortints+0xdd7>
jmp    1171 <sortints+0x71>
add    $0x3a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sortints>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
cmp    $0x2,%esi
jl     17dc <sortints+0x6dc>
mov    %rdi,-0x50(%rsp)
mov    %esi,-0x48(%rsp)
mov    $0x1,%ebp
jmp    113b <sortints+0x3b>
nopw   0x0(%rax,%rax,1)
mov    %r10d,%ebp
test   %ebp,%ebp
jle    17dc <sortints+0x6dc>
lea    -0x1(%rbp),%r10d
mov    %r10,%rcx
shl    $0x4,%rcx
mov    -0x50(%rsp,%rcx,1),%r13
mov    -0x48(%rsp,%rcx,1),%r15d
cmp    $0x9,%r15d
jg     1280 <sortints+0x180>
cmp    $0x2,%r15d
jl     1130 <sortints+0x30>
mov    0x0(%r13),%edx
mov    0x4(%r13),%eax
mov    $0x1,%ecx
cmp    %eax,%edx
jle    1177 <sortints+0x77>
mov    %edx,0x4(%r13)
xor    %ecx,%ecx
mov    %eax,0x0(%r13,%rcx,4)
cmp    $0x2,%r15d
je     1130 <sortints+0x30>
mov    $0x2,%eax
jmp    11a5 <sortints+0xa5>
nopl   0x0(%rax)
lea    -0x1(%rax),%rdx
movslq %edx,%rdx
mov    %ecx,0x0(%r13,%rdx,4)
add    $0x1,%rax
cmp    %rax,%r15
je     1130 <sortints+0x30>
mov    -0x4(%r13,%rax,4),%esi
mov    0x0(%r13,%rax,4),%ecx
mov    %rax,%rdx
cmp    %ecx,%esi
jle    1194 <sortints+0x94>
mov    %esi,0x0(%r13,%rax,4)
mov    -0x8(%r13,%rax,4),%edx
cmp    %ecx,%edx
jle    1190 <sortints+0x90>
mov    %edx,-0x4(%r13,%rax,4)
cmp    $0x2,%rax
jne    11d3 <sortints+0xd3>
xor    %edx,%edx
jmp    1194 <sortints+0x94>
mov    -0xc(%r13,%rax,4),%edx
cmp    %ecx,%edx
jle    1247 <sortints+0x147>
mov    %edx,-0x8(%r13,%rax,4)
cmp    $0x3,%rax
je     11cf <sortints+0xcf>
mov    -0x10(%r13,%rax,4),%edx
cmp    %ecx,%edx
jle    1250 <sortints+0x150>
mov    %edx,-0xc(%r13,%rax,4)
cmp    $0x4,%rax
je     11cf <sortints+0xcf>
mov    -0x14(%r13,%rax,4),%edx
cmp    %ecx,%edx
jle    1259 <sortints+0x159>
mov    %edx,-0x10(%r13,%rax,4)
cmp    $0x5,%rax
je     11cf <sortints+0xcf>
mov    -0x18(%r13,%rax,4),%edx
cmp    %ecx,%edx
jle    1262 <sortints+0x162>
mov    %edx,-0x14(%r13,%rax,4)
cmp    $0x6,%rax
je     11cf <sortints+0xcf>
mov    -0x1c(%r13,%rax,4),%edx
cmp    %ecx,%edx
jle    126b <sortints+0x16b>
mov    %edx,-0x18(%r13,%rax,4)
cmp    $0x7,%rax
je     11cf <sortints+0xcf>
mov    -0x20(%r13,%rax,4),%edx
cmp    %ecx,%edx
jle    1274 <sortints+0x174>
mov    %edx,-0x1c(%r13,%rax,4)
jmp    11cf <sortints+0xcf>
lea    -0x2(%rax),%rdx
jmp    1194 <sortints+0x94>
lea    -0x3(%rax),%rdx
jmp    1194 <sortints+0x94>
lea    -0x4(%rax),%rdx
jmp    1194 <sortints+0x94>
lea    -0x5(%rax),%rdx
jmp    1194 <sortints+0x94>
lea    -0x6(%rax),%rdx
jmp    1194 <sortints+0x94>
lea    -0x7(%rax),%rdx
jmp    1194 <sortints+0x94>
nopl   (%rax)
mov    0x0(%r13),%esi
cmp    $0x13f,%r15d
mov    %rbp,-0x70(%rsp)
ja     12d0 <sortints+0x1d0>
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    0x0(%r13,%rax,2),%eax
lea    -0x1(%r15),%edx
mov    0x0(%r13,%rdx,4),%edx
cmp    %eax,%esi
jle    12ed <sortints+0x1ed>
mov    %esi,%r9d
cmp    %edx,%esi
jle    13b0 <sortints+0x2b0>
cmp    %eax,%edx
cmovg  %edx,%eax
mov    %eax,%r9d
jmp    13b0 <sortints+0x2b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x4(%r13),%edi
mov    0x8(%r13),%eax
cmp    %edi,%esi
jle    1305 <sortints+0x205>
mov    %esi,%r8d
cmp    %eax,%esi
jle    1314 <sortints+0x214>
cmp    %edi,%eax
cmovg  %eax,%edi
mov    %edi,%r8d
jmp    1314 <sortints+0x214>
mov    %eax,%r9d
cmp    %edx,%eax
jle    13b0 <sortints+0x2b0>
cmp    %esi,%edx
cmovg  %edx,%esi
mov    %esi,%r9d
jmp    13b0 <sortints+0x2b0>
mov    %edi,%r8d
cmp    %eax,%edi
jle    1314 <sortints+0x214>
cmp    %esi,%eax
cmovg  %eax,%esi
mov    %esi,%r8d
mov    %r15,%rax
shr    %rax
lea    -0x1(%rax),%edx
mov    0x0(%r13,%rdx,4),%edi
mov    0x0(%r13,%rax,4),%esi
mov    0x4(%r13,%rax,4),%eax
cmp    %esi,%edi
jle    133f <sortints+0x23f>
mov    %edi,%edx
cmp    %eax,%edi
jle    134c <sortints+0x24c>
cmp    %esi,%eax
cmovg  %eax,%esi
mov    %esi,%edx
jmp    134c <sortints+0x24c>
mov    %esi,%edx
cmp    %eax,%esi
jle    134c <sortints+0x24c>
cmp    %edi,%eax
cmovg  %eax,%edi
mov    %edi,%edx
lea    -0x3(%r15),%eax
mov    0x0(%r13,%rax,4),%eax
lea    -0x2(%r15),%esi
mov    0x0(%r13,%rsi,4),%edi
lea    -0x1(%r15),%esi
mov    0x0(%r13,%rsi,4),%ebx
cmp    %edi,%eax
jle    137a <sortints+0x27a>
mov    %eax,%ebp
cmp    %ebx,%eax
jle    1387 <sortints+0x287>
cmp    %edi,%ebx
cmovg  %ebx,%edi
mov    %edi,%ebp
jmp    1387 <sortints+0x287>
mov    %edi,%ebp
cmp    %ebx,%edi
jle    1387 <sortints+0x287>
cmp    %eax,%ebx
cmovg  %ebx,%eax
mov    %eax,%ebp
cmp    %edx,%r8d
jle    139e <sortints+0x29e>
mov    %r8d,%r9d
cmp    %ebp,%r8d
jle    13b0 <sortints+0x2b0>
cmp    %edx,%ebp
cmovg  %ebp,%edx
mov    %edx,%r9d
jmp    13b0 <sortints+0x2b0>
mov    %edx,%r9d
cmp    %ebp,%edx
jle    13b0 <sortints+0x2b0>
cmp    %r8d,%ebp
cmovg  %ebp,%r8d
mov    %r8d,%r9d
nop
lea    (%rsp,%rcx,1),%rax
add    $0xffffffffffffffb0,%rax
mov    %rax,-0x78(%rsp)
lea    -0x1(%r15),%ebx
lea    0x0(%r13,%rbx,4),%rcx
mov    %r13,%rsi
mov    %r13,%rdx
mov    %rcx,%r12
cmp    %rcx,%rdx
jbe    13e9 <sortints+0x2e9>
jmp    1404 <sortints+0x304>
cs nopw 0x0(%rax,%rax,1)
add    $0x4,%rdx
cmp    %rcx,%rdx
ja     1404 <sortints+0x304>
cmp    %r9d,(%rdx)
jg     1404 <sortints+0x304>
jne    13e0 <sortints+0x2e0>
mov    (%rsi),%eax
mov    %eax,(%rdx)
mov    %r9d,(%rsi)
add    $0x4,%rsi
jmp    13e0 <sortints+0x2e0>
nopl   (%rax)
add    $0xfffffffffffffffc,%rcx
cmp    %rdx,%rcx
jb     1440 <sortints+0x340>
mov    (%rcx),%eax
cmp    %r9d,%eax
jl     1422 <sortints+0x322>
jne    1400 <sortints+0x300>
mov    (%r12),%eax
mov    %eax,(%rcx)
mov    %r9d,(%r12)
add    $0xfffffffffffffffc,%r12
jmp    1400 <sortints+0x300>
mov    (%rdx),%edi
mov    %eax,(%rdx)
mov    %edi,(%rcx)
add    $0x4,%rdx
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%rdx
jbe    13e9 <sortints+0x2e9>
jmp    1404 <sortints+0x304>
nopw   0x0(%rax,%rax,1)
mov    %rdx,%r14
sub    %rsi,%r14
sub    %r13,%rsi
shr    $0x2,%rsi
shr    $0x2,%r14
cmp    %esi,%r14d
cmovle %r14d,%esi
test   %esi,%esi
jle    14c7 <sortints+0x3c7>
mov    %esi,%r11d
lea    0x0(,%r11,4),%rax
mov    %rdx,%r8
sub    %rax,%r8
lea    -0x1(%rsi),%ebp
cmp    $0x7,%ebp
jb     14a0 <sortints+0x3a0>
mov    %rbp,%rax
sub    %r11,%rax
lea    (%rdx,%rax,4),%rax
add    $0x4,%rax
cmp    %rax,%r13
jae    16c1 <sortints+0x5c1>
lea    0x4(,%rbp,4),%rax
add    %r13,%rax
cmp    %rax,%r8
jae    16c1 <sortints+0x5c1>
mov    %r13,%rdi
add    $0x1,%esi
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    (%r8,%rax,1),%ebp
mov    %ebp,(%rdi,%rax,1)
mov    %r9d,(%r8,%rax,1)
add    $0x4,%rax
add    $0xffffffff,%esi
cmp    $0x1,%esi
ja     14b0 <sortints+0x3b0>
mov    %r12,%rax
sub    %r13,%rax
shr    $0x2,%rax
sub    %rcx,%r12
shr    $0x2,%r12
sub    %eax,%ebx
cmp    %r12d,%ebx
cmovge %r12d,%ebx
test   %ebx,%ebx
jle    1636 <sortints+0x536>
mov    %r15d,%eax
sub    %ebx,%eax
movslq %eax,%rdi
lea    0x0(,%rdi,4),%rcx
add    %r13,%rcx
lea    -0x1(%rbx),%esi
cmp    $0x7,%esi
jb     1610 <sortints+0x510>
lea    (%rdx,%rsi,4),%rax
add    $0x4,%rax
cmp    %rax,%rcx
jae    1535 <sortints+0x435>
movslq %r15d,%rax
add    %rsi,%rax
movslq %ebx,%rbp
sub    %rbp,%rax
lea    0x4(,%rax,4),%rax
add    %r13,%rax
cmp    %rax,%rdx
jb     1610 <sortints+0x510>
mov    %r10,%r11
add    $0x1,%rsi
mov    %rsi,%r8
movabs $0x1fffffff8,%rax
and    %rax,%r8
movd   %r9d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%r8),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     17c0 <sortints+0x6c0>
mov    %r10,%rbp
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%rbp
lea    0x30(,%rdi,4),%rax
add    %r13,%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rdi,4),%xmm1
movups 0x10(%rdx,%rdi,4),%xmm2
movups %xmm1,-0x30(%rax,%rdi,4)
movups %xmm2,-0x20(%rax,%rdi,4)
movdqu %xmm0,(%rdx,%rdi,4)
movdqu %xmm0,0x10(%rdx,%rdi,4)
movups 0x20(%rdx,%rdi,4),%xmm1
movups 0x30(%rdx,%rdi,4),%xmm2
movups %xmm1,-0x10(%rax,%rdi,4)
movups %xmm2,(%rax,%rdi,4)
movdqu %xmm0,0x20(%rdx,%rdi,4)
movdqu %xmm0,0x30(%rdx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1590 <sortints+0x490>
test   $0x1,%r10b
je     15fa <sortints+0x4fa>
movups (%rdx,%rdi,4),%xmm1
movups 0x10(%rdx,%rdi,4),%xmm2
movups %xmm1,(%rcx,%rdi,4)
movups %xmm2,0x10(%rcx,%rdi,4)
movdqu %xmm0,(%rdx,%rdi,4)
movdqu %xmm0,0x10(%rdx,%rdi,4)
cmp    %r8,%rsi
mov    %r11,%r10
je     1636 <sortints+0x536>
lea    (%rdx,%r8,4),%rdx
lea    (%rcx,%r8,4),%rcx
sub    %r8d,%ebx
nopl   (%rax)
add    $0x1,%ebx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%rax,1),%esi
mov    %esi,(%rcx,%rax,1)
mov    %r9d,(%rdx,%rax,1)
add    $0x4,%rax
add    $0xffffffff,%ebx
cmp    $0x1,%ebx
ja     1620 <sortints+0x520>
cmp    %r12d,%r14d
jle    1670 <sortints+0x570>
cmp    $0x2,%r14d
jl     164f <sortints+0x54f>
mov    -0x78(%rsp),%rax
mov    %r14d,0x8(%rax)
mov    -0x70(%rsp),%r10
cmp    $0x2,%r12d
jl     1130 <sortints+0x30>
sub    %r12d,%r15d
movslq %r15d,%rax
lea    0x0(%r13,%rax,4),%r13
mov    %r12d,%r14d
jmp    16a5 <sortints+0x5a5>
nopl   0x0(%rax)
cmp    $0x2,%r12d
jl     1698 <sortints+0x598>
sub    %r12d,%r15d
movslq %r15d,%rax
lea    0x0(,%rax,4),%rax
add    %r13,%rax
mov    -0x78(%rsp),%rcx
mov    %rax,(%rcx)
mov    %r12d,0x8(%rcx)
mov    -0x70(%rsp),%r10
mov    %r10d,%ebp
cmp    $0x2,%r14d
jl     1133 <sortints+0x33>
movslq %r10d,%rbp
mov    %rbp,%rax
shl    $0x4,%rax
mov    %r13,-0x50(%rsp,%rax,1)
mov    %r14d,-0x48(%rsp,%rax,1)
add    $0x1,%ebp
jmp    1133 <sortints+0x33>
mov    %r10,-0x58(%rsp)
add    $0x1,%rbp
mov    %rbp,%rdi
movabs $0x1fffffff8,%rax
and    %rax,%rdi
movd   %r9d,%xmm0
pshufd $0x0,%xmm0,%xmm0
mov    %rdi,-0x60(%rsp)
lea    -0x8(%rdi),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
mov    %r10,-0x68(%rsp)
je     17d1 <sortints+0x6d1>
neg    %r11
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
and    %rax,%r10
lea    (%rdx,%r11,4),%rax
add    $0x30,%rax
xor    %edi,%edi
movups -0x30(%rax,%rdi,4),%xmm1
movups -0x20(%rax,%rdi,4),%xmm2
movups %xmm1,0x0(%r13,%rdi,4)
movups %xmm2,0x10(%r13,%rdi,4)
movdqu %xmm0,-0x30(%rax,%rdi,4)
movdqu %xmm0,-0x20(%rax,%rdi,4)
movups -0x10(%rax,%rdi,4),%xmm1
movups (%rax,%rdi,4),%xmm2
movups %xmm1,0x20(%r13,%rdi,4)
movups %xmm2,0x30(%r13,%rdi,4)
movdqu %xmm0,-0x10(%rax,%rdi,4)
movdqu %xmm0,(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%r10
jne    1720 <sortints+0x620>
testb  $0x1,-0x68(%rsp)
je     1797 <sortints+0x697>
movups (%r8,%rdi,4),%xmm1
movups 0x10(%r8,%rdi,4),%xmm2
movups %xmm1,0x0(%r13,%rdi,4)
movups %xmm2,0x10(%r13,%rdi,4)
movdqu %xmm0,(%r8,%rdi,4)
movdqu %xmm0,0x10(%r8,%rdi,4)
mov    -0x60(%rsp),%rax
cmp    %rax,%rbp
mov    -0x58(%rsp),%r10
je     14c7 <sortints+0x3c7>
lea    0x0(,%rax,4),%rdi
add    %r13,%rdi
lea    (%r8,%rax,4),%r8
sub    %eax,%esi
jmp    14a3 <sortints+0x3a3>
xor    %edi,%edi
test   $0x1,%r10b
jne    15dd <sortints+0x4dd>
jmp    15fa <sortints+0x4fa>
xor    %edi,%edi
testb  $0x1,-0x68(%rsp)
jne    1773 <sortints+0x673>
jmp    1797 <sortints+0x697>
add    $0x238,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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