#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 DBL_EPSILON;
double fabs(double);
double sqrt(double);
int odr1v_(int *n, int *b1, int *bn, double *lambda, double *d__, double *l,
           double *ld, double *lld, double *pivmin, double *gaptol, double *z__,
           int *wantnc, int *negcnt, double *ztz, double *mingma, int *r__,
           int *isuppz, double *nrminv, double *resid, double *rqcorr,
           double *work) {
  int i__1;
  double d__1, d__2, d__3;
  int i__;
  double s;
  int r1, r2;
  double eps, tmp;
  int neg1, neg2, indp, inds;
  double dplus;
  extern int odnan_(double *);
  int indlpl, indumn;
  double dminus;
  int sawnan1, sawnan2;
  --work;
  --isuppz;
  --z__;
  --lld;
  --ld;
  --l;
  --d__;
  eps = DBL_EPSILON;
  if (*r__ == 0) {
    r1 = *b1;
    r2 = *bn;
  } else {
    r1 = *r__;
    r2 = *r__;
  }
  indlpl = 0;
  indumn = *n;
  inds = (*n << 1) + 1;
  indp = *n * 3 + 1;
  if (*b1 == 1) {
    work[inds] = 0.;
  } else {
    work[inds + *b1 - 1] = lld[*b1 - 1];
  }
  sawnan1 = (0);
  neg1 = 0;
  s = work[inds + *b1 - 1] - *lambda;
  i__1 = r1 - 1;
  for (i__ = *b1; i__ <= i__1; ++i__) {
    dplus = d__[i__] + s;
    work[indlpl + i__] = ld[i__] / dplus;
    if (dplus < 0.) {
      ++neg1;
    }
    work[inds + i__] = s * work[indlpl + i__] * l[i__];
    s = work[inds + i__] - *lambda;
  }
  sawnan1 = odnan_(&s);
  if (sawnan1) {
    goto L60;
  }
  i__1 = r2 - 1;
  for (i__ = r1; i__ <= i__1; ++i__) {
    dplus = d__[i__] + s;
    work[indlpl + i__] = ld[i__] / dplus;
    work[inds + i__] = s * work[indlpl + i__] * l[i__];
    s = work[inds + i__] - *lambda;
  }
  sawnan1 = odnan_(&s);
L60:
  if (sawnan1) {
    neg1 = 0;
    s = work[inds + *b1 - 1] - *lambda;
    i__1 = r1 - 1;
    for (i__ = *b1; i__ <= i__1; ++i__) {
      dplus = d__[i__] + s;
      if (fabs(dplus) < *pivmin) {
        dplus = -(*pivmin);
      }
      work[indlpl + i__] = ld[i__] / dplus;
      if (dplus < 0.) {
        ++neg1;
      }
      work[inds + i__] = s * work[indlpl + i__] * l[i__];
      if (work[indlpl + i__] == 0.) {
        work[inds + i__] = lld[i__];
      }
      s = work[inds + i__] - *lambda;
    }
    i__1 = r2 - 1;
    for (i__ = r1; i__ <= i__1; ++i__) {
      dplus = d__[i__] + s;
      if (fabs(dplus) < *pivmin) {
        dplus = -(*pivmin);
      }
      work[indlpl + i__] = ld[i__] / dplus;
      work[inds + i__] = s * work[indlpl + i__] * l[i__];
      if (work[indlpl + i__] == 0.) {
        work[inds + i__] = lld[i__];
      }
      s = work[inds + i__] - *lambda;
    }
  }
  sawnan2 = (0);
  neg2 = 0;
  work[indp + *bn - 1] = d__[*bn] - *lambda;
  i__1 = r1;
  for (i__ = *bn - 1; i__ >= i__1; --i__) {
    dminus = lld[i__] + work[indp + i__];
    tmp = d__[i__] / dminus;
    if (dminus < 0.) {
      ++neg2;
    }
    work[indumn + i__] = l[i__] * tmp;
    work[indp + i__ - 1] = work[indp + i__] * tmp - *lambda;
  }
  tmp = work[indp + r1 - 1];
  sawnan2 = odnan_(&tmp);
  if (sawnan2) {
    neg2 = 0;
    i__1 = r1;
    for (i__ = *bn - 1; i__ >= i__1; --i__) {
      dminus = lld[i__] + work[indp + i__];
      if (fabs(dminus) < *pivmin) {
        dminus = -(*pivmin);
      }
      tmp = d__[i__] / dminus;
      if (dminus < 0.) {
        ++neg2;
      }
      work[indumn + i__] = l[i__] * tmp;
      work[indp + i__ - 1] = work[indp + i__] * tmp - *lambda;
      if (tmp == 0.) {
        work[indp + i__ - 1] = d__[i__] - *lambda;
      }
    }
  }
  *mingma = work[inds + r1 - 1] + work[indp + r1 - 1];
  if (*mingma < 0.) {
    ++neg1;
  }
  if (*wantnc) {
    *negcnt = neg1 + neg2;
  } else {
    *negcnt = -1;
  }
  if (fabs(*mingma) == 0.) {
    *mingma = eps * work[inds + r1 - 1];
  }
  *r__ = r1;
  i__1 = r2 - 1;
  for (i__ = r1; i__ <= i__1; ++i__) {
    tmp = work[inds + i__] + work[indp + i__];
    if (tmp == 0.) {
      tmp = eps * work[inds + i__];
    }
    if (fabs(tmp) <= fabs(*mingma)) {
      *mingma = tmp;
      *r__ = i__ + 1;
    }
  }
  isuppz[1] = *b1;
  isuppz[2] = *bn;
  z__[*r__] = 1.;
  *ztz = 1.;
  if (!sawnan1 && !sawnan2) {
    i__1 = *b1;
    for (i__ = *r__ - 1; i__ >= i__1; --i__) {
      z__[i__] = -(work[indlpl + i__] * z__[i__ + 1]);
      if (((d__1 = z__[i__], fabs(d__1)) + (d__2 = z__[i__ + 1], fabs(d__2))) *
              (d__3 = ld[i__], fabs(d__3)) <
          *gaptol) {
        z__[i__] = 0.;
        isuppz[1] = i__ + 1;
        goto L220;
      }
      *ztz += z__[i__] * z__[i__];
    }
  L220:;
  } else {
    i__1 = *b1;
    for (i__ = *r__ - 1; i__ >= i__1; --i__) {
      if (z__[i__ + 1] == 0.) {
        z__[i__] = -(ld[i__ + 1] / ld[i__]) * z__[i__ + 2];
      } else {
        z__[i__] = -(work[indlpl + i__] * z__[i__ + 1]);
      }
      if (((d__1 = z__[i__], fabs(d__1)) + (d__2 = z__[i__ + 1], fabs(d__2))) *
              (d__3 = ld[i__], fabs(d__3)) <
          *gaptol) {
        z__[i__] = 0.;
        isuppz[1] = i__ + 1;
        goto L240;
      }
      *ztz += z__[i__] * z__[i__];
    }
  L240:;
  }
  if (!sawnan1 && !sawnan2) {
    i__1 = *bn - 1;
    for (i__ = *r__; i__ <= i__1; ++i__) {
      z__[i__ + 1] = -(work[indumn + i__] * z__[i__]);
      if (((d__1 = z__[i__], fabs(d__1)) + (d__2 = z__[i__ + 1], fabs(d__2))) *
              (d__3 = ld[i__], fabs(d__3)) <
          *gaptol) {
        z__[i__ + 1] = 0.;
        isuppz[2] = i__;
        goto L260;
      }
      *ztz += z__[i__ + 1] * z__[i__ + 1];
    }
  L260:;
  } else {
    i__1 = *bn - 1;
    for (i__ = *r__; i__ <= i__1; ++i__) {
      if (z__[i__] == 0.) {
        z__[i__ + 1] = -(ld[i__ - 1] / ld[i__]) * z__[i__ - 1];
      } else {
        z__[i__ + 1] = -(work[indumn + i__] * z__[i__]);
      }
      if (((d__1 = z__[i__], fabs(d__1)) + (d__2 = z__[i__ + 1], fabs(d__2))) *
              (d__3 = ld[i__], fabs(d__3)) <
          *gaptol) {
        z__[i__ + 1] = 0.;
        isuppz[2] = i__;
        goto L280;
      }
      *ztz += z__[i__ + 1] * z__[i__ + 1];
    }
  L280:;
  }
  tmp = 1. / *ztz;
  *nrminv = sqrt(tmp);
  *resid = fabs(*mingma) * *nrminv;
  *rqcorr = *mingma * tmp;
  return 0;
}


