#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double *dvector(int /*<<< orphan*/, int);
double fabs(double);
int /*<<< orphan*/ free_dvector(double *, int /*<<< orphan*/, int);
double pythag(double, double);
double sqrt(double);
int svdecomp(double **a, double *w, double **v, int m, int n) {
  double eps = 2.2204460492503131e-016;
  double tol = 2.2250738585072014e-308 / eps;
  double *rv1, RV1[10];
  double anm;
  int i, j, k;
  int its;
  if (n <= 10)
    rv1 = RV1;
  else
    rv1 = dvector(0, n - 1);
  anm = 0.0;
  rv1[0] = 0.0;
  for (i = 0; i < n; i++) {
    int ip1 = i + 1;
    w[i] = 0.0;
    if (i < m) {
      double ss, ff = 0.0;
      for (ss = 0.0, k = m - 1; k >= i; k--) {
        ff = a[k][i];
        ss += ff * ff;
      }
      if (ss >= tol) {
        double gg, hh;
        gg = sqrt(ss);
        w[i] = gg = ff < 0.0 ? gg : -gg;
        hh = ff * gg - ss;
        a[i][i] = ff - gg;
        for (j = ip1; j < n; j++) {
          double tt;
          for (ss = 0.0, k = i; k < m; k++)
            ss += a[k][j] * a[k][i];
          tt = ss / hh;
          for (k = i; k < m; k++)
            a[k][j] += tt * a[k][i];
        }
      }
    }
    if (ip1 < n) {
      rv1[ip1] = 0.0;
      if (i < m) {
        double ss, ff = 0.0;
        for (ss = 0.0, k = n - 1; k >= ip1; k--) {
          ff = a[i][k];
          ss += ff * ff;
        }
        if (ss >= tol) {
          double gg, hh;
          gg = sqrt(ss);
          rv1[ip1] = gg = ff < 0.0 ? gg : -gg;
          hh = ff * gg - ss;
          a[i][ip1] = (ff - gg);
          for (j = ip1; j < m; j++) {
            double tt;
            for (ss = 0.0, k = ip1; k < n; k++)
              ss += a[j][k] * a[i][k];
            tt = ss / hh;
            for (k = ip1; k < n; k++)
              a[j][k] += tt * a[i][k];
          }
        }
      }
    }
    {
      double tt;
      tt = fabs(w[i]) + fabs(rv1[i]);
      if (tt > anm)
        anm = tt;
    }
  }
  for (i = n - 1; i >= 0; i--) {
    int ip1 = i + 1;
    if (ip1 < n) {
      double gg;
      gg = rv1[ip1];
      if (gg != 0.0) {
        gg = 1.0 / gg;
        for (j = ip1; j < n; j++)
          v[j][i] = (a[i][j] / a[i][ip1]) * gg;
        for (j = ip1; j < n; j++) {
          double ss;
          for (ss = 0.0, k = ip1; k < n; k++)
            ss += a[i][k] * v[k][j];
          for (k = ip1; k < n; k++)
            v[k][j] += ss * v[k][i];
        }
      }
      for (j = ip1; j < n; j++)
        v[i][j] = v[j][i] = 0.0;
    }
    v[i][i] = 1.0;
  }
  for (i = n < m ? n - 1 : m - 1; i >= 0; i--) {
    int ip1 = i + 1;
    double gg = w[i];
    if (ip1 < n)
      for (j = ip1; j < n; j++)
        a[i][j] = 0.0;
    if (gg == 0.0) {
      for (j = i; j < m; j++)
        a[j][i] = 0.0;
    } else {
      gg = 1.0 / gg;
      if (ip1 < n) {
        for (j = ip1; j < n; j++) {
          double ss, ff;
          for (ss = 0.0, k = ip1; k < m; k++)
            ss += a[k][i] * a[k][j];
          ff = (ss / a[i][i]) * gg;
          for (k = i; k < m; k++)
            a[k][j] += ff * a[k][i];
        }
      }
      for (j = i; j < m; j++)
        a[j][i] *= gg;
    }
    a[i][i] += 1.0;
  }
  eps *= anm;
  for (k = (n - 1); k >= 0; k--) {
    for (its = 0;; its++) {
      int flag;
      int lm1 = 0;
      int ll;
      double zz;
      for (flag = 1, ll = k; ll >= 0; ll--) {
        lm1 = ll - 1;
        if (fabs(rv1[ll]) <= eps) {
          flag = 0;
          break;
        }
        if (fabs(w[lm1]) <= eps)
          break;
      }
      if (flag != 0) {
        double cc = 0.0;
        double ss = 1.0;
        for (i = ll; i <= k; i++) {
          double ff, gg, hh;
          gg = rv1[i];
          rv1[i] = cc * gg;
          ff = ss * gg;
          if (fabs(ff) <= eps)
            break;
          gg = w[i];
          w[i] = hh = pythag(ff, gg);
          hh = 1.0 / hh;
          cc = gg * hh;
          ss = -ff * hh;
          for (j = 0; j < m; j++) {
            double y1, z1;
            y1 = a[j][lm1];
            z1 = a[j][i];
            a[j][lm1] = y1 * cc + z1 * ss;
            a[j][i] = z1 * cc - y1 * ss;
          }
        }
      }
      zz = w[k];
      if (k == ll) {
        if (zz < 0.0) {
          w[k] = -zz;
          for (j = 0; j < n; j++)
            v[j][k] = (-v[j][k]);
        }
        break;
      }
      if (its == 30) {
        if (rv1 != RV1)
          free_dvector(rv1, 0, n - 1);
        return 1;
      }
      {
        double ff, gg, hh, cc, ss, xx, yy;
        int km1;
        km1 = k - 1;
        xx = w[ll];
        yy = w[km1];
        gg = rv1[km1];
        hh = rv1[k];
        ff = ((yy - zz) * (yy + zz) + (gg - hh) * (gg + hh)) / (2.0 * hh * yy);
        gg = pythag(ff, 1.0);
        gg = ff < 0.0 ? -gg : gg;
        ff = ((xx - zz) * (xx + zz) + hh * ((yy / (ff + gg)) - hh)) / xx;
        cc = ss = 1.0;
        for (j = ll; j <= km1; j++) {
          double f2, g2, y2, h2, z2;
          int jp1 = j + 1;
          g2 = rv1[jp1];
          y2 = w[jp1];
          h2 = ss * g2;
          g2 = cc * g2;
          rv1[j] = z2 = pythag(ff, h2);
          cc = ff / z2;
          ss = h2 / z2;
          f2 = xx * cc + g2 * ss;
          g2 = g2 * cc - xx * ss;
          h2 = y2 * ss;
          y2 = y2 * cc;
          for (i = 0; i < n; i++) {
            double x1, z1;
            x1 = v[i][j];
            z1 = v[i][jp1];
            v[i][j] = x1 * cc + z1 * ss;
            v[i][jp1] = z1 * cc - x1 * ss;
          }
          w[j] = z2 = pythag(f2, h2);
          if (z2 != 0.0) {
            z2 = 1.0 / z2;
            cc = f2 * z2;
            ss = h2 * z2;
          }
          ff = (cc * g2) + (ss * y2);
          xx = (cc * y2) - (ss * g2);
          for (i = 0; i < m; i++) {
            double y1, z1;
            y1 = a[i][j];
            z1 = a[i][jp1];
            a[i][j] = y1 * cc + z1 * ss;
            a[i][jp1] = z1 * cc - y1 * ss;
          }
        }
        rv1[ll] = 0.0;
        rv1[k] = ff;
        w[k] = xx;
      }
    }
  }
  if (rv1 != RV1)
    free_dvector(rv1, 0, n - 1);
  return 0;
}


