void sortindirect(int *x, int *y, int n) {
  int i, j;
  int a, d, ba, dc, s, nn;
  int tmp2, v, v1, v2, v3;
  int tmp1, *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];
        tmp2 = y[tmp1];
        for (j = i; y[x0[j - 1]] > tmp2;) {
          x0[j] = x0[j - 1];
          if (--j == 0)
            break;
        }
        x0[j] = tmp1;
      }
      continue;
    }
    if (nn < 320)
      v = ((y[x0[0]]) <= (y[x0[nn / 2]])
               ? ((y[x0[nn / 2]]) <= (y[x0[nn - 1]]) ? (y[x0[nn / 2]])
                  : (y[x0[nn - 1]]) <= (y[x0[0]])    ? (y[x0[0]])
                                                     : (y[x0[nn - 1]]))
               : ((y[x0[0]]) <= (y[x0[nn - 1]])        ? (y[x0[0]])
                  : (y[x0[nn - 1]]) <= (y[x0[nn / 2]]) ? (y[x0[nn / 2]])
                                                       : (y[x0[nn - 1]])));
    else {
      v1 = ((y[x0[0]]) <= (y[x0[1]])
                ? ((y[x0[1]]) <= (y[x0[2]])   ? (y[x0[1]])
                   : (y[x0[2]]) <= (y[x0[0]]) ? (y[x0[0]])
                                              : (y[x0[2]]))
                : ((y[x0[0]]) <= (y[x0[2]])   ? (y[x0[0]])
                   : (y[x0[2]]) <= (y[x0[1]]) ? (y[x0[1]])
                                              : (y[x0[2]])));
      v2 = ((y[x0[nn / 2 - 1]]) <= (y[x0[nn / 2]])
                ? ((y[x0[nn / 2]]) <= (y[x0[nn / 2 + 1]]) ? (y[x0[nn / 2]])
                   : (y[x0[nn / 2 + 1]]) <= (y[x0[nn / 2 - 1]])
                       ? (y[x0[nn / 2 - 1]])
                       : (y[x0[nn / 2 + 1]]))
                : ((y[x0[nn / 2 - 1]]) <= (y[x0[nn / 2 + 1]])
                       ? (y[x0[nn / 2 - 1]])
                   : (y[x0[nn / 2 + 1]]) <= (y[x0[nn / 2]])
                       ? (y[x0[nn / 2]])
                       : (y[x0[nn / 2 + 1]])));
      v3 = ((y[x0[nn - 3]]) <= (y[x0[nn - 2]])
                ? ((y[x0[nn - 2]]) <= (y[x0[nn - 1]])   ? (y[x0[nn - 2]])
                   : (y[x0[nn - 1]]) <= (y[x0[nn - 3]]) ? (y[x0[nn - 3]])
                                                        : (y[x0[nn - 1]]))
                : ((y[x0[nn - 3]]) <= (y[x0[nn - 1]])   ? (y[x0[nn - 3]])
                   : (y[x0[nn - 1]]) <= (y[x0[nn - 2]]) ? (y[x0[nn - 2]])
                                                        : (y[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 && y[*xb] <= v) {
        if (y[*xb] == v) {
          tmp1 = *xa;
          *xa = *xb;
          *xb = tmp1;
          ;
          ++xa;
        }
        ++xb;
      }
      while (xc >= xb && y[*xc] >= v) {
        if (y[*xc] == v) {
          tmp1 = *xc;
          *xc = *xd;
          *xd = tmp1;
          ;
          --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) {
      tmp1 = *xl;
      *xl = *xh;
      *xh = tmp1;
      ;
      ++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) {
      tmp1 = *xl;
      *xl = *xh;
      *xh = tmp1;
      ;
      ++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):
<sortindirect>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3f0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x314(%rbp)
cmpl   $0x1,-0x14(%rbp)
jle    1170 <sortindirect+0x70>
mov    -0x8(%rbp),%rcx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x14(%rbp),%ecx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x314(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x314(%rbp)
jmp    1175 <sortindirect+0x75>
cmpl   $0x0,-0x314(%rbp)
jle    21ba <sortindirect+0x10ba>
mov    -0x314(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x314(%rbp)
movslq -0x314(%rbp),%rcx
lea    -0x310(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
movslq -0x314(%rbp),%rcx
lea    -0x310(%rbp),%rax
shl    $0x4,%rcx
add    %rcx,%rax
mov    0x8(%rax),%eax
mov    %eax,-0x34(%rbp)
cmpl   $0xa,-0x34(%rbp)
jge    1280 <sortindirect+0x180>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    127b <sortindirect+0x17b>
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x38(%rbp),%eax
jle    125f <sortindirect+0x15f>
mov    -0x58(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jne    125a <sortindirect+0x15a>
jmp    125f <sortindirect+0x15f>
jmp    1207 <sortindirect+0x107>
mov    -0x4c(%rbp),%edx
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11d9 <sortindirect+0xd9>
jmp    1175 <sortindirect+0x75>
cmpl   $0x140,-0x34(%rbp)
jge    14f5 <sortindirect+0x3f5>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x318(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    %rax,-0x320(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x320(%rbp),%rdx
mov    %eax,%esi
mov    -0x318(%rbp),%eax
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     13dd <sortindirect+0x2dd>
mov    -0x10(%rbp),%rax
mov    %rax,-0x328(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x328(%rbp),%rax
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     135d <sortindirect+0x25d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x338(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x338(%rbp),%rax
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x32c(%rbp)
jmp    13cc <sortindirect+0x2cc>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
movslq (%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     13a2 <sortindirect+0x2a2>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x33c(%rbp)
jmp    13c0 <sortindirect+0x2c0>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x33c(%rbp)
mov    -0x33c(%rbp),%eax
mov    %eax,-0x32c(%rbp)
mov    -0x32c(%rbp),%eax
mov    %eax,-0x340(%rbp)
jmp    14e7 <sortindirect+0x3e7>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1422 <sortindirect+0x322>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x344(%rbp)
jmp    14db <sortindirect+0x3db>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x348(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    %rax,-0x350(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x350(%rbp),%rdx
mov    %eax,%esi
mov    -0x348(%rbp),%eax
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     14b1 <sortindirect+0x3b1>
mov    -0x10(%rbp),%rax
mov    %rax,-0x360(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x360(%rbp),%rax
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x354(%rbp)
jmp    14cf <sortindirect+0x3cf>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x354(%rbp)
mov    -0x354(%rbp),%eax
mov    %eax,-0x344(%rbp)
mov    -0x344(%rbp),%eax
mov    %eax,-0x340(%rbp)
mov    -0x340(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1d0d <sortindirect+0xc0d>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
movslq 0x4(%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     15c4 <sortindirect+0x4c4>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
movslq 0x8(%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1556 <sortindirect+0x456>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x364(%rbp)
jmp    15b3 <sortindirect+0x4b3>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq 0x8(%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
movslq (%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1592 <sortindirect+0x492>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x368(%rbp)
jmp    15a7 <sortindirect+0x4a7>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq 0x8(%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x368(%rbp)
mov    -0x368(%rbp),%eax
mov    %eax,-0x364(%rbp)
mov    -0x364(%rbp),%eax
mov    %eax,-0x36c(%rbp)
jmp    166b <sortindirect+0x56b>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
movslq 0x8(%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1600 <sortindirect+0x500>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x370(%rbp)
jmp    165f <sortindirect+0x55f>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq 0x8(%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
movslq 0x4(%rdx),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     163e <sortindirect+0x53e>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq 0x4(%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x374(%rbp)
jmp    1653 <sortindirect+0x553>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq 0x8(%rcx),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x374(%rbp)
mov    -0x374(%rbp),%eax
mov    %eax,-0x370(%rbp)
mov    -0x370(%rbp),%eax
mov    %eax,-0x36c(%rbp)
mov    -0x36c(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x388(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x388(%rbp),%rax
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x378(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    %rax,-0x380(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x380(%rbp),%rdx
mov    %eax,%esi
mov    -0x378(%rbp),%eax
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     188a <sortindirect+0x78a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x3a0(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x3a0(%rbp),%rax
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38c(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    %rax,-0x398(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x398(%rbp),%rdx
mov    %eax,%esi
mov    -0x38c(%rbp),%eax
add    $0x1,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     178a <sortindirect+0x68a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x3b0(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x3b0(%rbp),%rax
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3a4(%rbp)
jmp    1879 <sortindirect+0x779>
mov    -0x10(%rbp),%rax
mov    %rax,-0x3c8(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x3c8(%rbp),%rax
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3b4(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    %rax,-0x3c0(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x3c0(%rbp),%rdx
mov    %eax,%esi
mov    -0x3b4(%rbp),%eax
sub    $0x1,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1837 <sortindirect+0x737>
mov    -0x10(%rbp),%rax
mov    %rax,-0x3d8(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x3d8(%rbp),%rax
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3cc(%rbp)
jmp    186d <sortindirect+0x76d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x3e0(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x3e0(%rbp),%rax
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3cc(%rbp)
mov    -0x3cc(%rbp),%eax
mov    %eax,-0x3a4(%rbp)
mov    -0x3a4(%rbp),%eax
mov    %eax,-0x3e4(%rbp)
jmp    1a2c <sortindirect+0x92c>
mov    -0x10(%rbp),%rax
mov    %rax,-0x3f8(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x3f8(%rbp),%rax
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3e8(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    %rax,-0x3f0(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x3f0(%rbp),%rdx
mov    %eax,%esi
mov    -0x3e8(%rbp),%eax
add    $0x1,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1937 <sortindirect+0x837>
mov    -0x10(%rbp),%rax
mov    %rax,-0x408(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x408(%rbp),%rax
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3fc(%rbp)
jmp    1a20 <sortindirect+0x920>
mov    -0x10(%rbp),%rax
mov    %rax,-0x420(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x420(%rbp),%rax
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40c(%rbp)
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rax
mov    %rax,-0x418(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    -0x418(%rbp),%rdx
mov    %eax,%esi
mov    -0x40c(%rbp),%eax
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     19de <sortindirect+0x8de>
mov    -0x10(%rbp),%rax
mov    %rax,-0x430(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x430(%rbp),%rax
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x424(%rbp)
jmp    1a14 <sortindirect+0x914>
mov    -0x10(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x438(%rbp),%rax
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x424(%rbp)
mov    -0x424(%rbp),%eax
mov    %eax,-0x3fc(%rbp)
mov    -0x3fc(%rbp),%eax
mov    %eax,-0x3e4(%rbp)
mov    -0x3e4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x3,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    -0x34(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1b58 <sortindirect+0xa58>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1ac4 <sortindirect+0x9c4>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x43c(%rbp)
jmp    1b47 <sortindirect+0xa47>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    -0x34(%rbp),%esi
sub    $0x3,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1b1d <sortindirect+0xa1d>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x3,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x440(%rbp)
jmp    1b3b <sortindirect+0xa3b>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x440(%rbp)
mov    -0x440(%rbp),%eax
mov    %eax,-0x43c(%rbp)
mov    -0x43c(%rbp),%eax
mov    %eax,-0x444(%rbp)
jmp    1c40 <sortindirect+0xb40>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x3,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    -0x34(%rbp),%esi
sub    $0x1,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1bb1 <sortindirect+0xab1>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x3,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x448(%rbp)
jmp    1c34 <sortindirect+0xb34>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
mov    -0x58(%rbp),%rdx
mov    -0x34(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
movslq (%rdx,%rsi,4),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1c0a <sortindirect+0xb0a>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x2,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44c(%rbp)
jmp    1c28 <sortindirect+0xb28>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44c(%rbp)
mov    -0x44c(%rbp),%eax
mov    %eax,-0x448(%rbp)
mov    -0x448(%rbp),%eax
mov    %eax,-0x444(%rbp)
mov    -0x444(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1caf <sortindirect+0xbaf>
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1c6f <sortindirect+0xb6f>
mov    -0x44(%rbp),%eax
mov    %eax,-0x450(%rbp)
jmp    1c9e <sortindirect+0xb9e>
mov    -0x48(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     1c89 <sortindirect+0xb89>
mov    -0x40(%rbp),%eax
mov    %eax,-0x454(%rbp)
jmp    1c92 <sortindirect+0xb92>
mov    -0x48(%rbp),%eax
mov    %eax,-0x454(%rbp)
mov    -0x454(%rbp),%eax
mov    %eax,-0x450(%rbp)
mov    -0x450(%rbp),%eax
mov    %eax,-0x458(%rbp)
jmp    1d04 <sortindirect+0xc04>
mov    -0x40(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     1cc9 <sortindirect+0xbc9>
mov    -0x40(%rbp),%eax
mov    %eax,-0x45c(%rbp)
jmp    1cf8 <sortindirect+0xbf8>
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1ce3 <sortindirect+0xbe3>
mov    -0x44(%rbp),%eax
mov    %eax,-0x460(%rbp)
jmp    1cec <sortindirect+0xbec>
mov    -0x48(%rbp),%eax
mov    %eax,-0x460(%rbp)
mov    -0x460(%rbp),%eax
mov    %eax,-0x45c(%rbp)
mov    -0x45c(%rbp),%eax
mov    %eax,-0x458(%rbp)
mov    -0x458(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    %rax,-0x60(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    %rax,-0x70(%rbp)
jmp    1d3a <sortindirect+0xc3a>
mov    -0x68(%rbp),%rcx
xor    %eax,%eax
cmp    -0x70(%rbp),%rcx
mov    %al,-0x461(%rbp)
ja     1d6a <sortindirect+0xc6a>
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
setle  %al
mov    %al,-0x461(%rbp)
mov    -0x461(%rbp),%al
test   $0x1,%al
jne    1d7d <sortindirect+0xc7d>
jmp    1dcf <sortindirect+0xccf>
mov    -0x10(%rbp),%rax
mov    -0x68(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    1dbe <sortindirect+0xcbe>
mov    -0x60(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x68(%rbp),%rax
mov    (%rax),%ecx
mov    -0x60(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x60(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x60(%rbp)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
jmp    1d3a <sortindirect+0xc3a>
jmp    1dd4 <sortindirect+0xcd4>
mov    -0x70(%rbp),%rcx
xor    %eax,%eax
cmp    -0x68(%rbp),%rcx
mov    %al,-0x462(%rbp)
jb     1e04 <sortindirect+0xd04>
mov    -0x10(%rbp),%rax
mov    -0x70(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
setge  %al
mov    %al,-0x462(%rbp)
mov    -0x462(%rbp),%al
test   $0x1,%al
jne    1e17 <sortindirect+0xd17>
jmp    1e69 <sortindirect+0xd69>
mov    -0x10(%rbp),%rax
mov    -0x70(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    1e58 <sortindirect+0xd58>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x78(%rbp),%rax
mov    (%rax),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x78(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x70(%rbp)
jmp    1dd4 <sortindirect+0xcd4>
mov    -0x68(%rbp),%rax
cmp    -0x70(%rbp),%rax
jbe    1e7c <sortindirect+0xd7c>
jmp    1eb7 <sortindirect+0xdb7>
mov    -0x68(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x70(%rbp),%rax
mov    (%rax),%ecx
mov    -0x68(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x68(%rbp)
mov    -0x70(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x70(%rbp)
jmp    1d35 <sortindirect+0xc35>
mov    -0x60(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x20(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x60(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1ef2 <sortindirect+0xdf2>
mov    -0x20(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1ef8 <sortindirect+0xdf8>
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x30(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    1f75 <sortindirect+0xe75>
mov    -0x88(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x88(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x80(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x88(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1f1b <sortindirect+0xe1b>
mov    -0x78(%rbp),%rax
mov    -0x58(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x24(%rbp)
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%rcx
sub    %rcx,%rax
sar    $0x2,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jle    1fbe <sortindirect+0xebe>
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1fc4 <sortindirect+0xec4>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x58(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0x30(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
cmpl   $0x0,-0x30(%rbp)
jle    2041 <sortindirect+0xf41>
mov    -0x88(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x80(%rbp),%rax
mov    (%rax),%ecx
mov    -0x88(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%ecx
mov    -0x80(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x88(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x88(%rbp)
mov    -0x80(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x80(%rbp)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    1fe7 <sortindirect+0xee7>
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jle    2101 <sortindirect+0x1001>
cmpl   $0x1,-0x28(%rbp)
jle    209d <sortindirect+0xf9d>
mov    -0x58(%rbp),%rcx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x28(%rbp),%ecx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x314(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x314(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jle    20fc <sortindirect+0xffc>
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x2c(%rbp),%ecx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x314(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x314(%rbp)
jmp    21b5 <sortindirect+0x10b5>
cmpl   $0x1,-0x2c(%rbp)
jle    2160 <sortindirect+0x1060>
mov    -0x58(%rbp),%rcx
mov    -0x34(%rbp),%eax
sub    -0x2c(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rcx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x2c(%rbp),%ecx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x314(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x314(%rbp)
cmpl   $0x1,-0x28(%rbp)
jle    21b0 <sortindirect+0x10b0>
mov    -0x58(%rbp),%rcx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %rcx,(%rax)
mov    -0x28(%rbp),%ecx
movslq -0x314(%rbp),%rdx
lea    -0x310(%rbp),%rax
shl    $0x4,%rdx
add    %rdx,%rax
mov    %ecx,0x8(%rax)
mov    -0x314(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x314(%rbp)
jmp    21b5 <sortindirect+0x10b5>
jmp    1175 <sortindirect+0x75>
add    $0x3f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sortindirect>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x238,%rsp
cmp    $0x2,%edx
jl     1876 <sortindirect+0x776>
mov    %rdi,-0x50(%rsp)
mov    %edx,-0x48(%rsp)
mov    $0x1,%ebp
jmp    113b <sortindirect+0x3b>
nopw   0x0(%rax,%rax,1)
mov    %r10d,%ebp
test   %ebp,%ebp
jle    1876 <sortindirect+0x776>
lea    -0x1(%rbp),%r10d
mov    %r10,%rax
shl    $0x4,%rax
mov    -0x50(%rsp,%rax,1),%r14
mov    -0x48(%rsp,%rax,1),%r12d
cmp    $0x9,%r12d
jg     1170 <sortindirect+0x70>
cmp    $0x2,%r12d
jl     1130 <sortindirect+0x30>
add    $0xffffffffffffffff,%r12
mov    $0x1,%eax
xor    %ecx,%ecx
jmp    177a <sortindirect+0x67a>
nopl   0x0(%rax)
movslq (%r14),%rcx
mov    (%rsi,%rcx,4),%edx
cmp    $0x13f,%r12d
mov    %rbp,-0x70(%rsp)
ja     11c0 <sortindirect+0xc0>
mov    %r12d,%ecx
and    $0xfffffffe,%ecx
movslq (%r14,%rcx,2),%rcx
mov    (%rsi,%rcx,4),%ecx
lea    -0x1(%r12),%edi
movslq (%r14,%rdi,4),%rdi
mov    (%rsi,%rdi,4),%edi
cmp    %ecx,%edx
jle    11e3 <sortindirect+0xe3>
mov    %edx,%ebp
cmp    %edi,%edx
jle    12c0 <sortindirect+0x1c0>
cmp    %ecx,%edi
cmovg  %edi,%ecx
mov    %ecx,%ebp
jmp    12c0 <sortindirect+0x1c0>
nopw   0x0(%rax,%rax,1)
movslq 0x4(%r14),%rcx
mov    (%rsi,%rcx,4),%edi
movslq 0x8(%r14),%rcx
mov    (%rsi,%rcx,4),%ecx
cmp    %edi,%edx
jle    11f9 <sortindirect+0xf9>
mov    %edx,%r8d
cmp    %ecx,%edx
jle    1208 <sortindirect+0x108>
cmp    %edi,%ecx
cmovg  %ecx,%edi
mov    %edi,%r8d
jmp    1208 <sortindirect+0x108>
mov    %ecx,%ebp
cmp    %edi,%ecx
jle    12c0 <sortindirect+0x1c0>
cmp    %edx,%edi
cmovg  %edi,%edx
mov    %edx,%ebp
jmp    12c0 <sortindirect+0x1c0>
mov    %edi,%r8d
cmp    %ecx,%edi
jle    1208 <sortindirect+0x108>
cmp    %edx,%ecx
cmovg  %ecx,%edx
mov    %edx,%r8d
mov    %r12,%rdi
shr    %rdi
lea    -0x1(%rdi),%ecx
movslq (%r14,%rcx,4),%rcx
mov    (%rsi,%rcx,4),%ecx
movslq (%r14,%rdi,4),%rdx
mov    (%rsi,%rdx,4),%edx
movslq 0x4(%r14,%rdi,4),%rdi
mov    (%rsi,%rdi,4),%edi
cmp    %edx,%ecx
jle    123c <sortindirect+0x13c>
mov    %ecx,%r9d
cmp    %edi,%ecx
jle    124b <sortindirect+0x14b>
cmp    %edx,%edi
cmovg  %edi,%edx
mov    %edx,%r9d
jmp    124b <sortindirect+0x14b>
mov    %edx,%r9d
cmp    %edi,%edx
jle    124b <sortindirect+0x14b>
cmp    %ecx,%edi
cmovg  %edi,%ecx
mov    %ecx,%r9d
lea    -0x3(%r12),%ecx
movslq (%r14,%rcx,4),%rcx
mov    (%rsi,%rcx,4),%edi
lea    -0x2(%r12),%ecx
movslq (%r14,%rcx,4),%rcx
mov    (%rsi,%rcx,4),%ebx
lea    -0x1(%r12),%ecx
movslq (%r14,%rcx,4),%rcx
mov    (%rsi,%rcx,4),%ebp
cmp    %ebx,%edi
jle    1282 <sortindirect+0x182>
mov    %edi,%ecx
cmp    %ebp,%edi
jle    128f <sortindirect+0x18f>
cmp    %ebx,%ebp
cmovg  %ebp,%ebx
mov    %ebx,%ecx
jmp    128f <sortindirect+0x18f>
mov    %ebx,%ecx
cmp    %ebp,%ebx
jle    128f <sortindirect+0x18f>
cmp    %edi,%ebp
cmovg  %ebp,%edi
mov    %edi,%ecx
cmp    %r9d,%r8d
jle    12a8 <sortindirect+0x1a8>
mov    %r8d,%ebp
cmp    %ecx,%r8d
jle    12c0 <sortindirect+0x1c0>
cmp    %r9d,%ecx
cmovg  %ecx,%r9d
mov    %r9d,%ebp
jmp    12c0 <sortindirect+0x1c0>
mov    %r9d,%ebp
cmp    %ecx,%r9d
jle    12c0 <sortindirect+0x1c0>
cmp    %r8d,%ecx
cmovg  %ecx,%r8d
mov    %r8d,%ebp
nopw   0x0(%rax,%rax,1)
add    %rsp,%rax
add    $0xffffffffffffffb0,%rax
mov    %rax,-0x78(%rsp)
lea    -0x1(%r12),%r8d
lea    (%r14,%r8,4),%rcx
mov    %r14,%rdi
mov    %r14,%r13
mov    %rcx,%r15
cmp    %rcx,%r13
jbe    12f9 <sortindirect+0x1f9>
jmp    1324 <sortindirect+0x224>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x4,%r13
cmp    %rcx,%r13
ja     1324 <sortindirect+0x224>
movslq 0x0(%r13),%rax
cmp    %ebp,(%rsi,%rax,4)
jg     1324 <sortindirect+0x224>
jne    12f0 <sortindirect+0x1f0>
mov    (%rdi),%ebx
mov    %eax,(%rdi)
mov    %ebx,0x0(%r13)
add    $0x4,%rdi
jmp    12f0 <sortindirect+0x1f0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xfffffffffffffffc,%rcx
cmp    %r13,%rcx
jb     1360 <sortindirect+0x260>
movslq (%rcx),%rax
cmp    %ebp,(%rsi,%rax,4)
jl     1341 <sortindirect+0x241>
jne    1320 <sortindirect+0x220>
mov    (%r15),%ebx
mov    %ebx,(%rcx)
mov    %eax,(%r15)
add    $0xfffffffffffffffc,%r15
jmp    1320 <sortindirect+0x220>
mov    0x0(%r13),%ebx
mov    %eax,0x0(%r13)
mov    %ebx,(%rcx)
add    $0x4,%r13
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%r13
jbe    12f9 <sortindirect+0x1f9>
jmp    1324 <sortindirect+0x224>
nopw   0x0(%rax,%rax,1)
mov    %r13,%r11
sub    %rdi,%r11
sub    %r14,%rdi
shr    $0x2,%rdi
shr    $0x2,%r11
cmp    %edi,%r11d
cmovle %r11d,%edi
test   %edi,%edi
jle    13ea <sortindirect+0x2ea>
mov    %edi,%eax
lea    0x0(,%rax,4),%rbp
mov    %r13,%r9
sub    %rbp,%r9
lea    -0x1(%rdi),%ebp
cmp    $0x7,%ebp
jb     13bf <sortindirect+0x2bf>
mov    %rbp,%rbx
sub    %rax,%rbx
lea    0x4(,%rbx,4),%rbx
add    %r13,%rbx
cmp    %rbx,%r14
jae    150a <sortindirect+0x40a>
lea    (%r14,%rbp,4),%rbx
add    $0x4,%rbx
cmp    %rbx,%r9
jae    150a <sortindirect+0x40a>
mov    %r14,%rax
add    $0x1,%edi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rbp,1),%ebx
mov    (%r9,%rbp,1),%edx
mov    %edx,(%rax,%rbp,1)
mov    %ebx,(%r9,%rbp,1)
add    $0x4,%rbp
add    $0xffffffff,%edi
cmp    $0x1,%edi
ja     13d0 <sortindirect+0x2d0>
mov    %r15,%rax
sub    %r14,%rax
shr    $0x2,%rax
sub    %rcx,%r15
shr    $0x2,%r15
sub    %eax,%r8d
cmp    %r15d,%r8d
cmovge %r15d,%r8d
test   %r8d,%r8d
jle    148e <sortindirect+0x38e>
mov    %r11,-0x80(%rsp)
mov    %r10,%r11
mov    %r12d,%eax
sub    %r8d,%eax
movslq %eax,%rbp
lea    (%r14,%rbp,4),%rcx
lea    -0x1(%r8),%r10d
cmp    $0x7,%r10d
jb     145e <sortindirect+0x35e>
movslq %r12d,%rax
add    %r10,%rax
movslq %r8d,%rdx
sub    %rdx,%rax
lea    (%r14,%rax,4),%rax
add    $0x4,%rax
cmp    %rax,%r13
jae    1631 <sortindirect+0x531>
lea    0x4(,%r10,4),%rax
add    %r13,%rax
cmp    %rax,%rcx
jae    1631 <sortindirect+0x531>
mov    %r11,%r10
mov    -0x80(%rsp),%r11
add    $0x1,%r8d
xor    %eax,%eax
nopl   0x0(%rax)
mov    0x0(%r13,%rax,1),%edx
mov    (%rcx,%rax,1),%edi
mov    %edi,0x0(%r13,%rax,1)
mov    %edx,(%rcx,%rax,1)
add    $0x4,%rax
add    $0xffffffff,%r8d
cmp    $0x1,%r8d
ja     1470 <sortindirect+0x370>
cmp    %r15d,%r11d
jle    14c0 <sortindirect+0x3c0>
cmp    $0x2,%r11d
jl     14a7 <sortindirect+0x3a7>
mov    -0x78(%rsp),%rax
mov    %r11d,0x8(%rax)
mov    -0x70(%rsp),%r10
cmp    $0x2,%r15d
jl     1130 <sortindirect+0x30>
sub    %r15d,%r12d
movslq %r12d,%rax
lea    (%r14,%rax,4),%r14
mov    %r15d,%r11d
jmp    14ee <sortindirect+0x3ee>
cmp    $0x2,%r15d
jl     14e1 <sortindirect+0x3e1>
sub    %r15d,%r12d
movslq %r12d,%rax
lea    (%r14,%rax,4),%rax
mov    -0x78(%rsp),%rcx
mov    %rax,(%rcx)
mov    %r15d,0x8(%rcx)
mov    -0x70(%rsp),%r10
mov    %r10d,%ebp
cmp    $0x2,%r11d
jl     1133 <sortindirect+0x33>
movslq %r10d,%rbp
mov    %rbp,%rax
shl    $0x4,%rax
mov    %r14,-0x50(%rsp,%rax,1)
mov    %r11d,-0x48(%rsp,%rax,1)
add    $0x1,%ebp
jmp    1133 <sortindirect+0x33>
mov    %r11,-0x80(%rsp)
mov    %r10,-0x58(%rsp)
add    $0x1,%rbp
mov    %rbp,-0x68(%rsp)
movabs $0x1fffffff8,%rdx
and    %rdx,%rbp
mov    %rbp,-0x60(%rsp)
lea    -0x8(%rbp),%rbx
mov    %rbx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rbx,%rbx
je     1732 <sortindirect+0x632>
neg    %rax
mov    %rbp,%r11
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
and    %rdx,%r11
lea    0x30(,%rax,4),%rax
add    %r13,%rax
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
movups (%r14,%r10,4),%xmm0
movups 0x10(%r14,%r10,4),%xmm1
movups -0x30(%rax,%r10,4),%xmm2
movups -0x20(%rax,%r10,4),%xmm3
movups %xmm2,(%r14,%r10,4)
movups %xmm3,0x10(%r14,%r10,4)
movups %xmm0,-0x30(%rax,%r10,4)
movups %xmm1,-0x20(%rax,%r10,4)
movups 0x20(%r14,%r10,4),%xmm0
movups 0x30(%r14,%r10,4),%xmm1
movups -0x10(%rax,%r10,4),%xmm2
movups (%rax,%r10,4),%xmm3
movups %xmm2,0x20(%r14,%r10,4)
movups %xmm3,0x30(%r14,%r10,4)
movups %xmm0,-0x10(%rax,%r10,4)
movups %xmm1,(%rax,%r10,4)
add    $0x10,%r10
add    $0xfffffffffffffffe,%r11
jne    1570 <sortindirect+0x470>
test   $0x1,%bpl
je     1608 <sortindirect+0x508>
movups (%r14,%r10,4),%xmm0
movups 0x10(%r14,%r10,4),%xmm1
movups (%r9,%r10,4),%xmm2
movups 0x10(%r9,%r10,4),%xmm3
movups %xmm2,(%r14,%r10,4)
movups %xmm3,0x10(%r14,%r10,4)
movups %xmm0,(%r9,%r10,4)
movups %xmm1,0x10(%r9,%r10,4)
mov    -0x60(%rsp),%rdx
cmp    %rdx,-0x68(%rsp)
mov    -0x58(%rsp),%r10
mov    -0x80(%rsp),%r11
je     13ea <sortindirect+0x2ea>
lea    (%r14,%rdx,4),%rax
lea    (%r9,%rdx,4),%r9
sub    %edx,%edi
jmp    13c2 <sortindirect+0x2c2>
add    $0x1,%r10
mov    %r10,%rbx
movabs $0x1fffffff8,%rax
and    %rax,%rbx
lea    -0x8(%rbx),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1744 <sortindirect+0x644>
mov    %r9,%rax
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
and    %rdx,%rax
lea    (%r14,%rbp,4),%rdi
add    $0x30,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups 0x0(%r13,%rbp,4),%xmm0
movups 0x10(%r13,%rbp,4),%xmm1
movups -0x30(%rdi,%rbp,4),%xmm2
movups -0x20(%rdi,%rbp,4),%xmm3
movups %xmm2,0x0(%r13,%rbp,4)
movups %xmm3,0x10(%r13,%rbp,4)
movups %xmm0,-0x30(%rdi,%rbp,4)
movups %xmm1,-0x20(%rdi,%rbp,4)
movups 0x20(%r13,%rbp,4),%xmm0
movups 0x30(%r13,%rbp,4),%xmm1
movups -0x10(%rdi,%rbp,4),%xmm2
movups (%rdi,%rbp,4),%xmm3
movups %xmm2,0x20(%r13,%rbp,4)
movups %xmm3,0x30(%r13,%rbp,4)
movups %xmm0,-0x10(%rdi,%rbp,4)
movups %xmm1,(%rdi,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rax
jne    1680 <sortindirect+0x580>
test   $0x1,%r9b
je     1710 <sortindirect+0x610>
movups 0x0(%r13,%rbp,4),%xmm0
movups 0x10(%r13,%rbp,4),%xmm1
movups (%rcx,%rbp,4),%xmm2
movups 0x10(%rcx,%rbp,4),%xmm3
movups %xmm2,0x0(%r13,%rbp,4)
movups %xmm3,0x10(%r13,%rbp,4)
movups %xmm0,(%rcx,%rbp,4)
movups %xmm1,0x10(%rcx,%rbp,4)
cmp    %rbx,%r10
mov    %r11,%r10
mov    -0x80(%rsp),%r11
je     148e <sortindirect+0x38e>
lea    0x0(%r13,%rbx,4),%r13
lea    (%rcx,%rbx,4),%rcx
sub    %ebx,%r8d
jmp    1466 <sortindirect+0x366>
xor    %r10d,%r10d
test   $0x1,%bpl
jne    15dc <sortindirect+0x4dc>
jmp    1608 <sortindirect+0x508>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    16e6 <sortindirect+0x5e6>
jmp    1710 <sortindirect+0x610>
mov    %ebp,-0x18(%r14,%rcx,4)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %ebp,%ebp
movslq %ebp,%rdi
mov    %edx,(%r14,%rdi,4)
add    $0x1,%rax
add    $0x1,%rcx
cmp    %rcx,%r12
je     1130 <sortindirect+0x30>
movslq 0x4(%r14,%rcx,4),%rdx
mov    (%rsi,%rdx,4),%edi
movslq (%r14,%rcx,4),%rbx
mov    %rax,%rbp
cmp    %edi,(%rsi,%rbx,4)
jle    1762 <sortindirect+0x662>
mov    %ebx,0x4(%r14,%rcx,4)
test   %rcx,%rcx
je     1760 <sortindirect+0x660>
movslq -0x4(%r14,%rcx,4),%rbp
cmp    %edi,(%rsi,%rbp,4)
jle    1840 <sortindirect+0x740>
mov    %ebp,(%r14,%rcx,4)
cmp    $0x1,%rcx
je     1760 <sortindirect+0x660>
movslq -0x8(%r14,%rcx,4),%rbp
cmp    %edi,(%rsi,%rbp,4)
jle    1849 <sortindirect+0x749>
mov    %ebp,-0x4(%r14,%rcx,4)
cmp    $0x2,%rcx
je     1760 <sortindirect+0x660>
movslq -0xc(%r14,%rcx,4),%rbp
cmp    %edi,(%rsi,%rbp,4)
jle    1852 <sortindirect+0x752>
mov    %ebp,-0x8(%r14,%rcx,4)
cmp    $0x3,%rcx
je     1760 <sortindirect+0x660>
movslq -0x10(%r14,%rcx,4),%rbp
cmp    %edi,(%rsi,%rbp,4)
jle    185b <sortindirect+0x75b>
mov    %ebp,-0xc(%r14,%rcx,4)
cmp    $0x4,%rcx
je     1760 <sortindirect+0x660>
movslq -0x14(%r14,%rcx,4),%rbp
cmp    %edi,(%rsi,%rbp,4)
jle    1864 <sortindirect+0x764>
mov    %ebp,-0x10(%r14,%rcx,4)
cmp    $0x5,%rcx
je     1760 <sortindirect+0x660>
movslq -0x18(%r14,%rcx,4),%rbp
cmp    %edi,(%rsi,%rbp,4)
jle    186d <sortindirect+0x76d>
mov    %ebp,-0x14(%r14,%rcx,4)
cmp    $0x6,%rcx
je     1760 <sortindirect+0x660>
movslq -0x1c(%r14,%rcx,4),%rbp
cmp    %edi,(%rsi,%rbp,4)
jg     174e <sortindirect+0x64e>
lea    -0x6(%rcx),%rbp
jmp    1762 <sortindirect+0x662>
lea    -0x1(%rax),%rbp
jmp    1762 <sortindirect+0x662>
lea    -0x2(%rax),%rbp
jmp    1762 <sortindirect+0x662>
lea    -0x3(%rax),%rbp
jmp    1762 <sortindirect+0x662>
lea    -0x4(%rax),%rbp
jmp    1762 <sortindirect+0x662>
lea    -0x5(%rax),%rbp
jmp    1762 <sortindirect+0x662>
lea    -0x6(%rax),%rbp
jmp    1762 <sortindirect+0x662>
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 @sortindirect(i32* %0, i32* %1, i32 %2) {
%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 i32*
%26 = alloca i32*
%27 = alloca i32*
%28 = alloca [40 x %struct.anon]
%29 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i32 %2, i32* %6
store i32 0, i32* %29
%30 = load i32, i32* %6
%31 = icmp sgt i32 %30, 1
br i1 %31, label %32, label %45
32: ; preds = %3
%33 = load i32*, i32** %4
%34 = load i32, i32* %29
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %35
%37 = getelementptr inbounds %struct.anon, %struct.anon* %36, i32 0, i32 0
store i32* %33, i32** %37
%38 = load i32, i32* %6
%39 = load i32, i32* %29
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %40
%42 = getelementptr inbounds %struct.anon, %struct.anon* %41, i32 0, i32 1
store i32 %38, i32* %42
%43 = load i32, i32* %29
%44 = add nsw i32 %43, 1
store i32 %44, i32* %29
br label %45
45: ; preds = %32, %3
br label %46
46: ; preds = %1135, %119, %45
%47 = load i32, i32* %29
%48 = icmp sgt i32 %47, 0
br i1 %48, label %49, label %1136
49: ; preds = %46
%50 = load i32, i32* %29
%51 = add nsw i32 %50, -1
store i32 %51, i32* %29
%52 = load i32, i32* %29
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %53
%55 = getelementptr inbounds %struct.anon, %struct.anon* %54, i32 0, i32 0
%56 = load i32*, i32** %55
store i32* %56, i32** %21
%57 = load i32, i32* %29
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %58
%60 = getelementptr inbounds %struct.anon, %struct.anon* %59, i32 0, i32 1
%61 = load i32, i32* %60
store i32 %61, i32* %14
%62 = load i32, i32* %14
%63 = icmp slt i32 %62, 10
br i1 %63, label %64, label %120
64: ; preds = %49
store i32 1, i32* %7
br label %65
65: ; preds = %116, %64
%66 = load i32, i32* %7
%67 = load i32, i32* %14
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %119
69: ; preds = %65
%70 = load i32*, i32** %21
%71 = load i32, i32* %7
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i32, i32* %70, i64 %72
%74 = load i32, i32* %73
store i32 %74, i32* %20
%75 = load i32*, i32** %5
%76 = load i32, i32* %20
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i32, i32* %75, i64 %77
%79 = load i32, i32* %78
store i32 %79, i32* %15
%80 = load i32, i32* %7
store i32 %80, i32* %8
br label %81
81: ; preds = %109, %69
%82 = load i32*, i32** %5
%83 = load i32*, i32** %21
%84 = load i32, i32* %8
%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 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %82, i64 %89
%91 = load i32, i32* %90
%92 = load i32, i32* %15
%93 = icmp sgt i32 %91, %92
br i1 %93, label %94, label %110
94: ; preds = %81
%95 = load i32*, i32** %21
%96 = load i32, i32* %8
%97 = sub nsw i32 %96, 1
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i32, i32* %95, i64 %98
%100 = load i32, i32* %99
%101 = load i32*, i32** %21
%102 = load i32, i32* %8
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %101, i64 %103
store i32 %100, i32* %104
%105 = load i32, i32* %8
%106 = add nsw i32 %105, -1
store i32 %106, i32* %8
%107 = icmp eq i32 %106, 0
br i1 %107, label %108, label %109
108: ; preds = %94
br label %110
109: ; preds = %94
br label %81
110: ; preds = %108, %81
%111 = load i32, i32* %20
%112 = load i32*, i32** %21
%113 = load i32, i32* %8
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i32, i32* %112, i64 %114
store i32 %111, i32* %115
br label %116
116: ; preds = %110
%117 = load i32, i32* %7
%118 = add nsw i32 %117, 1
store i32 %118, i32* %7
br label %65
119: ; preds = %65
br label %46
120: ; preds = %49
%121 = load i32, i32* %14
%122 = icmp slt i32 %121, 320
br i1 %122, label %123, label %294
123: ; preds = %120
%124 = load i32*, i32** %5
%125 = load i32*, i32** %21
%126 = getelementptr inbounds i32, i32* %125, i64 0
%127 = load i32, i32* %126
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %124, i64 %128
%130 = load i32, i32* %129
%131 = load i32*, i32** %5
%132 = load i32*, i32** %21
%133 = load i32, i32* %14
%134 = sdiv i32 %133, 2
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %132, i64 %135
%137 = load i32, i32* %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i32, i32* %131, i64 %138
%140 = load i32, i32* %139
%141 = icmp sle i32 %130, %140
br i1 %141, label %142, label %217
142: ; preds = %123
%143 = load i32*, i32** %5
%144 = load i32*, i32** %21
%145 = load i32, i32* %14
%146 = sdiv i32 %145, 2
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %144, i64 %147
%149 = load i32, i32* %148
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %143, i64 %150
%152 = load i32, i32* %151
%153 = load i32*, i32** %5
%154 = load i32*, i32** %21
%155 = load i32, i32* %14
%156 = sub nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %154, i64 %157
%159 = load i32, i32* %158
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %153, i64 %160
%162 = load i32, i32* %161
%163 = icmp sle i32 %152, %162
br i1 %163, label %164, label %175
164: ; preds = %142
%165 = load i32*, i32** %5
%166 = load i32*, i32** %21
%167 = load i32, i32* %14
%168 = sdiv i32 %167, 2
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i32, i32* %166, i64 %169
%171 = load i32, i32* %170
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i32, i32* %165, i64 %172
%174 = load i32, i32* %173
br label %215
175: ; preds = %142
%176 = load i32*, i32** %5
%177 = load i32*, i32** %21
%178 = load i32, i32* %14
%179 = sub nsw i32 %178, 1
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds i32, i32* %177, i64 %180
%182 = load i32, i32* %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i32, i32* %176, i64 %183
%185 = load i32, i32* %184
%186 = load i32*, i32** %5
%187 = load i32*, i32** %21
%188 = getelementptr inbounds i32, i32* %187, i64 0
%189 = load i32, i32* %188
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds i32, i32* %186, i64 %190
%192 = load i32, i32* %191
%193 = icmp sle i32 %185, %192
br i1 %193, label %194, label %202
194: ; preds = %175
%195 = load i32*, i32** %5
%196 = load i32*, i32** %21
%197 = getelementptr inbounds i32, i32* %196, i64 0
%198 = load i32, i32* %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %195, i64 %199
%201 = load i32, i32* %200
br label %213
202: ; preds = %175
%203 = load i32*, i32** %5
%204 = load i32*, i32** %21
%205 = load i32, i32* %14
%206 = sub nsw i32 %205, 1
%207 = sext i32 %206 to i64
%208 = getelementptr inbounds i32, i32* %204, i64 %207
%209 = load i32, i32* %208
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32, i32* %203, i64 %210
%212 = load i32, i32* %211
br label %213
213: ; preds = %202, %194
%214 = phi i32 [ %201, %194 ], [ %212, %202 ]
br label %215
215: ; preds = %213, %164
%216 = phi i32 [ %174, %164 ], [ %214, %213 ]
br label %292
217: ; preds = %123
%218 = load i32*, i32** %5
%219 = load i32*, i32** %21
%220 = getelementptr inbounds i32, i32* %219, i64 0
%221 = load i32, i32* %220
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i32, i32* %218, i64 %222
%224 = load i32, i32* %223
%225 = load i32*, i32** %5
%226 = load i32*, i32** %21
%227 = load i32, i32* %14
%228 = sub nsw i32 %227, 1
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i32, i32* %226, i64 %229
%231 = load i32, i32* %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i32, i32* %225, i64 %232
%234 = load i32, i32* %233
%235 = icmp sle i32 %224, %234
br i1 %235, label %236, label %244
236: ; preds = %217
%237 = load i32*, i32** %5
%238 = load i32*, i32** %21
%239 = getelementptr inbounds i32, i32* %238, i64 0
%240 = load i32, i32* %239
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32, i32* %237, i64 %241
%243 = load i32, i32* %242
br label %290
244: ; preds = %217
%245 = load i32*, i32** %5
%246 = load i32*, i32** %21
%247 = load i32, i32* %14
%248 = sub nsw i32 %247, 1
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i32, i32* %246, i64 %249
%251 = load i32, i32* %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i32, i32* %245, i64 %252
%254 = load i32, i32* %253
%255 = load i32*, i32** %5
%256 = load i32*, i32** %21
%257 = load i32, i32* %14
%258 = sdiv i32 %257, 2
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds i32, i32* %256, i64 %259
%261 = load i32, i32* %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds i32, i32* %255, i64 %262
%264 = load i32, i32* %263
%265 = icmp sle i32 %254, %264
br i1 %265, label %266, label %277
266: ; preds = %244
%267 = load i32*, i32** %5
%268 = load i32*, i32** %21
%269 = load i32, i32* %14
%270 = sdiv i32 %269, 2
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %268, i64 %271
%273 = load i32, i32* %272
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds i32, i32* %267, i64 %274
%276 = load i32, i32* %275
br label %288
277: ; preds = %244
%278 = load i32*, i32** %5
%279 = load i32*, i32** %21
%280 = load i32, i32* %14
%281 = sub nsw i32 %280, 1
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i32, i32* %279, i64 %282
%284 = load i32, i32* %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32, i32* %278, i64 %285
%287 = load i32, i32* %286
br label %288
288: ; preds = %277, %266
%289 = phi i32 [ %276, %266 ], [ %287, %277 ]
br label %290
290: ; preds = %288, %236
%291 = phi i32 [ %243, %236 ], [ %289, %288 ]
br label %292
292: ; preds = %290, %215
%293 = phi i32 [ %216, %215 ], [ %291, %290 ]
store i32 %293, i32* %16
br label %854
294: ; preds = %120
%295 = load i32*, i32** %5
%296 = load i32*, i32** %21
%297 = getelementptr inbounds i32, i32* %296, i64 0
%298 = load i32, i32* %297
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds i32, i32* %295, i64 %299
%301 = load i32, i32* %300
%302 = load i32*, i32** %5
%303 = load i32*, i32** %21
%304 = getelementptr inbounds i32, i32* %303, i64 1
%305 = load i32, i32* %304
%306 = sext i32 %305 to i64
%307 = getelementptr inbounds i32, i32* %302, i64 %306
%308 = load i32, i32* %307
%309 = icmp sle i32 %301, %308
br i1 %309, label %310, label %370
310: ; preds = %294
%311 = load i32*, i32** %5
%312 = load i32*, i32** %21
%313 = getelementptr inbounds i32, i32* %312, i64 1
%314 = load i32, i32* %313
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds i32, i32* %311, i64 %315
%317 = load i32, i32* %316
%318 = load i32*, i32** %5
%319 = load i32*, i32** %21
%320 = getelementptr inbounds i32, i32* %319, i64 2
%321 = load i32, i32* %320
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds i32, i32* %318, i64 %322
%324 = load i32, i32* %323
%325 = icmp sle i32 %317, %324
br i1 %325, label %326, label %334
326: ; preds = %310
%327 = load i32*, i32** %5
%328 = load i32*, i32** %21
%329 = getelementptr inbounds i32, i32* %328, i64 1
%330 = load i32, i32* %329
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds i32, i32* %327, i64 %331
%333 = load i32, i32* %332
br label %368
334: ; preds = %310
%335 = load i32*, i32** %5
%336 = load i32*, i32** %21
%337 = getelementptr inbounds i32, i32* %336, i64 2
%338 = load i32, i32* %337
%339 = sext i32 %338 to i64
%340 = getelementptr inbounds i32, i32* %335, i64 %339
%341 = load i32, i32* %340
%342 = load i32*, i32** %5
%343 = load i32*, i32** %21
%344 = getelementptr inbounds i32, i32* %343, i64 0
%345 = load i32, i32* %344
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i32, i32* %342, i64 %346
%348 = load i32, i32* %347
%349 = icmp sle i32 %341, %348
br i1 %349, label %350, label %358
350: ; preds = %334
%351 = load i32*, i32** %5
%352 = load i32*, i32** %21
%353 = getelementptr inbounds i32, i32* %352, i64 0
%354 = load i32, i32* %353
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds i32, i32* %351, i64 %355
%357 = load i32, i32* %356
br label %366
358: ; preds = %334
%359 = load i32*, i32** %5
%360 = load i32*, i32** %21
%361 = getelementptr inbounds i32, i32* %360, i64 2
%362 = load i32, i32* %361
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds i32, i32* %359, i64 %363
%365 = load i32, i32* %364
br label %366
366: ; preds = %358, %350
%367 = phi i32 [ %357, %350 ], [ %365, %358 ]
br label %368
368: ; preds = %366, %326
%369 = phi i32 [ %333, %326 ], [ %367, %366 ]
br label %430
370: ; preds = %294
%371 = load i32*, i32** %5
%372 = load i32*, i32** %21
%373 = getelementptr inbounds i32, i32* %372, i64 0
%374 = load i32, i32* %373
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds i32, i32* %371, i64 %375
%377 = load i32, i32* %376
%378 = load i32*, i32** %5
%379 = load i32*, i32** %21
%380 = getelementptr inbounds i32, i32* %379, i64 2
%381 = load i32, i32* %380
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds i32, i32* %378, i64 %382
%384 = load i32, i32* %383
%385 = icmp sle i32 %377, %384
br i1 %385, label %386, label %394
386: ; preds = %370
%387 = load i32*, i32** %5
%388 = load i32*, i32** %21
%389 = getelementptr inbounds i32, i32* %388, i64 0
%390 = load i32, i32* %389
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds i32, i32* %387, i64 %391
%393 = load i32, i32* %392
br label %428
394: ; preds = %370
%395 = load i32*, i32** %5
%396 = load i32*, i32** %21
%397 = getelementptr inbounds i32, i32* %396, i64 2
%398 = load i32, i32* %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds i32, i32* %395, i64 %399
%401 = load i32, i32* %400
%402 = load i32*, i32** %5
%403 = load i32*, i32** %21
%404 = getelementptr inbounds i32, i32* %403, i64 1
%405 = load i32, i32* %404
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds i32, i32* %402, i64 %406
%408 = load i32, i32* %407
%409 = icmp sle i32 %401, %408
br i1 %409, label %410, label %418
410: ; preds = %394
%411 = load i32*, i32** %5
%412 = load i32*, i32** %21
%413 = getelementptr inbounds i32, i32* %412, i64 1
%414 = load i32, i32* %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds i32, i32* %411, i64 %415
%417 = load i32, i32* %416
br label %426
418: ; preds = %394
%419 = load i32*, i32** %5
%420 = load i32*, i32** %21
%421 = getelementptr inbounds i32, i32* %420, i64 2
%422 = load i32, i32* %421
%423 = sext i32 %422 to i64
%424 = getelementptr inbounds i32, i32* %419, i64 %423
%425 = load i32, i32* %424
br label %426
426: ; preds = %418, %410
%427 = phi i32 [ %417, %410 ], [ %425, %418 ]
br label %428
428: ; preds = %426, %386
%429 = phi i32 [ %393, %386 ], [ %427, %426 ]
br label %430
430: ; preds = %428, %368
%431 = phi i32 [ %369, %368 ], [ %429, %428 ]
store i32 %431, i32* %17
%432 = load i32*, i32** %5
%433 = load i32*, i32** %21
%434 = load i32, i32* %14
%435 = sdiv i32 %434, 2
%436 = sub nsw i32 %435, 1
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds i32, i32* %433, i64 %437
%439 = load i32, i32* %438
%440 = sext i32 %439 to i64
%441 = getelementptr inbounds i32, i32* %432, i64 %440
%442 = load i32, i32* %441
%443 = load i32*, i32** %5
%444 = load i32*, i32** %21
%445 = load i32, i32* %14
%446 = sdiv i32 %445, 2
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds i32, i32* %444, i64 %447
%449 = load i32, i32* %448
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds i32, i32* %443, i64 %450
%452 = load i32, i32* %451
%453 = icmp sle i32 %442, %452
br i1 %453, label %454, label %540
454: ; preds = %430
%455 = load i32*, i32** %5
%456 = load i32*, i32** %21
%457 = load i32, i32* %14
%458 = sdiv i32 %457, 2
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds i32, i32* %456, i64 %459
%461 = load i32, i32* %460
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds i32, i32* %455, i64 %462
%464 = load i32, i32* %463
%465 = load i32*, i32** %5
%466 = load i32*, i32** %21
%467 = load i32, i32* %14
%468 = sdiv i32 %467, 2
%469 = add nsw i32 %468, 1
%470 = sext i32 %469 to i64
%471 = getelementptr inbounds i32, i32* %466, i64 %470
%472 = load i32, i32* %471
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds i32, i32* %465, i64 %473
%475 = load i32, i32* %474
%476 = icmp sle i32 %464, %475
br i1 %476, label %477, label %488
477: ; preds = %454
%478 = load i32*, i32** %5
%479 = load i32*, i32** %21
%480 = load i32, i32* %14
%481 = sdiv i32 %480, 2
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds i32, i32* %479, i64 %482
%484 = load i32, i32* %483
%485 = sext i32 %484 to i64
%486 = getelementptr inbounds i32, i32* %478, i64 %485
%487 = load i32, i32* %486
br label %538
488: ; preds = %454
%489 = load i32*, i32** %5
%490 = load i32*, i32** %21
%491 = load i32, i32* %14
%492 = sdiv i32 %491, 2
%493 = add nsw i32 %492, 1
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds i32, i32* %490, i64 %494
%496 = load i32, i32* %495
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds i32, i32* %489, i64 %497
%499 = load i32, i32* %498
%500 = load i32*, i32** %5
%501 = load i32*, i32** %21
%502 = load i32, i32* %14
%503 = sdiv i32 %502, 2
%504 = sub nsw i32 %503, 1
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds i32, i32* %501, i64 %505
%507 = load i32, i32* %506
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds i32, i32* %500, i64 %508
%510 = load i32, i32* %509
%511 = icmp sle i32 %499, %510
br i1 %511, label %512, label %524
512: ; preds = %488
%513 = load i32*, i32** %5
%514 = load i32*, i32** %21
%515 = load i32, i32* %14
%516 = sdiv i32 %515, 2
%517 = sub nsw i32 %516, 1
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds i32, i32* %514, i64 %518
%520 = load i32, i32* %519
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds i32, i32* %513, i64 %521
%523 = load i32, i32* %522
br label %536
524: ; preds = %488
%525 = load i32*, i32** %5
%526 = load i32*, i32** %21
%527 = load i32, i32* %14
%528 = sdiv i32 %527, 2
%529 = add nsw i32 %528, 1
%530 = sext i32 %529 to i64
%531 = getelementptr inbounds i32, i32* %526, i64 %530
%532 = load i32, i32* %531
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds i32, i32* %525, i64 %533
%535 = load i32, i32* %534
br label %536
536: ; preds = %524, %512
%537 = phi i32 [ %523, %512 ], [ %535, %524 ]
br label %538
538: ; preds = %536, %477
%539 = phi i32 [ %487, %477 ], [ %537, %536 ]
br label %626
540: ; preds = %430
%541 = load i32*, i32** %5
%542 = load i32*, i32** %21
%543 = load i32, i32* %14
%544 = sdiv i32 %543, 2
%545 = sub nsw i32 %544, 1
%546 = sext i32 %545 to i64
%547 = getelementptr inbounds i32, i32* %542, i64 %546
%548 = load i32, i32* %547
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds i32, i32* %541, i64 %549
%551 = load i32, i32* %550
%552 = load i32*, i32** %5
%553 = load i32*, i32** %21
%554 = load i32, i32* %14
%555 = sdiv i32 %554, 2
%556 = add nsw i32 %555, 1
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds i32, i32* %553, i64 %557
%559 = load i32, i32* %558
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds i32, i32* %552, i64 %560
%562 = load i32, i32* %561
%563 = icmp sle i32 %551, %562
br i1 %563, label %564, label %576
564: ; preds = %540
%565 = load i32*, i32** %5
%566 = load i32*, i32** %21
%567 = load i32, i32* %14
%568 = sdiv i32 %567, 2
%569 = sub nsw i32 %568, 1
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds i32, i32* %566, i64 %570
%572 = load i32, i32* %571
%573 = sext i32 %572 to i64
%574 = getelementptr inbounds i32, i32* %565, i64 %573
%575 = load i32, i32* %574
br label %624
576: ; preds = %540
%577 = load i32*, i32** %5
%578 = load i32*, i32** %21
%579 = load i32, i32* %14
%580 = sdiv i32 %579, 2
%581 = add nsw i32 %580, 1
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds i32, i32* %578, i64 %582
%584 = load i32, i32* %583
%585 = sext i32 %584 to i64
%586 = getelementptr inbounds i32, i32* %577, i64 %585
%587 = load i32, i32* %586
%588 = load i32*, i32** %5
%589 = load i32*, i32** %21
%590 = load i32, i32* %14
%591 = sdiv i32 %590, 2
%592 = sext i32 %591 to i64
%593 = getelementptr inbounds i32, i32* %589, i64 %592
%594 = load i32, i32* %593
%595 = sext i32 %594 to i64
%596 = getelementptr inbounds i32, i32* %588, i64 %595
%597 = load i32, i32* %596
%598 = icmp sle i32 %587, %597
br i1 %598, label %599, label %610
599: ; preds = %576
%600 = load i32*, i32** %5
%601 = load i32*, i32** %21
%602 = load i32, i32* %14
%603 = sdiv i32 %602, 2
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds i32, i32* %601, i64 %604
%606 = load i32, i32* %605
%607 = sext i32 %606 to i64
%608 = getelementptr inbounds i32, i32* %600, i64 %607
%609 = load i32, i32* %608
br label %622
610: ; preds = %576
%611 = load i32*, i32** %5
%612 = load i32*, i32** %21
%613 = load i32, i32* %14
%614 = sdiv i32 %613, 2
%615 = add nsw i32 %614, 1
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds i32, i32* %612, i64 %616
%618 = load i32, i32* %617
%619 = sext i32 %618 to i64
%620 = getelementptr inbounds i32, i32* %611, i64 %619
%621 = load i32, i32* %620
br label %622
622: ; preds = %610, %599
%623 = phi i32 [ %609, %599 ], [ %621, %610 ]
br label %624
624: ; preds = %622, %564
%625 = phi i32 [ %575, %564 ], [ %623, %622 ]
br label %626
626: ; preds = %624, %538
%627 = phi i32 [ %539, %538 ], [ %625, %624 ]
store i32 %627, i32* %18
%628 = load i32*, i32** %5
%629 = load i32*, i32** %21
%630 = load i32, i32* %14
%631 = sub nsw i32 %630, 3
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds i32, i32* %629, i64 %632
%634 = load i32, i32* %633
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds i32, i32* %628, i64 %635
%637 = load i32, i32* %636
%638 = load i32*, i32** %5
%639 = load i32*, i32** %21
%640 = load i32, i32* %14
%641 = sub nsw i32 %640, 2
%642 = sext i32 %641 to i64
%643 = getelementptr inbounds i32, i32* %639, i64 %642
%644 = load i32, i32* %643
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds i32, i32* %638, i64 %645
%647 = load i32, i32* %646
%648 = icmp sle i32 %637, %647
br i1 %648, label %649, label %730
649: ; preds = %626
%650 = load i32*, i32** %5
%651 = load i32*, i32** %21
%652 = load i32, i32* %14
%653 = sub nsw i32 %652, 2
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds i32, i32* %651, i64 %654
%656 = load i32, i32* %655
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds i32, i32* %650, i64 %657
%659 = load i32, i32* %658
%660 = load i32*, i32** %5
%661 = load i32*, i32** %21
%662 = load i32, i32* %14
%663 = sub nsw i32 %662, 1
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds i32, i32* %661, i64 %664
%666 = load i32, i32* %665
%667 = sext i32 %666 to i64
%668 = getelementptr inbounds i32, i32* %660, i64 %667
%669 = load i32, i32* %668
%670 = icmp sle i32 %659, %669
br i1 %670, label %671, label %682
671: ; preds = %649
%672 = load i32*, i32** %5
%673 = load i32*, i32** %21
%674 = load i32, i32* %14
%675 = sub nsw i32 %674, 2
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds i32, i32* %673, i64 %676
%678 = load i32, i32* %677
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds i32, i32* %672, i64 %679
%681 = load i32, i32* %680
br label %728
682: ; preds = %649
%683 = load i32*, i32** %5
%684 = load i32*, i32** %21
%685 = load i32, i32* %14
%686 = sub nsw i32 %685, 1
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds i32, i32* %684, i64 %687
%689 = load i32, i32* %688
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds i32, i32* %683, i64 %690
%692 = load i32, i32* %691
%693 = load i32*, i32** %5
%694 = load i32*, i32** %21
%695 = load i32, i32* %14
%696 = sub nsw i32 %695, 3
%697 = sext i32 %696 to i64
%698 = getelementptr inbounds i32, i32* %694, i64 %697
%699 = load i32, i32* %698
%700 = sext i32 %699 to i64
%701 = getelementptr inbounds i32, i32* %693, i64 %700
%702 = load i32, i32* %701
%703 = icmp sle i32 %692, %702
br i1 %703, label %704, label %715
704: ; preds = %682
%705 = load i32*, i32** %5
%706 = load i32*, i32** %21
%707 = load i32, i32* %14
%708 = sub nsw i32 %707, 3
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds i32, i32* %706, i64 %709
%711 = load i32, i32* %710
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds i32, i32* %705, i64 %712
%714 = load i32, i32* %713
br label %726
715: ; preds = %682
%716 = load i32*, i32** %5
%717 = load i32*, i32** %21
%718 = load i32, i32* %14
%719 = sub nsw i32 %718, 1
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds i32, i32* %717, i64 %720
%722 = load i32, i32* %721
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds i32, i32* %716, i64 %723
%725 = load i32, i32* %724
br label %726
726: ; preds = %715, %704
%727 = phi i32 [ %714, %704 ], [ %725, %715 ]
br label %728
728: ; preds = %726, %671
%729 = phi i32 [ %681, %671 ], [ %727, %726 ]
br label %811
730: ; preds = %626
%731 = load i32*, i32** %5
%732 = load i32*, i32** %21
%733 = load i32, i32* %14
%734 = sub nsw i32 %733, 3
%735 = sext i32 %734 to i64
%736 = getelementptr inbounds i32, i32* %732, i64 %735
%737 = load i32, i32* %736
%738 = sext i32 %737 to i64
%739 = getelementptr inbounds i32, i32* %731, i64 %738
%740 = load i32, i32* %739
%741 = load i32*, i32** %5
%742 = load i32*, i32** %21
%743 = load i32, i32* %14
%744 = sub nsw i32 %743, 1
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds i32, i32* %742, i64 %745
%747 = load i32, i32* %746
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds i32, i32* %741, i64 %748
%750 = load i32, i32* %749
%751 = icmp sle i32 %740, %750
br i1 %751, label %752, label %763
752: ; preds = %730
%753 = load i32*, i32** %5
%754 = load i32*, i32** %21
%755 = load i32, i32* %14
%756 = sub nsw i32 %755, 3
%757 = sext i32 %756 to i64
%758 = getelementptr inbounds i32, i32* %754, i64 %757
%759 = load i32, i32* %758
%760 = sext i32 %759 to i64
%761 = getelementptr inbounds i32, i32* %753, i64 %760
%762 = load i32, i32* %761
br label %809
763: ; preds = %730
%764 = load i32*, i32** %5
%765 = load i32*, i32** %21
%766 = load i32, i32* %14
%767 = sub nsw i32 %766, 1
%768 = sext i32 %767 to i64
%769 = getelementptr inbounds i32, i32* %765, i64 %768
%770 = load i32, i32* %769
%771 = sext i32 %770 to i64
%772 = getelementptr inbounds i32, i32* %764, i64 %771
%773 = load i32, i32* %772
%774 = load i32*, i32** %5
%775 = load i32*, i32** %21
%776 = load i32, i32* %14
%777 = sub nsw i32 %776, 2
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds i32, i32* %775, i64 %778
%780 = load i32, i32* %779
%781 = sext i32 %780 to i64
%782 = getelementptr inbounds i32, i32* %774, i64 %781
%783 = load i32, i32* %782
%784 = icmp sle i32 %773, %783
br i1 %784, label %785, label %796
785: ; preds = %763
%786 = load i32*, i32** %5
%787 = load i32*, i32** %21
%788 = load i32, i32* %14
%789 = sub nsw i32 %788, 2
%790 = sext i32 %789 to i64
%791 = getelementptr inbounds i32, i32* %787, i64 %790
%792 = load i32, i32* %791
%793 = sext i32 %792 to i64
%794 = getelementptr inbounds i32, i32* %786, i64 %793
%795 = load i32, i32* %794
br label %807
796: ; preds = %763
%797 = load i32*, i32** %5
%798 = load i32*, i32** %21
%799 = load i32, i32* %14
%800 = sub nsw i32 %799, 1
%801 = sext i32 %800 to i64
%802 = getelementptr inbounds i32, i32* %798, i64 %801
%803 = load i32, i32* %802
%804 = sext i32 %803 to i64
%805 = getelementptr inbounds i32, i32* %797, i64 %804
%806 = load i32, i32* %805
br label %807
807: ; preds = %796, %785
%808 = phi i32 [ %795, %785 ], [ %806, %796 ]
br label %809
809: ; preds = %807, %752
%810 = phi i32 [ %762, %752 ], [ %808, %807 ]
br label %811
811: ; preds = %809, %728
%812 = phi i32 [ %729, %728 ], [ %810, %809 ]
store i32 %812, i32* %19
%813 = load i32, i32* %17
%814 = load i32, i32* %18
%815 = icmp sle i32 %813, %814
br i1 %815, label %816, label %834
816: ; preds = %811
%817 = load i32, i32* %18
%818 = load i32, i32* %19
%819 = icmp sle i32 %817, %818
br i1 %819, label %820, label %822
820: ; preds = %816
%821 = load i32, i32* %18
br label %832
822: ; preds = %816
%823 = load i32, i32* %19
%824 = load i32, i32* %17
%825 = icmp sle i32 %823, %824
br i1 %825, label %826, label %828
826: ; preds = %822
%827 = load i32, i32* %17
br label %830
828: ; preds = %822
%829 = load i32, i32* %19
br label %830
830: ; preds = %828, %826
%831 = phi i32 [ %827, %826 ], [ %829, %828 ]
br label %832
832: ; preds = %830, %820
%833 = phi i32 [ %821, %820 ], [ %831, %830 ]
br label %852
834: ; preds = %811
%835 = load i32, i32* %17
%836 = load i32, i32* %19
%837 = icmp sle i32 %835, %836
br i1 %837, label %838, label %840
838: ; preds = %834
%839 = load i32, i32* %17
br label %850
840: ; preds = %834
%841 = load i32, i32* %19
%842 = load i32, i32* %18
%843 = icmp sle i32 %841, %842
br i1 %843, label %844, label %846
844: ; preds = %840
%845 = load i32, i32* %18
br label %848
846: ; preds = %840
%847 = load i32, i32* %19
br label %848
848: ; preds = %846, %844
%849 = phi i32 [ %845, %844 ], [ %847, %846 ]
br label %850
850: ; preds = %848, %838
%851 = phi i32 [ %839, %838 ], [ %849, %848 ]
br label %852
852: ; preds = %850, %832
%853 = phi i32 [ %833, %832 ], [ %851, %850 ]
store i32 %853, i32* %16
br label %854
854: ; preds = %852, %292
%855 = load i32*, i32** %21
store i32* %855, i32** %23
store i32* %855, i32** %22
%856 = load i32*, i32** %21
%857 = load i32, i32* %14
%858 = sub nsw i32 %857, 1
%859 = sext i32 %858 to i64
%860 = getelementptr inbounds i32, i32* %856, i64 %859
store i32* %860, i32** %25
store i32* %860, i32** %24
br label %861
861: ; preds = %942, %854
br label %862
862: ; preds = %896, %861
%863 = load i32*, i32** %23
%864 = load i32*, i32** %24
%865 = icmp ule i32* %863, %864
br i1 %865, label %866, label %875
866: ; preds = %862
%867 = load i32*, i32** %5
%868 = load i32*, i32** %23
%869 = load i32, i32* %868
%870 = sext i32 %869 to i64
%871 = getelementptr inbounds i32, i32* %867, i64 %870
%872 = load i32, i32* %871
%873 = load i32, i32* %16
%874 = icmp sle i32 %872, %873
br label %875
875: ; preds = %866, %862
%876 = phi i1 [ false, %862 ], [ %874, %866 ]
br i1 %876, label %877, label %899
877: ; preds = %875
%878 = load i32*, i32** %5
%879 = load i32*, i32** %23
%880 = load i32, i32* %879
%881 = sext i32 %880 to i64
%882 = getelementptr inbounds i32, i32* %878, i64 %881
%883 = load i32, i32* %882
%884 = load i32, i32* %16
%885 = icmp eq i32 %883, %884
br i1 %885, label %886, label %896
886: ; preds = %877
%887 = load i32*, i32** %22
%888 = load i32, i32* %887
store i32 %888, i32* %20
%889 = load i32*, i32** %23
%890 = load i32, i32* %889
%891 = load i32*, i32** %22
store i32 %890, i32* %891
%892 = load i32, i32* %20
%893 = load i32*, i32** %23
store i32 %892, i32* %893
%894 = load i32*, i32** %22
%895 = getelementptr inbounds i32, i32* %894, i32 1
store i32* %895, i32** %22
br label %896
896: ; preds = %886, %877
%897 = load i32*, i32** %23
%898 = getelementptr inbounds i32, i32* %897, i32 1
store i32* %898, i32** %23
br label %862
899: ; preds = %875
br label %900
900: ; preds = %934, %899
%901 = load i32*, i32** %24
%902 = load i32*, i32** %23
%903 = icmp uge i32* %901, %902
br i1 %903, label %904, label %913
904: ; preds = %900
%905 = load i32*, i32** %5
%906 = load i32*, i32** %24
%907 = load i32, i32* %906
%908 = sext i32 %907 to i64
%909 = getelementptr inbounds i32, i32* %905, i64 %908
%910 = load i32, i32* %909
%911 = load i32, i32* %16
%912 = icmp sge i32 %910, %911
br label %913
913: ; preds = %904, %900
%914 = phi i1 [ false, %900 ], [ %912, %904 ]
br i1 %914, label %915, label %937
915: ; preds = %913
%916 = load i32*, i32** %5
%917 = load i32*, i32** %24
%918 = load i32, i32* %917
%919 = sext i32 %918 to i64
%920 = getelementptr inbounds i32, i32* %916, i64 %919
%921 = load i32, i32* %920
%922 = load i32, i32* %16
%923 = icmp eq i32 %921, %922
br i1 %923, label %924, label %934
924: ; preds = %915
%925 = load i32*, i32** %24
%926 = load i32, i32* %925
store i32 %926, i32* %20
%927 = load i32*, i32** %25
%928 = load i32, i32* %927
%929 = load i32*, i32** %24
store i32 %928, i32* %929
%930 = load i32, i32* %20
%931 = load i32*, i32** %25
store i32 %930, i32* %931
%932 = load i32*, i32** %25
%933 = getelementptr inbounds i32, i32* %932, i32 -1
store i32* %933, i32** %25
br label %934
934: ; preds = %924, %915
%935 = load i32*, i32** %24
%936 = getelementptr inbounds i32, i32* %935, i32 -1
store i32* %936, i32** %24
br label %900
937: ; preds = %913
%938 = load i32*, i32** %23
%939 = load i32*, i32** %24
%940 = icmp ugt i32* %938, %939
br i1 %940, label %941, label %942
941: ; preds = %937
br label %954
942: ; preds = %937
%943 = load i32*, i32** %23
%944 = load i32, i32* %943
store i32 %944, i32* %20
%945 = load i32*, i32** %24
%946 = load i32, i32* %945
%947 = load i32*, i32** %23
store i32 %946, i32* %947
%948 = load i32, i32* %20
%949 = load i32*, i32** %24
store i32 %948, i32* %949
%950 = load i32*, i32** %23
%951 = getelementptr inbounds i32, i32* %950, i32 1
store i32* %951, i32** %23
%952 = load i32*, i32** %24
%953 = getelementptr inbounds i32, i32* %952, i32 -1
store i32* %953, i32** %24
br label %861
954: ; preds = %941
%955 = load i32*, i32** %22
%956 = load i32*, i32** %21
%957 = ptrtoint i32* %955 to i64
%958 = ptrtoint i32* %956 to i64
%959 = sub i64 %957, %958
%960 = sdiv exact i64 %959, 4
%961 = trunc i64 %960 to i32
store i32 %961, i32* %9
%962 = load i32*, i32** %23
%963 = load i32*, i32** %22
%964 = ptrtoint i32* %962 to i64
%965 = ptrtoint i32* %963 to i64
%966 = sub i64 %964, %965
%967 = sdiv exact i64 %966, 4
%968 = trunc i64 %967 to i32
store i32 %968, i32* %11
%969 = load i32, i32* %11
%970 = load i32, i32* %9
%971 = icmp sgt i32 %969, %970
br i1 %971, label %972, label %974
972: ; preds = %954
%973 = load i32, i32* %9
store i32 %973, i32* %13
br label %976
974: ; preds = %954
%975 = load i32, i32* %11
store i32 %975, i32* %13
br label %976
976: ; preds = %974, %972
%977 = load i32*, i32** %21
store i32* %977, i32** %27
%978 = load i32*, i32** %23
%979 = load i32, i32* %13
%980 = sext i32 %979 to i64
%981 = sub i64 0, %980
%982 = getelementptr inbounds i32, i32* %978, i64 %981
store i32* %982, i32** %26
br label %983
983: ; preds = %998, %976
%984 = load i32, i32* %13
%985 = icmp sgt i32 %984, 0
br i1 %985, label %986, label %1001
986: ; preds = %983
%987 = load i32*, i32** %27
%988 = load i32, i32* %987
store i32 %988, i32* %20
%989 = load i32*, i32** %26
%990 = load i32, i32* %989
%991 = load i32*, i32** %27
store i32 %990, i32* %991
%992 = load i32, i32* %20
%993 = load i32*, i32** %26
store i32 %992, i32* %993
%994 = load i32*, i32** %27
%995 = getelementptr inbounds i32, i32* %994, i32 1
store i32* %995, i32** %27
%996 = load i32*, i32** %26
%997 = getelementptr inbounds i32, i32* %996, i32 1
store i32* %997, i32** %26
br label %998
998: ; preds = %986
%999 = load i32, i32* %13
%1000 = add nsw i32 %999, -1
store i32 %1000, i32* %13
br label %983
1001: ; preds = %983
%1002 = load i32*, i32** %25
%1003 = load i32*, i32** %21
%1004 = ptrtoint i32* %1002 to i64
%1005 = ptrtoint i32* %1003 to i64
%1006 = sub i64 %1004, %1005
%1007 = sdiv exact i64 %1006, 4
%1008 = trunc i64 %1007 to i32
store i32 %1008, i32* %10
%1009 = load i32*, i32** %25
%1010 = load i32*, i32** %24
%1011 = ptrtoint i32* %1009 to i64
%1012 = ptrtoint i32* %1010 to i64
%1013 = sub i64 %1011, %1012
%1014 = sdiv exact i64 %1013, 4
%1015 = trunc i64 %1014 to i32
store i32 %1015, i32* %12
%1016 = load i32, i32* %12
%1017 = load i32, i32* %14
%1018 = sub nsw i32 %1017, 1
%1019 = load i32, i32* %10
%1020 = sub nsw i32 %1018, %1019
%1021 = icmp sgt i32 %1016, %1020
br i1 %1021, label %1022, label %1027
1022: ; preds = %1001
%1023 = load i32, i32* %14
%1024 = sub nsw i32 %1023, 1
%1025 = load i32, i32* %10
%1026 = sub nsw i32 %1024, %1025
store i32 %1026, i32* %13
br label %1029
1027: ; preds = %1001
%1028 = load i32, i32* %12
store i32 %1028, i32* %13
br label %1029
1029: ; preds = %1027, %1022
%1030 = load i32*, i32** %23
store i32* %1030, i32** %27
%1031 = load i32*, i32** %21
%1032 = load i32, i32* %14
%1033 = load i32, i32* %13
%1034 = sub nsw i32 %1032, %1033
%1035 = sext i32 %1034 to i64
%1036 = getelementptr inbounds i32, i32* %1031, i64 %1035
store i32* %1036, i32** %26
br label %1037
1037: ; preds = %1052, %1029
%1038 = load i32, i32* %13
%1039 = icmp sgt i32 %1038, 0
br i1 %1039, label %1040, label %1055
1040: ; preds = %1037
%1041 = load i32*, i32** %27
%1042 = load i32, i32* %1041
store i32 %1042, i32* %20
%1043 = load i32*, i32** %26
%1044 = load i32, i32* %1043
%1045 = load i32*, i32** %27
store i32 %1044, i32* %1045
%1046 = load i32, i32* %20
%1047 = load i32*, i32** %26
store i32 %1046, i32* %1047
%1048 = load i32*, i32** %27
%1049 = getelementptr inbounds i32, i32* %1048, i32 1
store i32* %1049, i32** %27
%1050 = load i32*, i32** %26
%1051 = getelementptr inbounds i32, i32* %1050, i32 1
store i32* %1051, i32** %26
br label %1052
1052: ; preds = %1040
%1053 = load i32, i32* %13
%1054 = add nsw i32 %1053, -1
store i32 %1054, i32* %13
br label %1037
1055: ; preds = %1037
%1056 = load i32, i32* %11
%1057 = load i32, i32* %12
%1058 = icmp sgt i32 %1056, %1057
br i1 %1058, label %1059, label %1097
1059: ; preds = %1055
%1060 = load i32, i32* %11
%1061 = icmp sgt i32 %1060, 1
br i1 %1061, label %1062, label %1075
1062: ; preds = %1059
%1063 = load i32*, i32** %21
%1064 = load i32, i32* %29
%1065 = sext i32 %1064 to i64
%1066 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %1065
%1067 = getelementptr inbounds %struct.anon, %struct.anon* %1066, i32 0, i32 0
store i32* %1063, i32** %1067
%1068 = load i32, i32* %11
%1069 = load i32, i32* %29
%1070 = sext i32 %1069 to i64
%1071 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %1070
%1072 = getelementptr inbounds %struct.anon, %struct.anon* %1071, i32 0, i32 1
store i32 %1068, i32* %1072
%1073 = load i32, i32* %29
%1074 = add nsw i32 %1073, 1
store i32 %1074, i32* %29
br label %1075
1075: ; preds = %1062, %1059
%1076 = load i32, i32* %12
%1077 = icmp sgt i32 %1076, 1
br i1 %1077, label %1078, label %1096
1078: ; preds = %1075
%1079 = load i32*, i32** %21
%1080 = load i32, i32* %14
%1081 = load i32, i32* %12
%1082 = sub nsw i32 %1080, %1081
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds i32, i32* %1079, i64 %1083
%1085 = load i32, i32* %29
%1086 = sext i32 %1085 to i64
%1087 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %1086
%1088 = getelementptr inbounds %struct.anon, %struct.anon* %1087, i32 0, i32 0
store i32* %1084, i32** %1088
%1089 = load i32, i32* %12
%1090 = load i32, i32* %29
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %1091
%1093 = getelementptr inbounds %struct.anon, %struct.anon* %1092, i32 0, i32 1
store i32 %1089, i32* %1093
%1094 = load i32, i32* %29
%1095 = add nsw i32 %1094, 1
store i32 %1095, i32* %29
br label %1096
1096: ; preds = %1078, %1075
br label %1135
1097: ; preds = %1055
%1098 = load i32, i32* %12
%1099 = icmp sgt i32 %1098, 1
br i1 %1099, label %1100, label %1118
1100: ; preds = %1097
%1101 = load i32*, i32** %21
%1102 = load i32, i32* %14
%1103 = load i32, i32* %12
%1104 = sub nsw i32 %1102, %1103
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds i32, i32* %1101, i64 %1105
%1107 = load i32, i32* %29
%1108 = sext i32 %1107 to i64
%1109 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %1108
%1110 = getelementptr inbounds %struct.anon, %struct.anon* %1109, i32 0, i32 0
store i32* %1106, i32** %1110
%1111 = load i32, i32* %12
%1112 = load i32, i32* %29
%1113 = sext i32 %1112 to i64
%1114 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %1113
%1115 = getelementptr inbounds %struct.anon, %struct.anon* %1114, i32 0, i32 1
store i32 %1111, i32* %1115
%1116 = load i32, i32* %29
%1117 = add nsw i32 %1116, 1
store i32 %1117, i32* %29
br label %1118
1118: ; preds = %1100, %1097
%1119 = load i32, i32* %11
%1120 = icmp sgt i32 %1119, 1
br i1 %1120, label %1121, label %1134
1121: ; preds = %1118
%1122 = load i32*, i32** %21
%1123 = load i32, i32* %29
%1124 = sext i32 %1123 to i64
%1125 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %1124
%1126 = getelementptr inbounds %struct.anon, %struct.anon* %1125, i32 0, i32 0
store i32* %1122, i32** %1126
%1127 = load i32, i32* %11
%1128 = load i32, i32* %29
%1129 = sext i32 %1128 to i64
%1130 = getelementptr inbounds [40 x %struct.anon], [40 x %struct.anon]* %28, i64 0, i64 %1129
%1131 = getelementptr inbounds %struct.anon, %struct.anon* %1130, i32 0, i32 1
store i32 %1127, i32* %1131
%1132 = load i32, i32* %29
%1133 = add nsw i32 %1132, 1
store i32 %1133, i32* %29
br label %1134
1134: ; preds = %1121, %1118
br label %1135
1135: ; preds = %1134, %1096
br label %46
1136: ; preds = %46
ret void
}

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