void comqr(int nm, int n, int low, int igh, double *hr, double *hi, double *wr,
           double *wi, int *ierr) {
  int i, j, l, en, ll, itn, its, lp1, enm1;
  double si, sr, ti, tr, xi, xr, yi, yr, zzi, zzr, norm, tst1, tst2;
  *ierr = 0;
  if (low != igh) {
    l = low + 1;
    for (i = l; i <= igh; i++) {
      ll = (((i + 1) < (igh)) ? (i + 1) : (igh));
      if (hi[(i)-1 + ((i - 1) - 1) * (nm)] == 0.0)
        continue;
      norm = pythag(hr[(i)-1 + ((i - 1) - 1) * (nm)],
                    hi[(i)-1 + ((i - 1) - 1) * (nm)]);
      yr = hr[(i)-1 + ((i - 1) - 1) * (nm)] / norm;
      yi = hi[(i)-1 + ((i - 1) - 1) * (nm)] / norm;
      hr[(i)-1 + ((i - 1) - 1) * (nm)] = norm;
      hi[(i)-1 + ((i - 1) - 1) * (nm)] = 0.0;
      for (j = i; j <= igh; j++) {
        si = yr * hi[(i)-1 + ((j)-1) * (nm)] - yi * hr[(i)-1 + ((j)-1) * (nm)];
        hr[(i)-1 + ((j)-1) * (nm)] =
            yr * hr[(i)-1 + ((j)-1) * (nm)] + yi * hi[(i)-1 + ((j)-1) * (nm)];
        hi[(i)-1 + ((j)-1) * (nm)] = si;
      }
      for (j = low; j <= ll; j++) {
        si = yr * hi[(j)-1 + ((i)-1) * (nm)] + yi * hr[(j)-1 + ((i)-1) * (nm)];
        hr[(j)-1 + ((i)-1) * (nm)] =
            yr * hr[(j)-1 + ((i)-1) * (nm)] - yi * hi[(j)-1 + ((i)-1) * (nm)];
        hi[(j)-1 + ((i)-1) * (nm)] = si;
      }
    }
  }
  for (i = 1; i <= n; i++) {
    if (i >= low && i <= igh)
      continue;
    wr[(i)-1] = hr[(i)-1 + ((i)-1) * (nm)];
    wi[(i)-1] = hi[(i)-1 + ((i)-1) * (nm)];
  }
  en = igh;
  tr = 0.0;
  ti = 0.0;
  itn = 30 * n;
  while (1) {
    if (en < low)
      return;
    its = 0;
    enm1 = en - 1;
    while (1) {
      for (ll = low; ll <= en; ll++) {
        l = en + low - ll;
        if (l == low)
          break;
        tst1 = fabs(hr[(l - 1) - 1 + ((l - 1) - 1) * (nm)]) +
               fabs(hi[(l - 1) - 1 + ((l - 1) - 1) * (nm)]) +
               fabs(hr[(l)-1 + ((l)-1) * (nm)]) +
               fabs(hi[(l)-1 + ((l)-1) * (nm)]);
        tst2 = tst1 + fabs(hr[(l)-1 + ((l - 1) - 1) * (nm)]);
        if (tst2 == tst1)
          break;
      }
      if (l == en)
        break;
      if (itn == 0)
        goto L1000;
      if (its == 10 || its == 20) {
        sr = fabs(hr[(en)-1 + ((enm1)-1) * (nm)]) +
             fabs(hr[(enm1)-1 + ((en - 2) - 1) * (nm)]);
        si = 0.0;
      } else {
        sr = hr[(en)-1 + ((en)-1) * (nm)];
        si = hi[(en)-1 + ((en)-1) * (nm)];
        xr = hr[(enm1)-1 + ((en)-1) * (nm)] * hr[(en)-1 + ((enm1)-1) * (nm)];
        xi = hi[(enm1)-1 + ((en)-1) * (nm)] * hr[(en)-1 + ((enm1)-1) * (nm)];
        if (xr != 0.0 || xi != 0.0) {
          yr = (hr[(enm1)-1 + ((enm1)-1) * (nm)] - sr) / 2.0;
          yi = (hi[(enm1)-1 + ((enm1)-1) * (nm)] - si) / 2.0;
          csroot(yr * yr - yi * yi + xr, 2.0 * yr * yi + xi, &zzr, &zzi);
          if (yr * zzr + yi * zzi < 0.0) {
            zzr = -zzr;
            zzi = -zzi;
          }
          cdiv(xr, xi, yr + zzr, yi + zzi, &xr, &xi);
          sr -= xr;
          si -= xi;
        }
      }
      for (i = low; i <= en; i++) {
        hr[(i)-1 + ((i)-1) * (nm)] -= sr;
        hi[(i)-1 + ((i)-1) * (nm)] -= si;
      }
      tr += sr;
      ti += si;
      its++;
      itn--;
      lp1 = l + 1;
      for (i = lp1; i <= en; i++) {
        sr = hr[(i)-1 + ((i - 1) - 1) * (nm)];
        hr[(i)-1 + ((i - 1) - 1) * (nm)] = 0.0;
        norm = pythag(pythag(hr[(i - 1) - 1 + ((i - 1) - 1) * (nm)],
                             hi[(i - 1) - 1 + ((i - 1) - 1) * (nm)]),
                      sr);
        xr = hr[(i - 1) - 1 + ((i - 1) - 1) * (nm)] / norm;
        wr[(i - 1) - 1] = xr;
        xi = hi[(i - 1) - 1 + ((i - 1) - 1) * (nm)] / norm;
        wi[(i - 1) - 1] = xi;
        hr[(i - 1) - 1 + ((i - 1) - 1) * (nm)] = norm;
        hi[(i - 1) - 1 + ((i - 1) - 1) * (nm)] = 0.0;
        hi[(i)-1 + ((i - 1) - 1) * (nm)] = sr / norm;
        for (j = i; j <= en; j++) {
          yr = hr[(i - 1) - 1 + ((j)-1) * (nm)];
          yi = hi[(i - 1) - 1 + ((j)-1) * (nm)];
          zzr = hr[(i)-1 + ((j)-1) * (nm)];
          zzi = hi[(i)-1 + ((j)-1) * (nm)];
          hr[(i - 1) - 1 + ((j)-1) * (nm)] =
              xr * yr + xi * yi + hi[(i)-1 + ((i - 1) - 1) * (nm)] * zzr;
          hi[(i - 1) - 1 + ((j)-1) * (nm)] =
              xr * yi - xi * yr + hi[(i)-1 + ((i - 1) - 1) * (nm)] * zzi;
          hr[(i)-1 + ((j)-1) * (nm)] =
              xr * zzr - xi * zzi - hi[(i)-1 + ((i - 1) - 1) * (nm)] * yr;
          hi[(i)-1 + ((j)-1) * (nm)] =
              xr * zzi + xi * zzr - hi[(i)-1 + ((i - 1) - 1) * (nm)] * yi;
        }
      }
      si = hi[(en)-1 + ((en)-1) * (nm)];
      if (si != 0.0) {
        norm = pythag(hr[(en)-1 + ((en)-1) * (nm)], si);
        sr = hr[(en)-1 + ((en)-1) * (nm)] / norm;
        si = si / norm;
        hr[(en)-1 + ((en)-1) * (nm)] = norm;
        hi[(en)-1 + ((en)-1) * (nm)] = 0.0;
      }
      for (j = lp1; j <= en; j++) {
        xr = wr[(j - 1) - 1];
        xi = wi[(j - 1) - 1];
        for (i = l; i <= j; i++) {
          yr = hr[(i)-1 + ((j - 1) - 1) * (nm)];
          yi = 0.0;
          zzr = hr[(i)-1 + ((j)-1) * (nm)];
          zzi = hi[(i)-1 + ((j)-1) * (nm)];
          if (i != j) {
            yi = hi[(i)-1 + ((j - 1) - 1) * (nm)];
            hi[(i)-1 + ((j - 1) - 1) * (nm)] =
                xr * yi + xi * yr + hi[(j)-1 + ((j - 1) - 1) * (nm)] * zzi;
          }
          hr[(i)-1 + ((j - 1) - 1) * (nm)] =
              xr * yr - xi * yi + hi[(j)-1 + ((j - 1) - 1) * (nm)] * zzr;
          hr[(i)-1 + ((j)-1) * (nm)] =
              xr * zzr + xi * zzi - hi[(j)-1 + ((j - 1) - 1) * (nm)] * yr;
          hi[(i)-1 + ((j)-1) * (nm)] =
              xr * zzi - xi * zzr - hi[(j)-1 + ((j - 1) - 1) * (nm)] * yi;
        }
      }
      if (si == 0.0)
        continue;
      for (i = l; i <= en; i++) {
        yr = hr[(i)-1 + ((en)-1) * (nm)];
        yi = hi[(i)-1 + ((en)-1) * (nm)];
        hr[(i)-1 + ((en)-1) * (nm)] = sr * yr - si * yi;
        hi[(i)-1 + ((en)-1) * (nm)] = sr * yi + si * yr;
      }
    }
    wr[(en)-1] = hr[(en)-1 + ((en)-1) * (nm)] + tr;
    wi[(en)-1] = hi[(en)-1 + ((en)-1) * (nm)] + ti;
    en = enm1;
  }
L1000:
  *ierr = en;
}