x86 assembly (clang, -O0):
<svdecomp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x240,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
movsd  0x1ea2(%rip),%xmm0
movsd  %xmm0,-0x30(%rbp)
movsd  0x1e8d(%rip),%xmm0
divsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
cmpl   $0xa,-0x28(%rbp)
jg     1197 <svdecomp+0x57>
lea    -0x90(%rbp),%rax
mov    %rax,-0x40(%rbp)
jmp    11a8 <svdecomp+0x68>
mov    -0x28(%rbp),%esi
sub    $0x1,%esi
xor    %edi,%edi
call   1040 <dvector@plt>
mov    %rax,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x40(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1893 <svdecomp+0x753>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14f2 <svdecomp+0x3b2>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x9c(%rbp),%eax
jl     129b <svdecomp+0x15b>
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
jmp    122a <svdecomp+0xea>
movsd  -0xb8(%rbp),%xmm0
ff
ucomisd -0x38(%rbp),%xmm0
jb     14ed <svdecomp+0x3ad>
movsd  -0xb8(%rbp),%xmm0
ff
call   1060 <sqrt@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xc0(%rbp),%xmm0
ff
jbe    12e9 <svdecomp+0x1a9>
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x228(%rbp)
ff
jmp    1310 <svdecomp+0x1d0>
movsd  -0xc8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movsd  -0x228(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xc0(%rbp),%xmm0
ff
movsd  -0xc8(%rbp),%xmm2
ff
movsd  -0xb8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
subsd  -0xc8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    14e8 <svdecomp+0x3a8>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    143d <svdecomp+0x2fd>
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    13cc <svdecomp+0x28c>
movsd  -0xb8(%rbp),%xmm0
ff
divsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    14cf <svdecomp+0x38f>
movsd  -0xd8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1461 <svdecomp+0x321>
jmp    14d4 <svdecomp+0x394>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    13a6 <svdecomp+0x266>
jmp    14ed <svdecomp+0x3ad>
jmp    14f2 <svdecomp+0x3b2>
mov    -0xac(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1812 <svdecomp+0x6d2>
mov    -0x40(%rbp),%rax
movslq -0xac(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    180d <svdecomp+0x6cd>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0xac(%rbp),%eax
jl     15b6 <svdecomp+0x476>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xe8(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
jmp    1545 <svdecomp+0x405>
movsd  -0xe0(%rbp),%xmm0
ff
ucomisd -0x38(%rbp),%xmm0
jb     1808 <svdecomp+0x6c8>
movsd  -0xe0(%rbp),%xmm0
ff
call   1060 <sqrt@plt>
movsd  %xmm0,-0xf0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xe8(%rbp),%xmm0
ff
jbe    1604 <svdecomp+0x4c4>
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x230(%rbp)
ff
jmp    162b <svdecomp+0x4eb>
movsd  -0xf0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x40(%rbp),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xe8(%rbp),%xmm0
ff
movsd  -0xf0(%rbp),%xmm2
ff
movsd  -0xe0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
subsd  -0xf0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xac(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1803 <svdecomp+0x6c3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0xac(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1758 <svdecomp+0x618>
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xe0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    16e7 <svdecomp+0x5a7>
movsd  -0xe0(%rbp),%xmm0
ff
divsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0xac(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    17ea <svdecomp+0x6aa>
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    177c <svdecomp+0x63c>
jmp    17ef <svdecomp+0x6af>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    16c1 <svdecomp+0x581>
jmp    1808 <svdecomp+0x6c8>
jmp    180d <svdecomp+0x6cd>
jmp    1812 <svdecomp+0x6d2>
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movaps 0x17f7(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x17dc(%rip),%xmm2
pand   %xmm2,%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
movsd  -0x108(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jbe    187a <svdecomp+0x73a>
movsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0x98(%rbp)
ff
jmp    187f <svdecomp+0x73f>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    11c8 <svdecomp+0x88>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x9c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jl     1b84 <svdecomp+0xa44>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10c(%rbp)
mov    -0x10c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b4d <svdecomp+0xa0d>
mov    -0x40(%rbp),%rax
movslq -0x10c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1902 <svdecomp+0x7c2>
jp     1902 <svdecomp+0x7c2>
jmp    1add <svdecomp+0x99d>
movsd  0x1706(%rip),%xmm0
divsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
mov    -0x10c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    19a2 <svdecomp+0x862>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mulsd  -0x118(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1926 <svdecomp+0x7e6>
mov    -0x10c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1ad8 <svdecomp+0x998>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x10c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1a45 <svdecomp+0x905>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    19d4 <svdecomp+0x894>
mov    -0x10c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1abf <svdecomp+0x97f>
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1a51 <svdecomp+0x911>
jmp    1ac4 <svdecomp+0x984>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    19ae <svdecomp+0x86e>
jmp    1add <svdecomp+0x99d>
mov    -0x10c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1b48 <svdecomp+0xa08>
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1ae9 <svdecomp+0x9a9>
jmp    1b4d <svdecomp+0xa0d>
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  0x14a5(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x9c(%rbp)
jmp    189f <svdecomp+0x75f>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1ba1 <svdecomp+0xa61>
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x234(%rbp)
jmp    1bad <svdecomp+0xa6d>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x234(%rbp)
mov    -0x234(%rbp),%eax
mov    %eax,-0x9c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jl     1ee8 <svdecomp+0xda8>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x124(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x124(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1c4e <svdecomp+0xb0e>
mov    -0x124(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1c49 <svdecomp+0xb09>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1c08 <svdecomp+0xac8>
jmp    1c4e <svdecomp+0xb0e>
movsd  -0x130(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1cbb <svdecomp+0xb7b>
jp     1cbb <svdecomp+0xb7b>
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1cb6 <svdecomp+0xb76>
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1c75 <svdecomp+0xb35>
jmp    1eac <svdecomp+0xd6c>
movsd  0x134d(%rip),%xmm0
divsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
mov    -0x124(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e50 <svdecomp+0xd10>
mov    -0x124(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1e4b <svdecomp+0xd0b>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0x124(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1d85 <svdecomp+0xc45>
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x138(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1d14 <svdecomp+0xbd4>
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mulsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1e32 <svdecomp+0xcf2>
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1dc4 <svdecomp+0xc84>
jmp    1e37 <svdecomp+0xcf7>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1cee <svdecomp+0xbae>
jmp    1e50 <svdecomp+0xd10>
mov    -0x9c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1ea7 <svdecomp+0xd67>
movsd  -0x130(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    1e5c <svdecomp+0xd1c>
jmp    1eac <svdecomp+0xd6c>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  0x1146(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x9c(%rbp)
jmp    1bb9 <svdecomp+0xa79>
movsd  -0x98(%rbp),%xmm0
ff
mulsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x28(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xa4(%rbp)
cmpl   $0x0,-0xa4(%rbp)
jl     2abc <svdecomp+0x197c>
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0x148(%rbp)
movl   $0x1,-0x144(%rbp)
mov    -0xa4(%rbp),%eax
mov    %eax,-0x14c(%rbp)
cmpl   $0x0,-0x14c(%rbp)
jl     1fda <svdecomp+0xe9a>
mov    -0x14c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x148(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x10b0(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1f92 <svdecomp+0xe52>
movl   $0x0,-0x144(%rbp)
jmp    1fda <svdecomp+0xe9a>
mov    -0x18(%rbp),%rax
movslq -0x148(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movaps 0x1077(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1fc1 <svdecomp+0xe81>
jmp    1fda <svdecomp+0xe9a>
jmp    1fc6 <svdecomp+0xe86>
mov    -0x14c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14c(%rbp)
jmp    1f3d <svdecomp+0xdfd>
cmpl   $0x0,-0x144(%rbp)
je     2269 <svdecomp+0x1129>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x160(%rbp)
ff
movsd  0x1016(%rip),%xmm0
movsd  %xmm0,-0x168(%rbp)
mov    -0x14c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0xa4(%rbp),%eax
jg     2264 <svdecomp+0x1124>
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x160(%rbp),%xmm0
ff
mulsd  -0x178(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x168(%rbp),%xmm0
ff
mulsd  -0x178(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0x170(%rbp),%xmm1
ff
movaps 0xfa1(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     2097 <svdecomp+0xf57>
jmp    2264 <svdecomp+0x1124>
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
movsd  -0x178(%rbp),%xmm1
ff
call   1030 <pythag@plt>
movsd  %xmm0,-0x180(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0xf2c(%rip),%xmm0
divsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0x178(%rbp),%xmm0
ff
mulsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0x170(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  -0x180(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    224b <svdecomp+0x110b>
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x148(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x188(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x188(%rbp),%xmm0
ff
movsd  -0x160(%rbp),%xmm2
ff
movsd  -0x190(%rbp),%xmm1
ff
mulsd  -0x168(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x148(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x190(%rbp),%xmm0
ff
movsd  -0x160(%rbp),%xmm2
ff
movsd  -0x188(%rbp),%xmm1
ff
mulsd  -0x168(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x9c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    2145 <svdecomp+0x1005>
jmp    2250 <svdecomp+0x1110>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    200e <svdecomp+0xece>
jmp    2269 <svdecomp+0x1129>
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x158(%rbp)
ff
mov    -0xa4(%rbp),%eax
cmp    -0x14c(%rbp),%eax
jne    2357 <svdecomp+0x1217>
xorps  %xmm0,%xmm0
ucomisd -0x158(%rbp),%xmm0
ff
jbe    2352 <svdecomp+0x1212>
movsd  -0x158(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    234d <svdecomp+0x120d>
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0xa0(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    22dd <svdecomp+0x119d>
jmp    2352 <svdecomp+0x1212>
jmp    2aa3 <svdecomp+0x1963>
cmpl   $0x1e,-0xa8(%rbp)
jne    2395 <svdecomp+0x1255>
mov    -0x40(%rbp),%rax
lea    -0x90(%rbp),%rcx
cmp    %rcx,%rax
je     2389 <svdecomp+0x1249>
mov    -0x40(%rbp),%rdi
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1050 <free_dvector@plt>
movl   $0x1,-0x4(%rbp)
jmp    2ae8 <svdecomp+0x19a8>
mov    -0xa4(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1cc(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x14c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x1cc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1c8(%rbp)
ff
mov    -0x40(%rbp),%rax
movslq -0x1cc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
mov    -0x40(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
movsd  -0x1c8(%rbp),%xmm0
ff
subsd  -0x158(%rbp),%xmm0
ff
movsd  -0x1c8(%rbp),%xmm2
ff
addsd  -0x158(%rbp),%xmm2
ff
movsd  -0x1a0(%rbp),%xmm1
ff
subsd  -0x1a8(%rbp),%xmm1
ff
movsd  -0x1a0(%rbp),%xmm3
ff
addsd  -0x1a8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xbc0(%rip),%xmm1
mulsd  -0x1a8(%rbp),%xmm1
ff
mulsd  -0x1c8(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
movsd  0xb8c(%rip),%xmm1
call   1030 <pythag@plt>
movsd  %xmm0,-0x1a0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0x198(%rbp),%xmm0
ff
jbe    24ce <svdecomp+0x138e>
movsd  -0x1a0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
jmp    24de <svdecomp+0x139e>
movsd  -0x1a0(%rbp),%xmm0
ff
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x240(%rbp),%xmm0
ff
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
subsd  -0x158(%rbp),%xmm0
ff
movsd  -0x1c0(%rbp),%xmm2
ff
addsd  -0x158(%rbp),%xmm2
ff
movsd  -0x1a8(%rbp),%xmm1
ff
movsd  -0x1c8(%rbp),%xmm3
ff
movsd  -0x198(%rbp),%xmm4
ff
addsd  -0x1a0(%rbp),%xmm4
ff
divsd  %xmm4,%xmm3
subsd  -0x1a8(%rbp),%xmm3
ff
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x1c0(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%rbp)
ff
movsd  0xab2(%rip),%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  0xaa2(%rip),%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
mov    -0x14c(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x1cc(%rbp),%eax
jg     2a4c <svdecomp+0x190c>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1fc(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x1fc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x1fc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0x1b8(%rbp),%xmm0
ff
mulsd  -0x1e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm0
ff
mulsd  -0x1e0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x198(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm1
ff
call   1030 <pythag@plt>
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x40(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x198(%rbp),%xmm0
ff
divsd  -0x1f8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
divsd  -0x1f8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1c0(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x1e0(%rbp),%xmm1
ff
mulsd  -0x1b8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d8(%rbp)
ff
movsd  -0x1e0(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x1c0(%rbp),%xmm1
ff
mulsd  -0x1b8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  -0x1b8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f0(%rbp)
ff
movsd  -0x1e8(%rbp),%xmm0
ff
mulsd  -0x1b0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e8(%rbp)
ff
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    2817 <svdecomp+0x16d7>
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x208(%rbp)
ff
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1fc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
movsd  -0x208(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x210(%rbp),%xmm1
ff
mulsd  -0x1b8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x210(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x208(%rbp),%xmm1
ff
mulsd  -0x1b8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1fc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    2711 <svdecomp+0x15d1>
movsd  -0x1d8(%rbp),%xmm0
ff
movsd  -0x1f0(%rbp),%xmm1
ff
call   1030 <pythag@plt>
movsd  %xmm0,-0x1f8(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1f8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    2864 <svdecomp+0x1724>
jp     2864 <svdecomp+0x1724>
jmp    28ac <svdecomp+0x176c>
movsd  0x7a4(%rip),%xmm0
divsd  -0x1f8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0x1d8(%rbp),%xmm0
ff
mulsd  -0x1f8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0x1f0(%rbp),%xmm0
ff
mulsd  -0x1f8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  -0x1e0(%rbp),%xmm2
ff
movsd  -0x1b8(%rbp),%xmm1
ff
mulsd  -0x1e8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0x1b0(%rbp),%xmm0
ff
movsd  -0x1e8(%rbp),%xmm2
ff
movsd  -0x1b8(%rbp),%xmm1
ff
mulsd  -0x1e0(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x1c0(%rbp)
ff
movl   $0x0,-0x9c(%rbp)
mov    -0x9c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    2a33 <svdecomp+0x18f3>
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1fc(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0x218(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x220(%rbp),%xmm1
ff
mulsd  -0x1b8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa0(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x220(%rbp),%xmm0
ff
movsd  -0x1b0(%rbp),%xmm2
ff
movsd  -0x218(%rbp),%xmm1
ff
mulsd  -0x1b8(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1fc(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    292d <svdecomp+0x17ed>
jmp    2a38 <svdecomp+0x18f8>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    2582 <svdecomp+0x1442>
mov    -0x40(%rbp),%rax
movslq -0x14c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x198(%rbp),%xmm0
ff
mov    -0x40(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x1c0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1f1d <svdecomp+0xddd>
jmp    2aa8 <svdecomp+0x1968>
mov    -0xa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xa4(%rbp)
jmp    1f06 <svdecomp+0xdc6>
mov    -0x40(%rbp),%rax
lea    -0x90(%rbp),%rcx
cmp    %rcx,%rax
je     2ae1 <svdecomp+0x19a1>
mov    -0x40(%rbp),%rdi
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1050 <free_dvector@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x240,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<svdecomp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %rdx,%rbx
mov    %rdi,%r14
movslq %ecx,%r11
mov    %r8d,%r12d
mov    %rcx,0x78(%rsp)
mov    %ecx,%r9d
cmp    $0xb,%r8d
mov    %rsi,0x30(%rsp)
mov    %r9,0x38(%rsp)
mov    %r8,0x8(%rsp)
mov    %r11,0x50(%rsp)
jge    11be <svdecomp+0x6e>
lea    0xf0(%rsp),%rax
movq   $0x0,0xf0(%rsp)
test   %r8d,%r8d
mov    %rax,0x28(%rsp)
jg     11e4 <svdecomp+0x94>
xorpd  %xmm5,%xmm5
movl   $0x0,0x20(%rsp)
jmp    1b64 <svdecomp+0xa14>
lea    -0x1(%r8),%esi
xor    %edi,%edi
call   1050 <dvector@plt>
mov    0x50(%rsp),%r11
mov    0x38(%rsp),%r9
mov    0x30(%rsp),%rsi
mov    %rax,0x28(%rsp)
movq   $0x0,(%rax)
mov    %r12,%rdx
neg    %rdx
lea    -0x5(%r12),%rax
xorpd  %xmm8,%xmm8
mov    $0x1,%edi
mov    $0x7,%ecx
mov    %rcx,0xb0(%rsp)
xor    %ebp,%ebp
movsd  0x1df0(%rip),%xmm7
movapd 0x1e07(%rip),%xmm9
movapd 0x1e0e(%rip),%xmm10
mov    %r9,%r15
mov    %r14,%r13
xorpd  %xmm5,%xmm5
mov    %rdx,0x80(%rsp)
jmp    129b <svdecomp+0x14b>
cs nopw 0x0(%rax,%rax,1)
mov    0x30(%rsp),%rsi
movsd  (%rsi,%rbp,8),%xmm0
andpd  %xmm10,%xmm0
mov    0x28(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm5
andpd  %xmm10,%xmm5
addsd  %xmm0,%xmm5
maxsd  %xmm11,%xmm5
add    $0x1,%rdi
add    $0x8,%r13
add    $0xffffffffffffffff,%r15
addq   $0x1,0xb0(%rsp)
mov    0x90(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    0x40(%rsp),%rbp
cmp    %r12,%rbp
mov    0x50(%rsp),%r11
je     17e7 <svdecomp+0x697>
movapd %xmm5,%xmm11
lea    0x1(%rbp),%r8
movq   $0x0,(%rsi,%rbp,8)
cmp    %r11,%rbp
mov    %r8,%rcx
mov    %r8,0x40(%rsp)
mov    %rax,0x90(%rsp)
jge    1350 <svdecomp+0x200>
shr    $0x2,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x60(%rsp)
mov    %rbp,%rax
not    %rax
lea    (%rax,%r12,1),%rcx
add    $0xfffffffffffffffc,%rcx
add    %r12,%rax
mov    %rax,(%rsp)
mov    %rcx,0x70(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %rcx,0x68(%rsp)
xorpd  %xmm4,%xmm4
mov    %r11,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x8(%r14,%rax,8),%rcx
add    $0xffffffffffffffff,%rax
movsd  (%rcx,%rbp,8),%xmm3
movapd %xmm3,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm0,%xmm4
cmp    %rbp,%rax
jg     1310 <svdecomp+0x1c0>
ucomisd %xmm7,%xmm4
jb     149a <svdecomp+0x34a>
ucomisd %xmm8,%xmm4
jb     1370 <svdecomp+0x220>
xorps  %xmm0,%xmm0
sqrtsd %xmm4,%xmm0
jmp    13dd <svdecomp+0x28d>
nopl   0x0(%rax)
cmp    %r12,%r8
jae    1240 <svdecomp+0xf0>
mov    0x28(%rsp),%rax
mov    0x40(%rsp),%rcx
movq   $0x0,(%rax,%rcx,8)
jmp    1240 <svdecomp+0xf0>
movapd %xmm4,%xmm0
mov    %rdi,0x10(%rsp)
movsd  %xmm11,0xc0(%rsp)
movsd  %xmm3,0x20(%rsp)
movsd  %xmm4,0x18(%rsp)
call   1070 <sqrt@plt>
movsd  0x18(%rsp),%xmm4
movsd  0x20(%rsp),%xmm3
movsd  0xc0(%rsp),%xmm11
mov    0x40(%rsp),%r8
movapd 0x1c78(%rip),%xmm10
movapd 0x1c5f(%rip),%xmm9
movsd  0x1c37(%rip),%xmm7
mov    0x10(%rsp),%rdi
xorpd  %xmm8,%xmm8
mov    0x38(%rsp),%r9
mov    0x30(%rsp),%rsi
movapd %xmm3,%xmm1
cmpltsd %xmm8,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm9,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
movlpd %xmm1,(%rsi,%rbp,8)
movapd %xmm3,%xmm0
subsd  %xmm1,%xmm0
mov    (%r14,%rbp,8),%rax
movsd  %xmm0,(%rax,%rbp,8)
cmp    %r12,%r8
jae    149a <svdecomp+0x34a>
mulsd  %xmm1,%xmm3
subsd  %xmm4,%xmm3
mov    %rdi,%rax
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%r13,%rcx,8),%rdx
movsd  (%rdx,%rax,8),%xmm1
mulsd  (%rdx,%rbp,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1440 <svdecomp+0x2f0>
divsd  %xmm3,%xmm0
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rcx,8),%rdx
movsd  (%rdx,%rbp,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rdx,%rax,8),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    1470 <svdecomp+0x320>
add    $0x1,%rax
cmp    %r12,%rax
jne    1430 <svdecomp+0x2e0>
cmp    %r12,%r8
jae    1240 <svdecomp+0xf0>
mov    0x28(%rsp),%rax
mov    0x40(%rsp),%rdx
movq   $0x0,(%rax,%rdx,8)
mov    (%r14,%rbp,8),%rax
xorpd  %xmm3,%xmm3
mov    %r12,%rcx
movsd  -0x8(%rax,%rcx,8),%xmm12
add    $0xffffffffffffffff,%rcx
movapd %xmm12,%xmm0
mulsd  %xmm12,%xmm0
addsd  %xmm0,%xmm3
cmp    %rdx,%rcx
jg     14c0 <svdecomp+0x370>
ucomisd %xmm7,%xmm3
jb     1240 <svdecomp+0xf0>
ucomisd %xmm8,%xmm3
jb     14f8 <svdecomp+0x3a8>
xorps  %xmm0,%xmm0
sqrtsd %xmm3,%xmm0
jmp    155d <svdecomp+0x40d>
movapd %xmm3,%xmm0
mov    %rdi,0x10(%rsp)
movsd  %xmm11,0xc0(%rsp)
movsd  %xmm12,0x20(%rsp)
movsd  %xmm3,0x18(%rsp)
call   1070 <sqrt@plt>
movsd  0x18(%rsp),%xmm3
movsd  0x20(%rsp),%xmm12
movsd  0xc0(%rsp),%xmm11
movapd 0x1af3(%rip),%xmm10
movapd 0x1ada(%rip),%xmm9
movsd  0x1ab2(%rip),%xmm7
mov    0x10(%rsp),%rdi
xorpd  %xmm8,%xmm8
mov    0x38(%rsp),%r9
movapd %xmm12,%xmm1
cmpltsd %xmm8,%xmm1
movapd %xmm1,%xmm2
andpd  %xmm0,%xmm2
xorpd  %xmm9,%xmm0
andnpd %xmm0,%xmm1
orpd   %xmm2,%xmm1
mov    0x28(%rsp),%rax
mov    0x40(%rsp),%rcx
movlpd %xmm1,(%rax,%rcx,8)
movapd %xmm12,%xmm0
subsd  %xmm1,%xmm0
mov    (%r14,%rbp,8),%rax
movsd  %xmm0,(%rax,%rcx,8)
cmp    0x50(%rsp),%rcx
jge    1240 <svdecomp+0xf0>
mulsd  %xmm1,%xmm12
subsd  %xmm3,%xmm12
lea    (%rax,%rdi,8),%rcx
mov    %rcx,0xc0(%rsp)
lea    (%rax,%r12,8),%rcx
mov    %rcx,0x10(%rsp)
mov    (%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x20(%rsp)
add    %rdi,%rcx
mov    %rcx,0x18(%rsp)
mov    0xb0(%rsp),%rcx
lea    (%rax,%rcx,8),%r11
mov    %rdi,%r10
jmp    15fd <svdecomp+0x4ad>
xchg   %ax,%ax
add    $0x1,%r10
cmp    %r9,%r10
je     1240 <svdecomp+0xf0>
mov    (%r14,%r10,8),%rcx
xorpd  %xmm0,%xmm0
mov    %rdi,%rdx
nopl   0x0(%rax,%rax,1)
movsd  (%rcx,%rdx,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%r12
jne    1610 <svdecomp+0x4c0>
divsd  %xmm12,%xmm0
mov    (%r14,%r10,8),%rcx
mov    %rdi,%rsi
cmpq   $0x4,(%rsp)
jb     1760 <svdecomp+0x610>
lea    (%rcx,%rdi,8),%rdx
cmp    0x10(%rsp),%rdx
jae    165e <svdecomp+0x50e>
lea    (%rcx,%r12,8),%rdx
mov    %rdi,%rsi
cmp    %rdx,0xc0(%rsp)
jb     1760 <svdecomp+0x610>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x4,0x70(%rsp)
jae    1675 <svdecomp+0x525>
xor    %edx,%edx
jmp    170b <svdecomp+0x5bb>
mov    0xb0(%rsp),%rdx
lea    (%rcx,%rdx,8),%r8
mov    0x60(%rsp),%r9
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%r11,%rdx,8),%xmm2
movupd -0x20(%r11,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
movupd -0x30(%r8,%rdx,8),%xmm4
addpd  %xmm2,%xmm4
movupd -0x20(%r8,%rdx,8),%xmm2
movupd -0x10(%r8,%rdx,8),%xmm5
movupd (%r8,%rdx,8),%xmm6
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,-0x30(%r8,%rdx,8)
movupd %xmm3,-0x20(%r8,%rdx,8)
movupd -0x10(%r11,%rdx,8),%xmm2
movupd (%r11,%rdx,8),%xmm3
mulpd  %xmm1,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,-0x10(%r8,%rdx,8)
movupd %xmm3,(%r8,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%r9
jne    1690 <svdecomp+0x540>
testb  $0x1,0x68(%rsp)
mov    0x38(%rsp),%r9
je     174b <svdecomp+0x5fb>
add    %rdi,%rdx
movupd (%rax,%rdx,8),%xmm2
movupd 0x10(%rax,%rdx,8),%xmm3
movupd (%rcx,%rdx,8),%xmm4
movupd 0x10(%rcx,%rdx,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%rcx,%rdx,8)
movupd %xmm3,0x10(%rcx,%rdx,8)
mov    0x18(%rsp),%rsi
mov    0x20(%rsp),%rdx
cmp    %rdx,(%rsp)
je     15f0 <svdecomp+0x4a0>
nop
mov    %r9,%r8
mov    %rdi,%r9
mov    %r12d,%edi
sub    %esi,%edi
mov    %rsi,%rdx
test   $0x1,%dil
je     178b <svdecomp+0x63b>
movsd  (%rax,%rsi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rsi,8),%xmm1
movsd  %xmm1,(%rcx,%rsi,8)
lea    0x1(%rsi),%rdx
not    %rsi
cmp    0x80(%rsp),%rsi
mov    %r9,%rdi
mov    %r8,%r9
je     15f0 <svdecomp+0x4a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%rcx,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%rcx,%rdx,8),%xmm1
movsd  %xmm1,0x8(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%r12
jne    17b0 <svdecomp+0x660>
jmp    15f0 <svdecomp+0x4a0>
mulsd  0x1819(%rip),%xmm5
movslq 0x8(%rsp),%rdx
mov    %rdx,%r8
neg    %r8
lea    (%rbx,%rdx,8),%r13
xor    %r15d,%r15d
xorpd  %xmm0,%xmm0
movsd  0x1803(%rip),%xmm1
movabs $0x3ff0000000000000,%rsi
mov    %rdx,%rax
mov    %rdx,0xb0(%rsp)
jmp    184e <svdecomp+0x6fe>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx,%rax,8),%rcx
mov    %rsi,(%rcx,%rax,8)
add    $0x1,%r15d
add    $0x1,%r8
add    $0xfffffffffffffff8,%r13
cmp    $0x1,%r10
jle    1b54 <svdecomp+0xa04>
mov    %rax,%r10
add    $0xffffffffffffffff,%rax
cmp    %rdx,%r10
jge    1830 <svdecomp+0x6e0>
mov    %r8,0x80(%rsp)
mov    %r15d,%esi
and    $0x3,%esi
lea    -0x1(%r15),%ecx
mov    %ecx,(%rsp)
mov    0x28(%rsp),%rcx
movsd  (%rcx,%r10,8),%xmm3
ucomisd %xmm0,%xmm3
jne    1886 <svdecomp+0x736>
jnp    1a90 <svdecomp+0x940>
movapd %xmm1,%xmm2
divsd  %xmm3,%xmm2
mov    (%r14,%rax,8),%rdi
mov    %r10,%rbp
test   $0x1,%r15b
je     18b6 <svdecomp+0x766>
movsd  (%rdi,%r10,8),%xmm3
divsd  %xmm3,%xmm3
mulsd  %xmm2,%xmm3
mov    (%rbx,%r10,8),%rcx
movsd  %xmm3,(%rcx,%rax,8)
lea    0x1(%r10),%rbp
cmp    $0x1,%r15d
mov    0x80(%rsp),%rdx
je     190b <svdecomp+0x7bb>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rbp,8),%xmm3
divsd  (%rdi,%r10,8),%xmm3
mulsd  %xmm2,%xmm3
mov    (%rbx,%rbp,8),%rcx
movsd  %xmm3,(%rcx,%rax,8)
movsd  0x8(%rdi,%rbp,8),%xmm3
divsd  (%rdi,%r10,8),%xmm3
mulsd  %xmm2,%xmm3
mov    0x8(%rbx,%rbp,8),%rcx
movsd  %xmm3,(%rcx,%rax,8)
add    $0x2,%rbp
cmp    %ebp,%r12d
jne    18d0 <svdecomp+0x780>
mov    (%r14,%rax,8),%rbp
lea    0x1(%r10),%rcx
mov    %rcx,0x90(%rsp)
neg    %rdx
mov    %rdx,0x40(%rsp)
lea    0x0(,%r10,8),%r8
add    %rbp,%r8
mov    %r10,%rdi
jmp    194e <svdecomp+0x7fe>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdi
cmp    0x8(%rsp),%edi
je     1a90 <svdecomp+0x940>
xorpd  %xmm2,%xmm2
test   $0x3,%r15b
je     1a70 <svdecomp+0x920>
xor    %r9d,%r9d
nop
movsd  (%r8,%r9,8),%xmm3
mov    0x0(%r13,%r9,8),%rcx
mulsd  (%rcx,%rdi,8),%xmm3
addsd  %xmm3,%xmm2
add    $0x1,%r9
cmp    %r9d,%esi
jne    1960 <svdecomp+0x810>
add    0x40(%rsp),%r9
cmpl   $0x3,(%rsp)
jb     19ed <svdecomp+0x89d>
nopl   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%r9,8),%xmm3
movsd  0x8(%rbp,%r9,8),%xmm4
mov    (%rbx,%r9,8),%rcx
mov    0x8(%rbx,%r9,8),%r11
mulsd  (%rcx,%rdi,8),%xmm3
addsd  %xmm2,%xmm3
mulsd  (%r11,%rdi,8),%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%rbp,%r9,8),%xmm3
mov    0x10(%rbx,%r9,8),%rcx
mulsd  (%rcx,%rdi,8),%xmm3
movsd  0x18(%rbp,%r9,8),%xmm2
mov    0x18(%rbx,%r9,8),%rcx
mulsd  (%rcx,%rdi,8),%xmm2
addsd  %xmm4,%xmm3
addsd  %xmm3,%xmm2
add    $0x4,%r9
cmp    %r9d,%r12d
jne    1990 <svdecomp+0x840>
mov    %r10,%rcx
test   $0x1,%r15b
je     1a15 <svdecomp+0x8c5>
mov    (%rbx,%r10,8),%rcx
movsd  (%rcx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rcx,%rdi,8),%xmm3
movsd  %xmm3,(%rcx,%rdi,8)
mov    0x90(%rsp),%rcx
cmp    $0x1,%r15d
mov    0x50(%rsp),%r11
je     1940 <svdecomp+0x7f0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rbx,%rcx,8),%rdx
movsd  (%rdx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rdx,%rdi,8),%xmm3
movsd  %xmm3,(%rdx,%rdi,8)
mov    0x8(%rbx,%rcx,8),%rdx
movsd  (%rdx,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  (%rdx,%rdi,8),%xmm3
movsd  %xmm3,(%rdx,%rdi,8)
add    $0x2,%rcx
cmp    %ecx,%r12d
jne    1a30 <svdecomp+0x8e0>
jmp    1940 <svdecomp+0x7f0>
nopl   (%rax)
mov    %r10,%r9
cmpl   $0x3,(%rsp)
jae    1990 <svdecomp+0x840>
jmp    19ed <svdecomp+0x89d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rax,8),%rdi
mov    %r10,%rbp
test   $0x3,%r15b
mov    0x38(%rsp),%r9
mov    0x80(%rsp),%r8
je     1ad0 <svdecomp+0x980>
lea    (%rdi,%r10,8),%rcx
xor    %ebp,%ebp
mov    0x0(%r13,%rbp,8),%rdx
movq   $0x0,(%rdx,%rax,8)
movq   $0x0,(%rcx,%rbp,8)
add    $0x1,%rbp
cmp    %ebp,%esi
jne    1ab0 <svdecomp+0x960>
sub    %r8,%rbp
cmpl   $0x3,(%rsp)
mov    0xb0(%rsp),%rdx
movabs $0x3ff0000000000000,%rsi
jb     1830 <svdecomp+0x6e0>
nopl   0x0(%rax)
mov    (%rbx,%rbp,8),%rcx
movq   $0x0,(%rcx,%rax,8)
movq   $0x0,(%rdi,%rbp,8)
mov    0x8(%rbx,%rbp,8),%rcx
movq   $0x0,(%rcx,%rax,8)
movq   $0x0,0x8(%rdi,%rbp,8)
mov    0x10(%rbx,%rbp,8),%rcx
movq   $0x0,(%rcx,%rax,8)
movq   $0x0,0x10(%rdi,%rbp,8)
mov    0x18(%rbx,%rbp,8),%rcx
movq   $0x0,(%rcx,%rax,8)
movq   $0x0,0x18(%rdi,%rbp,8)
add    $0x4,%rbp
cmp    %ebp,%r12d
jne    1af0 <svdecomp+0x9a0>
jmp    1830 <svdecomp+0x6e0>
mov    $0x1,%al
mov    %eax,0x20(%rsp)
mov    0x30(%rsp),%rsi
mov    0x8(%rsp),%r8
lea    -0x1(%r8),%edx
mov    0x78(%rsp),%rcx
lea    -0x1(%rcx),%eax
cmp    %ecx,%r8d
mov    %edx,0xac(%rsp)
cmovl  %edx,%eax
test   %eax,%eax
movapd %xmm5,0xc0(%rsp)
js     1ed1 <svdecomp+0xd81>
lea    0x1(%rax),%edi
mov    0xac(%rsp),%ecx
sub    %edi,%ecx
mov    %rcx,0x60(%rsp)
movslq 0x8(%rsp),%rcx
mov    %rcx,0x40(%rsp)
mov    %eax,%r13d
mov    0x78(%rsp),%rbp
mov    %ebp,%edx
sub    %dil,%dl
lea    (%r14,%r13,8),%r15
sub    %edi,%ebp
add    $0x1,%ebp
xor    %r10d,%r10d
xorpd  %xmm4,%xmm4
movsd  0x1442(%rip),%xmm6
mov    %edi,%r8d
mov    %rdi,0x68(%rsp)
jmp    1c1d <svdecomp+0xacd>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%r13,8),%rax
movsd  (%rax,%r13,8),%xmm0
addsd  %xmm6,%xmm0
movsd  %xmm0,(%rax,%r13,8)
add    $0x1,%r10
add    $0xffffffff,%r8d
add    $0xffffffffffffffff,%r13
add    $0x1,%dl
add    $0xfffffffffffffff8,%r15
add    $0x1,%rbp
cmp    %rdi,%r10
movapd 0xc0(%rsp),%xmm5
je     1ed1 <svdecomp+0xd81>
movsd  (%rsi,%r13,8),%xmm1
lea    0x1(%r13),%eax
mov    %eax,(%rsp)
cmp    0x8(%rsp),%eax
jge    1e30 <svdecomp+0xce0>
mov    0x60(%rsp),%rax
add    %r10d,%eax
mov    %dl,0x80(%rsp)
lea    0x8(,%rax,8),%rdx
mov    %edi,%eax
sub    %r10d,%eax
cltq
mov    (%r14,%r13,8),%rcx
mov    %rcx,0x90(%rsp)
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    %r10,0xb0(%rsp)
mov    %r8d,0x10(%rsp)
movsd  %xmm1,0x70(%rsp)
call   1030 <memset@plt>
movsd  0x70(%rsp),%xmm1
mov    0x10(%rsp),%r8d
movsd  0x1381(%rip),%xmm6
xorpd  %xmm4,%xmm4
mov    0xb0(%rsp),%r10
mov    0x80(%rsp),%dl
mov    0x68(%rsp),%rdi
mov    0x50(%rsp),%r11
mov    0x38(%rsp),%r9
mov    0x30(%rsp),%rsi
ucomisd %xmm4,%xmm1
jne    1cc2 <svdecomp+0xb72>
jnp    1e38 <svdecomp+0xce8>
mov    %r8d,%esi
movzbl %dl,%r8d
and    $0x3,%r8d
shl    $0x3,%r8
mov    %edi,%eax
sub    %r10d,%eax
movslq %eax,%rcx
mov    %r11,%r10
sub    %rcx,%r10
not    %rcx
add    %r11,%rcx
movslq %esi,%r9
movapd %xmm6,%xmm0
divsd  %xmm1,%xmm0
mov    %r9,%rdi
jmp    1d0f <svdecomp+0xbbf>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
cmp    0x40(%rsp),%rdi
jge    1e69 <svdecomp+0xd19>
xorpd  %xmm1,%xmm1
mov    (%rsp),%eax
cmp    0x78(%rsp),%eax
jge    1dc8 <svdecomp+0xc78>
xorpd  %xmm1,%xmm1
test   $0x3,%r10b
je     1e15 <svdecomp+0xcc5>
mov    %r8,%rax
mov    %r9,%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r14,%rsi,8),%rdx
movsd  (%rdx,%r13,8),%xmm2
mulsd  (%rdx,%rdi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rsi
add    $0xfffffffffffffff8,%rax
jne    1d40 <svdecomp+0xbf0>
cmp    $0x3,%rcx
jb     1dc8 <svdecomp+0xc78>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r14,%rsi,8),%rax
mov    0x8(%r14,%rsi,8),%rdx
movsd  (%rax,%r13,8),%xmm2
mulsd  (%rax,%rdi,8),%xmm2
addsd  %xmm1,%xmm2
movsd  (%rdx,%r13,8),%xmm3
mulsd  (%rdx,%rdi,8),%xmm3
addsd  %xmm2,%xmm3
mov    0x10(%r14,%rsi,8),%rax
movsd  (%rax,%r13,8),%xmm2
mulsd  (%rax,%rdi,8),%xmm2
mov    0x18(%r14,%rsi,8),%rax
movsd  (%rax,%r13,8),%xmm1
mulsd  (%rax,%rdi,8),%xmm1
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm1
add    $0x4,%rsi
cmp    %r11,%rsi
jl     1d70 <svdecomp+0xc20>
cmp    %r11,%r13
jge    1d00 <svdecomp+0xbb0>
mov    0x90(%rsp),%rax
divsd  (%rax,%r13,8),%xmm1
mulsd  %xmm0,%xmm1
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rax,8),%rdx
movsd  (%rdx,%r13,8),%xmm2
mulsd  %xmm1,%xmm2
addsd  (%rdx,%rdi,8),%xmm2
movsd  %xmm2,(%rdx,%rdi,8)
add    $0x1,%rax
cmp    %eax,%ebp
jne    1df0 <svdecomp+0xca0>
jmp    1d00 <svdecomp+0xbb0>
mov    %r9,%rsi
cmp    $0x3,%rcx
jae    1d70 <svdecomp+0xc20>
jmp    1dc8 <svdecomp+0xc78>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
ucomisd %xmm4,%xmm1
jne    1e97 <svdecomp+0xd47>
jp     1e97 <svdecomp+0xd47>
cmp    %r11,%r13
jge    1be0 <svdecomp+0xa90>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rax,8),%rcx
movq   $0x0,(%rcx,%r13,8)
add    $0x1,%rax
cmp    %eax,%ebp
jne    1e50 <svdecomp+0xd00>
jmp    1be0 <svdecomp+0xa90>
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%r9
mov    0x68(%rsp),%rdi
mov    0x80(%rsp),%dl
mov    0xb0(%rsp),%r10
mov    0x10(%rsp),%r8d
cmp    %r11,%r13
jge    1be0 <svdecomp+0xa90>
jmp    1ea8 <svdecomp+0xd58>
movapd %xmm6,%xmm0
divsd  %xmm1,%xmm0
cmp    %r11,%r13
jge    1be0 <svdecomp+0xa90>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rax,8),%rcx
movsd  (%rcx,%r13,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%rcx,%r13,8)
add    $0x1,%rax
cmp    %eax,%ebp
jne    1eb0 <svdecomp+0xd60>
jmp    1be0 <svdecomp+0xa90>
cmpb   $0x0,0x20(%rsp)
mov    0x28(%rsp),%r15
je     2702 <svdecomp+0x15b2>
movslq 0x8(%rsp),%rax
lea    -0x1(%rax),%rdi
lea    -0x1(%r12),%rcx
mov    %rcx,0x70(%rsp)
mov    %r12d,%ebp
and    $0xfffffffe,%ebp
and    $0xfffffffe,%r9d
mov    %r9,0x68(%rsp)
mov    %r12d,%r8d
and    $0x3,%r8d
mov    %r12d,%r9d
and    $0xfffffffc,%r9d
movapd 0x1117(%rip),%xmm1
movapd 0x10ff(%rip),%xmm2
movapd 0x10f7(%rip),%xmm6
mov    %r8,0xe0(%rsp)
mov    %r9,0xd8(%rsp)
mov    %rdi,%r10
add    $0xffffffffffffffff,%rdi
movl   $0x0,0x60(%rsp)
mov    %rax,0xe8(%rsp)
mov    %r10d,%edx
mov    %rdi,0x18(%rsp)
mov    %r10,0x10(%rsp)
jmp    1fd0 <svdecomp+0xe80>
movapd %xmm0,%xmm2
mov    0x30(%rsp),%rsi
movapd 0x10b0(%rip),%xmm6
mov    0x20(%rsp),%rax
movq   $0x0,(%r15,%rax,8)
movsd  %xmm3,(%r15,%r10,8)
movsd  %xmm2,(%rsi,%r10,8)
addl   $0x1,0x60(%rsp)
mov    0xe8(%rsp),%rax
mov    %r10d,%edx
movapd 0xc0(%rsp),%xmm5
mov    0x18(%rsp),%rdi
mov    0xe0(%rsp),%r8
mov    0xd8(%rsp),%r9
movapd 0x1071(%rip),%xmm1
movapd 0x1059(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
lea    -0x1(%rax),%ecx
movsd  (%r15,%rcx,8),%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm5
jae    200a <svdecomp+0xeba>
movsd  -0x10(%rsi,%rax,8),%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm5
jae    2018 <svdecomp+0xec8>
add    $0xffffffff,%edx
add    $0xffffffffffffffff,%rax
jg     1fd0 <svdecomp+0xe80>
mov    $0xffffffff,%edx
mov    $0xffffffffffffffff,%rax
jmp    201c <svdecomp+0xecc>
movsd  0xffd(%rip),%xmm8
jmp    2199 <svdecomp+0x1049>
add    $0xfffffffffffffffe,%rax
mov    %edx,0x8(%rsp)
movslq %edx,%r13
cmp    %r13,%r10
movsd  0xfe1(%rip),%xmm8
jge    204b <svdecomp+0xefb>
mov    0x18(%rsp),%rdi
mov    0xe0(%rsp),%r8
mov    0xd8(%rsp),%r9
jmp    2195 <svdecomp+0x1045>
movslq %eax,%r15
xorpd  %xmm7,%xmm7
movapd %xmm8,%xmm4
jmp    208e <svdecomp+0xf3e>
nopl   0x0(%rax)
lea    0x1(%r13),%rax
mov    0x10(%rsp),%r10
cmp    %r10,%r13
mov    %rax,%r13
movapd 0xc0(%rsp),%xmm5
movapd 0xfb0(%rip),%xmm1
movapd 0xf98(%rip),%xmm6
jge    216a <svdecomp+0x101a>
mov    0x28(%rsp),%rax
movsd  (%rax,%r13,8),%xmm0
mulsd  %xmm0,%xmm7
movsd  %xmm7,(%rax,%r13,8)
mulsd  %xmm0,%xmm4
movapd %xmm4,%xmm0
andpd  %xmm1,%xmm0
ucomisd %xmm0,%xmm5
jae    216a <svdecomp+0x101a>
movsd  (%rsi,%r13,8),%xmm1
movsd  %xmm1,(%rsp)
movapd %xmm4,%xmm0
movapd %xmm4,0x50(%rsp)
call   1040 <pythag@plt>
movsd  (%rsp),%xmm7
movapd 0x50(%rsp),%xmm4
mov    0x38(%rsp),%rdx
mov    0x30(%rsp),%rsi
movsd  %xmm0,(%rsi,%r13,8)
movsd  0xf1a(%rip),%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm7
xorpd  0xf1a(%rip),%xmm4
mulsd  %xmm1,%xmm4
cmpl   $0x0,0x78(%rsp)
jle    2060 <svdecomp+0xf10>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rax,8),%rcx
movsd  (%rcx,%r15,8),%xmm0
movsd  (%rcx,%r13,8),%xmm1
movapd %xmm4,%xmm2
mulsd  %xmm1,%xmm2
movapd %xmm4,%xmm3
mulsd  %xmm0,%xmm3
mulsd  %xmm7,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx,%r15,8)
mulsd  %xmm7,%xmm1
subsd  %xmm3,%xmm1
movsd  %xmm1,(%rcx,%r13,8)
add    $0x1,%rax
cmp    %rax,%rdx
jne    2120 <svdecomp+0xfd0>
jmp    2060 <svdecomp+0xf10>
mov    0x28(%rsp),%r15
mov    0x18(%rsp),%rdi
mov    0xe0(%rsp),%r8
mov    0xd8(%rsp),%r9
movsd  0xe83(%rip),%xmm8
movapd 0xe8b(%rip),%xmm2
mov    0x8(%rsp),%edx
movsd  (%rsi,%r10,8),%xmm3
mov    %edx,%eax
cmp    %rax,%r10
je     2630 <svdecomp+0x14e0>
cmpl   $0x1e,0x60(%rsp)
je     2706 <svdecomp+0x15b6>
movslq %edx,%r13
movsd  (%rsi,%r13,8),%xmm0
movsd  %xmm0,0x8(%rsp)
movsd  (%rsi,%rdi,8),%xmm6
movsd  (%r15,%rdi,8),%xmm0
movsd  (%r15,%r10,8),%xmm4
movsd  %xmm4,(%rsp)
movapd %xmm8,%xmm1
movapd %xmm6,%xmm5
subsd  %xmm3,%xmm5
movapd %xmm3,%xmm2
addsd  %xmm6,%xmm2
movapd %xmm6,0x50(%rsp)
mulsd  %xmm5,%xmm2
movapd %xmm0,%xmm5
subsd  %xmm4,%xmm5
addsd  %xmm4,%xmm0
mulsd  %xmm5,%xmm0
addsd  %xmm2,%xmm0
movapd %xmm4,%xmm2
addsd  %xmm4,%xmm2
mulsd  %xmm6,%xmm2
divsd  %xmm2,%xmm0
movsd  %xmm0,0x90(%rsp)
movapd %xmm3,0x40(%rsp)
call   1040 <pythag@plt>
movapd 0x50(%rsp),%xmm3
mov    0x10(%rsp),%r10
movsd  0x90(%rsp),%xmm5
movapd %xmm5,%xmm1
cmpltsd 0xdc6(%rip),%xmm1
movapd %xmm1,%xmm2
andnpd %xmm0,%xmm2
xorpd  0xdbe(%rip),%xmm0
andpd  %xmm1,%xmm0
orpd   %xmm2,%xmm0
movsd  0x8(%rsp),%xmm2
movapd %xmm2,%xmm1
movapd 0x40(%rsp),%xmm4
subsd  %xmm4,%xmm1
addsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm5,%xmm0
divsd  %xmm0,%xmm3
movapd %xmm2,%xmm0
movsd  (%rsp),%xmm1
subsd  %xmm1,%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
divsd  %xmm2,%xmm3
cmp    %r13,%r10
mov    %r13,0x20(%rsp)
jle    1f5f <svdecomp+0xe0f>
mov    %r13,%rax
movsd  0xd50(%rip),%xmm1
movapd %xmm1,%xmm7
mov    0x30(%rsp),%rsi
jmp    2325 <svdecomp+0x11d5>
nopl   0x0(%rax,%rax,1)
movapd 0x90(%rsp),%xmm0
mulsd  0x8(%rsp),%xmm0
movsd  (%rsp),%xmm4
mulsd  %xmm8,%xmm4
subsd  %xmm0,%xmm4
movsd  0x40(%rsp),%xmm2
mulsd  %xmm8,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm7,%xmm0
movapd %xmm1,%xmm3
mulsd  %xmm4,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm7,%xmm4
mulsd  %xmm1,%xmm2
subsd  %xmm4,%xmm2
movapd %xmm2,%xmm0
cmp    %r10,%rax
jge    1f70 <svdecomp+0xe20>
movsd  %xmm1,(%rsp)
movsd  %xmm0,0x8(%rsp)
movapd %xmm3,0x50(%rsp)
mov    %rax,%r13
movsd  0x8(%r15,%rax,8),%xmm1
movsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,0x40(%rsp)
movsd  %xmm1,0x90(%rsp)
mulsd  %xmm1,%xmm7
movapd %xmm7,0x80(%rsp)
movapd %xmm3,%xmm0
movapd %xmm7,%xmm1
call   1040 <pythag@plt>
movapd 0x50(%rsp),%xmm6
movsd  %xmm0,(%r15,%r13,8)
unpcklpd 0x80(%rsp),%xmm6
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm6
movapd %xmm6,%xmm7
unpckhpd %xmm6,%xmm7
movapd %xmm6,%xmm0
unpcklpd %xmm6,%xmm0
cmpq   $0x0,0x70(%rsp)
je     2550 <svdecomp+0x1400>
xor    %eax,%eax
movapd 0xc6e(%rip),%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rax,8),%rcx
movupd (%rcx,%r13,8),%xmm1
movapd %xmm1,%xmm2
xorpd  %xmm5,%xmm2
movapd %xmm1,%xmm3
shufpd $0x1,%xmm2,%xmm3
movapd %xmm7,%xmm2
shufpd $0x1,%xmm7,%xmm2
mulpd  %xmm2,%xmm3
mulpd  %xmm0,%xmm1
addpd  %xmm3,%xmm1
movupd %xmm1,(%rcx,%r13,8)
mov    0x8(%rbx,%rax,8),%rcx
movupd (%rcx,%r13,8),%xmm1
movapd %xmm1,%xmm3
xorpd  %xmm5,%xmm3
movapd %xmm1,%xmm4
shufpd $0x1,%xmm3,%xmm4
mulpd  %xmm2,%xmm4
mulpd  %xmm0,%xmm1
addpd  %xmm4,%xmm1
movupd %xmm1,(%rcx,%r13,8)
add    $0x2,%rax
cmp    %rax,%rbp
jne    23c0 <svdecomp+0x1270>
test   $0x1,%r12b
je     2460 <svdecomp+0x1310>
mov    (%rbx,%rax,8),%rax
movupd (%rax,%r13,8),%xmm1
movapd %xmm1,%xmm2
mulpd  %xmm1,%xmm0
xorpd  0xbd3(%rip),%xmm1
shufpd $0x1,%xmm1,%xmm2
mulpd  %xmm7,%xmm2
addpd  %xmm2,%xmm0
movupd %xmm0,(%rax,%r13,8)
movsd  (%rsp),%xmm0
mulsd  0x90(%rsp),%xmm0
movsd  %xmm0,(%rsp)
movapd %xmm0,%xmm1
mulsd  %xmm7,%xmm1
movsd  0x8(%rsp),%xmm0
mulsd  %xmm6,%xmm0
addsd  %xmm1,%xmm0
movsd  0x40(%rsp),%xmm1
movapd %xmm7,0x90(%rsp)
mulsd  %xmm7,%xmm1
movapd %xmm0,0x80(%rsp)
movapd %xmm1,0xb0(%rsp)
movapd %xmm6,0x50(%rsp)
call   1040 <pythag@plt>
movapd 0x50(%rsp),%xmm8
mov    0x30(%rsp),%rsi
movsd  %xmm0,(%rsi,%r13,8)
ucomisd 0xb45(%rip),%xmm0
movapd %xmm8,%xmm1
jne    24dc <svdecomp+0x138c>
jnp    2502 <svdecomp+0x13b2>
movsd  0xb2c(%rip),%xmm1
divsd  %xmm0,%xmm1
movapd 0x80(%rsp),%xmm0
unpcklpd 0xb0(%rsp),%xmm0
unpcklpd %xmm1,%xmm1
mulpd  %xmm0,%xmm1
lea    0x1(%r13),%rax
movapd %xmm1,%xmm7
unpckhpd %xmm1,%xmm7
cmpl   $0x0,0x78(%rsp)
mov    0x38(%rsp),%r8
mov    0x68(%rsp),%rdi
movapd 0xafb(%rip),%xmm6
mov    0x10(%rsp),%r10
jle    22d0 <svdecomp+0x1180>
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
cmpl   $0x1,0x78(%rsp)
jne    2570 <svdecomp+0x1420>
xor    %ecx,%ecx
jmp    25ed <svdecomp+0x149d>
cs nopw 0x0(%rax,%rax,1)
xor    %eax,%eax
test   $0x1,%r12b
jne    2433 <svdecomp+0x12e3>
jmp    2460 <svdecomp+0x1310>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r14,%rcx,8),%rdx
movupd (%rdx,%r13,8),%xmm2
movapd %xmm2,%xmm3
xorpd  %xmm6,%xmm3
movapd %xmm2,%xmm4
shufpd $0x1,%xmm3,%xmm4
movapd %xmm7,%xmm3
shufpd $0x1,%xmm7,%xmm3
mulpd  %xmm3,%xmm4
mulpd  %xmm0,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm2,(%rdx,%r13,8)
mov    0x8(%r14,%rcx,8),%rdx
movupd (%rdx,%r13,8),%xmm2
movapd %xmm2,%xmm4
xorpd  %xmm6,%xmm4
movapd %xmm2,%xmm5
shufpd $0x1,%xmm4,%xmm5
mulpd  %xmm3,%xmm5
mulpd  %xmm0,%xmm2
addpd  %xmm5,%xmm2
movupd %xmm2,(%rdx,%r13,8)
add    $0x2,%rcx
cmp    %rcx,%rdi
jne    2580 <svdecomp+0x1430>
test   $0x1,%r8b
je     22d0 <svdecomp+0x1180>
mov    (%r14,%rcx,8),%rcx
movupd (%rcx,%r13,8),%xmm2
movapd %xmm2,%xmm3
mulpd  %xmm2,%xmm0
xorpd  0xa0f(%rip),%xmm2
shufpd $0x1,%xmm2,%xmm3
mulpd  %xmm7,%xmm3
addpd  %xmm3,%xmm0
movupd %xmm0,(%rcx,%r13,8)
jmp    22d0 <svdecomp+0x1180>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
ucomisd %xmm3,%xmm0
jbe    26ed <svdecomp+0x159d>
xorpd  %xmm2,%xmm3
movlpd %xmm3,(%rsi,%r10,8)
cmpq   $0x3,0x70(%rsp)
jae    2654 <svdecomp+0x1504>
xor    %eax,%eax
jmp    26bc <svdecomp+0x156c>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
xorpd  %xmm6,%xmm0
movlpd %xmm0,(%rcx,%r10,8)
mov    0x8(%rbx,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
xorpd  %xmm6,%xmm0
movlpd %xmm0,(%rcx,%r10,8)
mov    0x10(%rbx,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
xorpd  %xmm6,%xmm0
movlpd %xmm0,(%rcx,%r10,8)
mov    0x18(%rbx,%rax,8),%rcx
movsd  (%rcx,%r10,8),%xmm0
xorpd  %xmm6,%xmm0
movlpd %xmm0,(%rcx,%r10,8)
add    $0x4,%rax
cmp    %rax,%r9
jne    2660 <svdecomp+0x1510>
test   %r8,%r8
je     26ed <svdecomp+0x159d>
lea    (%rbx,%rax,8),%rax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rcx,8),%rdx
movsd  (%rdx,%r10,8),%xmm0
xorpd  %xmm2,%xmm0
movlpd %xmm0,(%rdx,%r10,8)
add    $0x1,%rcx
cmp    %rcx,%r8
jne    26d0 <svdecomp+0x1580>
mov    0xe8(%rsp),%rax
add    $0xffffffffffffffff,%rax
test   %r10,%r10
jg     1f39 <svdecomp+0xde9>
xor    %ebx,%ebx
jmp    270b <svdecomp+0x15bb>
mov    $0x1,%ebx
lea    0xf0(%rsp),%rax
cmp    %rax,%r15
je     2729 <svdecomp+0x15d9>
mov    %r15,%rdi
xor    %esi,%esi
mov    0xac(%rsp),%edx
call   1060 <free_dvector@plt>
mov    %ebx,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @svdecomp(double** nocapture %0, double* nocapture %1, double** nocapture %2, i32 %3, i32 %4) {
%6 = alloca [10 x double]
%7 = bitcast [10 x double]* %6 to i8*
%8 = icmp slt i32 %4, 11
br i1 %8, label %12, label %9
9: ; preds = %5
%10 = add nsw i32 %4, -1
%11 = tail call double* @dvector(i32 0, i32 %10)
store double 0.000000e+00, double* %11
br label %15
12: ; preds = %5
%13 = getelementptr inbounds [10 x double], [10 x double]* %6, i64 0, i64 0
store double 0.000000e+00, double* %13
%14 = icmp sgt i32 %4, 0
br i1 %14, label %15, label %480
15: ; preds = %9, %12
%16 = phi double* [ %11, %9 ], [ %13, %12 ]
%17 = sext i32 %3 to i64
%18 = zext i32 %4 to i64
%19 = zext i32 %4 to i64
%20 = zext i32 %3 to i64
%21 = zext i32 %3 to i64
%22 = zext i32 %3 to i64
%23 = sub nsw i64 0, %19
br label %24
24: ; preds = %15, %260
%25 = phi i64 [ 1, %15 ], [ %269, %260 ]
%26 = phi i64 [ 0, %15 ], [ %35, %260 ]
%27 = phi double [ 0.000000e+00, %15 ], [ %268, %260 ]
%28 = xor i64 %26, -1
%29 = add nsw i64 %28, %19
%30 = add i64 %29, -4
%31 = lshr i64 %30, 2
%32 = add nuw nsw i64 %31, 1
%33 = xor i64 %26, -1
%34 = add nsw i64 %33, %19
%35 = add nuw nsw i64 %26, 1
%36 = getelementptr inbounds double, double* %1, i64 %26
store double 0.000000e+00, double* %36
%37 = icmp slt i64 %26, %17
br i1 %37, label %38, label %94
38: ; preds = %24, %38
%39 = phi i64 [ %41, %38 ], [ %17, %24 ]
%40 = phi double [ %46, %38 ], [ 0.000000e+00, %24 ]
%41 = add nsw i64 %39, -1
%42 = getelementptr inbounds double*, double** %0, i64 %41
%43 = load double*, double** %42
%44 = getelementptr inbounds double, double* %43, i64 %26
%45 = load double, double* %44
%46 = tail call double @llvm.fmuladd.f64(double %45, double %45, double %40)
%47 = icmp sgt i64 %41, %26
br i1 %47, label %38, label %48
48: ; preds = %38
%49 = fcmp ult double %46, 0x350000000000000
br i1 %49, label %92, label %50
50: ; preds = %48
%51 = tail call double @sqrt(double %46)
%52 = fcmp olt double %45, 0.000000e+00
%53 = fneg double %51
%54 = select i1 %52, double %51, double %53
store double %54, double* %36
%55 = fneg double %46
%56 = tail call double @llvm.fmuladd.f64(double %45, double %54, double %55)
%57 = fsub double %45, %54
%58 = getelementptr inbounds double*, double** %0, i64 %26
%59 = load double*, double** %58
%60 = getelementptr inbounds double, double* %59, i64 %26
store double %57, double* %60
%61 = icmp ult i64 %35, %18
br i1 %61, label %62, label %92
62: ; preds = %50, %89
%63 = phi i64 [ %90, %89 ], [ %25, %50 ]
br label %64
64: ; preds = %62, %64
%65 = phi i64 [ %26, %62 ], [ %74, %64 ]
%66 = phi double [ 0.000000e+00, %62 ], [ %73, %64 ]
%67 = getelementptr inbounds double*, double** %0, i64 %65
%68 = load double*, double** %67
%69 = getelementptr inbounds double, double* %68, i64 %63
%70 = load double, double* %69
%71 = getelementptr inbounds double, double* %68, i64 %26
%72 = load double, double* %71
%73 = tail call double @llvm.fmuladd.f64(double %70, double %72, double %66)
%74 = add nuw nsw i64 %65, 1
%75 = icmp eq i64 %74, %20
br i1 %75, label %76, label %64
76: ; preds = %64
%77 = fdiv double %73, %56
br label %78
78: ; preds = %76, %78
%79 = phi i64 [ %26, %76 ], [ %87, %78 ]
%80 = getelementptr inbounds double*, double** %0, i64 %79
%81 = load double*, double** %80
%82 = getelementptr inbounds double, double* %81, i64 %26
%83 = load double, double* %82
%84 = getelementptr inbounds double, double* %81, i64 %63
%85 = load double, double* %84
%86 = tail call double @llvm.fmuladd.f64(double %77, double %83, double %85)
store double %86, double* %84
%87 = add nuw nsw i64 %79, 1
%88 = icmp eq i64 %87, %21
br i1 %88, label %89, label %78
89: ; preds = %78
%90 = add nuw nsw i64 %63, 1
%91 = icmp eq i64 %90, %19
br i1 %91, label %92, label %62
92: ; preds = %89, %50, %48
%93 = icmp ult i64 %35, %18
br i1 %93, label %98, label %260
94: ; preds = %24
%95 = icmp ult i64 %35, %18
br i1 %95, label %96, label %260
96: ; preds = %94
%97 = getelementptr inbounds double, double* %16, i64 %35
store double 0.000000e+00, double* %97
br label %260
98: ; preds = %92
%99 = getelementptr inbounds double, double* %16, i64 %35
store double 0.000000e+00, double* %99
%100 = getelementptr inbounds double*, double** %0, i64 %26
%101 = load double*, double** %100
br label %102
102: ; preds = %98, %102
%103 = phi i64 [ %18, %98 ], [ %105, %102 ]
%104 = phi double [ 0.000000e+00, %98 ], [ %108, %102 ]
%105 = add nsw i64 %103, -1
%106 = getelementptr inbounds double, double* %101, i64 %105
%107 = load double, double* %106
%108 = tail call double @llvm.fmuladd.f64(double %107, double %107, double %104)
%109 = icmp sgt i64 %105, %35
br i1 %109, label %102, label %110
110: ; preds = %102
%111 = fcmp ult double %108, 0x350000000000000
br i1 %111, label %260, label %112
112: ; preds = %110
%113 = tail call double @sqrt(double %108)
%114 = fcmp olt double %107, 0.000000e+00
%115 = fneg double %113
%116 = select i1 %114, double %113, double %115
store double %116, double* %99
%117 = fneg double %108
%118 = tail call double @llvm.fmuladd.f64(double %107, double %116, double %117)
%119 = fsub double %107, %116
%120 = getelementptr inbounds double*, double** %0, i64 %26
%121 = load double*, double** %120
%122 = getelementptr inbounds double, double* %121, i64 %35
store double %119, double* %122
%123 = icmp slt i64 %35, %17
br i1 %123, label %124, label %260
124: ; preds = %112
%125 = getelementptr double, double* %121, i64 %25
%126 = getelementptr double, double* %121, i64 %19
%127 = icmp ult i64 %34, 4
%128 = and i64 %34, -4
%129 = add i64 %25, %128
%130 = and i64 %32, 1
%131 = icmp ult i64 %30, 4
%132 = and i64 %32, 9223372036854775806
%133 = icmp eq i64 %130, 0
%134 = icmp eq i64 %34, %128
br label %135
135: ; preds = %124, %257
%136 = phi i64 [ %258, %257 ], [ %25, %124 ]
%137 = getelementptr inbounds double*, double** %0, i64 %136
%138 = load double*, double** %137
br label %139
139: ; preds = %135, %139
%140 = phi i64 [ %25, %135 ], [ %147, %139 ]
%141 = phi double [ 0.000000e+00, %135 ], [ %146, %139 ]
%142 = getelementptr inbounds double, double* %138, i64 %140
%143 = load double, double* %142
%144 = getelementptr inbounds double, double* %121, i64 %140
%145 = load double, double* %144
%146 = tail call double @llvm.fmuladd.f64(double %143, double %145, double %141)
%147 = add nuw nsw i64 %140, 1
%148 = icmp eq i64 %147, %19
br i1 %148, label %149, label %139
149: ; preds = %139
%150 = fdiv double %146, %118
%151 = getelementptr inbounds double*, double** %0, i64 %136
%152 = load double*, double** %151
br i1 %127, label %226, label %153
153: ; preds = %149
%154 = getelementptr double, double* %152, i64 %25
%155 = getelementptr double, double* %152, i64 %19
%156 = icmp ult double* %154, %126
%157 = icmp ult double* %125, %155
%158 = and i1 %156, %157
br i1 %158, label %226, label %159
159: ; preds = %153
%160 = insertelement <2 x double> poison, double %150, i64 0
%161 = shufflevector <2 x double> %160, <2 x double> poison, <2 x i32> zeroinitializer
%162 = insertelement <2 x double> poison, double %150, i64 0
%163 = shufflevector <2 x double> %162, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %131, label %205, label %164
164: ; preds = %159, %164
%165 = phi i64 [ %202, %164 ], [ 0, %159 ]
%166 = phi i64 [ %203, %164 ], [ 0, %159 ]
%167 = add i64 %25, %165
%168 = getelementptr inbounds double, double* %121, i64 %167
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = getelementptr inbounds double, double* %168, i64 2
%172 = bitcast double* %171 to <2 x double>*
%173 = load <2 x double>, <2 x double>* %172
%174 = getelementptr inbounds double, double* %152, i64 %167
%175 = bitcast double* %174 to <2 x double>*
%176 = load <2 x double>, <2 x double>* %175
%177 = getelementptr inbounds double, double* %174, i64 2
%178 = bitcast double* %177 to <2 x double>*
%179 = load <2 x double>, <2 x double>* %178
%180 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %161, <2 x double> %170, <2 x double> %176)
%181 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %163, <2 x double> %173, <2 x double> %179)
%182 = bitcast double* %174 to <2 x double>*
store <2 x double> %180, <2 x double>* %182
%183 = bitcast double* %177 to <2 x double>*
store <2 x double> %181, <2 x double>* %183
%184 = or i64 %165, 4
%185 = add i64 %25, %184
%186 = getelementptr inbounds double, double* %121, i64 %185
%187 = bitcast double* %186 to <2 x double>*
%188 = load <2 x double>, <2 x double>* %187
%189 = getelementptr inbounds double, double* %186, i64 2
%190 = bitcast double* %189 to <2 x double>*
%191 = load <2 x double>, <2 x double>* %190
%192 = getelementptr inbounds double, double* %152, i64 %185
%193 = bitcast double* %192 to <2 x double>*
%194 = load <2 x double>, <2 x double>* %193
%195 = getelementptr inbounds double, double* %192, i64 2
%196 = bitcast double* %195 to <2 x double>*
%197 = load <2 x double>, <2 x double>* %196
%198 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %161, <2 x double> %188, <2 x double> %194)
%199 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %163, <2 x double> %191, <2 x double> %197)
%200 = bitcast double* %192 to <2 x double>*
store <2 x double> %198, <2 x double>* %200
%201 = bitcast double* %195 to <2 x double>*
store <2 x double> %199, <2 x double>* %201
%202 = add nuw i64 %165, 8
%203 = add i64 %166, 2
%204 = icmp eq i64 %203, %132
br i1 %204, label %205, label %164
205: ; preds = %164, %159
%206 = phi i64 [ 0, %159 ], [ %202, %164 ]
br i1 %133, label %225, label %207
207: ; preds = %205
%208 = add i64 %25, %206
%209 = getelementptr inbounds double, double* %121, i64 %208
%210 = bitcast double* %209 to <2 x double>*
%211 = load <2 x double>, <2 x double>* %210
%212 = getelementptr inbounds double, double* %209, i64 2
%213 = bitcast double* %212 to <2 x double>*
%214 = load <2 x double>, <2 x double>* %213
%215 = getelementptr inbounds double, double* %152, i64 %208
%216 = bitcast double* %215 to <2 x double>*
%217 = load <2 x double>, <2 x double>* %216
%218 = getelementptr inbounds double, double* %215, i64 2
%219 = bitcast double* %218 to <2 x double>*
%220 = load <2 x double>, <2 x double>* %219
%221 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %161, <2 x double> %211, <2 x double> %217)
%222 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %163, <2 x double> %214, <2 x double> %220)
%223 = bitcast double* %215 to <2 x double>*
store <2 x double> %221, <2 x double>* %223
%224 = bitcast double* %218 to <2 x double>*
store <2 x double> %222, <2 x double>* %224
br label %225
225: ; preds = %205, %207
br i1 %134, label %257, label %226
226: ; preds = %153, %149, %225
%227 = phi i64 [ %25, %153 ], [ %25, %149 ], [ %129, %225 ]
%228 = sub i64 %19, %227
%229 = xor i64 %227, -1
%230 = and i64 %228, 1
%231 = icmp eq i64 %230, 0
br i1 %231, label %239, label %232
232: ; preds = %226
%233 = getelementptr inbounds double, double* %121, i64 %227
%234 = load double, double* %233
%235 = getelementptr inbounds double, double* %152, i64 %227
%236 = load double, double* %235
%237 = tail call double @llvm.fmuladd.f64(double %150, double %234, double %236)
store double %237, double* %235
%238 = add nuw nsw i64 %227, 1
br label %239
239: ; preds = %232, %226
%240 = phi i64 [ %227, %226 ], [ %238, %232 ]
%241 = icmp eq i64 %229, %23
br i1 %241, label %257, label %242
242: ; preds = %239, %242
%243 = phi i64 [ %255, %242 ], [ %240, %239 ]
%244 = getelementptr inbounds double, double* %121, i64 %243
%245 = load double, double* %244
%246 = getelementptr inbounds double, double* %152, i64 %243
%247 = load double, double* %246
%248 = tail call double @llvm.fmuladd.f64(double %150, double %245, double %247)
store double %248, double* %246
%249 = add nuw nsw i64 %243, 1
%250 = getelementptr inbounds double, double* %121, i64 %249
%251 = load double, double* %250
%252 = getelementptr inbounds double, double* %152, i64 %249
%253 = load double, double* %252
%254 = tail call double @llvm.fmuladd.f64(double %150, double %251, double %253)
store double %254, double* %252
%255 = add nuw nsw i64 %243, 2
%256 = icmp eq i64 %255, %19
br i1 %256, label %257, label %242
257: ; preds = %239, %242, %225
%258 = add nuw nsw i64 %136, 1
%259 = icmp eq i64 %258, %22
br i1 %259, label %260, label %135
260: ; preds = %257, %112, %96, %94, %110, %92
%261 = load double, double* %36
%262 = tail call double @llvm.fabs.f64(double %261)
%263 = getelementptr inbounds double, double* %16, i64 %26
%264 = load double, double* %263
%265 = tail call double @llvm.fabs.f64(double %264)
%266 = fadd double %262, %265
%267 = fcmp ogt double %266, %27
%268 = select i1 %267, double %266, double %27
%269 = add nuw nsw i64 %25, 1
%270 = icmp eq i64 %35, %19
br i1 %270, label %271, label %24
271: ; preds = %260
%272 = fmul double %268, 0x3CB0000000000000
%273 = sext i32 %4 to i64
br label %274
274: ; preds = %271, %473
%275 = phi i32 [ 0, %271 ], [ %479, %473 ]
%276 = phi i64 [ %273, %271 ], [ %280, %473 ]
%277 = phi i64 [ %273, %271 ], [ %478, %473 ]
%278 = add i32 %275, -1
%279 = add i32 %275, -1
%280 = add nsw i64 %276, -1
%281 = icmp slt i64 %276, %273
br i1 %281, label %282, label %473
282: ; preds = %274
%283 = getelementptr inbounds double, double* %16, i64 %276
%284 = load double, double* %283
%285 = fcmp une double %284, 0.000000e+00
br i1 %285, label %286, label %431
286: ; preds = %282
%287 = fdiv double 1.000000e+00, %284
%288 = getelementptr inbounds double*, double** %0, i64 %280
%289 = load double*, double** %288
%290 = getelementptr inbounds double, double* %289, i64 %276
%291 = and i32 %275, 1
%292 = icmp eq i32 %291, 0
br i1 %292, label %303, label %293
293: ; preds = %286
%294 = getelementptr inbounds double, double* %289, i64 %277
%295 = load double, double* %294
%296 = load double, double* %290
%297 = fdiv double %295, %296
%298 = fmul double %287, %297
%299 = getelementptr inbounds double*, double** %2, i64 %277
%300 = load double*, double** %299
%301 = getelementptr inbounds double, double* %300, i64 %280
store double %298, double* %301
%302 = add nsw i64 %277, 1
br label %303
303: ; preds = %293, %286
%304 = phi i64 [ %277, %286 ], [ %302, %293 ]
%305 = icmp eq i32 %275, 1
br i1 %305, label %306, label %317
306: ; preds = %317, %303
%307 = getelementptr inbounds double*, double** %0, i64 %280
%308 = load double*, double** %307
%309 = and i32 %275, 3
%310 = icmp eq i32 %309, 0
%311 = icmp ult i32 %279, 3
%312 = and i32 %275, 1
%313 = icmp eq i32 %312, 0
%314 = getelementptr inbounds double*, double** %2, i64 %277
%315 = add nsw i64 %277, 1
%316 = icmp eq i32 %275, 1
br label %339
317: ; preds = %303, %317
%318 = phi i64 [ %336, %317 ], [ %304, %303 ]
%319 = getelementptr inbounds double, double* %289, i64 %318
%320 = load double, double* %319
%321 = load double, double* %290
%322 = fdiv double %320, %321
%323 = fmul double %287, %322
%324 = getelementptr inbounds double*, double** %2, i64 %318
%325 = load double*, double** %324
%326 = getelementptr inbounds double, double* %325, i64 %280
store double %323, double* %326
%327 = add nsw i64 %318, 1
%328 = getelementptr inbounds double, double* %289, i64 %327
%329 = load double, double* %328
%330 = load double, double* %290
%331 = fdiv double %329, %330
%332 = fmul double %287, %331
%333 = getelementptr inbounds double*, double** %2, i64 %327
%334 = load double*, double** %333
%335 = getelementptr inbounds double, double* %334, i64 %280
store double %332, double* %335
%336 = add nsw i64 %318, 2
%337 = trunc i64 %336 to i32
%338 = icmp eq i32 %337, %4
br i1 %338, label %306, label %317
339: ; preds = %427, %306
%340 = phi i64 [ %277, %306 ], [ %428, %427 ]
br i1 %310, label %355, label %341
341: ; preds = %339, %341
%342 = phi i64 [ %352, %341 ], [ %277, %339 ]
%343 = phi double [ %351, %341 ], [ 0.000000e+00, %339 ]
%344 = phi i32 [ %353, %341 ], [ 0, %339 ]
%345 = getelementptr inbounds double, double* %308, i64 %342
%346 = load double, double* %345
%347 = getelementptr inbounds double*, double** %2, i64 %342
%348 = load double*, double** %347
%349 = getelementptr inbounds double, double* %348, i64 %340
%350 = load double, double* %349
%351 = tail call double @llvm.fmuladd.f64(double %346, double %350, double %343)
%352 = add nsw i64 %342, 1
%353 = add i32 %344, 1
%354 = icmp eq i32 %353, %309
br i1 %354, label %355, label %341
355: ; preds = %341, %339
%356 = phi double [ undef, %339 ], [ %351, %341 ]
%357 = phi i64 [ %277, %339 ], [ %352, %341 ]
%358 = phi double [ 0.000000e+00, %339 ], [ %351, %341 ]
br i1 %311, label %396, label %359
359: ; preds = %355, %359
%360 = phi i64 [ %393, %359 ], [ %357, %355 ]
%361 = phi double [ %392, %359 ], [ %358, %355 ]
%362 = getelementptr inbounds double, double* %308, i64 %360
%363 = load double, double* %362
%364 = getelementptr inbounds double*, double** %2, i64 %360
%365 = load double*, double** %364
%366 = getelementptr inbounds double, double* %365, i64 %340
%367 = load double, double* %366
%368 = tail call double @llvm.fmuladd.f64(double %363, double %367, double %361)
%369 = add nsw i64 %360, 1
%370 = getelementptr inbounds double, double* %308, i64 %369
%371 = load double, double* %370
%372 = getelementptr inbounds double*, double** %2, i64 %369
%373 = load double*, double** %372
%374 = getelementptr inbounds double, double* %373, i64 %340
%375 = load double, double* %374
%376 = tail call double @llvm.fmuladd.f64(double %371, double %375, double %368)
%377 = add nsw i64 %360, 2
%378 = getelementptr inbounds double, double* %308, i64 %377
%379 = load double, double* %378
%380 = getelementptr inbounds double*, double** %2, i64 %377
%381 = load double*, double** %380
%382 = getelementptr inbounds double, double* %381, i64 %340
%383 = load double, double* %382
%384 = tail call double @llvm.fmuladd.f64(double %379, double %383, double %376)
%385 = add nsw i64 %360, 3
%386 = getelementptr inbounds double, double* %308, i64 %385
%387 = load double, double* %386
%388 = getelementptr inbounds double*, double** %2, i64 %385
%389 = load double*, double** %388
%390 = getelementptr inbounds double, double* %389, i64 %340
%391 = load double, double* %390
%392 = tail call double @llvm.fmuladd.f64(double %387, double %391, double %384)
%393 = add nsw i64 %360, 4
%394 = trunc i64 %393 to i32
%395 = icmp eq i32 %394, %4
br i1 %395, label %396, label %359
396: ; preds = %359, %355
%397 = phi double [ %356, %355 ], [ %392, %359 ]
br i1 %313, label %405, label %398
398: ; preds = %396
%399 = load double*, double** %314
%400 = getelementptr inbounds double, double* %399, i64 %280
%401 = load double, double* %400
%402 = getelementptr inbounds double, double* %399, i64 %340
%403 = load double, double* %402
%404 = tail call double @llvm.fmuladd.f64(double %397, double %401, double %403)
store double %404, double* %402
br label %405
405: ; preds = %398, %396
%406 = phi i64 [ %277, %396 ], [ %315, %398 ]
br i1 %316, label %427, label %407
407: ; preds = %405, %407
%408 = phi i64 [ %424, %407 ], [ %406, %405 ]
%409 = getelementptr inbounds double*, double** %2, i64 %408
%410 = load double*, double** %409
%411 = getelementptr inbounds double, double* %410, i64 %280
%412 = load double, double* %411
%413 = getelementptr inbounds double, double* %410, i64 %340
%414 = load double, double* %413
%415 = tail call double @llvm.fmuladd.f64(double %397, double %412, double %414)
store double %415, double* %413
%416 = add nsw i64 %408, 1
%417 = getelementptr inbounds double*, double** %2, i64 %416
%418 = load double*, double** %417
%419 = getelementptr inbounds double, double* %418, i64 %280
%420 = load double, double* %419
%421 = getelementptr inbounds double, double* %418, i64 %340
%422 = load double, double* %421
%423 = tail call double @llvm.fmuladd.f64(double %397, double %420, double %422)
store double %423, double* %421
%424 = add nsw i64 %408, 2
%425 = trunc i64 %424 to i32
%426 = icmp eq i32 %425, %4
br i1 %426, label %427, label %407
427: ; preds = %407, %405
%428 = add nsw i64 %340, 1
%429 = trunc i64 %428 to i32
%430 = icmp eq i32 %429, %4
br i1 %430, label %431, label %339
431: ; preds = %427, %282
%432 = getelementptr inbounds double*, double** %2, i64 %280
%433 = load double*, double** %432
%434 = and i32 %275, 3
%435 = icmp eq i32 %434, 0
br i1 %435, label %446, label %436
436: ; preds = %431, %436
%437 = phi i64 [ %443, %436 ], [ %277, %431 ]
%438 = phi i32 [ %444, %436 ], [ 0, %431 ]
%439 = getelementptr inbounds double*, double** %2, i64 %437
%440 = load double*, double** %439
%441 = getelementptr inbounds double, double* %440, i64 %280
store double 0.000000e+00, double* %441
%442 = getelementptr inbounds double, double* %433, i64 %437
store double 0.000000e+00, double* %442
%443 = add nsw i64 %437, 1
%444 = add i32 %438, 1
%445 = icmp eq i32 %444, %434
br i1 %445, label %446, label %436
446: ; preds = %436, %431
%447 = phi i64 [ %277, %431 ], [ %443, %436 ]
%448 = icmp ult i32 %278, 3
br i1 %448, label %473, label %449
449: ; preds = %446, %449
%450 = phi i64 [ %470, %449 ], [ %447, %446 ]
%451 = getelementptr inbounds double*, double** %2, i64 %450
%452 = load double*, double** %451
%453 = getelementptr inbounds double, double* %452, i64 %280
store double 0.000000e+00, double* %453
%454 = getelementptr inbounds double, double* %433, i64 %450
store double 0.000000e+00, double* %454
%455 = add nsw i64 %450, 1
%456 = getelementptr inbounds double*, double** %2, i64 %455
%457 = load double*, double** %456
%458 = getelementptr inbounds double, double* %457, i64 %280
store double 0.000000e+00, double* %458
%459 = getelementptr inbounds double, double* %433, i64 %455
store double 0.000000e+00, double* %459
%460 = add nsw i64 %450, 2
%461 = getelementptr inbounds double*, double** %2, i64 %460
%462 = load double*, double** %461
%463 = getelementptr inbounds double, double* %462, i64 %280
store double 0.000000e+00, double* %463
%464 = getelementptr inbounds double, double* %433, i64 %460
store double 0.000000e+00, double* %464
%465 = add nsw i64 %450, 3
%466 = getelementptr inbounds double*, double** %2, i64 %465
%467 = load double*, double** %466
%468 = getelementptr inbounds double, double* %467, i64 %280
store double 0.000000e+00, double* %468
%469 = getelementptr inbounds double, double* %433, i64 %465
store double 0.000000e+00, double* %469
%470 = add nsw i64 %450, 4
%471 = trunc i64 %470 to i32
%472 = icmp eq i32 %471, %4
br i1 %472, label %473, label %449
473: ; preds = %446, %449, %274
%474 = getelementptr inbounds double*, double** %2, i64 %280
%475 = load double*, double** %474
%476 = getelementptr inbounds double, double* %475, i64 %280
store double 1.000000e+00, double* %476
%477 = icmp sgt i64 %276, 1
%478 = add nsw i64 %277, -1
%479 = add i32 %275, 1
br i1 %477, label %274, label %480
480: ; preds = %473, %12
%481 = phi double [ 0.000000e+00, %12 ], [ %272, %473 ]
%482 = phi i1 [ false, %12 ], [ true, %473 ]
%483 = phi double* [ %13, %12 ], [ %16, %473 ]
%484 = add i32 %4, -1
%485 = icmp slt i32 %4, %3
%486 = add nsw i32 %3, -1
%487 = select i1 %485, i32 %484, i32 %486
%488 = icmp sgt i32 %487, -1
br i1 %488, label %489, label %651
489: ; preds = %480
%490 = add nuw i32 %487, 1
%491 = sub i32 %484, %490
%492 = sext i32 %3 to i64
%493 = zext i32 %487 to i64
%494 = sext i32 %4 to i64
%495 = zext i32 %487 to i64
%496 = zext i32 %490 to i64
br label %497
497: ; preds = %489, %640
%498 = phi i64 [ %495, %489 ], [ %649, %640 ]
%499 = phi i64 [ 0, %489 ], [ %647, %640 ]
%500 = phi i64 [ %493, %489 ], [ %646, %640 ]
%501 = phi i32 [ %490, %489 ], [ %648, %640 ]
%502 = trunc i64 %499 to i32
%503 = sub i32 %490, %502
%504 = sext i32 %503 to i64
%505 = sub nsw i64 %492, %504
%506 = xor i64 %504, -1
%507 = add nsw i64 %506, %492
%508 = sext i32 %501 to i64
%509 = getelementptr inbounds double, double* %1, i64 %498
%510 = load double, double* %509
%511 = trunc i64 %498 to i32
%512 = add i32 %511, 1
%513 = icmp slt i32 %512, %4
br i1 %513, label %514, label %528
514: ; preds = %497
%515 = trunc i64 %499 to i32
%516 = add i32 %491, %515
%517 = zext i32 %516 to i64
%518 = shl nuw nsw i64 %517, 3
%519 = add nuw nsw i64 %518, 8
%520 = trunc i64 %499 to i32
%521 = sub i32 %490, %520
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double*, double** %0, i64 %498
%524 = load double*, double** %523
%525 = getelementptr double, double* %524, i64 %522
%526 = bitcast double* %525 to i8*
%527 = fcmp oeq double %510, 0.000000e+00
br i1 %527, label %530, label %542
528: ; preds = %497
%529 = fcmp oeq double %510, 0.000000e+00
br i1 %529, label %530, label %532
530: ; preds = %514, %528
%531 = icmp slt i64 %498, %492
br i1 %531, label %534, label %640
532: ; preds = %528
%533 = fdiv double 1.000000e+00, %510
br label %627
534: ; preds = %530, %534
%535 = phi i64 [ %539, %534 ], [ %500, %530 ]
%536 = getelementptr inbounds double*, double** %0, i64 %535
%537 = load double*, double** %536
%538 = getelementptr inbounds double, double* %537, i64 %498
store double 0.000000e+00, double* %538
%539 = add nsw i64 %535, 1
%540 = trunc i64 %539 to i32
%541 = icmp eq i32 %540, %3
br i1 %541, label %640, label %534
542: ; preds = %514
%543 = fdiv double 1.000000e+00, %510
%544 = icmp slt i32 %512, %3
%545 = getelementptr inbounds double, double* %524, i64 %498
%546 = icmp slt i64 %498, %492
%547 = and i64 %505, 3
%548 = icmp eq i64 %547, 0
%549 = icmp ult i64 %507, 3
br label %550
550: ; preds = %542, %624
%551 = phi i64 [ %508, %542 ], [ %625, %624 ]
br i1 %544, label %552, label %607
552: ; preds = %550
br i1 %548, label %567, label %553
553: ; preds = %552, %553
%554 = phi i64 [ %564, %553 ], [ %508, %552 ]
%555 = phi double [ %563, %553 ], [ 0.000000e+00, %552 ]
%556 = phi i64 [ %565, %553 ], [ 0, %552 ]
%557 = getelementptr inbounds double*, double** %0, i64 %554
%558 = load double*, double** %557
%559 = getelementptr inbounds double, double* %558, i64 %498
%560 = load double, double* %559
%561 = getelementptr inbounds double, double* %558, i64 %551
%562 = load double, double* %561
%563 = tail call double @llvm.fmuladd.f64(double %560, double %562, double %555)
%564 = add nsw i64 %554, 1
%565 = add i64 %556, 1
%566 = icmp eq i64 %565, %547
br i1 %566, label %567, label %553
567: ; preds = %553, %552
%568 = phi i64 [ %508, %552 ], [ %564, %553 ]
%569 = phi double [ 0.000000e+00, %552 ], [ %563, %553 ]
%570 = phi double [ undef, %552 ], [ %563, %553 ]
br i1 %549, label %607, label %571
571: ; preds = %567, %571
%572 = phi i64 [ %605, %571 ], [ %568, %567 ]
%573 = phi double [ %604, %571 ], [ %569, %567 ]
%574 = getelementptr inbounds double*, double** %0, i64 %572
%575 = load double*, double** %574
%576 = getelementptr inbounds double, double* %575, i64 %498
%577 = load double, double* %576
%578 = getelementptr inbounds double, double* %575, i64 %551
%579 = load double, double* %578
%580 = tail call double @llvm.fmuladd.f64(double %577, double %579, double %573)
%581 = add nsw i64 %572, 1
%582 = getelementptr inbounds double*, double** %0, i64 %581
%583 = load double*, double** %582
%584 = getelementptr inbounds double, double* %583, i64 %498
%585 = load double, double* %584
%586 = getelementptr inbounds double, double* %583, i64 %551
%587 = load double, double* %586
%588 = tail call double @llvm.fmuladd.f64(double %585, double %587, double %580)
%589 = add nsw i64 %572, 2
%590 = getelementptr inbounds double*, double** %0, i64 %589
%591 = load double*, double** %590
%592 = getelementptr inbounds double, double* %591, i64 %498
%593 = load double, double* %592
%594 = getelementptr inbounds double, double* %591, i64 %551
%595 = load double, double* %594
%596 = tail call double @llvm.fmuladd.f64(double %593, double %595, double %588)
%597 = add nsw i64 %572, 3
%598 = getelementptr inbounds double*, double** %0, i64 %597
%599 = load double*, double** %598
%600 = getelementptr inbounds double, double* %599, i64 %498
%601 = load double, double* %600
%602 = getelementptr inbounds double, double* %599, i64 %551
%603 = load double, double* %602
%604 = tail call double @llvm.fmuladd.f64(double %601, double %603, double %596)
%605 = add nsw i64 %572, 4
%606 = icmp slt i64 %605, %492
br i1 %606, label %571, label %607
607: ; preds = %567, %571, %550
%608 = phi double [ 0.000000e+00, %550 ], [ %570, %567 ], [ %604, %571 ]
%609 = load double, double* %545
%610 = fdiv double %608, %609
%611 = fmul double %543, %610
br i1 %546, label %612, label %624
612: ; preds = %607, %612
%613 = phi i64 [ %621, %612 ], [ %500, %607 ]
%614 = getelementptr inbounds double*, double** %0, i64 %613
%615 = load double*, double** %614
%616 = getelementptr inbounds double, double* %615, i64 %498
%617 = load double, double* %616
%618 = getelementptr inbounds double, double* %615, i64 %551
%619 = load double, double* %618
%620 = tail call double @llvm.fmuladd.f64(double %611, double %617, double %619)
store double %620, double* %618
%621 = add nsw i64 %613, 1
%622 = trunc i64 %621 to i32
%623 = icmp eq i32 %622, %3
br i1 %623, label %624, label %612
624: ; preds = %612, %607
%625 = add nsw i64 %551, 1
%626 = icmp slt i64 %625, %494
br i1 %626, label %550, label %627
627: ; preds = %624, %532
%628 = phi double [ %533, %532 ], [ %543, %624 ]
%629 = icmp slt i64 %498, %492
br i1 %629, label %630, label %640
630: ; preds = %627, %630
%631 = phi i64 [ %637, %630 ], [ %500, %627 ]
%632 = getelementptr inbounds double*, double** %0, i64 %631
%633 = load double*, double** %632
%634 = getelementptr inbounds double, double* %633, i64 %498
%635 = load double, double* %634
%636 = fmul double %628, %635
store double %636, double* %634
%637 = add nsw i64 %631, 1
%638 = trunc i64 %637 to i32
%639 = icmp eq i32 %638, %3
br i1 %639, label %640, label %630
640: ; preds = %630, %534, %627, %530
%641 = getelementptr inbounds double*, double** %0, i64 %498
%642 = load double*, double** %641
%643 = getelementptr inbounds double, double* %642, i64 %498
%644 = load double, double* %643
%645 = fadd double %644, 1.000000e+00
store double %645, double* %643
%646 = add nsw i64 %500, -1
%647 = add nuw nsw i64 %499, 1
%648 = add i32 %501, -1
%649 = add nsw i64 %498, -1
%650 = icmp eq i64 %647, %496
br i1 %650, label %651, label %497
651: ; preds = %640, %480
br i1 %482, label %652, label %993
652: ; preds = %651
%653 = icmp sgt i32 %3, 0
%654 = sext i32 %4 to i64
%655 = add nsw i64 %654, -1
%656 = zext i32 %3 to i64
%657 = zext i32 %4 to i64
%658 = add nsw i64 %657, -1
%659 = and i64 %657, 1
%660 = icmp eq i64 %658, 0
%661 = and i64 %657, 4294967294
%662 = icmp eq i64 %659, 0
%663 = and i64 %656, 1
%664 = icmp eq i32 %3, 1
%665 = and i64 %656, 4294967294
%666 = icmp eq i64 %663, 0
%667 = and i64 %657, 3
%668 = icmp ult i64 %658, 3
%669 = and i64 %657, 4294967292
%670 = icmp eq i64 %667, 0
br label %671
671: ; preds = %652, %991
%672 = phi i64 [ %655, %652 ], [ %674, %991 ]
%673 = getelementptr inbounds double, double* %1, i64 %672
%674 = add nsw i64 %672, -1
%675 = getelementptr inbounds double, double* %1, i64 %674
%676 = getelementptr inbounds double, double* %483, i64 %674
%677 = getelementptr inbounds double, double* %483, i64 %672
br label %678
678: ; preds = %973, %671
%679 = phi i32 [ %977, %973 ], [ 0, %671 ]
br label %682
680: ; preds = %690
%681 = icmp sgt i64 %683, 0
br i1 %681, label %682, label %697
682: ; preds = %678, %680
%683 = phi i64 [ %672, %678 ], [ %684, %680 ]
%684 = add nsw i64 %683, -1
%685 = and i64 %683, 4294967295
%686 = getelementptr inbounds double, double* %483, i64 %685
%687 = load double, double* %686
%688 = tail call double @llvm.fabs.f64(double %687)
%689 = fcmp ugt double %688, %481
br i1 %689, label %690, label %741
690: ; preds = %682
%691 = getelementptr inbounds double, double* %1, i64 %684
%692 = load double, double* %691
%693 = tail call double @llvm.fabs.f64(double %692)
%694 = fcmp ugt double %693, %481
br i1 %694, label %680, label %695
695: ; preds = %690
%696 = trunc i64 %683 to i32
br label %697
697: ; preds = %680, %695
%698 = phi i64 [ %684, %695 ], [ -1, %680 ]
%699 = phi i32 [ %696, %695 ], [ -1, %680 ]
%700 = sext i32 %699 to i64
%701 = icmp slt i64 %672, %700
br i1 %701, label %743, label %702
702: ; preds = %697
%703 = shl i64 %698, 32
%704 = ashr exact i64 %703, 32
br label %705
705: ; preds = %702, %738
%706 = phi i64 [ %700, %702 ], [ %739, %738 ]
%707 = phi double [ 1.000000e+00, %702 ], [ %722, %738 ]
%708 = phi double [ 0.000000e+00, %702 ], [ %720, %738 ]
%709 = getelementptr inbounds double, double* %483, i64 %706
%710 = load double, double* %709
%711 = fmul double %708, %710
store double %711, double* %709
%712 = fmul double %707, %710
%713 = tail call double @llvm.fabs.f64(double %712)
%714 = fcmp ugt double %713, %481
br i1 %714, label %715, label %743
715: ; preds = %705
%716 = getelementptr inbounds double, double* %1, i64 %706
%717 = load double, double* %716
%718 = tail call double @pythag(double %712, double %717)
store double %718, double* %716
%719 = fdiv double 1.000000e+00, %718
%720 = fmul double %717, %719
%721 = fneg double %712
%722 = fmul double %719, %721
br i1 %653, label %723, label %738
723: ; preds = %715, %723
%724 = phi i64 [ %736, %723 ], [ 0, %715 ]
%725 = getelementptr inbounds double*, double** %0, i64 %724
%726 = load double*, double** %725
%727 = getelementptr inbounds double, double* %726, i64 %704
%728 = load double, double* %727
%729 = getelementptr inbounds double, double* %726, i64 %706
%730 = load double, double* %729
%731 = fmul double %722, %730
%732 = tail call double @llvm.fmuladd.f64(double %728, double %720, double %731)
store double %732, double* %727
%733 = fneg double %728
%734 = fmul double %722, %733
%735 = tail call double @llvm.fmuladd.f64(double %730, double %720, double %734)
store double %735, double* %729
%736 = add nuw nsw i64 %724, 1
%737 = icmp eq i64 %736, %656
br i1 %737, label %738, label %723
738: ; preds = %723, %715
%739 = add nsw i64 %706, 1
%740 = icmp slt i64 %706, %672
br i1 %740, label %705, label %743
741: ; preds = %682
%742 = trunc i64 %683 to i32
br label %743
743: ; preds = %738, %705, %741, %697
%744 = phi i32 [ %699, %697 ], [ %742, %741 ], [ %699, %705 ], [ %699, %738 ]
%745 = load double, double* %673
%746 = zext i32 %744 to i64
%747 = icmp eq i64 %672, %746
br i1 %747, label %748, label %781
748: ; preds = %743
%749 = fcmp olt double %745, 0.000000e+00
br i1 %749, label %750, label %991
750: ; preds = %748
%751 = fneg double %745
store double %751, double* %673
br i1 %668, label %978, label %752
752: ; preds = %750, %752
%753 = phi i64 [ %778, %752 ], [ 0, %750 ]
%754 = phi i64 [ %779, %752 ], [ 0, %750 ]
%755 = getelementptr inbounds double*, double** %2, i64 %753
%756 = load double*, double** %755
%757 = getelementptr inbounds double, double* %756, i64 %672
%758 = load double, double* %757
%759 = fneg double %758
store double %759, double* %757
%760 = or i64 %753, 1
%761 = getelementptr inbounds double*, double** %2, i64 %760
%762 = load double*, double** %761
%763 = getelementptr inbounds double, double* %762, i64 %672
%764 = load double, double* %763
%765 = fneg double %764
store double %765, double* %763
%766 = or i64 %753, 2
%767 = getelementptr inbounds double*, double** %2, i64 %766
%768 = load double*, double** %767
%769 = getelementptr inbounds double, double* %768, i64 %672
%770 = load double, double* %769
%771 = fneg double %770
store double %771, double* %769
%772 = or i64 %753, 3
%773 = getelementptr inbounds double*, double** %2, i64 %772
%774 = load double*, double** %773
%775 = getelementptr inbounds double, double* %774, i64 %672
%776 = load double, double* %775
%777 = fneg double %776
store double %777, double* %775
%778 = add nuw nsw i64 %753, 4
%779 = add i64 %754, 4
%780 = icmp eq i64 %779, %669
br i1 %780, label %978, label %752
781: ; preds = %743
%782 = icmp eq i32 %679, 30
br i1 %782, label %783, label %786
783: ; preds = %781
%784 = getelementptr inbounds [10 x double], [10 x double]* %6, i64 0, i64 0
%785 = icmp eq double* %483, %784
br i1 %785, label %999, label %996
786: ; preds = %781
%787 = sext i32 %744 to i64
%788 = getelementptr inbounds double, double* %1, i64 %787
%789 = load double, double* %788
%790 = load double, double* %675
%791 = load double, double* %676
%792 = load double, double* %677
%793 = fsub double %790, %745
%794 = fadd double %745, %790
%795 = fsub double %791, %792
%796 = fadd double %791, %792
%797 = fmul double %795, %796
%798 = tail call double @llvm.fmuladd.f64(double %793, double %794, double %797)
%799 = fmul double %792, 2.000000e+00
%800 = fmul double %790, %799
%801 = fdiv double %798, %800
%802 = tail call double @pythag(double %801, double 1.000000e+00)
%803 = fcmp olt double %801, 0.000000e+00
%804 = fneg double %802
%805 = select i1 %803, double %804, double %802
%806 = fsub double %789, %745
%807 = fadd double %745, %789
%808 = fadd double %801, %805
%809 = fdiv double %790, %808
%810 = fsub double %809, %792
%811 = fmul double %792, %810
%812 = tail call double @llvm.fmuladd.f64(double %806, double %807, double %811)
%813 = fdiv double %812, %789
%814 = icmp sgt i64 %672, %787
br i1 %814, label %834, label %973
815: ; preds = %942, %936
%816 = phi i64 [ 0, %936 ], [ %970, %942 ]
br i1 %666, label %832, label %817
817: ; preds = %815
%818 = getelementptr inbounds double*, double** %0, i64 %816
%819 = load double*, double** %818
%820 = getelementptr inbounds double, double* %819, i64 %835
%821 = bitcast double* %820 to <2 x double>*
%822 = load <2 x double>, <2 x double>* %821
%823 = extractelement <2 x double> %822, i64 0
%824 = fneg double %823
%825 = shufflevector <2 x double> %928, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%826 = insertelement <2 x double> %822, double %824, i64 0
%827 = fmul <2 x double> %825, %826
%828 = shufflevector <2 x double> %827, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%829 = shufflevector <2 x double> %928, <2 x double> undef, <2 x i32> zeroinitializer
%830 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %822, <2 x double> %829, <2 x double> %828)
%831 = bitcast double* %820 to <2 x double>*
store <2 x double> %830, <2 x double>* %831
br label %832
832: ; preds = %817, %815, %927
%833 = icmp slt i64 %840, %672
br i1 %833, label %834, label %973
834: ; preds = %786, %832
%835 = phi i64 [ %840, %832 ], [ %787, %786 ]
%836 = phi double [ %935, %832 ], [ %789, %786 ]
%837 = phi double [ %929, %832 ], [ 1.000000e+00, %786 ]
%838 = phi double [ %931, %832 ], [ 1.000000e+00, %786 ]
%839 = phi double [ %932, %832 ], [ %813, %786 ]
%840 = add nsw i64 %835, 1
%841 = getelementptr inbounds double, double* %483, i64 %840
%842 = load double, double* %841
%843 = getelementptr inbounds double, double* %1, i64 %840
%844 = load double, double* %843
%845 = fmul double %837, %842
%846 = fmul double %838, %842
%847 = tail call double @pythag(double %839, double %845)
%848 = getelementptr inbounds double, double* %483, i64 %835
store double %847, double* %848
%849 = insertelement <2 x double> poison, double %839, i64 0
%850 = insertelement <2 x double> %849, double %845, i64 1
%851 = insertelement <2 x double> poison, double %847, i64 0
%852 = shufflevector <2 x double> %851, <2 x double> poison, <2 x i32> zeroinitializer
%853 = fdiv <2 x double> %850, %852
%854 = extractelement <2 x double> %853, i64 1
%855 = fmul double %846, %854
%856 = extractelement <2 x double> %853, i64 0
%857 = tail call double @llvm.fmuladd.f64(double %836, double %856, double %855)
%858 = fneg double %836
%859 = fmul double %854, %858
%860 = tail call double @llvm.fmuladd.f64(double %846, double %856, double %859)
%861 = fmul double %844, %854
%862 = fmul double %844, %856
br i1 %660, label %899, label %863
863: ; preds = %834
%864 = shufflevector <2 x double> %853, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%865 = shufflevector <2 x double> %853, <2 x double> undef, <2 x i32> zeroinitializer
%866 = shufflevector <2 x double> %853, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%867 = shufflevector <2 x double> %853, <2 x double> undef, <2 x i32> zeroinitializer
br label %868
868: ; preds = %868, %863
%869 = phi i64 [ 0, %863 ], [ %896, %868 ]
%870 = phi i64 [ 0, %863 ], [ %897, %868 ]
%871 = getelementptr inbounds double*, double** %2, i64 %869
%872 = load double*, double** %871
%873 = getelementptr inbounds double, double* %872, i64 %835
%874 = bitcast double* %873 to <2 x double>*
%875 = load <2 x double>, <2 x double>* %874
%876 = extractelement <2 x double> %875, i64 0
%877 = fneg double %876
%878 = insertelement <2 x double> %875, double %877, i64 0
%879 = fmul <2 x double> %864, %878
%880 = shufflevector <2 x double> %879, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%881 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %875, <2 x double> %865, <2 x double> %880)
%882 = bitcast double* %873 to <2 x double>*
store <2 x double> %881, <2 x double>* %882
%883 = or i64 %869, 1
%884 = getelementptr inbounds double*, double** %2, i64 %883
%885 = load double*, double** %884
%886 = getelementptr inbounds double, double* %885, i64 %835
%887 = bitcast double* %886 to <2 x double>*
%888 = load <2 x double>, <2 x double>* %887
%889 = extractelement <2 x double> %888, i64 0
%890 = fneg double %889
%891 = insertelement <2 x double> %888, double %890, i64 0
%892 = fmul <2 x double> %866, %891
%893 = shufflevector <2 x double> %892, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%894 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %888, <2 x double> %867, <2 x double> %893)
%895 = bitcast double* %886 to <2 x double>*
store <2 x double> %894, <2 x double>* %895
%896 = add nuw nsw i64 %869, 2
%897 = add i64 %870, 2
%898 = icmp eq i64 %897, %661
br i1 %898, label %899, label %868
899: ; preds = %868, %834
%900 = phi i64 [ 0, %834 ], [ %896, %868 ]
br i1 %662, label %916, label %901
901: ; preds = %899
%902 = getelementptr inbounds double*, double** %2, i64 %900
%903 = load double*, double** %902
%904 = getelementptr inbounds double, double* %903, i64 %835
%905 = bitcast double* %904 to <2 x double>*
%906 = load <2 x double>, <2 x double>* %905
%907 = extractelement <2 x double> %906, i64 0
%908 = fneg double %907
%909 = shufflevector <2 x double> %853, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%910 = insertelement <2 x double> %906, double %908, i64 0
%911 = fmul <2 x double> %909, %910
%912 = shufflevector <2 x double> %911, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%913 = shufflevector <2 x double> %853, <2 x double> undef, <2 x i32> zeroinitializer
%914 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %906, <2 x double> %913, <2 x double> %912)
%915 = bitcast double* %904 to <2 x double>*
store <2 x double> %914, <2 x double>* %915
br label %916
916: ; preds = %899, %901
%917 = tail call double @pythag(double %857, double %861)
%918 = getelementptr inbounds double, double* %1, i64 %835
store double %917, double* %918
%919 = fcmp une double %917, 0.000000e+00
br i1 %919, label %920, label %927
920: ; preds = %916
%921 = fdiv double 1.000000e+00, %917
%922 = insertelement <2 x double> poison, double %857, i64 0
%923 = insertelement <2 x double> %922, double %861, i64 1
%924 = insertelement <2 x double> poison, double %921, i64 0
%925 = shufflevector <2 x double> %924, <2 x double> poison, <2 x i32> zeroinitializer
%926 = fmul <2 x double> %923, %925
br label %927
927: ; preds = %920, %916
%928 = phi <2 x double> [ %926, %920 ], [ %853, %916 ]
%929 = extractelement <2 x double> %928, i64 1
%930 = fmul double %862, %929
%931 = extractelement <2 x double> %928, i64 0
%932 = tail call double @llvm.fmuladd.f64(double %931, double %860, double %930)
%933 = fneg double %929
%934 = fmul double %860, %933
%935 = tail call double @llvm.fmuladd.f64(double %931, double %862, double %934)
br i1 %653, label %936, label %832
936: ; preds = %927
br i1 %664, label %815, label %937
937: ; preds = %936
%938 = shufflevector <2 x double> %928, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%939 = shufflevector <2 x double> %928, <2 x double> undef, <2 x i32> zeroinitializer
%940 = shufflevector <2 x double> %928, <2 x double> undef, <2 x i32> <i32 1, i32 1>
%941 = shufflevector <2 x double> %928, <2 x double> undef, <2 x i32> zeroinitializer
br label %942
942: ; preds = %942, %937
%943 = phi i64 [ 0, %937 ], [ %970, %942 ]
%944 = phi i64 [ 0, %937 ], [ %971, %942 ]
%945 = getelementptr inbounds double*, double** %0, i64 %943
%946 = load double*, double** %945
%947 = getelementptr inbounds double, double* %946, i64 %835
%948 = bitcast double* %947 to <2 x double>*
%949 = load <2 x double>, <2 x double>* %948
%950 = extractelement <2 x double> %949, i64 0
%951 = fneg double %950
%952 = insertelement <2 x double> %949, double %951, i64 0
%953 = fmul <2 x double> %938, %952
%954 = shufflevector <2 x double> %953, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%955 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %949, <2 x double> %939, <2 x double> %954)
%956 = bitcast double* %947 to <2 x double>*
store <2 x double> %955, <2 x double>* %956
%957 = or i64 %943, 1
%958 = getelementptr inbounds double*, double** %0, i64 %957
%959 = load double*, double** %958
%960 = getelementptr inbounds double, double* %959, i64 %835
%961 = bitcast double* %960 to <2 x double>*
%962 = load <2 x double>, <2 x double>* %961
%963 = extractelement <2 x double> %962, i64 0
%964 = fneg double %963
%965 = insertelement <2 x double> %962, double %964, i64 0
%966 = fmul <2 x double> %940, %965
%967 = shufflevector <2 x double> %966, <2 x double> poison, <2 x i32> <i32 1, i32 0>
%968 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %962, <2 x double> %941, <2 x double> %967)
%969 = bitcast double* %960 to <2 x double>*
store <2 x double> %968, <2 x double>* %969
%970 = add nuw nsw i64 %943, 2
%971 = add i64 %944, 2
%972 = icmp eq i64 %971, %665
br i1 %972, label %815, label %942
973: ; preds = %832, %786
%974 = phi double [ %813, %786 ], [ %932, %832 ]
%975 = phi double [ %789, %786 ], [ %935, %832 ]
%976 = getelementptr inbounds double, double* %483, i64 %787
store double 0.000000e+00, double* %976
store double %974, double* %677
store double %975, double* %673
%977 = add nuw nsw i32 %679, 1
br label %678
978: ; preds = %752, %750
%979 = phi i64 [ 0, %750 ], [ %778, %752 ]
br i1 %670, label %991, label %980
980: ; preds = %978, %980
%981 = phi i64 [ %988, %980 ], [ %979, %978 ]
%982 = phi i64 [ %989, %980 ], [ 0, %978 ]
%983 = getelementptr inbounds double*, double** %2, i64 %981
%984 = load double*, double** %983
%985 = getelementptr inbounds double, double* %984, i64 %672
%986 = load double, double* %985
%987 = fneg double %986
store double %987, double* %985
%988 = add nuw nsw i64 %981, 1
%989 = add i64 %982, 1
%990 = icmp eq i64 %989, %667
br i1 %990, label %991, label %980
991: ; preds = %978, %980, %748
%992 = icmp sgt i64 %672, 0
br i1 %992, label %671, label %993
993: ; preds = %991, %651
%994 = getelementptr inbounds [10 x double], [10 x double]* %6, i64 0, i64 0
%995 = icmp eq double* %483, %994
br i1 %995, label %999, label %996
996: ; preds = %993, %783
%997 = phi i32 [ 1, %783 ], [ 0, %993 ]
%998 = call i32 @free_dvector(double* %483, i32 0, i32 %484)
br label %999
999: ; preds = %996, %783, %993
%1000 = phi i32 [ 0, %993 ], [ 1, %783 ], [ %997, %996 ]
ret i32 %1000
}