void corth(int nm, int n, int low, int igh, double *ar, double *ai,
           double *ortr, double *orti) {
  int i, j, m, ii, jj, la, mp, kp1;
  double f, g, h, fi, fr, scale;
  la = igh - 1;
  kp1 = low + 1;
  if (la < kp1)
    return;
  for (m = kp1; m <= la; m++) {
    h = 0.0;
    ortr[(m)-1] = 0.0;
    orti[(m)-1] = 0.0;
    scale = 0.0;
    for (i = m; i <= igh; i++)
      scale += fabs(ar[(i)-1 + ((m - 1) - 1) * (nm)]) +
               fabs(ai[(i)-1 + ((m - 1) - 1) * (nm)]);
    if (scale == 0.0)
      continue;
    mp = m + igh;
    for (ii = m; ii <= igh; ii++) {
      i = mp - ii;
      ortr[(i)-1] = ar[(i)-1 + ((m - 1) - 1) * (nm)] / scale;
      orti[(i)-1] = ai[(i)-1 + ((m - 1) - 1) * (nm)] / scale;
      h = h + ortr[(i)-1] * ortr[(i)-1] + orti[(i)-1] * orti[(i)-1];
    }
    g = sqrt(h);
    f = pythag(ortr[(m)-1], orti[(m)-1]);
    if (f != 0.0) {
      h += f * g;
      g /= f;
      ortr[(m)-1] = (1.0 + g) * ortr[(m)-1];
      orti[(m)-1] = (1.0 + g) * orti[(m)-1];
    } else {
      ortr[(m)-1] = g;
      ar[(m)-1 + ((m - 1) - 1) * (nm)] = scale;
    }
    for (j = m; j <= n; j++) {
      fr = 0.0;
      fi = 0.0;
      for (ii = m; ii <= igh; ii++) {
        i = mp - ii;
        fr = fr + ortr[(i)-1] * ar[(i)-1 + ((j)-1) * (nm)] +
             orti[(i)-1] * ai[(i)-1 + ((j)-1) * (nm)];
        fi = fi + ortr[(i)-1] * ai[(i)-1 + ((j)-1) * (nm)] -
             orti[(i)-1] * ar[(i)-1 + ((j)-1) * (nm)];
      }
      fr /= h;
      fi /= h;
      for (i = m; i <= igh; i++) {
        ar[(i)-1 + ((j)-1) * (nm)] =
            ar[(i)-1 + ((j)-1) * (nm)] - fr * ortr[(i)-1] + fi * orti[(i)-1];
        ai[(i)-1 + ((j)-1) * (nm)] =
            ai[(i)-1 + ((j)-1) * (nm)] - fr * orti[(i)-1] - fi * ortr[(i)-1];
      }
    }
    for (i = 1; i <= igh; i++) {
      fr = 0.0;
      fi = 0.0;
      for (jj = m; jj <= igh; jj++) {
        j = mp - jj;
        fr = fr + ortr[(j)-1] * ar[(i)-1 + ((j)-1) * (nm)] -
             orti[(j)-1] * ai[(i)-1 + ((j)-1) * (nm)];
        fi = fi + ortr[(j)-1] * ai[(i)-1 + ((j)-1) * (nm)] +
             orti[(j)-1] * ar[(i)-1 + ((j)-1) * (nm)];
      }
      fr /= h;
      fi /= h;
      for (j = m; j <= igh; j++) {
        ar[(i)-1 + ((j)-1) * (nm)] =
            ar[(i)-1 + ((j)-1) * (nm)] - fr * ortr[(j)-1] - fi * orti[(j)-1];
        ai[(i)-1 + ((j)-1) * (nm)] =
            ai[(i)-1 + ((j)-1) * (nm)] + fr * orti[(j)-1] - fi * ortr[(j)-1];
      }
    }
    ortr[(m)-1] = scale * ortr[(m)-1];
    orti[(m)-1] = scale * orti[(m)-1];
    ar[(m)-1 + ((m - 1) - 1) * (nm)] = -g * ar[(m)-1 + ((m - 1) - 1) * (nm)];
    ai[(m)-1 + ((m - 1) - 1) * (nm)] = -g * ai[(m)-1 + ((m - 1) - 1) * (nm)];
  }
}


