void tce_sortacc_4_scalar(double *unsorted, double *sorted, int a, int b, int c,
                          int d, int i, int j, int k, int l, double factor) {
  int id[4], jd[4], ia, ib, j1, j2, j3, j4;
  int l1, l2, l3, l4;
  int ia1, ia2, ia3, ia4;
  int ib1, ib2, ib3, ib4;
  int rangea1, rangea2, rangea3, rangea4;
  int rangeb1, rangeb2, rangeb3, rangeb4;
  int range[4], order[4], order_r[4];
  int jj1, jj2, jj3, jj4;
  int jj1_bound, jj2_bound, jj3_bound, jj4_bound;
  int count, ir, jr, kr, lr, N1, N2;
  double *pA, *pB;
  jd[0] = a;
  jd[1] = b;
  jd[2] = c;
  jd[3] = d;
  range[0] = b * c * d;
  range[1] = c * d;
  range[2] = d;
  range[3] = 1;
  l1 = jd[i];
  l2 = jd[j];
  l3 = jd[k];
  l4 = jd[l];
  rangea1 = range[i];
  rangea2 = range[j];
  rangea3 = range[k];
  rangea4 = range[l];
  rangeb1 = l2 * l3 * l4;
  rangeb2 = l3 * l4;
  rangeb3 = l4;
  rangeb4 = 1;
  if (l == 3) {
    for (j1 = 0; j1 < l1; j1++) {
      ia1 = j1 * rangea1;
      ib1 = j1 * rangeb1;
      for (j2 = 0; j2 < l2; j2++) {
        ia2 = ia1 + j2 * rangea2;
        ib2 = ib1 + j2 * rangeb2;
        for (j3 = 0; j3 < l3; j3++) {
          ia3 = ia2 + j3 * rangea3;
          ib3 = ib2 + j3 * rangeb3;
          for (j4 = 0; j4 < l4; j4++) {
            ia = ia3 + j4 * rangea4;
            ib = ib3 + j4 * rangeb4;
            sorted[ib] += unsorted[ia] * factor;
          }
        }
      }
    }
  }
  if (k == 3) {
    for (j1 = 0; j1 < l1; j1++) {
      ia1 = j1 * rangea1;
      ib1 = j1 * rangeb1;
      for (j2 = 0; j2 < l2; j2++) {
        ia2 = ia1 + j2 * rangea2;
        ib2 = ib1 + j2 * rangeb2;
        for (j3 = 0; j3 < l3; j3 += 8) {
          for (j4 = 0; j4 < l4; j4 += 8) {
            jj3_bound = (j3 + 8 > l3) ? l3 : j3 + 8;
            for (jj3 = j3; jj3 < jj3_bound; jj3++) {
              ia3 = ia2 + jj3 * rangea3;
              ib3 = ib2 + jj3 * rangeb3;
              jj4_bound = (j4 + 8 > l4) ? l4 : j4 + 8;
              for (jj4 = j4; jj4 < jj4_bound; jj4++) {
                ia = ia3 + jj4 * rangea4;
                ib = ib3 + jj4 * rangeb4;
                sorted[ib] += unsorted[ia] * factor;
              }
            }
          }
        }
      }
    }
  }
  if (j == 3) {
    for (j1 = 0; j1 < l1; j1++) {
      ia1 = j1 * rangea1;
      ib1 = j1 * rangeb1;
      for (j2 = 0; j2 < l2; j2 += 8) {
        for (j3 = 0; j3 < l3; j3++) {
          ia3 = ia1 + j3 * rangea3;
          ib3 = ib1 + j3 * rangeb3;
          for (j4 = 0; j4 < l4; j4 += 8) {
            jj2_bound = (j2 + 8 > l2) ? l2 : j2 + 8;
            for (jj2 = j2; jj2 < jj2_bound; jj2++) {
              ia2 = ia3 + jj2 * rangea2;
              ib2 = ib3 + jj2 * rangeb2;
              jj4_bound = (j4 + 8 > l4) ? l4 : j4 + 8;
              for (jj4 = j4; jj4 < jj4_bound; jj4++) {
                ia = ia2 + jj4 * rangea4;
                ib = ib2 + jj4 * rangeb4;
                sorted[ib] += unsorted[ia] * factor;
              }
            }
          }
        }
      }
    }
  }
  if (i == 3) {
    for (j1 = 0; j1 < l1; j1 += 8) {
      for (j2 = 0; j2 < l2; j2++) {
        ia2 = j2 * rangea2;
        ib2 = j2 * rangeb2;
        for (j3 = 0; j3 < l3; j3++) {
          ia3 = ia2 + j3 * rangea3;
          ib3 = ib2 + j3 * rangeb3;
          for (j4 = 0; j4 < l4; j4 += 8) {
            jj1_bound = (j1 + 8 > l1) ? l1 : j1 + 8;
            for (jj1 = j1; jj1 < jj1_bound; jj1++) {
              ia1 = ia3 + jj1 * rangea1;
              ib1 = ib3 + jj1 * rangeb1;
              jj4_bound = (j4 + 8 > l4) ? l4 : j4 + 8;
              for (jj4 = j4; jj4 < jj4_bound; jj4++) {
                ia = ia1 + jj4 * rangea4;
                ib = ib1 + jj4 * rangeb4;
                sorted[ib] += unsorted[ia] * factor;
              }
            }
          }
        }
      }
    }
  }
}