x86 assembly (clang, -O0):
<comqr>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x20(%rbp),%rax
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    0x20(%rbp),%rax
movl   $0x0,(%rax)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
je     154e <comqr+0x41e>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1549 <comqr+0x419>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cmp    -0x10(%rbp),%eax
jge    11ac <comqr+0x7c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    11b5 <comqr+0x85>
mov    -0x10(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0xb4(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f7 <comqr+0xc7>
jp     11f7 <comqr+0xc7>
jmp    153b <comqr+0x40b>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1040 <pythag@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x80(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%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    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1417 <comqr+0x2e7>
movsd  -0x88(%rbp),%xmm0
ff
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
movsd  -0x80(%rbp),%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
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
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
movsd  -0x80(%rbp),%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
mulsd  (%rax,%rcx,8),%xmm1
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)
movsd  -0x50(%rbp),%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    12fe <comqr+0x1ce>
mov    -0xc(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1536 <comqr+0x406>
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%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    141d <comqr+0x2ed>
jmp    153b <comqr+0x40b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1180 <comqr+0x50>
jmp    154e <comqr+0x41e>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     15ec <comqr+0x4bc>
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     157e <comqr+0x44e>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     157e <comqr+0x44e>
jmp    15de <comqr+0x4ae>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%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    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1555 <comqr+0x425>
mov    -0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
imul   $0x1e,-0x8(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    161a <comqr+0x4ea>
jmp    263f <comqr+0x150f>
movl   $0x0,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1791 <comqr+0x661>
mov    -0x30(%rbp),%eax
add    -0xc(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    1659 <comqr+0x529>
jmp    1791 <comqr+0x661>
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%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 0x197c(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%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 0x194d(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1920(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x18f3(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
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  (%rax,%rcx,8),%xmm1
movaps 0x18b3(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
ucomisd -0xa8(%rbp),%xmm0
ff
jne    177e <comqr+0x64e>
jp     177e <comqr+0x64e>
jmp    1791 <comqr+0x661>
jmp    1783 <comqr+0x653>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1630 <comqr+0x500>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jne    17a2 <comqr+0x672>
jmp    25c1 <comqr+0x1491>
cmpl   $0x0,-0x38(%rbp)
jne    17b1 <comqr+0x681>
jmp    2636 <comqr+0x1506>
cmpl   $0xa,-0x3c(%rbp)
je     17c5 <comqr+0x695>
cmpl   $0x14,-0x3c(%rbp)
jne    1830 <comqr+0x700>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x1816(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x2,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x17ea(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1aee <comqr+0x9be>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    192d <comqr+0x7fd>
jp     192d <comqr+0x7fd>
movsd  -0x70(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    192d <comqr+0x7fd>
jp     192d <comqr+0x7fd>
jmp    1ae9 <comqr+0x9b9>
mov    -0x18(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x58(%rbp),%xmm0
movsd  0x16b8(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  0x1681(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
addsd  -0x78(%rbp),%xmm0
movsd  0x1632(%rip),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
movsd  -0x80(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
lea    -0x98(%rbp),%rdi
lea    -0x90(%rbp),%rsi
mov    $0x2,%al
call   1030 <csroot@plt>
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1a8d <comqr+0x95d>
movsd  -0x98(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movsd  -0x70(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm2
ff
addsd  -0x98(%rbp),%xmm2
ff
movsd  -0x80(%rbp),%xmm3
addsd  -0x90(%rbp),%xmm3
ff
lea    -0x78(%rbp),%rdi
lea    -0x70(%rbp),%rsi
mov    $0x4,%al
call   1050 <cdiv@plt>
movsd  -0x78(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x70(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1aee <comqr+0x9be>
mov    -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1b66 <comqr+0xa36>
movsd  -0x58(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x50(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1af4 <comqr+0x9c4>
movsd  -0x58(%rbp),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x50(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     2066 <comqr+0xf36>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    $0x2,%al
call   1040 <pythag@plt>
mov    %eax,%edi
movsd  -0x58(%rbp),%xmm0
mov    $0x1,%al
call   1040 <pythag@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%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
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     2053 <comqr+0xf23>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%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  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%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  %xmm0,-0x80(%rbp)
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  %xmm0,-0x98(%rbp)
ff
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  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%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)
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%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)
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
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)
movsd  -0x78(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%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    1d81 <comqr+0xc51>
jmp    2058 <comqr+0xf28>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1ba5 <comqr+0xa75>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    20a6 <comqr+0xf76>
jp     20a6 <comqr+0xf76>
jmp    2160 <comqr+0x1030>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x50(%rbp),%xmm1
mov    $0x2,%al
call   1040 <pythag@plt>
cvtsi2sd %eax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%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    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     24a5 <comqr+0x1375>
mov    0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     2492 <comqr+0x1362>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
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  %xmm0,-0x98(%rbp)
ff
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  %xmm0,-0x90(%rbp)
ff
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
je     22d8 <comqr+0x11a8>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm1
movsd  -0x80(%rbp),%xmm2
movsd  -0x70(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x90(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x98(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm1
movsd  -0x98(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
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)
movsd  -0x78(%rbp),%xmm1
movsd  -0x90(%rbp),%xmm2
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x98(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x80(%rbp),%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    21ac <comqr+0x107c>
jmp    2497 <comqr+0x1367>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    2166 <comqr+0x1036>
movsd  -0x50(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    24c2 <comqr+0x1392>
jp     24c2 <comqr+0x1392>
jmp    162a <comqr+0x4fa>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     25bc <comqr+0x148c>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x88(%rbp),%xmm2
ff
movsd  -0x50(%rbp),%xmm1
mulsd  -0x80(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x58(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%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    24c8 <comqr+0x1398>
jmp    162a <comqr+0x4fa>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x68(%rbp),%xmm0
mov    0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
imul   -0x4(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
mov    %eax,-0x30(%rbp)
jmp    1609 <comqr+0x4d9>
mov    -0x30(%rbp),%ecx
mov    0x20(%rbp),%rax
mov    %ecx,(%rax)
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<comqr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x188,%rsp
mov    %r9,%r14
mov    0x1d0(%rsp),%rax
movl   $0x0,(%rax)
cmp    %ecx,%edx
mov    %r8,0xa0(%rsp)
mov    %rcx,0x130(%rsp)
mov    %rdx,0x80(%rsp)
mov    %edi,0x24(%rsp)
je     154f <comqr+0x41f>
lea    0x1(%rdx),%r15d
cmp    %ecx,%edx
jge    154f <comqr+0x41f>
mov    %esi,0xf0(%rsp)
mov    %r15,0xf8(%rsp)
movslq %edx,%rsi
lea    0x1(%rsi),%r11
movslq %edi,%rbp
movslq %ecx,%r9
lea    0x1(%rcx),%eax
mov    %eax,0x30(%rsp)
lea    0x1(%rbp),%r10d
imul   %edx,%r10d
add    $0xffffffff,%r10d
mov    $0x1,%eax
sub    %rsi,%rax
lea    (%r8,%rax,8),%rbx
mov    %rbx,0x88(%rsp)
mov    %rax,0x90(%rsp)
lea    (%r14,%rax,8),%rax
mov    %rax,0x38(%rsp)
mov    %rdx,%r12
lea    0x1(%rbp),%rax
imul   %rsi,%rax
lea    (%r14,%rax,8),%r13
lea    0x0(,%rbp,8),%rdx
mov    %rdx,0x98(%rsp)
lea    0x8(,%rbp,8),%rdx
mov    %rdx,0xa8(%rsp)
lea    (%r8,%rax,8),%r15
imul   %edi,%r12d
add    $0xffffffff,%r12d
mov    %rbp,0x48(%rsp)
mov    %ebp,%eax
mov    %rax,0x100(%rsp)
xorpd  %xmm10,%xmm10
mov    %r10d,0x40(%rsp)
mov    %rsi,%rax
mov    %rsi,0x10(%rsp)
mov    %rsi,0x70(%rsp)
xor    %esi,%esi
mov    %r9,0x28(%rsp)
jmp    1271 <comqr+0x141>
add    $0x1,%esi
addq   $0x1,0x70(%rsp)
mov    0xa8(%rsp),%rax
add    %rax,%r13
add    %rax,%r15
mov    (%rsp),%r10d
add    %edi,%r10d
add    0x100(%rsp),%r12
cmp    %r11d,0x30(%rsp)
je     1540 <comqr+0x410>
mov    %r10d,(%rsp)
mov    %r11,%rbx
add    $0x1,%r11
cmp    %r9,%r11
mov    %ecx,%ebp
cmovl  %r11d,%ebp
lea    -0x2(%rbx),%rax
imul   0x48(%rsp),%rax
lea    (%rbx,%rax,1),%rdx
movsd  -0x8(%r14,%rdx,8),%xmm1
ucomisd %xmm10,%xmm1
jne    12a3 <comqr+0x173>
jnp    1240 <comqr+0x110>
mov    %ebp,0x18(%rsp)
mov    %rsi,0xc0(%rsp)
mov    %r11,0x8(%rsp)
lea    (%rbx,%rax,1),%rbp
add    $0xffffffffffffffff,%rbp
movsd  (%r8,%rbp,8),%xmm0
mov    $0x2,%al
call   1040 <pythag@plt>
mov    0x28(%rsp),%r9
mov    0xa0(%rsp),%r8
xorps  %xmm2,%xmm2
cvtsi2sd %eax,%xmm2
movsd  (%r8,%rbp,8),%xmm0
divsd  %xmm2,%xmm0
movsd  (%r14,%rbp,8),%xmm1
divsd  %xmm2,%xmm1
movsd  %xmm2,(%r8,%rbp,8)
movq   $0x0,(%r14,%rbp,8)
cmp    %r9,%rbx
mov    0x98(%rsp),%rdx
jg     1366 <comqr+0x236>
movapd %xmm1,%xmm2
xorpd  0x1ce8(%rip),%xmm2
xor    %eax,%eax
mov    0x70(%rsp),%rcx
nop
movsd  0x0(%r13,%rax,1),%xmm3
movsd  (%r15,%rax,1),%xmm4
movapd %xmm4,%xmm5
mulsd  %xmm2,%xmm5
movapd %xmm0,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm1,%xmm3
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%r15,%rax,1)
movsd  %xmm6,0x0(%r13,%rax,1)
add    $0x1,%rcx
add    %rdx,%rax
cmp    %r9,%rcx
jl     1320 <comqr+0x1f0>
mov    0x18(%rsp),%eax
cmp    0x80(%rsp),%eax
mov    0x130(%rsp),%rcx
mov    0x24(%rsp),%edi
mov    0x8(%rsp),%r11
xorpd  %xmm10,%xmm10
mov    0xc0(%rsp),%rsi
jl     1240 <comqr+0x110>
movapd %xmm1,%xmm2
xorpd  0x1c5f(%rip),%xmm2
cltq
mov    0x90(%rsp),%rdx
add    %rax,%rdx
mov    0x10(%rsp),%rbx
mov    %rdx,0x18(%rsp)
cmp    $0x2,%rdx
jb     14f0 <comqr+0x3c0>
mov    %esi,%r10d
imul   %edi,%r10d
add    0x40(%rsp),%r10d
mov    %rax,%rdx
mov    0x10(%rsp),%rbx
sub    %rbx,%rdx
lea    (%rdx,%r10,1),%esi
cmp    %r10d,%esi
mov    0xc0(%rsp),%rsi
mov    0x8(%rsp),%r11
jl     14f0 <comqr+0x3c0>
shr    $0x20,%rdx
mov    0x10(%rsp),%rbx
jne    14f0 <comqr+0x3c0>
movslq %r10d,%rbx
lea    (%r8,%rbx,8),%rsi
lea    (%rax,%rbx,1),%rdx
mov    0x38(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rbp
cmp    %rbp,%rsi
mov    0x8(%rsp),%r11
jae    1447 <comqr+0x317>
lea    (%r14,%rbx,8),%rsi
mov    0x88(%rsp),%rbx
lea    (%rbx,%rdx,8),%rdx
mov    0x10(%rsp),%rbx
cmp    %rdx,%rsi
mov    0xc0(%rsp),%rsi
jb     14f0 <comqr+0x3c0>
mov    0x18(%rsp),%r10
mov    %r10,%r9
and    $0xfffffffffffffffe,%r9
mov    0x10(%rsp),%rdx
lea    (%r9,%rdx,1),%rbx
movapd %xmm1,%xmm8
unpcklpd %xmm1,%xmm8
movapd %xmm0,%xmm5
unpcklpd %xmm0,%xmm5
movapd %xmm2,%xmm9
unpcklpd %xmm2,%xmm9
mov    %r9,%rsi
mov    (%rsp),%edx
mov    %edx,%ebp
movslq %ebp,%rbp
movupd (%r14,%rbp,8),%xmm6
movupd (%r8,%rbp,8),%xmm7
movapd %xmm8,%xmm3
mulpd  %xmm7,%xmm3
movapd %xmm5,%xmm4
mulpd  %xmm6,%xmm4
addpd  %xmm3,%xmm4
mulpd  %xmm9,%xmm6
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm7,(%r8,%rbp,8)
movupd %xmm4,(%r14,%rbp,8)
add    $0x2,%ebp
add    $0xfffffffffffffffe,%rsi
jne    1480 <comqr+0x350>
cmp    %r9,%r10
mov    0x28(%rsp),%r9
mov    0x8(%rsp),%r11
mov    0xc0(%rsp),%rsi
je     1240 <comqr+0x110>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r12,%rbx,1),%edx
movslq %edx,%rdx
movsd  (%r14,%rdx,8),%xmm3
movsd  (%r8,%rdx,8),%xmm4
movapd %xmm1,%xmm5
mulsd  %xmm4,%xmm5
movapd %xmm0,%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
mulsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  %xmm4,(%r8,%rdx,8)
movsd  %xmm6,(%r14,%rdx,8)
lea    0x1(%rbx),%rdx
cmp    %rax,%rbx
mov    %rdx,%rbx
jl     14f0 <comqr+0x3c0>
jmp    1240 <comqr+0x110>
mov    0xf8(%rsp),%r15
mov    0xf0(%rsp),%esi
test   %esi,%esi
jle    15b6 <comqr+0x486>
movslq %ecx,%r9
movslq 0x80(%rsp),%r10
mov    %esi,%r11d
xor    %ebp,%ebp
xor    %eax,%eax
jmp    15a6 <comqr+0x476>
nopw   0x0(%rax,%rax,1)
movslq %eax,%rbx
add    %rbp,%rbx
movsd  (%r8,%rbx,8),%xmm0
mov    0x1c0(%rsp),%rdx
movsd  %xmm0,(%rdx,%rbp,8)
movsd  (%r14,%rbx,8),%xmm0
mov    0x1c8(%rsp),%rbx
movsd  %xmm0,(%rbx,%rbp,8)
add    %edi,%eax
mov    %r12,%rbp
cmp    %r12,%r11
je     15b6 <comqr+0x486>
lea    0x1(%rbp),%r12
cmp    %r10,%r12
jl     1570 <comqr+0x440>
cmp    %r9,%r12
jle    159c <comqr+0x46c>
jmp    1570 <comqr+0x440>
mov    %ecx,%edx
mov    0x80(%rsp),%rax
sub    %eax,%edx
mov    %edx,0x114(%rsp)
jl     2249 <comqr+0x1119>
mov    $0xffffffff,%r9d
mov    %esi,%r13d
shl    $0x5,%r13d
sub    %esi,%r13d
sub    %esi,%r13d
movslq %eax,%r12
movslq %edi,%r11
movslq %ecx,%rbx
lea    -0x1(%rcx),%esi
imul   %edi,%esi
add    $0xffffffff,%esi
lea    0x1(%rbx),%r10
lea    -0x2(%rcx),%ebp
imul   %edi,%ebp
lea    -0x2(%rbp),%edx
mov    %edx,0x6c(%rsp)
mov    %edi,%edx
not    %edx
mov    %edx,0x68(%rsp)
add    $0xffffffff,%ebp
mov    %rbp,0xe8(%rsp)
lea    -0x1(%rax),%edx
mov    %r11,%rax
imul   %edi,%edx
mov    %edx,0x110(%rsp)
lea    -0x1(%r12),%rdx
mov    %rdx,0x178(%rsp)
lea    0x1(%r11),%rdx
mov    %rdx,0x120(%rsp)
lea    0x0(,%r11,8),%rdx
mov    %rdx,0xa8(%rsp)
lea    -0x1(%rbx),%rdx
imul   %r11,%rdx
add    %r9,%rdx
mov    %rdx,0xd8(%rsp)
xorpd  %xmm9,%xmm9
movapd 0x199e(%rip),%xmm8
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x10(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x28(%rsp)
lea    0x8(,%r11,8),%rdx
mov    %rdx,0x100(%rsp)
lea    -0x8(%r8),%rdx
mov    %rdx,0x170(%rsp)
lea    -0x8(%r14),%rdx
mov    %rdx,0x168(%rsp)
xor    %edx,%edx
mov    %rdx,0xe0(%rsp)
mov    %r10,0x118(%rsp)
mov    %esi,0x64(%rsp)
xor    %r11d,%r11d
mov    %esi,0x10c(%rsp)
mov    %r10,0x40(%rsp)
mov    %r12,0xf0(%rsp)
mov    %rax,0x30(%rsp)
mov    %rax,%rbp
mov    %r11d,%eax
imul   %edi,%eax
mov    %esi,%edx
sub    %eax,%edx
mov    %rdx,0x158(%rsp)
mov    %r10,%rax
sub    %r11,%rax
lea    (%r8,%rax,8),%rdx
mov    %rdx,0x140(%rsp)
lea    (%r14,%rax,8),%rax
mov    %rax,0x148(%rsp)
lea    -0x1(%rbx),%r9
lea    -0x2(%rbx),%rax
imul   %rbp,%rax
lea    (%rax,%rbx,1),%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,0x128(%rsp)
lea    -0x3(%rbx),%rdx
imul   %rbp,%rdx
add    %rbx,%rdx
add    $0xfffffffffffffffe,%rdx
mov    %rdx,0x180(%rsp)
mov    %r9,%rsi
imul   %rbp,%rsi
mov    %r9,0x138(%rsp)
mov    %r9d,%edx
imul   %edi,%edx
movslq %edx,%rdx
add    %rbx,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,0x38(%rsp)
lea    -0x2(%rsi,%rbx,1),%rdx
mov    %rdx,0x160(%rsp)
lea    -0x2(%rax,%rbx,1),%rax
mov    %rax,0x150(%rsp)
movl   $0x0,0x98(%rsp)
mov    %rbx,(%rsp)
mov    %r11,0x88(%rsp)
nopl   0x0(%rax,%rax,1)
mov    0xf0(%rsp),%r12
cmp    %r12,%rbx
jl     1894 <comqr+0x764>
mov    0x64(%rsp),%eax
mov    0xe8(%rsp),%rdx
mov    0x6c(%rsp),%esi
mov    0xe0(%rsp),%rbx
mov    %r12,%r9
mov    0x114(%rsp),%r10d
mov    0x68(%rsp),%r15d
nopl   0x0(%rax)
mov    %r10d,%ebp
add    %ebx,%ebp
je     1880 <comqr+0x750>
lea    (%rcx,%rsi,1),%ebp
movslq %ebp,%rbp
movsd  (%r8,%rbp,8),%xmm0
andpd  %xmm8,%xmm0
movsd  (%r14,%rbp,8),%xmm1
andpd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
lea    (%rcx,%rax,1),%ebp
movslq %ebp,%rbp
movsd  (%r8,%rbp,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm1,%xmm0
movsd  (%r14,%rbp,8),%xmm1
andpd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
lea    (%rcx,%rdx,1),%ebp
movslq %ebp,%rbp
movsd  (%r8,%rbp,8),%xmm0
andpd  %xmm8,%xmm0
addsd  %xmm1,%xmm0
add    $0xffffffff,%ebx
ucomisd %xmm1,%xmm0
jne    184f <comqr+0x71f>
jnp    1869 <comqr+0x739>
lea    0x1(%r9),%rbp
add    %r15d,%esi
add    %r15d,%edx
add    %r15d,%eax
cmp    (%rsp),%r9
mov    %rbp,%r9
jl     17e0 <comqr+0x6b0>
lea    (%rcx,%rbx,1),%r15d
add    $0x1,%r15d
jmp    188b <comqr+0x75b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x80(%rsp),%rax
mov    %eax,%r15d
mov    (%rsp),%rbx
mov    0x40(%rsp),%r10
cmp    %ebx,%r15d
je     21a0 <comqr+0x1070>
test   %r13d,%r13d
je     223f <comqr+0x110f>
mov    0x98(%rsp),%eax
cmp    $0x14,%eax
je     18bb <comqr+0x78b>
cmp    $0xa,%eax
jne    1f00 <comqr+0xdd0>
mov    0x128(%rsp),%rax
movsd  (%r8,%rax,8),%xmm0
andpd  %xmm8,%xmm0
mov    0x180(%rsp),%rax
movsd  (%r8,%rax,8),%xmm1
andpd  %xmm8,%xmm1
addsd  %xmm0,%xmm1
xorpd  %xmm3,%xmm3
mov    %r13d,0x90(%rsp)
cmp    %r12,%rbx
jl     1942 <comqr+0x812>
mov    0x178(%rsp),%rax
mov    0x110(%rsp),%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movslq %ecx,%rcx
lea    (%rax,%rcx,1),%rdx
movsd  (%r8,%rdx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%r8,%rdx,8)
movsd  (%r14,%rdx,8),%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,(%r14,%rdx,8)
add    %edi,%ecx
add    $0x1,%rax
cmp    %rbx,%rax
jl     1910 <comqr+0x7e0>
movsd  %xmm3,0x18(%rsp)
mov    %r15,0xf8(%rsp)
movslq %r15d,%rax
movapd %xmm1,0xc0(%rsp)
movapd %xmm1,%xmm10
mov    %rax,0x8(%rsp)
cmp    %rax,%rbx
jle    1b80 <comqr+0xa50>
mov    0x120(%rsp),%rax
mov    0x8(%rsp),%rcx
imul   %rcx,%rax
lea    (%r8,%rax,8),%rbp
lea    (%r14,%rax,8),%r12
mov    %rcx,%rsi
jmp    19b9 <comqr+0x889>
nopl   (%rax)
movsd  %xmm3,0xb0(%rsp)
movsd  %xmm4,0xb8(%rsp)
mov    0x100(%rsp),%rax
add    %rax,%rbp
add    %rax,%r12
cmp    %rbx,%rsi
jge    1b80 <comqr+0xa50>
mov    %rsi,%rbx
lea    0x1(%rsi),%rax
mov    %rax,0x48(%rsp)
lea    -0x1(%rsi),%rax
imul   0x30(%rsp),%rax
lea    (%rax,%rsi,1),%r15
movsd  (%r8,%r15,8),%xmm0
movaps %xmm0,0x70(%rsp)
movq   $0x0,(%r8,%r15,8)
lea    -0x1(%rax,%rsi,1),%r13
movsd  (%r8,%r13,8),%xmm0
movsd  (%r14,%r13,8),%xmm1
mov    $0x2,%al
call   1040 <pythag@plt>
mov    %eax,%edi
movaps 0x70(%rsp),%xmm0
mov    $0x1,%al
call   1040 <pythag@plt>
mov    0x48(%rsp),%rsi
movapd 0x70(%rsp),%xmm10
mov    0xa0(%rsp),%r8
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movsd  (%r8,%r13,8),%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,0x50(%rsp)
mov    0x1c0(%rsp),%rax
movsd  %xmm2,-0x8(%rax,%rbx,8)
movsd  (%r14,%r13,8),%xmm8
divsd  %xmm0,%xmm8
movsd  %xmm8,0x58(%rsp)
mov    0x1c8(%rsp),%rax
movsd  %xmm8,-0x8(%rax,%rbx,8)
movsd  %xmm0,(%r8,%r13,8)
movq   $0x0,(%r14,%r13,8)
movapd %xmm10,%xmm6
divsd  %xmm0,%xmm6
movsd  %xmm6,(%r14,%r15,8)
cmp    (%rsp),%rbx
mov    (%rsp),%rbx
jge    19a2 <comqr+0x872>
movapd %xmm8,%xmm9
xorpd  0x1561(%rip),%xmm9
xor    %eax,%eax
mov    %rsi,%rcx
mov    0xa8(%rsp),%rdx
nopl   0x0(%rax)
movsd  -0x8(%rbp,%rax,1),%xmm7
movsd  0x0(%rbp,%rax,1),%xmm3
movsd  -0x8(%r12,%rax,1),%xmm5
movsd  (%r12,%rax,1),%xmm4
movapd %xmm8,%xmm1
mulsd  %xmm5,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm7,%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm3,%xmm6
addsd  %xmm0,%xmm6
movsd  %xmm6,-0x8(%rbp,%rax,1)
movapd %xmm7,%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm2,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm0,%xmm1
movsd  (%r14,%r15,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x8(%r12,%rax,1)
movapd %xmm4,%xmm0
mulsd  %xmm9,%xmm0
movapd %xmm2,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
mulsd  (%r14,%r15,8),%xmm7
subsd  %xmm7,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,1)
movapd %xmm8,%xmm0
mulsd  %xmm3,%xmm0
movapd %xmm2,%xmm1
mulsd  %xmm4,%xmm1
mulsd  (%r14,%r15,8),%xmm5
addsd  %xmm0,%xmm1
subsd  %xmm5,%xmm1
movsd  %xmm1,(%r12,%rax,1)
cmp    %rbx,%rcx
jge    1990 <comqr+0x860>
add    $0x1,%rcx
movsd  (%r14,%r15,8),%xmm6
add    %rdx,%rax
jmp    1ab0 <comqr+0x980>
nopl   0x0(%rax,%rax,1)
mov    0x38(%rsp),%rbp
movsd  (%r14,%rbp,8),%xmm1
xorpd  %xmm9,%xmm9
ucomisd %xmm9,%xmm1
jne    1b99 <comqr+0xa69>
jnp    1bf0 <comqr+0xac0>
movsd  (%r8,%rbp,8),%xmm0
mov    $0x2,%al
movapd %xmm1,0x70(%rsp)
call   1040 <pythag@plt>
movapd 0x70(%rsp),%xmm1
xorpd  %xmm9,%xmm9
mov    0xa0(%rsp),%r8
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
movhpd (%r8,%rbp,8),%xmm1
movsd  %xmm0,(%r8,%rbp,8)
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm1
movq   $0x0,(%r14,%rbp,8)
jmp    1bf5 <comqr+0xac5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
unpcklpd %xmm10,%xmm1
mov    $0xffffffff,%r12d
mov    0x90(%rsp),%r13d
movsd  0x18(%rsp),%xmm10
mov    0x8(%rsp),%rbp
cmp    %rbp,%rbx
mov    0xf8(%rsp),%r15
jle    1ddd <comqr+0xcad>
lea    -0x1(%rbp),%rcx
imul   0x30(%rsp),%rcx
add    %rbp,%rcx
mov    0x170(%rsp),%rdx
lea    (%rdx,%rcx,8),%rax
mov    0x168(%rsp),%rsi
lea    (%rsi,%rcx,8),%r10
mov    0x120(%rsp),%rcx
imul   %rbp,%rcx
lea    (%rdx,%rcx,8),%rdx
lea    (%rsi,%rcx,8),%rsi
xor    %r9d,%r9d
mov    %rbp,%rcx
jmp    1caf <comqr+0xb7f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm3,0xb0(%rsp)
movsd  %xmm4,0xb8(%rsp)
mov    (%rsp),%rbx
mov    0x8(%rsp),%rbp
add    $0x1,%r9
mov    0xa8(%rsp),%rcx
add    %rcx,%rax
add    %rcx,%r10
add    %rcx,%rdx
add    %rcx,%rsi
mov    %r11,%rcx
cmp    %rbx,%r11
jge    1dd0 <comqr+0xca0>
lea    0x1(%rcx),%r11
mov    0x1c0(%rsp),%rdi
movsd  -0x8(%rdi,%rcx,8),%xmm2
mov    0x1c8(%rsp),%rdi
movsd  -0x8(%rdi,%rcx,8),%xmm8
cmp    %rbp,%r11
jl     1c8b <comqr+0xb5b>
lea    -0x1(%rcx),%rbp
imul   0x30(%rsp),%rbp
add    %rcx,%rbp
movapd %xmm8,%xmm11
xorpd  0x1310(%rip),%xmm11
lea    0x1(%r9),%rdi
lea    0x2(%r9),%rbx
xor    %ecx,%ecx
jmp    1d7c <comqr+0xc4c>
nop
movapd %xmm5,%xmm0
mulsd  %xmm11,%xmm0
movapd %xmm2,%xmm7
mulsd  %xmm6,%xmm7
addsd  %xmm0,%xmm7
movsd  (%r14,%rbp,8),%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm7,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movapd %xmm8,%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm2,%xmm7
mulsd  %xmm3,%xmm7
mulsd  (%r14,%rbp,8),%xmm6
addsd  %xmm0,%xmm7
subsd  %xmm6,%xmm7
movsd  %xmm7,(%rdx,%rcx,8)
movapd %xmm3,%xmm0
mulsd  %xmm11,%xmm0
movapd %xmm2,%xmm6
mulsd  %xmm4,%xmm6
addsd  %xmm0,%xmm6
mulsd  (%r14,%rbp,8),%xmm5
subsd  %xmm5,%xmm6
movsd  %xmm6,(%rsi,%rcx,8)
add    $0x1,%rcx
cmp    %ecx,%ebx
je     1c70 <comqr+0xb40>
movsd  (%rax,%rcx,8),%xmm6
movsd  (%rdx,%rcx,8),%xmm3
movsd  (%rsi,%rcx,8),%xmm4
xorpd  %xmm5,%xmm5
cmp    %rcx,%rdi
je     1d00 <comqr+0xbd0>
movsd  (%r10,%rcx,8),%xmm5
movapd %xmm8,%xmm7
mulsd  %xmm6,%xmm7
movapd %xmm2,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm7,%xmm0
movsd  (%r14,%rbp,8),%xmm7
mulsd  %xmm4,%xmm7
addsd  %xmm0,%xmm7
movsd  %xmm7,(%r10,%rcx,8)
jmp    1d00 <comqr+0xbd0>
nopl   0x0(%rax)
movsd  %xmm2,0x50(%rsp)
movsd  %xmm8,0x58(%rsp)
movsd  0x10(%rsp),%xmm0
addsd  0xc0(%rsp),%xmm0
movsd  %xmm0,0x10(%rsp)
movsd  0x28(%rsp),%xmm0
addsd  %xmm10,%xmm0
movsd  %xmm0,0x28(%rsp)
addl   $0x1,0x98(%rsp)
01
add    $0xffffffff,%r13d
ucomisd %xmm9,%xmm1
mov    0x130(%rsp),%rcx
mov    0x24(%rsp),%edi
mov    0x40(%rsp),%r10
movapd 0x11e2(%rip),%xmm8
movabs $0x200000000,%r9
mov    0x88(%rsp),%r11
jne    1e48 <comqr+0xd18>
jnp    17a0 <comqr+0x670>
mov    %rbx,%rax
sub    %rbp,%rax
jl     17a0 <comqr+0x670>
movapd %xmm1,%xmm10
xorpd  0x119e(%rip),%xmm10
mov    %r10,%rbx
sub    %r11,%rbx
sub    %rbp,%rbx
movapd %xmm1,%xmm0
unpckhpd %xmm1,%xmm0
cmp    $0x2,%rbx
jae    2090 <comqr+0xf60>
mov    %rbp,%rax
mov    (%rsp),%rbx
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rax,1),%esi
shl    $0x20,%rsi
add    $0xffffffffffffffff,%rax
nopw   0x0(%rax,%rax,1)
lea    (%r12,%rsi,1),%rdx
add    $0x1,%rdx
sar    $0x1d,%rsi
movsd  (%r8,%rsi,1),%xmm2
movsd  (%r14,%rsi,1),%xmm3
movapd %xmm3,%xmm4
mulsd  %xmm10,%xmm4
movapd %xmm0,%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movsd  %xmm5,(%r8,%rsi,1)
mulsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movsd  %xmm3,(%r14,%rsi,1)
add    $0x1,%rax
mov    %rdx,%rsi
cmp    %rbx,%rax
jl     1ea0 <comqr+0xd70>
jmp    17a0 <comqr+0x670>
cs nopw 0x0(%rax,%rax,1)
mov    0x38(%rsp),%rax
movsd  (%r8,%rax,8),%xmm1
movsd  (%r14,%rax,8),%xmm3
mov    0x128(%rsp),%rax
movsd  (%r8,%rax,8),%xmm2
mov    0x160(%rsp),%rax
movsd  (%r8,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
movsd  %xmm0,0x50(%rsp)
mulsd  (%r14,%rax,8),%xmm2
movsd  %xmm2,0x58(%rsp)
ucomisd %xmm9,%xmm0
jne    1f59 <comqr+0xe29>
jp     1f59 <comqr+0xe29>
ucomisd %xmm9,%xmm2
jne    1f59 <comqr+0xe29>
jnp    18e9 <comqr+0x7b9>
mov    0x150(%rsp),%rax
movsd  (%r8,%rax,8),%xmm4
movapd %xmm1,0xc0(%rsp)
subsd  %xmm1,%xmm4
movsd  0x10a4(%rip),%xmm1
mulsd  %xmm1,%xmm4
movsd  %xmm4,0x70(%rsp)
movsd  (%r14,%rax,8),%xmm5
movsd  %xmm3,0x18(%rsp)
subsd  %xmm3,%xmm5
mulsd  %xmm1,%xmm5
movapd %xmm5,%xmm1
movsd  %xmm5,0x48(%rsp)
mulsd  %xmm5,%xmm1
movapd %xmm4,%xmm3
mulsd  %xmm4,%xmm3
subsd  %xmm1,%xmm3
addsd  %xmm3,%xmm0
movapd %xmm4,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm5,%xmm1
addsd  %xmm2,%xmm1
lea    0xb0(%rsp),%rdi
lea    0xb8(%rsp),%rsi
mov    $0x2,%al
call   1030 <csroot@plt>
movsd  0x48(%rsp),%xmm3
movsd  0x70(%rsp),%xmm2
xorpd  %xmm4,%xmm4
movsd  0xb0(%rsp),%xmm6
movsd  0xb8(%rsp),%xmm5
movapd %xmm3,%xmm0
mulsd  %xmm5,%xmm0
movapd %xmm2,%xmm1
mulsd  %xmm6,%xmm1
addsd  %xmm0,%xmm1
ucomisd %xmm1,%xmm4
jbe    203d <comqr+0xf0d>
movapd 0xfdd(%rip),%xmm0
xorpd  %xmm0,%xmm6
movlpd %xmm6,0xb0(%rsp)
xorpd  %xmm0,%xmm5
movlpd %xmm5,0xb8(%rsp)
movsd  0x50(%rsp),%xmm0
movsd  0x58(%rsp),%xmm1
addsd  %xmm6,%xmm2
addsd  %xmm5,%xmm3
lea    0x50(%rsp),%rdi
lea    0x58(%rsp),%rsi
mov    $0x4,%al
call   1050 <cdiv@plt>
movapd 0xc0(%rsp),%xmm1
subsd  0x50(%rsp),%xmm1
movsd  0x18(%rsp),%xmm3
subsd  0x58(%rsp),%xmm3
mov    0xa0(%rsp),%r8
mov    0x24(%rsp),%edi
jmp    18e9 <comqr+0x7b9>
xchg   %ax,%ax
mov    0x158(%rsp),%rdx
add    %r15d,%edx
lea    (%rax,%rdx,1),%esi
cmp    %edx,%esi
jl     1e7d <comqr+0xd4d>
shr    $0x20,%rax
jne    1e7d <comqr+0xd4d>
movslq %edx,%rax
lea    (%r8,%rax,8),%rsi
mov    %rax,%rdx
sub    %rbp,%rdx
mov    0x148(%rsp),%rbp
lea    0x0(%rbp,%rdx,8),%rbp
cmp    %rbp,%rsi
jae    20ee <comqr+0xfbe>
mov    0x140(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
lea    (%r14,%rax,8),%rax
cmp    %rdx,%rax
jae    20ee <comqr+0xfbe>
mov    0x8(%rsp),%rax
jmp    1e80 <comqr+0xd50>
mov    %rbx,%r11
and    $0xfffffffffffffffe,%r11
mov    0x8(%rsp),%rdx
lea    (%r11,%rdx,1),%rax
movapd %xmm10,%xmm2
unpcklpd %xmm10,%xmm2
movapd %xmm1,%xmm3
unpcklpd %xmm1,%xmm3
mov    0x118(%rsp),%rsi
sub    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0xd8(%rsp),%rdx
add    %r15d,%edx
shl    $0x20,%rdx
xchg   %ax,%ax
mov    %rdx,%rbp
sar    $0x1d,%rbp
movupd (%r8,%rbp,1),%xmm4
movupd (%r14,%rbp,1),%xmm5
movapd %xmm5,%xmm6
mulpd  %xmm2,%xmm6
movapd %xmm0,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm6,%xmm7
movupd %xmm7,(%r8,%rbp,1)
mulpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm5
addpd  %xmm4,%xmm5
movupd %xmm5,(%r14,%rbp,1)
add    %r9,%rdx
add    $0xfffffffffffffffe,%rsi
jne    2130 <comqr+0x1000>
cmp    %r11,%rbx
mov    (%rsp),%rbx
mov    0x88(%rsp),%r11
je     17a0 <comqr+0x670>
jmp    1e84 <comqr+0xd54>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x38(%rsp),%rdx
movsd  (%r8,%rdx,8),%xmm0
addsd  0x10(%rsp),%xmm0
mov    0x1c0(%rsp),%rax
mov    0x138(%rsp),%rsi
movsd  %xmm0,(%rax,%rsi,8)
movsd  (%r14,%rdx,8),%xmm0
addsd  0x28(%rsp),%xmm0
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%rsi,8)
add    $0x1,%r11
mov    0xe0(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0xe0(%rsp)
mov    0x68(%rsp),%edx
add    %edx,0x6c(%rsp)
mov    0xe8(%rsp),%rax
add    %edx,%eax
mov    %rax,0xe8(%rsp)
add    %edx,0x64(%rsp)
addq   $0xffffffffffffffff,0x118(%rsp)
mov    0x30(%rsp),%rax
sub    %rax,0xd8(%rsp)
cmp    %r12,%rbx
mov    %rsi,%rbx
mov    0x10c(%rsp),%esi
jg     16e0 <comqr+0x5b0>
jmp    2249 <comqr+0x1119>
mov    0x1d0(%rsp),%rax
mov    %ebx,(%rax)
add    $0x188,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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