x86 assembly (clang, -O0):
<corth>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1167 <corth+0x47>
jmp    1b7a <corth+0xa5a>
mov    -0x40(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jg     1b7a <corth+0xa5a>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1239 <corth+0x119>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0xe23(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0xdf7(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
addsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b9 <corth+0x99>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1256 <corth+0x136>
jp     1256 <corth+0x136>
jmp    1b6c <corth+0xa4c>
mov    -0x2c(%rbp),%eax
add    -0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     135a <corth+0x23a>
mov    -0x3c(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1265 <corth+0x145>
movsd  -0x58(%rbp),%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,-0x50(%rbp)
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1030 <pythag@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13ba <corth+0x29a>
jp     13ba <corth+0x29a>
jmp    1450 <corth+0x330>
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x48(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0xc0f(%rip),%xmm0
addsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xbde(%rip),%xmm0
addsd  -0x50(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    148d <corth+0x36d>
movsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1775 <corth+0x655>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     15e3 <corth+0x4c3>
mov    -0x3c(%rbp),%eax
sub    -0x30(%rbp),%eax
mov    %eax,-0x24(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14b5 <corth+0x395>
movsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1762 <corth+0x642>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    160f <corth+0x4ef>
jmp    1767 <corth+0x647>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1493 <corth+0x373>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1a5e <corth+0x93e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     18cc <corth+0x7ac>
mov    -0x3c(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x28(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    179e <corth+0x67e>
movsd  -0x58(%rbp),%xmm1
movsd  -0x68(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x58(%rbp),%xmm1
movsd  -0x60(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1a4b <corth+0x92b>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x68(%rbp),%xmm1
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    18f8 <corth+0x7d8>
jmp    1a50 <corth+0x930>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    177c <corth+0x65c>
movsd  -0x70(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    116d <corth+0x4d>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<corth>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
lea    0x1(%rdx),%eax
mov    %rcx,0x98(%rsp)
cmp    %ecx,%eax
jge    1e73 <corth+0xd53>
mov    %esi,%ebx
movabs $0xffffffff00000000,%rbp
ff ff ff
movslq %eax,%rsi
mov    0x98(%rsp),%r10
movslq %r10d,%r13
movslq %edi,%rcx
movslq %ebx,%rax
mov    %rax,0x140(%rsp)
lea    -0x1(%rsi),%r11
mov    %r11,0x120(%rsp)
imul   %rcx,%r11
lea    (%r11,%rsi,1),%rbx
lea    -0x1(%rdx),%r14d
imul   %edi,%r14d
add    %edx,%r14d
mov    %r13,%rdx
shl    $0x20,%rdx
add    %rbp,%rdx
mov    %rdx,0x138(%rsp)
mov    $0x1,%edx
sub    %rsi,%rdx
lea    (%r9,%rbx,8),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x60(%rsp)
lea    -0x8(%r8,%rbx,8),%rax
mov    %rax,0x128(%rsp)
lea    -0x1(%r10),%r15d
mov    %edi,%eax
mov    %r15d,0xfc(%rsp)
imul   %r15d,%eax
mov    %eax,0xf8(%rsp)
mov    %rcx,%rax
shl    $0x4,%rax
mov    %rax,0x188(%rsp)
movapd 0xe10(%rip),%xmm8
xorpd  %xmm9,%xmm9
mov    0x1f8(%rsp),%r12
mov    0x1f0(%rsp),%r15
lea    0x1(%r10),%eax
mov    %rax,0x1a0(%rsp)
mov    0x60(%rsp),%rbx
lea    -0x1(%r11,%rsi,1),%rax
mov    %rax,0x198(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x148(%rsp)
lea    0x8(,%rcx,8),%rax
mov    %rax,0x100(%rsp)
mov    %rcx,0xe0(%rsp)
lea    0x1(%rcx),%ecx
mov    %ecx,0xf4(%rsp)
lea    -0x8(%r12,%rsi,8),%rcx
mov    %rcx,0xb8(%rsp)
lea    -0x8(%r15,%rsi,8),%rcx
mov    %rcx,0xb0(%rsp)
lea    (%r8,%r11,8),%rcx
mov    %rcx,0x90(%rsp)
lea    (%r9,%r11,8),%rcx
mov    %r11,%rax
mov    %rcx,0x88(%rsp)
xor    %ecx,%ecx
mov    0x120(%rsp),%r11
mov    %rsi,%r10
mov    %r9,0xe8(%rsp)
mov    %edi,0x5c(%rsp)
mov    0x100(%rsp),%rdi
mov    %r8,0x68(%rsp)
mov    %rsi,0x180(%rsp)
mov    %rax,0x178(%rsp)
jmp    13b5 <corth+0x295>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsp),%rax
movsd  -0x8(%r15,%rax,8),%xmm0
mulsd  %xmm12,%xmm0
movsd  %xmm0,-0x8(%r15,%rax,8)
mulsd  -0x8(%r12,%rax,8),%xmm12
movsd  %xmm12,-0x8(%r12,%rax,8)
xorpd  %xmm10,%xmm14
mov    0x110(%rsp),%rax
add    0x118(%rsp),%rax
movsd  (%r8,%rax,8),%xmm0
mulsd  %xmm14,%xmm0
movsd  %xmm0,(%r8,%rax,8)
mulsd  (%r9,%rax,8),%xmm14
movsd  %xmm14,(%r9,%rax,8)
movabs $0xffffffff00000000,%rbp
ff ff ff
mov    0xf0(%rsp),%r14d
mov    0x170(%rsp),%rdx
mov    0x60(%rsp),%rbx
mov    0x100(%rsp),%rdi
mov    (%rsp),%r10
add    $0x1,%r10
mov    0x190(%rsp),%rcx
add    $0x1,%rcx
add    $0x1,%r11
add    0xf4(%rsp),%r14d
add    $0xffffffffffffffff,%rdx
addq   $0x8,0xb8(%rsp)
addq   $0x8,0xb0(%rsp)
add    %rdi,%rbx
add    %rdi,0x128(%rsp)
mov    0x148(%rsp),%rax
add    %rax,0x90(%rsp)
add    %rax,0x88(%rsp)
cmp    0x98(%rsp),%r10d
je     1e73 <corth+0xd53>
mov    %r11,0x50(%rsp)
cmp    %r13,%r10
mov    %r13,%r11
cmovg  %r10,%r11
lea    (%r11,%rdx,1),%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x130(%rsp)
mov    0x180(%rsp),%rax
add    %rcx,%rax
mov    %r11,%rsi
sub    %rax,%rsi
neg    %rax
add    %r11,%rax
add    $0x1,%rax
mov    %rax,0x40(%rsp)
mov    %rdi,%rax
imul   %rcx,%rax
mov    %rax,0xc8(%rsp)
mov    0x178(%rsp),%rax
sub    %rcx,%rax
mov    %r11,0x1b0(%rsp)
add    %r11,%rax
mov    %rax,0xc0(%rsp)
mov    %rcx,0x190(%rsp)
mov    0x120(%rsp),%rax
add    %rax,%rcx
lea    (%r15,%rcx,8),%rax
mov    %rax,0x168(%rsp)
lea    (%r15,%r10,8),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,0x160(%rsp)
mov    %rcx,0x1a8(%rsp)
lea    (%r12,%rcx,8),%rax
mov    %rax,0x158(%rsp)
lea    (%r12,%r10,8),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,0x150(%rsp)
mov    0x50(%rsp),%r11
lea    -0x1(%r10),%rsi
movq   $0x0,-0x8(%r15,%r10,8)
mov    %r10,(%rsp)
movq   $0x0,-0x8(%r12,%r10,8)
mov    %r14d,%eax
mov    %r11,%rcx
xorpd  %xmm2,%xmm2
nopl   (%rax)
cltq
movsd  (%r8,%rax,8),%xmm0
andpd  %xmm8,%xmm0
movsd  (%r9,%rax,8),%xmm1
andpd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
addsd  %xmm1,%xmm2
add    $0x1,%rcx
add    $0x1,%eax
cmp    %r13,%rcx
jl     14a0 <corth+0x380>
ucomisd %xmm9,%xmm2
jne    14d9 <corth+0x3b9>
jnp    134e <corth+0x22e>
mov    %rsi,0x118(%rsp)
mov    %rdx,0x170(%rsp)
mov    (%rsp),%rax
lea    -0x2(%rax),%rdi
imul   0xe0(%rsp),%rdi
xorpd  %xmm0,%xmm0
mov    %r11,%rax
mov    0x138(%rsp),%rcx
nopl   0x0(%rax)
mov    %rcx,%rdx
sar    $0x20,%rdx
add    %rdi,%rdx
movsd  (%r8,%rdx,8),%xmm1
divsd  %xmm2,%xmm1
mov    %rcx,%rsi
sar    $0x1d,%rsi
movsd  %xmm1,(%r15,%rsi,1)
movsd  (%r9,%rdx,8),%xmm3
divsd  %xmm2,%xmm3
movsd  %xmm3,(%r12,%rsi,1)
movsd  (%r15,%rsi,1),%xmm1
mulsd  %xmm1,%xmm1
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm1
movapd %xmm3,%xmm0
addsd  %xmm1,%xmm0
add    %rbp,%rcx
add    $0x1,%rax
cmp    %r13,%rax
jl     1510 <corth+0x3f0>
ucomisd %xmm9,%xmm0
mov    %rbx,0x60(%rsp)
movsd  %xmm2,0x108(%rsp)
mov    %rdi,0x110(%rsp)
movsd  %xmm0,0x10(%rsp)
jb     1590 <corth+0x470>
sqrtsd %xmm0,%xmm0
jmp    1595 <corth+0x475>
call   1040 <sqrt@plt>
movapd %xmm0,0x70(%rsp)
mov    (%rsp),%rbx
movsd  -0x8(%r15,%rbx,8),%xmm0
movsd  -0x8(%r12,%rbx,8),%xmm1
mov    $0x2,%al
call   1030 <pythag@plt>
test   %eax,%eax
mov    %r14d,0xf0(%rsp)
je     1657 <corth+0x537>
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movapd %xmm0,%xmm1
movapd 0x70(%rsp),%xmm14
mulsd  %xmm14,%xmm1
movsd  0x10(%rsp),%xmm13
addsd  %xmm1,%xmm13
divsd  %xmm0,%xmm14
movapd %xmm14,%xmm0
addsd  0xa27(%rip),%xmm0
movsd  -0x8(%r15,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r15,%rbx,8)
mulsd  -0x8(%r12,%rbx,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rbx,8)
movapd 0x9de(%rip),%xmm8
xorpd  %xmm9,%xmm9
movapd 0x9e0(%rip),%xmm10
movapd 0x9d7(%rip),%xmm11
mov    0x50(%rsp),%r11
movsd  0x108(%rsp),%xmm12
cmp    0x140(%rsp),%rbx
jg     16d0 <corth+0x5b0>
jmp    1aa7 <corth+0x987>
movapd 0x70(%rsp),%xmm14
movsd  %xmm14,-0x8(%r15,%rbx,8)
mov    0x118(%rsp),%rax
mov    0x110(%rsp),%rcx
add    %rcx,%rax
mov    0x68(%rsp),%rcx
movsd  0x108(%rsp),%xmm12
movsd  %xmm12,(%rcx,%rax,8)
movapd 0x96a(%rip),%xmm8
xorpd  %xmm9,%xmm9
movapd 0x96c(%rip),%xmm10
movapd 0x963(%rip),%xmm11
mov    0x50(%rsp),%r11
movsd  0x10(%rsp),%xmm13
cmp    0x140(%rsp),%rbx
jle    1aa7 <corth+0x987>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x98(%rsp)
mov    0xe8(%rsp),%r9
mov    0x5c(%rsp),%edi
mov    0x68(%rsp),%r8
jle    12d0 <corth+0x1b0>
cmp    $0x1,%edi
sete   %al
mov    0x40(%rsp),%rcx
cmp    $0x2,%rcx
setae  %dl
and    %al,%dl
mov    %dl,0x38(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    (%rsp),%rax
mov    %rcx,0xa8(%rsp)
add    %rcx,%rax
mov    %rax,0xa0(%rsp)
mov    $0x1,%esi
mov    %r9,%r14
mov    %r8,%rbx
mov    0x90(%rsp),%rax
mov    %rax,0x18(%rsp)
mov    0x88(%rsp),%r10
xor    %edx,%edx
jmp    1798 <corth+0x678>
cs nopw 0x0(%rax,%rax,1)
mov    0x10(%rsp),%rsi
add    $0x1,%rsi
mov    0x70(%rsp),%rdx
add    $0x1,%rdx
add    $0x8,%r10
addq   $0x8,0x18(%rsp)
add    $0x8,%rbx
add    $0x8,%r14
cmp    0x1a0(%rsp),%rsi
mov    0xe8(%rsp),%r9
mov    0x5c(%rsp),%edi
mov    0x68(%rsp),%r8
mov    0x50(%rsp),%r11
je     12d0 <corth+0x1b0>
mov    0x1a8(%rsp),%rax
add    %rdx,%rax
lea    (%r8,%rax,8),%rcx
mov    %rcx,0x48(%rsp)
mov    0x1b0(%rsp),%rcx
mov    %rdx,0x70(%rsp)
lea    (%rcx,%rdx,1),%rdx
lea    (%r8,%rdx,8),%rcx
mov    %rcx,0x8(%rsp)
lea    (%r9,%rax,8),%rax
mov    %rax,0xd0(%rsp)
lea    (%r9,%rdx,8),%rax
mov    %rax,0xd8(%rsp)
mov    %rsi,0x10(%rsp)
add    $0xffffffffffffffff,%rsi
xorpd  %xmm0,%xmm0
mov    0xfc(%rsp),%eax
mov    0xf8(%rsp),%ecx
mov    %ecx,%ebp
mov    %r11,%rdx
xchg   %ax,%ax
cltq
movslq %ebp,%rbp
lea    (%rsi,%rbp,1),%rcx
movsd  (%r12,%rax,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm10,%xmm2
movsd  (%r15,%rax,8),%xmm3
unpcklpd %xmm3,%xmm3
movsd  (%r9,%rcx,8),%xmm4
movsd  (%r8,%rcx,8),%xmm5
movapd %xmm5,%xmm6
unpcklpd %xmm4,%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm0,%xmm6
unpcklpd %xmm1,%xmm2
unpcklpd %xmm5,%xmm4
mulpd  %xmm2,%xmm4
movapd %xmm4,%xmm0
addpd  %xmm6,%xmm0
add    $0x1,%rdx
sub    %edi,%ebp
add    $0xffffffff,%eax
cmp    %r13,%rdx
jl     1800 <corth+0x6e0>
movapd %xmm0,%xmm1
divsd  %xmm13,%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm11,%xmm2
unpckhpd %xmm0,%xmm0
xorpd  %xmm11,%xmm0
divsd  %xmm13,%xmm0
mov    (%rsp),%r8
mov    %r8,%r11
cmpb   $0x0,0x38(%rsp)
mov    0xe0(%rsp),%rdi
je     1a40 <corth+0x920>
mov    0xd8(%rsp),%rax
mov    0x48(%rsp),%rcx
cmp    %rax,%rcx
setb   0x30(%rsp)
mov    0xd0(%rsp),%r9
mov    0x8(%rsp),%r11
cmp    %r11,%r9
setb   0x28(%rsp)
mov    0x160(%rsp),%rdx
cmp    %rdx,%rcx
setb   0x20(%rsp)
mov    0x168(%rsp),%rbp
cmp    %r11,%rbp
setb   0xc8(%rsp)
mov    0x150(%rsp),%rsi
cmp    %rsi,%rcx
setb   0x48(%rsp)
mov    0x158(%rsp),%rcx
cmp    %r11,%rcx
setb   0x8(%rsp)
cmp    %rdx,%r9
setb   %dl
cmp    %rax,%rbp
setb   0xc0(%rsp)
cmp    %rsi,%r9
setb   %bpl
cmp    %rax,%rcx
setb   %al
mov    %r8,%r11
mov    0x28(%rsp),%cl
test   %cl,0x30(%rsp)
jne    1a40 <corth+0x920>
mov    %r8,%r11
mov    0xc8(%rsp),%cl
and    %cl,0x20(%rsp)
jne    1a40 <corth+0x920>
mov    %r8,%r11
mov    0x8(%rsp),%cl
and    %cl,0x48(%rsp)
jne    1a40 <corth+0x920>
mov    %r8,%r11
and    0xc0(%rsp),%dl
jne    1a40 <corth+0x920>
mov    %r8,%r11
and    %al,%bpl
jne    1a40 <corth+0x920>
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
movapd %xmm0,%xmm4
unpcklpd %xmm0,%xmm4
movapd %xmm1,%xmm5
unpcklpd %xmm1,%xmm5
xor    %eax,%eax
xor    %edx,%edx
mov    0x188(%rsp),%r8
mov    0xb8(%rsp),%rsi
mov    0xb0(%rsp),%rbp
mov    0x130(%rsp),%r9
mov    0x18(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movupd (%rcx,%rax,1),%xmm6
movupd 0x0(%rbp,%rdx,8),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movupd (%rsi,%rdx,8),%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm7,%xmm6
movupd %xmm6,(%rcx,%rax,1)
movupd (%r10,%rax,1),%xmm6
movupd (%rsi,%rdx,8),%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
movupd 0x0(%rbp,%rdx,8),%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm7,%xmm6
movupd %xmm6,(%r10,%rax,1)
add    $0x2,%rdx
add    %r8,%rax
cmp    %rdx,%r9
jne    19c0 <corth+0x8a0>
mov    0xa0(%rsp),%r11
mov    0xa8(%rsp),%rax
cmp    %rax,0x40(%rsp)
je     1750 <corth+0x630>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffffffffffff,%r11
mov    %rdi,%rax
imul   %r11,%rax
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%r11,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rbx,%rax,8),%xmm3
movsd  (%r12,%r11,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rbx,%rax,8)
movsd  (%r12,%r11,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  (%r14,%rax,8),%xmm3
movsd  (%r15,%r11,8),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%r14,%rax,8)
add    $0x1,%r11
add    %rdi,%rax
cmp    %r13,%r11
jl     1a50 <corth+0x930>
jmp    1750 <corth+0x630>
mov    0x40(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
mov    (%rsp),%rax
mov    %rcx,0xa8(%rsp)
add    %rax,%rcx
mov    %rcx,0xa0(%rsp)
mov    0x88(%rsp),%rdx
mov    0x90(%rsp),%rsi
mov    0x128(%rsp),%rcx
mov    %rcx,0x10(%rsp)
mov    0x60(%rsp),%r14
xor    %edi,%edi
mov    %rax,%rbx
jmp    1b2f <corth+0xa0f>
mov    0xd8(%rsp),%rbp
lea    0x1(%rbp),%rax
mov    0x70(%rsp),%rdi
add    $0x1,%rdi
mov    0x148(%rsp),%rcx
add    %rcx,%r14
add    %rcx,%rbx
mov    %rbx,0x10(%rsp)
add    %rcx,%rsi
add    %rcx,%rdx
cmp    0x140(%rsp),%rbp
mov    %rax,%rbx
jge    16d0 <corth+0x5b0>
mov    %rdi,0x70(%rsp)
mov    %rdi,%rax
mov    0xe0(%rsp),%r8
imul   %r8,%rax
mov    0x198(%rsp),%rdi
lea    (%rdi,%rax,1),%r10
mov    0x68(%rsp),%rdi
lea    (%rdi,%r10,8),%rbp
mov    0xc8(%rsp),%rcx
mov    %rbp,0x38(%rsp)
add    %rcx,%rbp
mov    %rbp,0x8(%rsp)
add    0xc0(%rsp),%rax
lea    (%rdi,%rax,8),%rbp
mov    %rbp,0x30(%rsp)
add    %rcx,%rbp
mov    %rbp,0x18(%rsp)
mov    0xe8(%rsp),%r9
lea    (%r9,%r10,8),%rbp
mov    %rbp,0x28(%rsp)
add    %rcx,%rbp
mov    %rbp,0xd0(%rsp)
lea    (%r9,%rax,8),%rax
mov    %rax,0x20(%rsp)
add    %rcx,%rax
mov    %rax,0x48(%rsp)
mov    %rbx,0xd8(%rsp)
lea    -0x1(%rbx),%rax
imul   %r8,%rax
xorpd  %xmm0,%xmm0
mov    %r11,%rbp
mov    0x138(%rsp),%r8
movabs $0xffffffff00000000,%r11
ff ff ff
nopl   0x0(%rax)
mov    %r8,%r10
sar    $0x20,%r10
mov    %r8,%rcx
sar    $0x1d,%rcx
add    %rax,%r10
movsd  (%r15,%rcx,1),%xmm1
unpcklpd %xmm1,%xmm1
movsd  (%r9,%r10,8),%xmm2
movsd  (%rdi,%r10,8),%xmm3
movapd %xmm3,%xmm4
unpcklpd %xmm2,%xmm4
mulpd  %xmm1,%xmm4
addpd  %xmm0,%xmm4
movsd  (%r12,%rcx,1),%xmm0
movapd %xmm0,%xmm1
xorpd  %xmm10,%xmm1
unpcklpd %xmm1,%xmm0
unpcklpd %xmm3,%xmm2
mulpd  %xmm0,%xmm2
movapd %xmm2,%xmm0
addpd  %xmm4,%xmm0
add    %r11,%r8
add    $0x1,%rbp
cmp    %r13,%rbp
jl     1be0 <corth+0xac0>
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
divsd  %xmm13,%xmm1
xorpd  %xmm11,%xmm0
divsd  %xmm13,%xmm0
movapd %xmm1,%xmm2
xorpd  %xmm11,%xmm2
mov    (%rsp),%rax
cmpq   $0x2,0x40(%rsp)
mov    0x50(%rsp),%r11
mov    0x10(%rsp),%rbx
jae    1ce0 <corth+0xbc0>
add    $0xffffffffffffffff,%rax
movsd  (%r15,%rax,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  (%rsi,%rax,8),%xmm3
movsd  (%r12,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rsi,%rax,8)
movsd  (%r12,%rax,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  (%rdx,%rax,8),%xmm3
movsd  (%r15,%rax,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %r13,%rax
jl     1c80 <corth+0xb60>
jmp    1af0 <corth+0x9d0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x20(%rsp),%rax
cmp    %rax,0x38(%rsp)
setb   0x38(%rsp)
mov    0x28(%rsp),%rax
cmp    0x30(%rsp),%rax
setb   0x30(%rsp)
mov    0x160(%rsp),%rdi
mov    0x8(%rsp),%rbp
cmp    %rdi,%rbp
setb   %r10b
mov    0x168(%rsp),%rax
mov    0x18(%rsp),%r9
cmp    %rax,%r9
seta   0x28(%rsp)
mov    0x150(%rsp),%rcx
cmp    %rcx,%rbp
setb   %bpl
mov    %r11,%r8
mov    0x158(%rsp),%r11
cmp    %r11,%r9
seta   0x8(%rsp)
mov    0xd0(%rsp),%r9
cmp    %rdi,%r9
setb   0x18(%rsp)
mov    0x48(%rsp),%rdi
cmp    %rax,%rdi
seta   0x20(%rsp)
cmp    %rcx,%r9
setb   %r9b
cmp    %r11,%rdi
mov    %r8,%r11
seta   %dil
mov    (%rsp),%rax
mov    0x30(%rsp),%cl
test   %cl,0x38(%rsp)
jne    1c7c <corth+0xb5c>
mov    (%rsp),%rax
and    0x28(%rsp),%r10b
jne    1c7c <corth+0xb5c>
mov    (%rsp),%rax
and    0x8(%rsp),%bpl
jne    1c7c <corth+0xb5c>
mov    (%rsp),%rax
mov    0x20(%rsp),%cl
and    %cl,0x18(%rsp)
jne    1c7c <corth+0xb5c>
mov    (%rsp),%rax
and    %dil,%r9b
jne    1c7c <corth+0xb5c>
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
movapd %xmm2,%xmm5
unpcklpd %xmm2,%xmm5
xor    %eax,%eax
mov    0xb8(%rsp),%rcx
mov    0xb0(%rsp),%rdi
mov    0x130(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm6
movupd (%rdi,%rax,8),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movupd (%rcx,%rax,8),%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm7,%xmm6
movupd %xmm6,(%rbx,%rax,8)
movupd (%r14,%rax,8),%xmm6
movupd (%rcx,%rax,8),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movupd (%rdi,%rax,8),%xmm6
mulpd  %xmm5,%xmm6
addpd  %xmm7,%xmm6
movupd %xmm6,(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1e00 <corth+0xce0>
mov    0xa0(%rsp),%rax
mov    0xa8(%rsp),%rcx
cmp    %rcx,0x40(%rsp)
je     1af0 <corth+0x9d0>
jmp    1c7c <corth+0xb5c>
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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