x86 assembly (clang, -O0):
<tce_sortacc_4_scalar>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x18(%rbp),%eax
imul   -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0xd0(%rbp)
mov    -0x1c(%rbp),%eax
imul   -0x20(%rbp),%eax
mov    %eax,-0xcc(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0xc8(%rbp)
movl   $0x1,-0xc4(%rbp)
movslq 0x10(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%eax
mov    %eax,-0x6c(%rbp)
movslq 0x18(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%eax
mov    %eax,-0x70(%rbp)
movslq 0x20(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%eax
mov    %eax,-0x74(%rbp)
movslq 0x28(%rbp),%rax
mov    -0x50(%rbp,%rax,4),%eax
mov    %eax,-0x78(%rbp)
movslq 0x10(%rbp),%rax
mov    -0xd0(%rbp,%rax,4),%eax
mov    %eax,-0x9c(%rbp)
movslq 0x18(%rbp),%rax
mov    -0xd0(%rbp,%rax,4),%eax
mov    %eax,-0xa0(%rbp)
movslq 0x20(%rbp),%rax
mov    -0xd0(%rbp,%rax,4),%eax
mov    %eax,-0xa4(%rbp)
movslq 0x28(%rbp),%rax
mov    -0xd0(%rbp,%rax,4),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x70(%rbp),%eax
imul   -0x74(%rbp),%eax
imul   -0x78(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0x74(%rbp),%eax
imul   -0x78(%rbp),%eax
mov    %eax,-0xb0(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0xb4(%rbp)
movl   $0x1,-0xb8(%rbp)
cmpl   $0x3,0x28(%rbp)
jne    1388 <tce_sortacc_4_scalar+0x288>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1383 <tce_sortacc_4_scalar+0x283>
mov    -0x5c(%rbp),%eax
imul   -0x9c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x5c(%rbp),%eax
imul   -0xac(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1370 <tce_sortacc_4_scalar+0x270>
mov    -0x7c(%rbp),%eax
mov    -0x60(%rbp),%ecx
imul   -0xa0(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x60(%rbp),%ecx
imul   -0xb0(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x90(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    135d <tce_sortacc_4_scalar+0x25d>
mov    -0x80(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   -0xa4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x90(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    134a <tce_sortacc_4_scalar+0x24a>
mov    -0x84(%rbp),%eax
mov    -0x68(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x68(%rbp),%ecx
imul   -0xb8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    12da <tce_sortacc_4_scalar+0x1da>
jmp    134f <tce_sortacc_4_scalar+0x24f>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    129a <tce_sortacc_4_scalar+0x19a>
jmp    1362 <tce_sortacc_4_scalar+0x262>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    125d <tce_sortacc_4_scalar+0x15d>
jmp    1375 <tce_sortacc_4_scalar+0x275>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    122d <tce_sortacc_4_scalar+0x12d>
jmp    1388 <tce_sortacc_4_scalar+0x288>
cmpl   $0x3,0x20(%rbp)
jne    15d2 <tce_sortacc_4_scalar+0x4d2>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    15cd <tce_sortacc_4_scalar+0x4cd>
mov    -0x5c(%rbp),%eax
imul   -0x9c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x5c(%rbp),%eax
imul   -0xac(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    15ba <tce_sortacc_4_scalar+0x4ba>
mov    -0x7c(%rbp),%eax
mov    -0x60(%rbp),%ecx
imul   -0xa0(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x60(%rbp),%ecx
imul   -0xb0(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x90(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    15a7 <tce_sortacc_4_scalar+0x4a7>
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1594 <tce_sortacc_4_scalar+0x494>
mov    -0x64(%rbp),%eax
add    $0x8,%eax
cmp    -0x74(%rbp),%eax
jle    1442 <tce_sortacc_4_scalar+0x342>
mov    -0x74(%rbp),%eax
mov    %eax,-0x144(%rbp)
jmp    144e <tce_sortacc_4_scalar+0x34e>
mov    -0x64(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x144(%rbp)
mov    -0x144(%rbp),%eax
mov    %eax,-0x10c(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0xfc(%rbp)
mov    -0xfc(%rbp),%eax
cmp    -0x10c(%rbp),%eax
jge    1581 <tce_sortacc_4_scalar+0x481>
mov    -0x80(%rbp),%eax
mov    -0xfc(%rbp),%ecx
imul   -0xa4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x90(%rbp),%eax
mov    -0xfc(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x68(%rbp),%eax
add    $0x8,%eax
cmp    -0x78(%rbp),%eax
jle    14c5 <tce_sortacc_4_scalar+0x3c5>
mov    -0x78(%rbp),%eax
mov    %eax,-0x148(%rbp)
jmp    14d1 <tce_sortacc_4_scalar+0x3d1>
mov    -0x68(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x148(%rbp)
mov    -0x148(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    -0x110(%rbp),%eax
jge    1568 <tce_sortacc_4_scalar+0x468>
mov    -0x84(%rbp),%eax
mov    -0x100(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x100(%rbp),%ecx
imul   -0xb8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    14e6 <tce_sortacc_4_scalar+0x3e6>
jmp    156d <tce_sortacc_4_scalar+0x46d>
mov    -0xfc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xfc(%rbp)
jmp    1463 <tce_sortacc_4_scalar+0x363>
jmp    1586 <tce_sortacc_4_scalar+0x486>
mov    -0x68(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x68(%rbp)
jmp    1419 <tce_sortacc_4_scalar+0x319>
jmp    1599 <tce_sortacc_4_scalar+0x499>
mov    -0x64(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x64(%rbp)
jmp    1406 <tce_sortacc_4_scalar+0x306>
jmp    15ac <tce_sortacc_4_scalar+0x4ac>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    13c9 <tce_sortacc_4_scalar+0x2c9>
jmp    15bf <tce_sortacc_4_scalar+0x4bf>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1399 <tce_sortacc_4_scalar+0x299>
jmp    15d2 <tce_sortacc_4_scalar+0x4d2>
cmpl   $0x3,0x18(%rbp)
jne    181c <tce_sortacc_4_scalar+0x71c>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1817 <tce_sortacc_4_scalar+0x717>
mov    -0x5c(%rbp),%eax
imul   -0x9c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x5c(%rbp),%eax
imul   -0xac(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1804 <tce_sortacc_4_scalar+0x704>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    17f1 <tce_sortacc_4_scalar+0x6f1>
mov    -0x7c(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   -0xa4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    17de <tce_sortacc_4_scalar+0x6de>
mov    -0x60(%rbp),%eax
add    $0x8,%eax
cmp    -0x70(%rbp),%eax
jle    168f <tce_sortacc_4_scalar+0x58f>
mov    -0x70(%rbp),%eax
mov    %eax,-0x14c(%rbp)
jmp    169b <tce_sortacc_4_scalar+0x59b>
mov    -0x60(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x108(%rbp)
mov    -0x60(%rbp),%eax
mov    %eax,-0xf8(%rbp)
mov    -0xf8(%rbp),%eax
cmp    -0x108(%rbp),%eax
jge    17cb <tce_sortacc_4_scalar+0x6cb>
mov    -0x84(%rbp),%eax
mov    -0xf8(%rbp),%ecx
imul   -0xa0(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x80(%rbp)
mov    -0x94(%rbp),%eax
mov    -0xf8(%rbp),%ecx
imul   -0xb0(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x90(%rbp)
mov    -0x68(%rbp),%eax
add    $0x8,%eax
cmp    -0x78(%rbp),%eax
jle    1712 <tce_sortacc_4_scalar+0x612>
mov    -0x78(%rbp),%eax
mov    %eax,-0x150(%rbp)
jmp    171e <tce_sortacc_4_scalar+0x61e>
mov    -0x68(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x150(%rbp)
mov    -0x150(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    -0x110(%rbp),%eax
jge    17b2 <tce_sortacc_4_scalar+0x6b2>
mov    -0x80(%rbp),%eax
mov    -0x100(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x90(%rbp),%eax
mov    -0x100(%rbp),%ecx
imul   -0xb8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    1733 <tce_sortacc_4_scalar+0x633>
jmp    17b7 <tce_sortacc_4_scalar+0x6b7>
mov    -0xf8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf8(%rbp)
jmp    16b0 <tce_sortacc_4_scalar+0x5b0>
jmp    17d0 <tce_sortacc_4_scalar+0x6d0>
mov    -0x68(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x68(%rbp)
jmp    1666 <tce_sortacc_4_scalar+0x566>
jmp    17e3 <tce_sortacc_4_scalar+0x6e3>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1626 <tce_sortacc_4_scalar+0x526>
jmp    17f6 <tce_sortacc_4_scalar+0x6f6>
mov    -0x60(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x60(%rbp)
jmp    1613 <tce_sortacc_4_scalar+0x513>
jmp    1809 <tce_sortacc_4_scalar+0x709>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    15e3 <tce_sortacc_4_scalar+0x4e3>
jmp    181c <tce_sortacc_4_scalar+0x71c>
cmpl   $0x3,0x10(%rbp)
jne    1a66 <tce_sortacc_4_scalar+0x966>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1a61 <tce_sortacc_4_scalar+0x961>
movl   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1a4e <tce_sortacc_4_scalar+0x94e>
mov    -0x60(%rbp),%eax
imul   -0xa0(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x60(%rbp),%eax
imul   -0xb0(%rbp),%eax
mov    %eax,-0x90(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x74(%rbp),%eax
jge    1a3b <tce_sortacc_4_scalar+0x93b>
mov    -0x80(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   -0xa4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x90(%rbp),%eax
mov    -0x64(%rbp),%ecx
imul   -0xb4(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x94(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    1a28 <tce_sortacc_4_scalar+0x928>
mov    -0x5c(%rbp),%eax
add    $0x8,%eax
cmp    -0x6c(%rbp),%eax
jle    18d9 <tce_sortacc_4_scalar+0x7d9>
mov    -0x6c(%rbp),%eax
mov    %eax,-0x154(%rbp)
jmp    18e5 <tce_sortacc_4_scalar+0x7e5>
mov    -0x5c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x154(%rbp)
mov    -0x154(%rbp),%eax
mov    %eax,-0x104(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0xf4(%rbp)
mov    -0xf4(%rbp),%eax
cmp    -0x104(%rbp),%eax
jge    1a15 <tce_sortacc_4_scalar+0x915>
mov    -0x84(%rbp),%eax
mov    -0xf4(%rbp),%ecx
imul   -0x9c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x94(%rbp),%eax
mov    -0xf4(%rbp),%ecx
imul   -0xac(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x68(%rbp),%eax
add    $0x8,%eax
cmp    -0x78(%rbp),%eax
jle    195c <tce_sortacc_4_scalar+0x85c>
mov    -0x78(%rbp),%eax
mov    %eax,-0x158(%rbp)
jmp    1968 <tce_sortacc_4_scalar+0x868>
mov    -0x68(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x158(%rbp)
mov    -0x158(%rbp),%eax
mov    %eax,-0x110(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x100(%rbp)
mov    -0x100(%rbp),%eax
cmp    -0x110(%rbp),%eax
jge    19fc <tce_sortacc_4_scalar+0x8fc>
mov    -0x7c(%rbp),%eax
mov    -0x100(%rbp),%ecx
imul   -0xa8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x8c(%rbp),%eax
mov    -0x100(%rbp),%ecx
imul   -0xb8(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x28(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x100(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x100(%rbp)
jmp    197d <tce_sortacc_4_scalar+0x87d>
jmp    1a01 <tce_sortacc_4_scalar+0x901>
mov    -0xf4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xf4(%rbp)
jmp    18fa <tce_sortacc_4_scalar+0x7fa>
jmp    1a1a <tce_sortacc_4_scalar+0x91a>
mov    -0x68(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x68(%rbp)
jmp    18b0 <tce_sortacc_4_scalar+0x7b0>
jmp    1a2d <tce_sortacc_4_scalar+0x92d>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1870 <tce_sortacc_4_scalar+0x770>
jmp    1a40 <tce_sortacc_4_scalar+0x940>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1840 <tce_sortacc_4_scalar+0x740>
jmp    1a53 <tce_sortacc_4_scalar+0x953>
mov    -0x5c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x5c(%rbp)
jmp    182d <tce_sortacc_4_scalar+0x72d>
jmp    1a66 <tce_sortacc_4_scalar+0x966>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tce_sortacc_4_scalar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
mov    %rsi,0x60(%rsp)
mov    %rdi,0x58(%rsp)
movslq 0x140(%rsp),%r11
movslq 0x138(%rsp),%rax
movslq 0x130(%rsp),%rbx
movslq 0x148(%rsp),%r10
mov    %edx,0xc0(%rsp)
mov    %ecx,0xc4(%rsp)
mov    %r8d,0xc8(%rsp)
mov    %r9d,0xcc(%rsp)
imul   %r9d,%r8d
imul   %r8d,%ecx
mov    0xc0(%rsp,%rax,4),%edi
mov    0xc0(%rsp,%r11,4),%esi
mov    0xc0(%rsp,%r10,4),%ebp
mov    %ebp,%edx
mov    %rsi,-0x8(%rsp)
imul   %esi,%edx
mov    %edx,%esi
mov    %rdi,-0x18(%rsp)
imul   %edi,%esi
mov    %ecx,0xb0(%rsp)
mov    %r8d,0xb4(%rsp)
mov    %r9d,0xb8(%rsp)
movl   $0x1,0xbc(%rsp)
mov    0xc0(%rsp,%rbx,4),%ecx
mov    %rcx,-0x30(%rsp)
mov    %rbp,(%rsp)
movslq %ebp,%rbp
mov    %rbx,0xe8(%rsp)
movslq 0xb0(%rsp,%rbx,4),%rdi
mov    %rdi,0x28(%rsp)
mov    %rax,0xe0(%rsp)
movslq 0xb0(%rsp,%rax,4),%rdi
mov    %rdi,0x38(%rsp)
movslq %esi,%rsi
mov    %rsi,0x20(%rsp)
mov    %r11,0x78(%rsp)
movslq 0xb0(%rsp,%r11,4),%rsi
mov    %rsi,0x48(%rsp)
movslq 0xb0(%rsp,%r10,4),%rcx
mov    %rcx,-0x40(%rsp)
mov    %rbp,%rcx
cmp    $0x3,%r10
movslq %edx,%rax
mov    %rax,0x30(%rsp)
mov    %rbp,-0x70(%rsp)
jne    149f <tce_sortacc_4_scalar+0x39f>
cmpl   $0x0,-0x30(%rsp)
jle    149f <tce_sortacc_4_scalar+0x39f>
mov    (%rsp),%r14
and    $0xfffffffe,%r14d
mov    0x58(%rsp),%rdx
mov    -0x40(%rsp),%rcx
lea    (%rdx,%rcx,8),%rax
mov    %rax,-0x80(%rsp)
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,-0x68(%rsp)
mov    0x38(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x50(%rsp)
mov    0x48(%rsp),%rax
lea    0x0(,%rax,8),%r9
mov    %rcx,%rax
shl    $0x4,%rax
mov    0x60(%rsp),%rcx
add    $0x8,%rcx
mov    %rcx,-0x48(%rsp)
mov    -0x70(%rsp),%rdi
mov    0x20(%rsp),%rsi
lea    0x0(,%rsi,8),%rcx
mov    %rcx,-0x50(%rsp)
mov    0x30(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x88(%rsp)
mov    %rdi,%rcx
lea    0x0(,%rdi,8),%r8
xor    %esi,%esi
mov    %rsi,-0x78(%rsp)
mov    %rdx,-0x60(%rsp)
jmp    1315 <tce_sortacc_4_scalar+0x215>
nopl   (%rax)
mov    -0x78(%rsp),%rdi
add    $0x1,%rdi
mov    -0x68(%rsp),%rdx
add    %rdx,-0x80(%rsp)
mov    -0x50(%rsp),%rsi
add    %rsi,-0x48(%rsp)
add    %rdx,-0x60(%rsp)
mov    %rdi,%rdx
mov    %rdi,-0x78(%rsp)
cmp    -0x30(%rsp),%rdi
je     149f <tce_sortacc_4_scalar+0x39f>
cmpl   $0x0,-0x18(%rsp)
jle    12e0 <tce_sortacc_4_scalar+0x1e0>
mov    -0x78(%rsp),%rdx
mov    %rdx,%rsi
imul   0x28(%rsp),%rsi
mov    %rsi,0x80(%rsp)
imul   0x20(%rsp),%rdx
mov    %rdx,0x40(%rsp)
mov    -0x60(%rsp),%rdx
mov    %rdx,0x68(%rsp)
mov    -0x48(%rsp),%rdx
mov    %rdx,0x10(%rsp)
mov    -0x80(%rsp),%rdx
mov    %rdx,0x8(%rsp)
xor    %r10d,%r10d
jmp    1390 <tce_sortacc_4_scalar+0x290>
add    $0x1,%r10
mov    0x50(%rsp),%rdx
add    %rdx,0x8(%rsp)
mov    0x10(%rsp),%rsi
add    0x88(%rsp),%rsi
mov    %rsi,0x10(%rsp)
add    %rdx,0x68(%rsp)
cmp    -0x18(%rsp),%r10
je     12e0 <tce_sortacc_4_scalar+0x1e0>
cmpl   $0x0,-0x8(%rsp)
jle    1360 <tce_sortacc_4_scalar+0x260>
mov    %r10,%r11
imul   0x38(%rsp),%r11
add    0x80(%rsp),%r11
mov    %r10,%r12
imul   0x30(%rsp),%r12
add    0x40(%rsp),%r12
mov    0x68(%rsp),%rsi
mov    0x10(%rsp),%rdi
mov    0x8(%rsp),%rbx
xor    %edx,%edx
jmp    13e8 <tce_sortacc_4_scalar+0x2e8>
nopl   0x0(%rax)
add    $0x1,%rdx
add    %r9,%rbx
add    %r8,%rdi
add    %r9,%rsi
cmp    -0x8(%rsp),%rdx
je     1360 <tce_sortacc_4_scalar+0x260>
test   %ecx,%ecx
jle    13d0 <tce_sortacc_4_scalar+0x2d0>
cmpl   $0x1,(%rsp)
jne    1400 <tce_sortacc_4_scalar+0x300>
xor    %r15d,%r15d
jmp    144a <tce_sortacc_4_scalar+0x34a>
nopw   0x0(%rax,%rax,1)
xor    %r13d,%r13d
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%r13,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rdi,%r15,8),%xmm1
movsd  %xmm1,-0x8(%rdi,%r15,8)
movsd  (%rbx,%r13,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdi,%r15,8),%xmm1
movsd  %xmm1,(%rdi,%r15,8)
add    $0x2,%r15
add    %rax,%r13
cmp    %r15,%r14
jne    1410 <tce_sortacc_4_scalar+0x310>
testb  $0x1,(%rsp)
je     13d0 <tce_sortacc_4_scalar+0x2d0>
mov    %rdx,%rbp
imul   0x48(%rsp),%rbp
add    %r11,%rbp
mov    %rdx,%rcx
imul   -0x70(%rsp),%rcx
add    %r12,%rcx
add    %r15,%rcx
imul   -0x40(%rsp),%r15
add    %rbp,%r15
mov    0x58(%rsp),%rbp
movsd  0x0(%rbp,%r15,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x60(%rsp),%rbp
addsd  0x0(%rbp,%rcx,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
mov    -0x70(%rsp),%rcx
jmp    13d0 <tce_sortacc_4_scalar+0x2d0>
cmpl   $0x3,0x78(%rsp)
jne    189f <tce_sortacc_4_scalar+0x79f>
cmpl   $0x0,-0x30(%rsp)
jle    189f <tce_sortacc_4_scalar+0x79f>
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0xd8(%rsp)
mov    0x38(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,-0x20(%rsp)
mov    0x48(%rsp),%rax
mov    %rax,%rdx
shl    $0x6,%rdx
mov    %rdx,0x78(%rsp)
lea    0x0(,%rax,8),%rdi
mov    -0x40(%rsp),%rax
lea    (%rax,%rax,1),%rbp
mov    0x60(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x90(%rsp)
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0xf0(%rsp)
mov    0x30(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0xa0(%rsp)
mov    %rcx,%rax
shl    $0x6,%rax
mov    %rax,0xa8(%rsp)
lea    0x0(,%rcx,8),%rsi
xor    %eax,%eax
mov    %rax,-0x38(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    %rsi,0x50(%rsp)
jmp    15ae <tce_sortacc_4_scalar+0x4ae>
nopl   0x0(%rax,%rax,1)
mov    -0x38(%rsp),%rdx
add    $0x1,%rdx
mov    0x18(%rsp),%rax
add    0xd8(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0xf0(%rsp),%rax
add    %rax,0x90(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x38(%rsp)
cmp    -0x30(%rsp),%rdx
je     189f <tce_sortacc_4_scalar+0x79f>
cmpl   $0x0,-0x18(%rsp)
jle    1570 <tce_sortacc_4_scalar+0x470>
mov    -0x38(%rsp),%rax
mov    %rax,%rdx
imul   0x28(%rsp),%rdx
mov    %rdx,0x98(%rsp)
imul   0x20(%rsp),%rax
mov    %rax,-0x28(%rsp)
mov    0x90(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    0x18(%rsp),%rax
mov    %rax,-0x10(%rsp)
xor    %eax,%eax
mov    %rax,-0x58(%rsp)
jmp    163d <tce_sortacc_4_scalar+0x53d>
cs nopw 0x0(%rax,%rax,1)
mov    -0x58(%rsp),%rdx
add    $0x1,%rdx
mov    -0x10(%rsp),%rax
add    -0x20(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    0x70(%rsp),%rax
add    0xa0(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x58(%rsp)
cmp    -0x18(%rsp),%rdx
je     1570 <tce_sortacc_4_scalar+0x470>
cmpl   $0x0,-0x8(%rsp)
jle    1600 <tce_sortacc_4_scalar+0x500>
mov    -0x58(%rsp),%rax
mov    %rax,%rdx
imul   0x38(%rsp),%rdx
add    0x98(%rsp),%rdx
mov    %rdx,0x40(%rsp)
imul   0x30(%rsp),%rax
add    -0x28(%rsp),%rax
mov    %rax,-0x78(%rsp)
mov    0x70(%rsp),%rax
mov    %rax,-0x68(%rsp)
mov    -0x10(%rsp),%rax
mov    %rax,-0x50(%rsp)
xor    %eax,%eax
mov    %rax,-0x80(%rsp)
jmp    16c9 <tce_sortacc_4_scalar+0x5c9>
nopl   0x0(%rax)
mov    -0x80(%rsp),%rdx
add    $0x8,%rdx
mov    -0x50(%rsp),%rax
add    0x78(%rsp),%rax
mov    %rax,-0x50(%rsp)
mov    -0x68(%rsp),%rax
add    0xa8(%rsp),%rax
mov    %rax,-0x68(%rsp)
mov    %rdx,-0x80(%rsp)
cmp    %edx,-0x8(%rsp)
jle    1600 <tce_sortacc_4_scalar+0x500>
test   %ecx,%ecx
jle    1690 <tce_sortacc_4_scalar+0x590>
mov    -0x80(%rsp),%rax
add    $0x8,%eax
mov    -0x8(%rsp),%rcx
cmp    %ecx,%eax
mov    %ecx,%edx
mov    -0x70(%rsp),%rcx
cmovle %eax,%edx
mov    %edx,-0x60(%rsp)
movslq %edx,%r15
xor    %eax,%eax
mov    %rax,-0x48(%rsp)
xor    %r14d,%r14d
jmp    170f <tce_sortacc_4_scalar+0x60f>
nopl   0x0(%rax)
add    $0x8,%r14
addq   $0x1,-0x48(%rsp)
cmp    %r14d,%ecx
jle    1690 <tce_sortacc_4_scalar+0x590>
lea    0x8(%r14),%eax
cmp    %eax,%ecx
mov    %eax,%edx
cmovl  %ecx,%edx
mov    -0x60(%rsp),%ebx
cmp    -0x80(%rsp),%ebx
jle    1700 <tce_sortacc_4_scalar+0x600>
mov    -0x48(%rsp),%rbx
lea    0x0(,%rbx,8),%rbx
movslq %edx,%rdx
not    %rbx
mov    %rbx,0x10(%rsp)
cmp    %ecx,%eax
mov    (%rsp),%rcx
mov    %ecx,%r10d
mov    -0x70(%rsp),%rcx
cmovle %eax,%r10d
movslq %r10d,%r11
mov    %r14,%rax
imul   -0x40(%rsp),%rax
mov    %rax,0x88(%rsp)
mov    %r14,%rax
or     $0x1,%rax
mov    %rax,0x80(%rsp)
mov    %rdx,%rax
mov    %rdx,0x68(%rsp)
neg    %rdx
mov    %rdx,0x8(%rsp)
mov    -0x68(%rsp),%rdx
mov    -0x50(%rsp),%rax
mov    -0x80(%rsp),%r9
jmp    17b3 <tce_sortacc_4_scalar+0x6b3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r9
add    %rdi,%rax
add    %rsi,%rdx
cmp    %r15,%r9
jge    1700 <tce_sortacc_4_scalar+0x600>
cmp    %r14d,%r10d
jle    17a0 <tce_sortacc_4_scalar+0x6a0>
mov    %r14,%r12
testb  $0x1,0x68(%rsp)
je     1816 <tce_sortacc_4_scalar+0x716>
mov    %r9,%rbx
imul   0x48(%rsp),%rbx
add    0x40(%rsp),%rbx
mov    %r9,%rsi
imul   %rcx,%rsi
add    -0x78(%rsp),%rsi
add    0x88(%rsp),%rbx
add    %r14,%rsi
mov    0x58(%rsp),%rcx
movsd  (%rcx,%rbx,8),%xmm1
mov    -0x70(%rsp),%rcx
mulsd  %xmm0,%xmm1
mov    0x60(%rsp),%rbx
addsd  (%rbx,%rsi,8),%xmm1
movsd  %xmm1,(%rbx,%rsi,8)
mov    0x50(%rsp),%rsi
mov    0x80(%rsp),%r12
mov    0x8(%rsp),%rbx
cmp    %rbx,0x10(%rsp)
je     17a0 <tce_sortacc_4_scalar+0x6a0>
lea    0x1(%r12),%rsi
mov    %rdi,%r8
mov    %rcx,%rdi
mov    -0x40(%rsp),%rcx
imul   %rcx,%rsi
lea    (%rax,%rsi,8),%rbx
mov    %rcx,%rsi
mov    %rdi,%rcx
mov    %r8,%rdi
imul   %r12,%rsi
lea    (%rax,%rsi,8),%r8
mov    0x50(%rsp),%rsi
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
movsd  (%r8,%r13,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rdx,%r12,8),%xmm1
movsd  %xmm1,-0x8(%rdx,%r12,8)
movsd  (%rbx,%r13,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%r12,8),%xmm1
movsd  %xmm1,(%rdx,%r12,8)
add    $0x2,%r12
add    %rbp,%r13
cmp    %r11,%r12
jl     1860 <tce_sortacc_4_scalar+0x760>
jmp    17a0 <tce_sortacc_4_scalar+0x6a0>
cmpl   $0x3,0xe0(%rsp)
03
jne    1c6f <tce_sortacc_4_scalar+0xb6f>
cmpl   $0x0,-0x30(%rsp)
jle    1c6f <tce_sortacc_4_scalar+0xb6f>
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0x90(%rsp)
mov    0x38(%rsp),%rax
mov    %rax,%rdx
shl    $0x6,%rdx
mov    %rdx,0xa0(%rsp)
mov    0x48(%rsp),%rdx
lea    0x0(,%rdx,8),%rdx
mov    %rdx,0x78(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x8(%rsp)
mov    -0x40(%rsp),%rax
lea    (%rax,%rax,1),%r8
mov    0x60(%rsp),%rax
add    $0x8,%rax
mov    %rax,0x18(%rsp)
mov    0x20(%rsp),%rax
lea    0x0(,%rax,8),%rax
mov    %rax,0xd8(%rsp)
mov    0x30(%rsp),%rax
mov    %rax,%rdx
shl    $0x6,%rdx
mov    %rdx,0x98(%rsp)
lea    0x0(,%rcx,8),%rdx
mov    %rdx,0xa8(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x10(%rsp)
xor    %eax,%eax
mov    %rax,-0x28(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,-0x38(%rsp)
jmp    19ab <tce_sortacc_4_scalar+0x8ab>
mov    -0x28(%rsp),%rdx
add    $0x1,%rdx
mov    -0x38(%rsp),%rax
add    0x90(%rsp),%rax
mov    %rax,-0x38(%rsp)
mov    0xd8(%rsp),%rax
add    %rax,0x18(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x28(%rsp)
cmp    -0x30(%rsp),%rdx
je     1c6f <tce_sortacc_4_scalar+0xb6f>
cmpl   $0x0,-0x18(%rsp)
jle    1970 <tce_sortacc_4_scalar+0x870>
mov    -0x28(%rsp),%rax
mov    %rax,%rdx
imul   0x28(%rsp),%rdx
mov    %rdx,0x70(%rsp)
imul   0x20(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    0x18(%rsp),%rax
mov    %rax,-0x58(%rsp)
mov    -0x38(%rsp),%rax
mov    %rax,-0x20(%rsp)
xor    %eax,%eax
mov    %rax,-0x80(%rsp)
jmp    1a2c <tce_sortacc_4_scalar+0x92c>
nopl   (%rax)
mov    -0x80(%rsp),%rdx
add    $0x8,%rdx
mov    -0x20(%rsp),%rax
add    0xa0(%rsp),%rax
mov    %rax,-0x20(%rsp)
mov    -0x58(%rsp),%rax
add    0x98(%rsp),%rax
mov    %rax,-0x58(%rsp)
mov    %rdx,-0x80(%rsp)
cmp    %edx,-0x18(%rsp)
jle    1970 <tce_sortacc_4_scalar+0x870>
cmpl   $0x0,-0x8(%rsp)
jle    19f0 <tce_sortacc_4_scalar+0x8f0>
mov    -0x80(%rsp),%rax
add    $0x8,%eax
mov    -0x18(%rsp),%rcx
cmp    %ecx,%eax
mov    %ecx,%edx
mov    -0x70(%rsp),%rcx
cmovle %eax,%edx
mov    %edx,-0x48(%rsp)
movslq %edx,%rdx
mov    -0x58(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    -0x20(%rsp),%rax
mov    %rax,-0x68(%rsp)
xor    %eax,%eax
mov    %rax,-0x50(%rsp)
jmp    1ab2 <tce_sortacc_4_scalar+0x9b2>
mov    -0x50(%rsp),%rcx
add    $0x1,%rcx
mov    -0x68(%rsp),%rax
add    0x78(%rsp),%rax
mov    %rax,-0x68(%rsp)
mov    -0x60(%rsp),%rax
add    0xa8(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    %rcx,%rax
mov    %rcx,-0x50(%rsp)
cmp    -0x8(%rsp),%rcx
mov    -0x70(%rsp),%rcx
je     19f0 <tce_sortacc_4_scalar+0x8f0>
test   %ecx,%ecx
jle    1a70 <tce_sortacc_4_scalar+0x970>
mov    -0x50(%rsp),%rax
mov    %rax,%rcx
imul   0x48(%rsp),%rcx
add    0x70(%rsp),%rcx
mov    %rcx,0x80(%rsp)
imul   -0x70(%rsp),%rax
add    -0x10(%rsp),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,-0x78(%rsp)
xor    %ebx,%ebx
jmp    1b03 <tce_sortacc_4_scalar+0xa03>
nopl   0x0(%rax)
add    $0x8,%rbx
addq   $0x1,-0x78(%rsp)
cmp    %ebx,(%rsp)
jle    1a70 <tce_sortacc_4_scalar+0x970>
lea    0x8(%rbx),%ecx
mov    -0x70(%rsp),%rax
cmp    %ecx,%eax
mov    %ecx,%esi
cmovl  %eax,%esi
mov    -0x48(%rsp),%eax
cmp    -0x80(%rsp),%eax
jle    1af0 <tce_sortacc_4_scalar+0x9f0>
mov    -0x78(%rsp),%rax
lea    0x0(,%rax,8),%rax
movslq %esi,%rsi
not    %rax
mov    %rax,0x68(%rsp)
cmp    (%rsp),%ecx
mov    -0x70(%rsp),%rax
mov    %eax,%r10d
mov    0x8(%rsp),%rax
cmovle %ecx,%r10d
movslq %r10d,%rdi
mov    %rbx,%rcx
imul   -0x40(%rsp),%rcx
mov    %rcx,0x50(%rsp)
mov    %rbx,%rcx
or     $0x1,%rcx
mov    %rcx,0x88(%rsp)
mov    %rsi,%r12
mov    %rsi,%rcx
neg    %rcx
mov    -0x60(%rsp),%r15
mov    -0x68(%rsp),%r11
mov    -0x80(%rsp),%r9
jmp    1ba5 <tce_sortacc_4_scalar+0xaa5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r9
add    %rax,%r11
add    0x10(%rsp),%r15
cmp    %rdx,%r9
jge    1af0 <tce_sortacc_4_scalar+0x9f0>
cmp    %ebx,%r10d
jle    1b90 <tce_sortacc_4_scalar+0xa90>
mov    %rbx,%r14
test   $0x1,%r12b
je     1c04 <tce_sortacc_4_scalar+0xb04>
mov    %r9,%rsi
imul   0x38(%rsp),%rsi
add    0x80(%rsp),%rsi
mov    %r9,%rbp
imul   0x30(%rsp),%rbp
add    0x40(%rsp),%rbp
add    0x50(%rsp),%rsi
add    %rbx,%rbp
mov    0x58(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm1
mov    0x8(%rsp),%rax
mulsd  %xmm0,%xmm1
mov    0x60(%rsp),%rsi
addsd  (%rsi,%rbp,8),%xmm1
movsd  %xmm1,(%rsi,%rbp,8)
mov    0x88(%rsp),%r14
cmp    %rcx,0x68(%rsp)
je     1b90 <tce_sortacc_4_scalar+0xa90>
lea    0x1(%r14),%rsi
mov    -0x40(%rsp),%rbp
imul   %rbp,%rsi
lea    (%r11,%rsi,8),%rsi
imul   %r14,%rbp
lea    (%r11,%rbp,8),%r13
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%r13,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r15,%r14,8),%xmm1
movsd  %xmm1,-0x8(%r15,%r14,8)
movsd  (%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r15,%r14,8),%xmm1
movsd  %xmm1,(%r15,%r14,8)
add    $0x2,%r14
add    %r8,%rbp
cmp    %rdi,%r14
jl     1c30 <tce_sortacc_4_scalar+0xb30>
jmp    1b90 <tce_sortacc_4_scalar+0xa90>
cmpl   $0x3,0xe8(%rsp)
03
jne    203e <tce_sortacc_4_scalar+0xf3e>
cmpl   $0x0,-0x30(%rsp)
jle    203e <tce_sortacc_4_scalar+0xf3e>
mov    0x28(%rsp),%rax
mov    %rax,%rdx
shl    $0x6,%rdx
mov    %rdx,0x18(%rsp)
mov    0x38(%rsp),%rdx
lea    0x0(,%rdx,8),%rdx
mov    %rdx,0xa0(%rsp)
mov    0x48(%rsp),%rdx
lea    0x0(,%rdx,8),%rdx
mov    %rdx,-0x50(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x10(%rsp)
mov    -0x40(%rsp),%rax
lea    (%rax,%rax,1),%r13
mov    0x60(%rsp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rsp)
mov    0x20(%rsp),%rax
mov    %rax,%rdx
shl    $0x6,%rdx
mov    %rdx,0x90(%rsp)
mov    %rcx,%rdx
mov    0x30(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
mov    %rcx,0x98(%rsp)
lea    0x0(,%rdx,8),%rcx
mov    %rcx,0x78(%rsp)
lea    0x0(,%rax,8),%rax
mov    %rax,0x68(%rsp)
xor    %eax,%eax
mov    %rax,-0x78(%rsp)
mov    0x58(%rsp),%rax
mov    %rax,-0x28(%rsp)
jmp    1d74 <tce_sortacc_4_scalar+0xc74>
nopl   (%rax)
mov    -0x78(%rsp),%rcx
add    $0x8,%rcx
mov    -0x28(%rsp),%rax
add    0x18(%rsp),%rax
mov    %rax,-0x28(%rsp)
mov    0x90(%rsp),%rax
add    %rax,-0x38(%rsp)
mov    %rcx,-0x78(%rsp)
cmp    %ecx,-0x30(%rsp)
jle    203e <tce_sortacc_4_scalar+0xf3e>
cmpl   $0x0,-0x18(%rsp)
jle    1d40 <tce_sortacc_4_scalar+0xc40>
mov    -0x78(%rsp),%rax
add    $0x8,%eax
mov    -0x30(%rsp),%rcx
cmp    %ecx,%eax
mov    %ecx,%edx
mov    -0x70(%rsp),%rcx
cmovle %eax,%edx
mov    %edx,-0x80(%rsp)
movslq %edx,%r9
mov    -0x38(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    -0x28(%rsp),%rax
mov    %rax,-0x58(%rsp)
xor    %eax,%eax
mov    %rax,-0x20(%rsp)
jmp    1e00 <tce_sortacc_4_scalar+0xd00>
nopl   0x0(%rax,%rax,1)
mov    -0x20(%rsp),%rdx
add    $0x1,%rdx
mov    -0x58(%rsp),%rax
add    0xa0(%rsp),%rax
mov    %rax,-0x58(%rsp)
mov    -0x10(%rsp),%rax
add    0x98(%rsp),%rax
mov    %rax,-0x10(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x20(%rsp)
cmp    -0x18(%rsp),%rdx
je     1d40 <tce_sortacc_4_scalar+0xc40>
cmpl   $0x0,-0x8(%rsp)
jle    1dc0 <tce_sortacc_4_scalar+0xcc0>
mov    -0x20(%rsp),%rax
mov    %rax,%rdx
imul   0x38(%rsp),%rdx
mov    %rdx,0xa8(%rsp)
imul   0x30(%rsp),%rax
mov    %rax,0x70(%rsp)
mov    -0x10(%rsp),%rax
mov    %rax,-0x48(%rsp)
mov    -0x58(%rsp),%rax
mov    %rax,-0x60(%rsp)
xor    %eax,%eax
mov    %rax,-0x68(%rsp)
jmp    1e8a <tce_sortacc_4_scalar+0xd8a>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x68(%rsp),%rdx
add    $0x1,%rdx
mov    -0x60(%rsp),%rax
add    -0x50(%rsp),%rax
mov    %rax,-0x60(%rsp)
mov    -0x48(%rsp),%rax
add    0x78(%rsp),%rax
mov    %rax,-0x48(%rsp)
mov    %rdx,%rax
mov    %rdx,-0x68(%rsp)
cmp    -0x8(%rsp),%rdx
je     1dc0 <tce_sortacc_4_scalar+0xcc0>
cmpl   $0x0,(%rsp)
jle    1e50 <tce_sortacc_4_scalar+0xd50>
mov    -0x68(%rsp),%rax
mov    %rax,%rdx
imul   0x48(%rsp),%rdx
add    0xa8(%rsp),%rdx
mov    %rdx,0x88(%rsp)
imul   %rcx,%rax
add    0x70(%rsp),%rax
mov    %rax,0x80(%rsp)
xor    %eax,%eax
mov    %rax,0x40(%rsp)
xor    %ebx,%ebx
jmp    1ee7 <tce_sortacc_4_scalar+0xde7>
nopw   0x0(%rax,%rax,1)
add    $0x8,%rbx
addq   $0x1,0x40(%rsp)
mov    -0x70(%rsp),%rcx
cmp    %ebx,%ecx
jle    1e50 <tce_sortacc_4_scalar+0xd50>
lea    0x8(%rbx),%eax
mov    (%rsp),%rcx
cmp    %eax,%ecx
mov    %eax,%edx
cmovl  %ecx,%edx
mov    -0x80(%rsp),%ecx
cmp    -0x78(%rsp),%ecx
jle    1ed0 <tce_sortacc_4_scalar+0xdd0>
mov    0x40(%rsp),%rcx
lea    0x0(,%rcx,8),%rcx
movslq %edx,%r15
not    %rcx
cmp    (%rsp),%eax
mov    -0x70(%rsp),%rdx
mov    %edx,%r10d
cmovle %eax,%r10d
movslq %r10d,%rdi
mov    %rbx,%rax
imul   -0x40(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    %rbx,%rax
or     $0x1,%rax
mov    %rax,0x50(%rsp)
mov    %r15,%rax
neg    %rax
mov    -0x48(%rsp),%r12
mov    -0x60(%rsp),%r14
mov    -0x78(%rsp),%r11
jmp    1f77 <tce_sortacc_4_scalar+0xe77>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r11
add    0x10(%rsp),%r14
add    0x68(%rsp),%r12
cmp    %r9,%r11
jge    1ed0 <tce_sortacc_4_scalar+0xdd0>
cmp    %ebx,%r10d
jle    1f60 <tce_sortacc_4_scalar+0xe60>
mov    %rbx,%rdx
test   $0x1,%r15b
je     1fd2 <tce_sortacc_4_scalar+0xed2>
mov    %r11,%rdx
imul   0x28(%rsp),%rdx
add    0x88(%rsp),%rdx
mov    %r11,%rsi
imul   0x20(%rsp),%rsi
add    0x80(%rsp),%rsi
add    0x8(%rsp),%rdx
add    %rbx,%rsi
mov    0x58(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
mov    0x60(%rsp),%rdx
addsd  (%rdx,%rsi,8),%xmm1
movsd  %xmm1,(%rdx,%rsi,8)
mov    0x50(%rsp),%rdx
cmp    %rax,%rcx
je     1f60 <tce_sortacc_4_scalar+0xe60>
lea    0x1(%rdx),%rsi
mov    -0x40(%rsp),%rbp
imul   %rbp,%rsi
lea    (%r14,%rsi,8),%rsi
imul   %rdx,%rbp
lea    (%r14,%rbp,8),%r8
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r8,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r12,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r12,%rdx,8)
movsd  (%rsi,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r12,%rdx,8),%xmm1
movsd  %xmm1,(%r12,%rdx,8)
add    $0x2,%rdx
add    %r13,%rbp
cmp    %rdi,%rdx
jl     2000 <tce_sortacc_4_scalar+0xf00>
jmp    1f60 <tce_sortacc_4_scalar+0xe60>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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