x86 assembly (clang, -O0):
<odr1v_>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x80(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x80(%rbp)
mov    0x60(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x60(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rbp)
mov    0x18(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x18(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x10(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    0x3e05(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x58(%rbp),%rax
cmpl   $0x0,(%rax)
jne    1210 <odr1v_+0xf0>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x68(%rbp)
jmp    1222 <odr1v_+0x102>
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x68(%rbp)
movl   $0x0,-0x94(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
shl    $0x1,%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
imul   $0x3,(%rax),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
mov    -0x10(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1282 <odr1v_+0x162>
mov    0x80(%rbp),%rax
movslq -0x88(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    12b5 <odr1v_+0x195>
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rcx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
mov    -0x10(%rbp),%rdx
add    (%rdx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0xa4(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
mov    -0x10(%rbp),%rdx
add    (%rdx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     13e5 <odr1v_+0x2c5>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    1370 <odr1v_+0x250>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1303 <odr1v_+0x1e3>
lea    -0x60(%rbp),%rdi
call   1030 <odnan_@plt>
mov    %eax,-0xa4(%rbp)
cmpl   $0x0,-0xa4(%rbp)
je     1406 <odr1v_+0x2e6>
jmp    14ec <odr1v_+0x3cc>
mov    -0x68(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     14dd <odr1v_+0x3bd>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1415 <odr1v_+0x2f5>
lea    -0x60(%rbp),%rdi
call   1030 <odnan_@plt>
mov    %eax,-0xa4(%rbp)
cmpl   $0x0,-0xa4(%rbp)
je     1833 <odr1v_+0x713>
movl   $0x0,-0x7c(%rbp)
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
mov    -0x10(%rbp),%rdx
add    (%rdx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     16bb <odr1v_+0x59b>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movaps 0x1a8e(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    15af <odr1v_+0x48f>
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    15f6 <odr1v_+0x4d6>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1688 <odr1v_+0x568>
jp     1688 <odr1v_+0x568>
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    153d <odr1v_+0x41d>
mov    -0x68(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     182e <odr1v_+0x70e>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm1
ff
movaps 0x1901(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    173c <odr1v_+0x61c>
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    17fb <odr1v_+0x6db>
jp     17fb <odr1v_+0x6db>
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    16ca <odr1v_+0x5aa>
jmp    1833 <odr1v_+0x713>
movl   $0x0,-0xa8(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
mov    -0x18(%rbp),%rdx
add    (%rdx),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     1990 <odr1v_+0x870>
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    18f9 <odr1v_+0x7d9>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0x80(%rbp),%rax
mov    -0x98(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    188c <odr1v_+0x76c>
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
lea    -0x78(%rbp),%rdi
call   1030 <odnan_@plt>
mov    %eax,-0xa8(%rbp)
cmpl   $0x0,-0xa8(%rbp)
je     1b87 <odr1v_+0xa67>
movl   $0x0,-0x80(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     1b82 <odr1v_+0xa62>
mov    0x18(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movaps 0x15d3(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1a6a <odr1v_+0x94a>
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jbe    1a9e <odr1v_+0x97e>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0x80(%rbp),%rax
mov    -0x98(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0x78(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1b6f <odr1v_+0xa4f>
jp     1b6f <odr1v_+0xa4f>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
subsd  (%rax),%xmm0
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1b74 <odr1v_+0xa54>
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    19e5 <odr1v_+0x8c5>
jmp    1b87 <odr1v_+0xa67>
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x50(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1bdf <odr1v_+0xabf>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
mov    0x38(%rbp),%rax
cmpl   $0x0,(%rax)
je     1bfd <odr1v_+0xadd>
mov    -0x7c(%rbp),%ecx
add    -0x80(%rbp),%ecx
mov    0x40(%rbp),%rax
mov    %ecx,(%rax)
jmp    1c07 <odr1v_+0xae7>
mov    0x40(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    0x50(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0x13ea(%rip),%xmm1
pand   %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1c55 <odr1v_+0xb35>
jp     1c55 <odr1v_+0xb35>
movsd  -0x70(%rbp),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x64(%rbp),%ecx
mov    0x58(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x68(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     1d41 <odr1v_+0xc21>
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x80(%rbp),%rax
mov    -0x84(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1ce8 <odr1v_+0xbc8>
jp     1ce8 <odr1v_+0xbc8>
movsd  -0x70(%rbp),%xmm0
mov    0x80(%rbp),%rax
mov    -0x88(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm1
movaps 0x130c(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x50(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0x12f9(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1d2e <odr1v_+0xc0e>
movsd  -0x78(%rbp),%xmm0
mov    0x50(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
mov    0x58(%rbp),%rax
mov    %ecx,(%rax)
jmp    1d33 <odr1v_+0xc13>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1c6d <odr1v_+0xb4d>
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
mov    0x60(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
mov    0x60(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    0x30(%rbp),%rax
mov    0x58(%rbp),%rcx
movslq (%rcx),%rcx
movsd  0x12a2(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
movsd  0x1291(%rip),%xmm0
movsd  %xmm0,(%rax)
cmpl   $0x0,-0xa4(%rbp)
jne    1ef9 <odr1v_+0xdd9>
cmpl   $0x0,-0xa8(%rbp)
jne    1ef9 <odr1v_+0xdd9>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     1eef <odr1v_+0xdcf>
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
movaps 0x11d6(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0x11af(%rip),%xmm2
pand   %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movaps 0x1189(%rip),%xmm2
pand   %xmm2,%xmm0
mulsd  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1eb3 <odr1v_+0xd93>
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
mov    0x60(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    1ef4 <odr1v_+0xdd4>
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    1db2 <odr1v_+0xc92>
jmp    1ef4 <odr1v_+0xdd4>
jmp    20d4 <odr1v_+0xfb4>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     20ca <odr1v_+0xfaa>
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1f99 <odr1v_+0xe79>
jp     1f99 <odr1v_+0xe79>
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1fe7 <odr1v_+0xec7>
mov    0x80(%rbp),%rax
mov    -0x94(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
movaps 0xffb(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0xfd4(%rip),%xmm2
pand   %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movaps 0xfae(%rip),%xmm2
pand   %xmm2,%xmm0
mulsd  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    208e <odr1v_+0xf6e>
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
mov    0x60(%rbp),%rax
mov    %ecx,0x4(%rax)
jmp    20cf <odr1v_+0xfaf>
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    1f0e <odr1v_+0xdee>
jmp    20cf <odr1v_+0xfaf>
jmp    20d4 <odr1v_+0xfb4>
cmpl   $0x0,-0xa4(%rbp)
jne    2256 <odr1v_+0x1136>
cmpl   $0x0,-0xa8(%rbp)
jne    2256 <odr1v_+0x1136>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     224c <odr1v_+0x112c>
mov    0x80(%rbp),%rax
mov    -0x98(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
movaps 0xe85(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0xe5e(%rip),%xmm2
pand   %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movaps 0xe38(%rip),%xmm2
pand   %xmm2,%xmm0
mulsd  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    2206 <odr1v_+0x10e6>
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%ecx
mov    0x60(%rbp),%rax
mov    %ecx,0x8(%rax)
jmp    2251 <odr1v_+0x1131>
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    2103 <odr1v_+0xfe3>
jmp    2251 <odr1v_+0x1131>
jmp    243d <odr1v_+0x131d>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
sub    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    0x58(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     2433 <odr1v_+0x1313>
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    22f6 <odr1v_+0x11d6>
jp     22f6 <odr1v_+0x11d6>
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2344 <odr1v_+0x1224>
mov    0x80(%rbp),%rax
mov    -0x98(%rbp),%ecx
add    -0x54(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x30(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x40(%rbp),%xmm1
movaps 0xc9e(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movaps 0xc77(%rip),%xmm2
pand   %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
movaps 0xc51(%rip),%xmm2
pand   %xmm2,%xmm0
mulsd  %xmm0,%xmm1
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    23ed <odr1v_+0x12cd>
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%ecx
mov    0x60(%rbp),%rax
mov    %ecx,0x8(%rax)
jmp    2438 <odr1v_+0x1318>
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    226b <odr1v_+0x114b>
jmp    2438 <odr1v_+0x1318>
jmp    243d <odr1v_+0x131d>
mov    0x48(%rbp),%rax
movsd  0xbc7(%rip),%xmm0
divsd  (%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
call   1040 <sqrt@plt>
mov    0x68(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x50(%rbp),%rax
movsd  (%rax),%xmm0
movaps 0xb8d(%rip),%xmm1
pand   %xmm1,%xmm0
mov    0x68(%rbp),%rax
mulsd  (%rax),%xmm0
mov    0x70(%rbp),%rax
movsd  %xmm0,(%rax)
mov    0x50(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0x78(%rbp),%xmm0
mov    0x78(%rbp),%rax
movsd  %xmm0,(%rax)
xor    %eax,%eax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<odr1v_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,0x28(%rsp)
mov    %r8,0x10(%rsp)
mov    %rdx,%r12
mov    0x118(%rsp),%rax
mov    0x2e9b(%rip),%rbp
mov    (%rax),%r15d
mov    %rsi,0x70(%rsp)
mov    (%rsi),%eax
mov    %r15d,%edx
mov    %r15d,0x4(%rsp)
test   %r15d,%r15d
jne    116f <odr1v_+0x4f>
mov    (%r12),%edx
mov    %edx,0x4(%rsp)
mov    %eax,%r15d
mov    0x140(%rsp),%r14
mov    0xd8(%rsp),%rbx
movsd  0x0(%rbp),%xmm4
movslq (%rdi),%r13
lea    0x1(%r13,%r13,1),%esi
movslq %esi,%r10
cmp    $0x1,%eax
mov    %rsi,0x80(%rsp)
jne    11aa <odr1v_+0x8a>
movq   $0x0,-0x8(%r14,%r10,8)
mov    %r10,%rdx
jmp    11c6 <odr1v_+0xa6>
lea    -0x1(%rax),%edx
movslq %edx,%rdx
movsd  -0x8(%rbx,%rdx,8),%xmm0
lea    (%rax,%rsi,1),%edx
add    $0xffffffff,%edx
movslq %edx,%rdx
movsd  %xmm0,-0x8(%r14,%rdx,8)
movsd  -0x8(%r14,%rdx,8),%xmm0
subsd  (%rcx),%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebp,%ebp
cmp    %r15d,%eax
jge    127b <odr1v_+0x15b>
movslq %eax,%rsi
movslq %r15d,%rax
lea    (%r10,%rsi,1),%rdx
lea    (%r14,%rdx,8),%r8
add    $0xfffffffffffffff8,%r8
mov    0x10(%rsp),%rdx
lea    -0x8(%rdx,%rsi,8),%r9
mov    0xd0(%rsp),%rdx
lea    -0x8(%rdx,%rsi,8),%r11
lea    (%r14,%rsi,8),%rdi
mov    0x28(%rsp),%rdx
lea    (%rdx,%rsi,8),%rbx
add    $0xfffffffffffffff8,%rbx
sub    %rsi,%rax
xor    %esi,%esi
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movsd  (%r9,%rsi,8),%xmm2
addsd  %xmm0,%xmm2
movsd  (%r11,%rsi,8),%xmm3
divsd  %xmm2,%xmm3
xor    %edx,%edx
ucomisd %xmm2,%xmm1
movsd  %xmm3,-0x8(%rdi,%rsi,8)
seta   %dl
add    %edx,%ebp
mulsd  %xmm0,%xmm3
mulsd  (%rbx,%rsi,8),%xmm3
movsd  %xmm3,(%r8,%rsi,8)
movapd %xmm3,%xmm0
subsd  (%rcx),%xmm0
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1230 <odr1v_+0x110>
movsd  %xmm0,0x8(%rsp)
mov    %rcx,0x20(%rsp)
mov    %r10,0x38(%rsp)
movsd  %xmm4,0x88(%rsp)
mov    0xe0(%rsp),%r14
lea    0x0(%r13,%r13,2),%ebx
movslq %r15d,%rax
mov    %rax,0x50(%rsp)
lea    0x8(%rsp),%rdi
call   1030 <odnan_@plt>
test   %eax,%eax
mov    %rbx,0x18(%rsp)
mov    %r13,0x48(%rsp)
jne    1376 <odr1v_+0x256>
cmp    0x4(%rsp),%r15d
jge    1364 <odr1v_+0x244>
movsd  0x8(%rsp),%xmm0
movslq %r15d,%rcx
movslq 0x4(%rsp),%rax
mov    0x38(%rsp),%rdx
add    %rcx,%rdx
mov    0x140(%rsp),%rdi
lea    -0x8(%rdi,%rdx,8),%r8
mov    0x10(%rsp),%rdx
lea    -0x8(%rdx,%rcx,8),%r9
mov    0xd0(%rsp),%rdx
lea    -0x8(%rdx,%rcx,8),%rsi
lea    (%rdi,%rcx,8),%rdi
mov    0x28(%rsp),%rdx
lea    (%rdx,%rcx,8),%rbx
add    $0xfffffffffffffff8,%rbx
sub    %rcx,%rax
xor    %ecx,%ecx
mov    0x20(%rsp),%rdx
nop
movsd  (%r9,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rsi,%rcx,8),%xmm2
divsd  %xmm1,%xmm2
movsd  %xmm2,-0x8(%rdi,%rcx,8)
mulsd  %xmm0,%xmm2
mulsd  (%rbx,%rcx,8),%xmm2
movsd  %xmm2,(%r8,%rcx,8)
movapd %xmm2,%xmm0
subsd  (%rdx),%xmm0
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1320 <odr1v_+0x200>
movsd  %xmm0,0x8(%rsp)
mov    0x18(%rsp),%rbx
lea    0x8(%rsp),%rdi
call   1030 <odnan_@plt>
test   %eax,%eax
je     15bd <odr1v_+0x49d>
lea    0x0(%r13,%r13,1),%eax
mov    0x70(%rsp),%rcx
movslq (%rcx),%rcx
add    %ecx,%eax
cltq
mov    0x140(%rsp),%r11
movsd  -0x8(%r11,%rax,8),%xmm0
mov    0x20(%rsp),%rax
movsd  (%rax),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rsp)
xor    %ebp,%ebp
cmp    %r15d,%ecx
jge    14b9 <odr1v_+0x399>
mov    0x38(%rsp),%rax
add    %rcx,%rax
lea    -0x8(%r11,%rax,8),%rax
mov    0x10(%rsp),%rdx
lea    -0x8(%rdx,%rcx,8),%r9
mov    0xd0(%rsp),%rdx
lea    -0x8(%rdx,%rcx,8),%r10
lea    (%r11,%rcx,8),%r11
mov    0x28(%rsp),%rdx
lea    -0x8(%rdx,%rcx,8),%rdi
mov    0xd8(%rsp),%rdx
lea    (%rdx,%rcx,8),%r8
add    $0xfffffffffffffff8,%r8
mov    0x50(%rsp),%rsi
sub    %rcx,%rsi
xor    %ecx,%ecx
movapd 0xbf8(%rip),%xmm2
movapd 0xc00(%rip),%xmm3
xorpd  %xmm4,%xmm4
xor    %ebp,%ebp
jmp    143a <odr1v_+0x31a>
nopl   0x0(%rax,%rax,1)
mov    %bl,%dl
add    %edx,%ebp
mov    0x20(%rsp),%rdx
movsd  (%rdx),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rsi
je     14a6 <odr1v_+0x386>
movsd  (%r9,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm5
andpd  %xmm2,%xmm5
movsd  (%r14),%xmm6
cmpltsd %xmm6,%xmm5
xorpd  %xmm3,%xmm6
andpd  %xmm5,%xmm6
andnpd %xmm1,%xmm5
orpd   %xmm5,%xmm6
movsd  (%r10,%rcx,8),%xmm1
divsd  %xmm6,%xmm1
xor    %edx,%edx
ucomisd %xmm6,%xmm4
seta   %bl
movsd  %xmm1,-0x8(%r11,%rcx,8)
mulsd  %xmm1,%xmm0
mulsd  (%rdi,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
ucomisd %xmm4,%xmm1
jne    1420 <odr1v_+0x300>
jp     1420 <odr1v_+0x300>
movsd  (%r8,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1420 <odr1v_+0x300>
movsd  %xmm0,0x8(%rsp)
mov    0x140(%rsp),%r11
mov    0x18(%rsp),%rbx
mov    $0x1,%al
mov    %eax,0x34(%rsp)
mov    0x4(%rsp),%eax
cmp    %eax,%r15d
jge    15d6 <odr1v_+0x4b6>
cltq
mov    0x38(%rsp),%rcx
mov    0x50(%rsp),%rdx
add    %rdx,%rcx
lea    -0x8(%r11,%rcx,8),%rcx
mov    0x10(%rsp),%rsi
lea    -0x8(%rsi,%rdx,8),%r9
mov    0xd0(%rsp),%rsi
lea    -0x8(%rsi,%rdx,8),%r10
lea    (%r11,%rdx,8),%rdi
mov    0x28(%rsp),%rsi
lea    (%rsi,%rdx,8),%rbx
add    $0xfffffffffffffff8,%rbx
mov    0xd8(%rsp),%rsi
lea    (%rsi,%rdx,8),%r8
add    $0xfffffffffffffff8,%r8
sub    %rdx,%rax
xor    %edx,%edx
movapd 0xadb(%rip),%xmm2
movapd 0xae3(%rip),%xmm3
xorpd  %xmm4,%xmm4
mov    0x20(%rsp),%rsi
jmp    1551 <odr1v_+0x431>
nopl   0x0(%rax,%rax,1)
movsd  (%rsi),%xmm1
subsd  %xmm1,%xmm0
add    $0x1,%rdx
cmp    %rdx,%rax
je     15b0 <odr1v_+0x490>
movsd  (%r9,%rdx,8),%xmm1
addsd  %xmm0,%xmm1
movapd %xmm1,%xmm5
andpd  %xmm2,%xmm5
movsd  (%r14),%xmm6
cmpltsd %xmm6,%xmm5
xorpd  %xmm3,%xmm6
andpd  %xmm5,%xmm6
andnpd %xmm1,%xmm5
orpd   %xmm5,%xmm6
movsd  (%r10,%rdx,8),%xmm1
divsd  %xmm6,%xmm1
movsd  %xmm1,-0x8(%rdi,%rdx,8)
mulsd  %xmm1,%xmm0
mulsd  (%rbx,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
ucomisd %xmm4,%xmm1
jne    1540 <odr1v_+0x420>
jp     1540 <odr1v_+0x420>
movsd  (%r8,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
jmp    1540 <odr1v_+0x420>
movsd  %xmm0,0x8(%rsp)
mov    0x18(%rsp),%rbx
jmp    15d6 <odr1v_+0x4b6>
mov    0x20(%rsp),%rax
movsd  (%rax),%xmm1
movl   $0x0,0x34(%rsp)
mov    0x140(%rsp),%r11
mov    %r12,0x68(%rsp)
movslq (%r12),%rax
mov    0x10(%rsp),%rcx
movsd  -0x8(%rcx,%rax,8),%xmm0
subsd  %xmm1,%xmm0
lea    (%rax,%rbx,1),%ecx
movslq %ecx,%rcx
movsd  %xmm0,-0x8(%r11,%rcx,8)
xor    %r14d,%r14d
cmp    %r15d,%eax
mov    0x20(%rsp),%r8
jle    16d6 <odr1v_+0x5b6>
movslq %r15d,%rcx
mov    %rcx,0x58(%rsp)
mov    0x18(%rsp),%rcx
lea    (%rax,%rcx,1),%r9d
lea    (%rax,%rcx,1),%r10d
add    $0xffffffff,%r10d
mov    0x48(%rsp),%rcx
add    %rax,%rcx
lea    -0x10(%r11,%rcx,8),%r13
mov    0xd8(%rsp),%rcx
lea    -0x10(%rcx,%rax,8),%r12
mov    0x10(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
add    $0xfffffffffffffff0,%rcx
mov    0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
add    $0xfffffffffffffff0,%rdx
xor    %esi,%esi
xorpd  %xmm0,%xmm0
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rsi,8),%xmm1
lea    (%r9,%rsi,1),%edi
movslq %edi,%rdi
addsd  -0x8(%r11,%rdi,8),%xmm1
movsd  (%rcx,%rsi,8),%xmm2
divsd  %xmm1,%xmm2
xor    %ebx,%ebx
ucomisd %xmm1,%xmm0
seta   %bl
add    %ebx,%r14d
movsd  (%rdx,%rsi,8),%xmm1
mulsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13,%rsi,8)
mulsd  -0x8(%r11,%rdi,8),%xmm2
subsd  (%r8),%xmm2
lea    (%r10,%rsi,1),%edi
movslq %edi,%rdi
movsd  %xmm2,-0x8(%r11,%rdi,8)
lea    (%rax,%rsi,1),%rdi
add    $0xffffffffffffffff,%rdi
add    $0xffffffffffffffff,%rsi
cmp    0x58(%rsp),%rdi
jg     1670 <odr1v_+0x550>
mov    0x18(%rsp),%rax
add    %r15d,%eax
cltq
mov    %rax,0x78(%rsp)
movsd  -0x8(%r11,%rax,8),%xmm0
movsd  %xmm0,0x40(%rsp)
lea    0x40(%rsp),%rdi
call   1030 <odnan_@plt>
mov    %eax,0x64(%rsp)
test   %eax,%eax
movsd  0x88(%rsp),%xmm7
je     186d <odr1v_+0x74d>
mov    0x68(%rsp),%rax
movslq (%rax),%rcx
xor    %r14d,%r14d
cmp    %r15d,%ecx
jle    186d <odr1v_+0x74d>
movslq %r15d,%rax
mov    %rax,0x58(%rsp)
mov    0x18(%rsp),%rax
lea    (%rcx,%rax,1),%edx
mov    %rdx,0x90(%rsp)
lea    -0x1(%rcx,%rax,1),%r10d
mov    0x48(%rsp),%rax
add    %rcx,%rax
mov    0x140(%rsp),%rdx
lea    -0x10(%rdx,%rax,8),%r11
mov    0xd8(%rsp),%rax
lea    -0x10(%rax,%rcx,8),%r13
mov    0x10(%rsp),%rax
lea    (%rax,%rcx,8),%rdi
add    $0xfffffffffffffff0,%rdi
mov    0x28(%rsp),%rax
lea    (%rax,%rcx,8),%rdx
add    $0xfffffffffffffff0,%rdx
xor    %r12d,%r12d
movapd 0x877(%rip),%xmm0
movapd 0x87f(%rip),%xmm1
xorpd  %xmm2,%xmm2
xor    %r14d,%r14d
mov    0x20(%rsp),%r9
jmp    17bd <odr1v_+0x69d>
nop
mov    %r8b,%bl
add    %ebx,%r14d
lea    (%rcx,%r12,1),%rax
add    $0xffffffffffffffff,%rax
add    $0xffffffffffffffff,%r12
cmp    0x58(%rsp),%rax
jle    186d <odr1v_+0x74d>
movsd  0x0(%r13,%r12,8),%xmm3
mov    0x90(%rsp),%rax
add    %r12d,%eax
cltq
mov    0x140(%rsp),%rsi
addsd  -0x8(%rsi,%rax,8),%xmm3
movapd %xmm3,%xmm4
andpd  %xmm0,%xmm4
mov    0xe0(%rsp),%rbx
movsd  (%rbx),%xmm5
cmpltsd %xmm5,%xmm4
xorpd  %xmm1,%xmm5
andpd  %xmm4,%xmm5
andnpd %xmm3,%xmm4
orpd   %xmm4,%xmm5
movsd  (%rdi,%r12,8),%xmm3
divsd  %xmm5,%xmm3
xor    %ebx,%ebx
ucomisd %xmm5,%xmm2
seta   %r8b
movsd  (%rdx,%r12,8),%xmm4
mulsd  %xmm3,%xmm4
movsd  %xmm4,(%r11,%r12,8)
movsd  -0x8(%rsi,%rax,8),%xmm4
mulsd  %xmm3,%xmm4
subsd  (%r9),%xmm4
lea    (%r10,%r12,1),%eax
cltq
movsd  %xmm4,-0x8(%rsi,%rax,8)
ucomisd %xmm2,%xmm3
jne    17a0 <odr1v_+0x680>
jp     17a0 <odr1v_+0x680>
movsd  (%rdi,%r12,8),%xmm3
subsd  (%r9),%xmm3
movsd  %xmm3,-0x8(%rsi,%rax,8)
jmp    17a0 <odr1v_+0x680>
mov    0x80(%rsp),%rax
add    %r15d,%eax
add    $0xffffffff,%eax
movslq %eax,%rcx
mov    0x140(%rsp),%r11
movsd  -0x8(%r11,%rcx,8),%xmm0
mov    0x78(%rsp),%rax
addsd  -0x8(%r11,%rax,8),%xmm0
mov    0x110(%rsp),%r13
movsd  %xmm0,0x0(%r13)
xorpd  %xmm1,%xmm1
xor    %eax,%eax
ucomisd %xmm0,%xmm1
seta   %al
add    %ebp,%r14d
add    %eax,%r14d
mov    0xf8(%rsp),%rax
cmpl   $0x1,(%rax)
sbb    %eax,%eax
or     %r14d,%eax
mov    0x100(%rsp),%rdx
mov    %eax,(%rdx)
ucomisd %xmm1,%xmm0
jne    18ed <odr1v_+0x7cd>
jp     18ed <odr1v_+0x7cd>
movsd  -0x8(%r11,%rcx,8),%xmm0
mulsd  %xmm7,%xmm0
movsd  %xmm0,0x0(%r13)
mov    0x120(%rsp),%r8
mov    0x108(%rsp),%r9
mov    0xf0(%rsp),%rsi
mov    0x118(%rsp),%r12
mov    %r15d,(%r12)
mov    0x4(%rsp),%eax
cmp    %eax,%r15d
mov    0xd0(%rsp),%rdx
mov    0x68(%rsp),%r10
mov    0x48(%rsp),%r14
mov    0x50(%rsp),%rcx
jge    19cd <odr1v_+0x8ad>
movslq %eax,%rdi
mov    0x38(%rsp),%rax
lea    (%r11,%rax,8),%rbp
add    $0xfffffffffffffff8,%rbp
add    $0x1,%r15d
xorpd  %xmm1,%xmm1
movapd 0x6ab(%rip),%xmm2
mov    0x18(%rsp),%rbx
jmp    1969 <odr1v_+0x849>
nopl   0x0(%rax)
add    $0x1,%r15d
cmp    %rcx,%rdi
je     19c7 <odr1v_+0x8a7>
movsd  0x0(%rbp,%rcx,8),%xmm4
add    $0x1,%rcx
lea    (%rbx,%r15,1),%eax
cltq
movapd %xmm7,%xmm5
mulsd  %xmm4,%xmm5
addsd  -0x8(%r11,%rax,8),%xmm4
movapd %xmm4,%xmm3
cmpeqsd %xmm1,%xmm3
movapd %xmm3,%xmm6
andnpd %xmm4,%xmm6
andpd  %xmm5,%xmm3
orpd   %xmm6,%xmm3
movapd %xmm3,%xmm4
andpd  %xmm2,%xmm4
movapd %xmm0,%xmm5
andpd  %xmm2,%xmm5
ucomisd %xmm4,%xmm5
jb     1960 <odr1v_+0x840>
movsd  %xmm3,0x0(%r13)
mov    %r15d,(%r12)
movapd %xmm3,%xmm0
jmp    1960 <odr1v_+0x840>
movsd  %xmm3,0x40(%rsp)
mov    0xe8(%rsp),%r15
cmpl   $0x0,0x64(%rsp)
setne  %bl
mov    0x70(%rsp),%rdi
mov    (%rdi),%eax
mov    %eax,(%r8)
mov    (%r10),%eax
mov    %eax,0x4(%r8)
movslq (%r12),%rax
movabs $0x3ff0000000000000,%rbp
mov    %rbp,-0x8(%rsi,%rax,8)
mov    %rbp,(%r9)
mov    0x34(%rsp),%ecx
or     %bl,%cl
movslq (%rdi),%rbp
je     1ac2 <odr1v_+0x9a2>
cmp    %ebp,%eax
jle    1b47 <odr1v_+0xa27>
xorpd  %xmm0,%xmm0
movapd 0x5e9(%rip),%xmm1
movapd 0x5d1(%rip),%xmm2
nop
movsd  -0x8(%rsi,%rax,8),%xmm4
ucomisd %xmm0,%xmm4
jne    1a60 <odr1v_+0x940>
jp     1a60 <odr1v_+0x940>
movsd  -0x8(%rdx,%rax,8),%xmm3
xorpd  %xmm1,%xmm3
divsd  -0x10(%rdx,%rax,8),%xmm3
mulsd  (%rsi,%rax,8),%xmm3
jmp    1a6f <odr1v_+0x94f>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x10(%r11,%rax,8),%xmm3
xorpd  %xmm1,%xmm3
mulsd  %xmm4,%xmm3
movsd  %xmm3,-0x10(%rsi,%rax,8)
movapd %xmm3,%xmm5
andpd  %xmm2,%xmm5
andpd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  -0x10(%rdx,%rax,8),%xmm5
andpd  %xmm2,%xmm5
mulsd  %xmm4,%xmm5
movsd  (%r15),%xmm4
ucomisd %xmm5,%xmm4
ja     1c0f <odr1v_+0xaef>
add    $0xffffffffffffffff,%rax
mulsd  %xmm3,%xmm3
addsd  (%r9),%xmm3
movsd  %xmm3,(%r9)
cmp    %rbp,%rax
jg     1a30 <odr1v_+0x910>
jmp    1b3f <odr1v_+0xa1f>
cmp    %ebp,%eax
jle    1c27 <odr1v_+0xb07>
movapd 0x53e(%rip),%xmm0
movapd 0x526(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rax,8),%xmm3
movsd  -0x10(%r11,%rax,8),%xmm2
xorpd  %xmm0,%xmm2
mulsd  %xmm3,%xmm2
movsd  %xmm2,-0x10(%rsi,%rax,8)
movapd %xmm2,%xmm4
andpd  %xmm1,%xmm4
andpd  %xmm1,%xmm3
addsd  %xmm4,%xmm3
movsd  -0x10(%rdx,%rax,8),%xmm4
andpd  %xmm1,%xmm4
mulsd  %xmm3,%xmm4
movsd  (%r15),%xmm3
ucomisd %xmm4,%xmm3
ja     1c0f <odr1v_+0xaef>
add    $0xffffffffffffffff,%rax
mulsd  %xmm2,%xmm2
addsd  (%r9),%xmm2
movsd  %xmm2,(%r9)
cmp    %rbp,%rax
jg     1ae0 <odr1v_+0x9c0>
test   %cl,%cl
je     1c27 <odr1v_+0xb07>
movslq (%r10),%rbp
movslq (%r12),%rax
cmp    %ebp,%eax
jge    1cb6 <odr1v_+0xb96>
lea    (%r11,%r14,8),%rbx
add    $0xfffffffffffffff8,%rbx
xorpd  %xmm0,%xmm0
movapd 0x4a6(%rip),%xmm1
movapd 0x48e(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%rsi,%rax,8),%xmm4
ucomisd %xmm0,%xmm4
jne    1bb0 <odr1v_+0xa90>
jp     1bb0 <odr1v_+0xa90>
movsd  -0x10(%rdx,%rax,8),%xmm3
xorpd  %xmm1,%xmm3
divsd  -0x8(%rdx,%rax,8),%xmm3
mulsd  -0x10(%rsi,%rax,8),%xmm3
jmp    1bbd <odr1v_+0xa9d>
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rax,8),%xmm3
xorpd  %xmm1,%xmm3
mulsd  %xmm4,%xmm3
movsd  %xmm3,(%rsi,%rax,8)
andpd  %xmm2,%xmm4
movapd %xmm3,%xmm5
andpd  %xmm2,%xmm5
addsd  %xmm4,%xmm5
movsd  -0x8(%rdx,%rax,8),%xmm4
andpd  %xmm2,%xmm4
mulsd  %xmm5,%xmm4
movsd  (%r15),%xmm5
ucomisd %xmm4,%xmm5
ja     1caa <odr1v_+0xb8a>
add    $0x1,%rax
mulsd  %xmm3,%xmm3
addsd  (%r9),%xmm3
movsd  %xmm3,(%r9)
cmp    %rax,%rbp
jne    1b80 <odr1v_+0xa60>
jmp    1cb6 <odr1v_+0xb96>
lea    -0x1(%rax),%rbp
movq   $0x0,-0x8(%rsi,%rbp,8)
mov    %eax,(%r8)
test   %cl,%cl
jne    1b47 <odr1v_+0xa27>
movslq (%r10),%rbp
movslq (%r12),%rax
cmp    %ebp,%eax
jge    1cb6 <odr1v_+0xb96>
lea    (%r11,%r14,8),%rbx
add    $0xfffffffffffffff8,%rbx
movapd 0x3ca(%rip),%xmm0
movapd 0x3b2(%rip),%xmm1
xchg   %ax,%ax
movsd  -0x8(%rsi,%rax,8),%xmm3
movsd  (%rbx,%rax,8),%xmm2
xorpd  %xmm0,%xmm2
mulsd  %xmm3,%xmm2
movsd  %xmm2,(%rsi,%rax,8)
andpd  %xmm1,%xmm3
movapd %xmm2,%xmm4
andpd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movsd  -0x8(%rdx,%rax,8),%xmm3
andpd  %xmm1,%xmm3
mulsd  %xmm4,%xmm3
movsd  (%r15),%xmm4
ucomisd %xmm3,%xmm4
ja     1caa <odr1v_+0xb8a>
add    $0x1,%rax
mulsd  %xmm2,%xmm2
addsd  (%r9),%xmm2
movsd  %xmm2,(%r9)
cmp    %rax,%rbp
jne    1c50 <odr1v_+0xb30>
jmp    1cb6 <odr1v_+0xb96>
movq   $0x0,(%rsi,%rax,8)
mov    %eax,0x4(%r8)
mov    0x138(%rsp),%r14
mov    0x130(%rsp),%rbp
mov    0x128(%rsp),%rbx
movsd  0x34a(%rip),%xmm0
divsd  (%r9),%xmm0
movsd  %xmm0,0x40(%rsp)
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1cf1 <odr1v_+0xbd1>
sqrtsd %xmm0,%xmm0
jmp    1cf6 <odr1v_+0xbd6>
call   1040 <sqrt@plt>
movsd  %xmm0,(%rbx)
movsd  0x0(%r13),%xmm1
andpd  0x2f8(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%rbp)
movsd  0x0(%r13),%xmm0
mulsd  0x40(%rsp),%xmm0
movsd  %xmm0,(%r14)
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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