#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 fabs(double);
double fmax(double, double);
double fmin(double, double);
int odebz_(int *ijob, int *nitmax, int *n, int *mmax, int *minp, int *nbmin,
           double *abstol, double *reltol, double *pivmin, double *d__,
           double *e, double *e2, int *nval, double *ab, double *c__, int *mout,
           int *nab, double *work, int *iwork, int *info) {
  int nab_dim1, nab_offset, ab_dim1, ab_offset, i__1, i__2, i__3, i__4, i__5,
      i__6;
  double d__1, d__2, d__3, d__4;
  int j, kf, ji, kl, jp, jit;
  double tmp1, tmp2;
  int itmp1, itmp2, kfnew, klnew;
  nab_dim1 = *mmax;
  nab_offset = 1 + nab_dim1;
  nab -= nab_offset;
  ab_dim1 = *mmax;
  ab_offset = 1 + ab_dim1;
  ab -= ab_offset;
  --d__;
  --e;
  --e2;
  --nval;
  --c__;
  --work;
  --iwork;
  *info = 0;
  if (*ijob < 1 || *ijob > 3) {
    *info = -1;
    return 0;
  }
  if (*ijob == 1) {
    *mout = 0;
    i__1 = *minp;
    for (ji = 1; ji <= i__1; ++ji) {
      for (jp = 1; jp <= 2; ++jp) {
        tmp1 = d__[1] - ab[ji + jp * ab_dim1];
        if (fabs(tmp1) < *pivmin) {
          tmp1 = -(*pivmin);
        }
        nab[ji + jp * nab_dim1] = 0;
        if (tmp1 <= 0.) {
          nab[ji + jp * nab_dim1] = 1;
        }
        i__2 = *n;
        for (j = 2; j <= i__2; ++j) {
          tmp1 = d__[j] - e2[j - 1] / tmp1 - ab[ji + jp * ab_dim1];
          if (fabs(tmp1) < *pivmin) {
            tmp1 = -(*pivmin);
          }
          if (tmp1 <= 0.) {
            ++nab[ji + jp * nab_dim1];
          }
        }
      }
      *mout = *mout + nab[ji + (nab_dim1 << 1)] - nab[ji + nab_dim1];
    }
    return 0;
  }
  kf = 1;
  kl = *minp;
  if (*ijob == 2) {
    i__1 = *minp;
    for (ji = 1; ji <= i__1; ++ji) {
      c__[ji] = (ab[ji + ab_dim1] + ab[ji + (ab_dim1 << 1)]) * .5;
    }
  }
  i__1 = *nitmax;
  for (jit = 1; jit <= i__1; ++jit) {
    if (kl - kf + 1 >= *nbmin && *nbmin > 0) {
      i__2 = kl;
      for (ji = kf; ji <= i__2; ++ji) {
        work[ji] = d__[1] - c__[ji];
        iwork[ji] = 0;
        if (work[ji] <= *pivmin) {
          iwork[ji] = 1;
          d__1 = work[ji], d__2 = -(*pivmin);
          work[ji] = fmin(d__1, d__2);
        }
        i__3 = *n;
        for (j = 2; j <= i__3; ++j) {
          work[ji] = d__[j] - e2[j - 1] / work[ji] - c__[ji];
          if (work[ji] <= *pivmin) {
            ++iwork[ji];
            d__1 = work[ji], d__2 = -(*pivmin);
            work[ji] = fmin(d__1, d__2);
          }
        }
      }
      if (*ijob <= 2) {
        klnew = kl;
        i__2 = kl;
        for (ji = kf; ji <= i__2; ++ji) {
          i__5 = nab[ji + nab_dim1], i__6 = iwork[ji];
          i__3 = nab[ji + (nab_dim1 << 1)],
          i__4 = ((i__5) > (i__6) ? (i__5) : (i__6));
          iwork[ji] = ((i__3) < (i__4) ? (i__3) : (i__4));
          if (iwork[ji] == nab[ji + (nab_dim1 << 1)]) {
            ab[ji + (ab_dim1 << 1)] = c__[ji];
          } else if (iwork[ji] == nab[ji + nab_dim1]) {
            ab[ji + ab_dim1] = c__[ji];
          } else {
            ++klnew;
            if (klnew <= *mmax) {
              ab[klnew + (ab_dim1 << 1)] = ab[ji + (ab_dim1 << 1)];
              nab[klnew + (nab_dim1 << 1)] = nab[ji + (nab_dim1 << 1)];
              ab[klnew + ab_dim1] = c__[ji];
              nab[klnew + nab_dim1] = iwork[ji];
              ab[ji + (ab_dim1 << 1)] = c__[ji];
              nab[ji + (nab_dim1 << 1)] = iwork[ji];
            } else {
              *info = *mmax + 1;
            }
          }
        }
        if (*info != 0) {
          return 0;
        }
        kl = klnew;
      } else {
        i__2 = kl;
        for (ji = kf; ji <= i__2; ++ji) {
          if (iwork[ji] <= nval[ji]) {
            ab[ji + ab_dim1] = c__[ji];
            nab[ji + nab_dim1] = iwork[ji];
          }
          if (iwork[ji] >= nval[ji]) {
            ab[ji + (ab_dim1 << 1)] = c__[ji];
            nab[ji + (nab_dim1 << 1)] = iwork[ji];
          }
        }
      }
    } else {
      klnew = kl;
      i__2 = kl;
      for (ji = kf; ji <= i__2; ++ji) {
        tmp1 = c__[ji];
        tmp2 = d__[1] - tmp1;
        itmp1 = 0;
        if (tmp2 <= *pivmin) {
          itmp1 = 1;
          d__1 = tmp2, d__2 = -(*pivmin);
          tmp2 = fmin(d__1, d__2);
        }
        i__3 = *n;
        for (j = 2; j <= i__3; ++j) {
          tmp2 = d__[j] - e2[j - 1] / tmp2 - tmp1;
          if (tmp2 <= *pivmin) {
            ++itmp1;
            d__1 = tmp2, d__2 = -(*pivmin);
            tmp2 = fmin(d__1, d__2);
          }
        }
        if (*ijob <= 2) {
          i__5 = nab[ji + nab_dim1];
          i__3 = nab[ji + (nab_dim1 << 1)],
          i__4 = ((i__5) > (itmp1) ? (i__5) : (itmp1));
          itmp1 = ((i__3) < (i__4) ? (i__3) : (i__4));
          if (itmp1 == nab[ji + (nab_dim1 << 1)]) {
            ab[ji + (ab_dim1 << 1)] = tmp1;
          } else if (itmp1 == nab[ji + nab_dim1]) {
            ab[ji + ab_dim1] = tmp1;
          } else if (klnew < *mmax) {
            ++klnew;
            ab[klnew + (ab_dim1 << 1)] = ab[ji + (ab_dim1 << 1)];
            nab[klnew + (nab_dim1 << 1)] = nab[ji + (nab_dim1 << 1)];
            ab[klnew + ab_dim1] = tmp1;
            nab[klnew + nab_dim1] = itmp1;
            ab[ji + (ab_dim1 << 1)] = tmp1;
            nab[ji + (nab_dim1 << 1)] = itmp1;
          } else {
            *info = *mmax + 1;
            return 0;
          }
        } else {
          if (itmp1 <= nval[ji]) {
            ab[ji + ab_dim1] = tmp1;
            nab[ji + nab_dim1] = itmp1;
          }
          if (itmp1 >= nval[ji]) {
            ab[ji + (ab_dim1 << 1)] = tmp1;
            nab[ji + (nab_dim1 << 1)] = itmp1;
          }
        }
      }
      kl = klnew;
    }
    kfnew = kf;
    i__2 = kl;
    for (ji = kf; ji <= i__2; ++ji) {
      tmp1 = (d__1 = ab[ji + (ab_dim1 << 1)] - ab[ji + ab_dim1], fabs(d__1));
      d__3 = (d__1 = ab[ji + (ab_dim1 << 1)], fabs(d__1)),
      d__4 = (d__2 = ab[ji + ab_dim1], fabs(d__2));
      tmp2 = fmax(d__3, d__4);
      d__1 = fmax(*abstol, *pivmin), d__2 = *reltol * tmp2;
      if (tmp1 < fmax(d__1, d__2) ||
          nab[ji + nab_dim1] >= nab[ji + (nab_dim1 << 1)]) {
        if (ji > kfnew) {
          tmp1 = ab[ji + ab_dim1];
          tmp2 = ab[ji + (ab_dim1 << 1)];
          itmp1 = nab[ji + nab_dim1];
          itmp2 = nab[ji + (nab_dim1 << 1)];
          ab[ji + ab_dim1] = ab[kfnew + ab_dim1];
          ab[ji + (ab_dim1 << 1)] = ab[kfnew + (ab_dim1 << 1)];
          nab[ji + nab_dim1] = nab[kfnew + nab_dim1];
          nab[ji + (nab_dim1 << 1)] = nab[kfnew + (nab_dim1 << 1)];
          ab[kfnew + ab_dim1] = tmp1;
          ab[kfnew + (ab_dim1 << 1)] = tmp2;
          nab[kfnew + nab_dim1] = itmp1;
          nab[kfnew + (nab_dim1 << 1)] = itmp2;
          if (*ijob == 3) {
            itmp1 = nval[ji];
            nval[ji] = nval[kfnew];
            nval[kfnew] = itmp1;
          }
        }
        ++kfnew;
      }
    }
    kf = kfnew;
    i__2 = kl;
    for (ji = kf; ji <= i__2; ++ji) {
      c__[ji] = (ab[ji + ab_dim1] + ab[ji + (ab_dim1 << 1)]) * .5;
    }
    if (kf > kl) {
      goto L140;
    }
  }
L140:
  i__1 = kl + 1 - kf;
  *info = ((i__1) > (0) ? (i__1) : (0));
  *mout = kl;
  return 0;
}


x86 assembly (clang, -O0):
<odebz_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
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,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%ecx
mov    0x60(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,0x60(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%ecx
mov    0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,0x48(%rbp)
mov    0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x28(%rbp)
mov    0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x30(%rbp)
mov    0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x38(%rbp)
mov    0x40(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rbp)
mov    0x50(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x50(%rbp)
mov    0x68(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,0x68(%rbp)
mov    0x70(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x70(%rbp)
mov    0x78(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x10(%rbp),%rax
cmpl   $0x1,(%rax)
jl     1228 <odebz_+0x128>
mov    -0x10(%rbp),%rax
cmpl   $0x3,(%rax)
jle    123e <odebz_+0x13e>
mov    0x78(%rbp),%rax
movl   $0xffffffff,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    267c <odebz_+0x157c>
mov    -0x10(%rbp),%rax
cmpl   $0x1,(%rax)
jne    14db <odebz_+0x3db>
mov    0x58(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     14cf <odebz_+0x3cf>
movl   $0x1,-0x94(%rbp)
cmpl   $0x2,-0x94(%rbp)
jg     1484 <odebz_+0x384>
mov    0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x94(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movaps 0x1d44(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    1309 <odebz_+0x209>
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    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x94(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jb     135a <odebz_+0x25a>
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x94(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x50(%rbp)
movl   $0x2,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     146b <odebz_+0x36b>
mov    0x28(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0xa0(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x94(%rbp),%edx
imul   -0x44(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm1
ff
movaps 0x1c2e(%rip),%xmm0
pand   %xmm0,%xmm1
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    141f <odebz_+0x31f>
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
ucomisd -0xa0(%rbp),%xmm0
ff
jb     1452 <odebz_+0x352>
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x94(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1457 <odebz_+0x357>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    136d <odebz_+0x26d>
jmp    1470 <odebz_+0x370>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1281 <odebz_+0x181>
mov    0x58(%rbp),%rax
mov    (%rax),%ecx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%edx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rax,%rdx,4),%ecx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%edx
add    -0x3c(%rbp),%edx
movslq %edx,%rdx
sub    (%rax,%rdx,4),%ecx
mov    0x58(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1268 <odebz_+0x168>
movl   $0x0,-0x4(%rbp)
jmp    267c <odebz_+0x157c>
movl   $0x1,-0x88(%rbp)
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x90(%rbp)
mov    -0x10(%rbp),%rax
cmpl   $0x2,(%rax)
jne    1584 <odebz_+0x484>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     157f <odebz_+0x47f>
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x1aa9(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1511 <odebz_+0x411>
jmp    1584 <odebz_+0x484>
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x1,-0x98(%rbp)
mov    -0x98(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     2621 <odebz_+0x1521>
mov    -0x90(%rbp),%eax
sub    -0x88(%rbp),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%rcx
cmp    (%rcx),%eax
jl     1c51 <odebz_+0xb51>
mov    -0x38(%rbp),%rax
cmpl   $0x0,(%rax)
jle    1c51 <odebz_+0xb51>
mov    -0x90(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1826 <odebz_+0x726>
mov    0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     16d2 <odebz_+0x5d2>
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
movl   $0x2,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     180d <odebz_+0x70d>
mov    0x28(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
subsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     17f4 <odebz_+0x6f4>
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
mov    0x68(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    17f9 <odebz_+0x6f9>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    16e5 <odebz_+0x5e5>
jmp    1812 <odebz_+0x712>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    15e3 <odebz_+0x4e3>
mov    -0x10(%rbp),%rax
cmpl   $0x2,(%rax)
jg     1b30 <odebz_+0xa30>
mov    -0x90(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1b06 <odebz_+0xa06>
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x60(%rbp)
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x60(%rbp),%eax
jle    18bf <odebz_+0x7bf>
mov    -0x5c(%rbp),%eax
mov    %eax,-0xbc(%rbp)
jmp    18c8 <odebz_+0x7c8>
mov    -0x60(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    18eb <odebz_+0x7eb>
mov    -0x54(%rbp),%eax
mov    %eax,-0xc0(%rbp)
jmp    18f4 <odebz_+0x7f4>
mov    -0x58(%rbp),%eax
mov    %eax,-0xc0(%rbp)
mov    -0xc0(%rbp),%edx
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x60(%rbp),%rcx
mov    -0x8c(%rbp),%edx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1963 <odebz_+0x863>
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1aed <odebz_+0x9ed>
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x60(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x3c(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    19b4 <odebz_+0x8b4>
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ae8 <odebz_+0x9e8>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jg     1ad4 <odebz_+0x9d4>
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0xb8(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x60(%rbp),%rax
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0xb8(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x60(%rbp),%rax
mov    -0xb8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1ae3 <odebz_+0x9e3>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    0x78(%rbp),%rax
mov    %ecx,(%rax)
jmp    1ae8 <odebz_+0x9e8>
jmp    1aed <odebz_+0x9ed>
jmp    1af2 <odebz_+0x9f2>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1854 <odebz_+0x754>
mov    0x78(%rbp),%rax
cmpl   $0x0,(%rax)
je     1b1f <odebz_+0xa1f>
movl   $0x0,-0x4(%rbp)
jmp    267c <odebz_+0x157c>
mov    -0xb8(%rbp),%eax
mov    %eax,-0x90(%rbp)
jmp    1c4c <odebz_+0xb4c>
mov    -0x90(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     1c47 <odebz_+0xb47>
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x40(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1bbc <odebz_+0xabc>
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x40(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     1c2e <odebz_+0xb2e>
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x70(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1c33 <odebz_+0xb33>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1b45 <odebz_+0xa45>
jmp    1c4c <odebz_+0xb4c>
jmp    2170 <odebz_+0x1070>
mov    -0x90(%rbp),%eax
mov    %eax,-0xb8(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     2164 <odebz_+0x1064>
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x28(%rbp),%rax
movsd  0x8(%rax),%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0xac(%rbp)
movsd  -0xa8(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1d41 <odebz_+0xc41>
movl   $0x1,-0xac(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
movl   $0x2,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x54(%rbp),%eax
jg     1e47 <odebz_+0xd47>
mov    0x28(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
divsd  -0xa8(%rbp),%xmm1
ff
subsd  %xmm1,%xmm0
subsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
ucomisd %xmm1,%xmm0
jb     1e2e <odebz_+0xd2e>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%xmm3
movsd  -0x70(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
minsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
jmp    1e33 <odebz_+0xd33>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1d54 <odebz_+0xc54>
mov    -0x10(%rbp),%rax
cmpl   $0x2,(%rax)
jg     209c <odebz_+0xf9c>
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x5c(%rbp)
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0xac(%rbp),%eax
jle    1ea2 <odebz_+0xda2>
mov    -0x5c(%rbp),%eax
mov    %eax,-0xc4(%rbp)
jmp    1eae <odebz_+0xdae>
mov    -0xac(%rbp),%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1ed1 <odebz_+0xdd1>
mov    -0x54(%rbp),%eax
mov    %eax,-0xc8(%rbp)
jmp    1eda <odebz_+0xdda>
mov    -0x58(%rbp),%eax
mov    %eax,-0xc8(%rbp)
mov    -0xc8(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    0x60(%rbp),%rcx
mov    -0x8c(%rbp),%edx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1f31 <odebz_+0xe31>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2097 <odebz_+0xf97>
mov    -0xac(%rbp),%eax
mov    0x60(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x3c(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1f72 <odebz_+0xe72>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    2092 <odebz_+0xf92>
mov    -0xb8(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jge    2072 <odebz_+0xf72>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0xb8(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x60(%rbp),%rax
mov    -0xb8(%rbp),%ecx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    -0xb8(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%edx
mov    0x60(%rbp),%rax
mov    -0xb8(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%edx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    208d <odebz_+0xf8d>
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    0x78(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x4(%rbp)
jmp    267c <odebz_+0x157c>
jmp    2092 <odebz_+0xf92>
jmp    2097 <odebz_+0xf97>
jmp    214b <odebz_+0x104b>
mov    -0xac(%rbp),%eax
mov    0x40(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     20ec <odebz_+0xfec>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%edx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
mov    0x40(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     2146 <odebz_+0x1046>
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%edx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    214b <odebz_+0x104b>
jmp    2150 <odebz_+0x1050>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1c72 <odebz_+0xb72>
mov    -0xb8(%rbp),%eax
mov    %eax,-0x90(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0xb4(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     2562 <odebz_+0x1462>
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
subsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movaps 0xe30(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movaps 0xdf9(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
movaps 0xdca(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x78(%rbp),%xmm3
movsd  -0x80(%rbp),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm3
mov    0x20(%rbp),%rax
movsd  (%rax),%xmm2
movaps %xmm2,%xmm4
movaps %xmm3,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm1
pand   %xmm4,%xmm1
maxsd  %xmm3,%xmm2
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x18(%rbp),%rax
movsd  (%rax),%xmm0
mulsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x70(%rbp)
movsd  -0xa0(%rbp),%xmm1
ff
movsd  -0x68(%rbp),%xmm4
movsd  -0x70(%rbp),%xmm3
movaps %xmm3,%xmm5
movaps %xmm4,%xmm0
cmpunordsd %xmm0,%xmm0
movaps %xmm0,%xmm2
pand   %xmm5,%xmm2
maxsd  %xmm4,%xmm3
pandn  %xmm3,%xmm0
por    %xmm2,%xmm0
ucomisd %xmm1,%xmm0
ja     2332 <odebz_+0x1232>
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    0x60(%rbp),%rcx
mov    -0x8c(%rbp),%edx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jl     2549 <odebz_+0x1449>
mov    -0x8c(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jle    253a <odebz_+0x143a>
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xac(%rbp)
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    0x48(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x48(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x60(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x60(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    -0x3c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    0x60(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x48(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xac(%rbp),%edx
mov    0x60(%rbp),%rax
mov    -0xb4(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xb0(%rbp),%edx
mov    0x60(%rbp),%rax
mov    -0xb4(%rbp),%ecx
mov    -0x3c(%rbp),%esi
shl    $0x1,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
cmpl   $0x3,(%rax)
jne    2535 <odebz_+0x1435>
mov    0x40(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xac(%rbp)
mov    0x40(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    0x40(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xac(%rbp),%edx
mov    0x40(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    253a <odebz_+0x143a>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    254e <odebz_+0x144e>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    2191 <odebz_+0x1091>
mov    -0xb4(%rbp),%eax
mov    %eax,-0x88(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x88(%rbp),%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x50(%rbp),%eax
jg     25f1 <odebz_+0x14f1>
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    -0x44(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0xa37(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x50(%rbp),%rax
movslq -0x8c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    2583 <odebz_+0x1483>
mov    -0x88(%rbp),%eax
cmp    -0x90(%rbp),%eax
jle    2608 <odebz_+0x1508>
jmp    2626 <odebz_+0x1526>
jmp    260d <odebz_+0x150d>
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    1597 <odebz_+0x497>
jmp    2626 <odebz_+0x1526>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
sub    -0x88(%rbp),%eax
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jle    2650 <odebz_+0x1550>
mov    -0x4c(%rbp),%eax
mov    %eax,-0xcc(%rbp)
jmp    265d <odebz_+0x155d>
xor    %eax,%eax
mov    %eax,-0xcc(%rbp)
jmp    265d <odebz_+0x155d>
mov    -0xcc(%rbp),%ecx
mov    0x78(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x90(%rbp),%ecx
mov    0x58(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<odebz_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x50,%rsp
mov    %r9,0x38(%rsp)
mov    %rdx,-0x30(%rsp)
mov    0xf0(%rsp),%rdx
mov    %rcx,0x8(%rsp)
movslq (%rcx),%rax
mov    %rax,-0x78(%rsp)
movl   $0x0,(%rdx)
mov    (%rdi),%eax
lea    -0x4(%rax),%ecx
cmp    $0xfffffffc,%ecx
ja     1148 <odebz_+0x48>
movl   $0xffffffff,(%rdx)
jmp    20f6 <odebz_+0xff6>
mov    0xd8(%rsp),%rcx
mov    0xd0(%rsp),%r11
mov    0xc0(%rsp),%rbx
mov    0xb0(%rsp),%r12
mov    0xa0(%rsp),%r10
mov    -0x78(%rsp),%r13
not    %r13
lea    (%rcx,%r13,4),%rcx
mov    %rcx,-0x40(%rsp)
lea    (%rbx,%r13,8),%rcx
mov    %rcx,-0x70(%rsp)
cmp    $0x1,%eax
jne    1381 <odebz_+0x281>
movl   $0x0,(%r11)
mov    (%r8),%r15d
test   %r15d,%r15d
mov    0x98(%rsp),%rax
jle    20f6 <odebz_+0xff6>
movsd  (%r10),%xmm8
movsd  (%rax),%xmm1
movapd 0x1e51(%rip),%xmm2
xorpd  %xmm1,%xmm2
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rcx,1),%eax
movslq %eax,%r8
add    $0x1,%r15
lea    (%rcx,%rcx,1),%r9
mov    $0x1,%ebp
movapd 0x1e3d(%rip),%xmm3
xorpd  %xmm4,%xmm4
mov    -0x40(%rsp),%rbx
jmp    120d <odebz_+0x10d>
xchg   %ax,%ax
lea    (%r8,%rbp,1),%rax
mov    (%rbx,%rax,4),%eax
add    (%r11),%eax
sub    (%rbx,%rsi,4),%eax
mov    %eax,(%r11)
add    $0x1,%rbp
cmp    %r15,%rbp
je     20f6 <odebz_+0xff6>
mov    -0x78(%rsp),%rax
lea    (%rax,%rbp,1),%rsi
mov    -0x70(%rsp),%rax
movsd  (%rax,%rsi,8),%xmm5
movapd %xmm8,%xmm7
subsd  %xmm5,%xmm7
movapd %xmm7,%xmm6
andpd  %xmm3,%xmm6
cmpltsd %xmm1,%xmm6
movapd %xmm6,%xmm0
andnpd %xmm7,%xmm0
andpd  %xmm2,%xmm6
orpd   %xmm0,%xmm6
xor    %edx,%edx
ucomisd %xmm6,%xmm4
setae  %dl
mov    %edx,(%rbx,%rsi,4)
mov    -0x30(%rsp),%rax
mov    (%rax),%edi
cmp    $0x2,%edi
jge    1320 <odebz_+0x220>
lea    (%r9,%rbp,1),%rdx
mov    -0x70(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm5
movapd %xmm8,%xmm0
subsd  %xmm5,%xmm0
movapd %xmm0,%xmm6
andpd  %xmm3,%xmm6
cmpltsd %xmm1,%xmm6
movapd %xmm6,%xmm7
andnpd %xmm0,%xmm7
andpd  %xmm2,%xmm6
orpd   %xmm7,%xmm6
xor    %edi,%edi
ucomisd %xmm6,%xmm4
setae  %dil
mov    %edi,(%rbx,%rdx,4)
mov    -0x30(%rsp),%rax
mov    (%rax),%ecx
cmp    $0x2,%ecx
jl     11f0 <odebz_+0xf0>
add    $0xffffffffffffffff,%rcx
xor    %eax,%eax
jmp    12cd <odebz_+0x1cd>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %rax,%rcx
je     11f0 <odebz_+0xf0>
movsd  0x8(%r10,%rax,8),%xmm0
movsd  (%r12,%rax,8),%xmm7
divsd  %xmm6,%xmm7
subsd  %xmm7,%xmm0
subsd  %xmm5,%xmm0
movapd %xmm0,%xmm6
andpd  %xmm3,%xmm6
cmpltsd %xmm1,%xmm6
movapd %xmm6,%xmm7
andnpd %xmm0,%xmm7
andpd  %xmm2,%xmm6
orpd   %xmm7,%xmm6
ucomisd %xmm6,%xmm4
jb     12c0 <odebz_+0x1c0>
add    $0x1,%edi
mov    %edi,(%rbx,%rdx,4)
jmp    12c0 <odebz_+0x1c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rdi
xor    %ecx,%ecx
jmp    133d <odebz_+0x23d>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
cmp    %rcx,%rdi
je     1262 <odebz_+0x162>
movsd  0x8(%r10,%rcx,8),%xmm0
movsd  (%r12,%rcx,8),%xmm7
divsd  %xmm6,%xmm7
subsd  %xmm7,%xmm0
subsd  %xmm5,%xmm0
movapd %xmm0,%xmm6
andpd  %xmm3,%xmm6
cmpltsd %xmm1,%xmm6
movapd %xmm6,%xmm7
andnpd %xmm0,%xmm7
andpd  %xmm2,%xmm6
orpd   %xmm7,%xmm6
ucomisd %xmm6,%xmm4
jb     1330 <odebz_+0x230>
add    $0x1,%edx
mov    %edx,(%rbx,%rsi,4)
jmp    1330 <odebz_+0x230>
mov    0xc8(%rsp),%r14
mov    (%r8),%ecx
mov    %rcx,-0x80(%rsp)
cmp    $0x2,%eax
jne    1560 <odebz_+0x460>
cmpl   $0x0,-0x80(%rsp)
jle    1560 <odebz_+0x460>
mov    -0x78(%rsp),%rax
add    %eax,%eax
movslq %eax,%r8
mov    -0x80(%rsp),%rcx
lea    0x1(%rcx),%r15
mov    $0x1,%eax
cmp    $0x4,%rcx
jae    1469 <odebz_+0x369>
mov    %rax,%rbp
not    %rbp
test   $0x1,%r15b
jne    1401 <odebz_+0x301>
mov    -0x78(%rsp),%rcx
add    %rax,%rcx
mov    -0x70(%rsp),%rdx
movsd  (%rdx,%rcx,8),%xmm0
lea    (%rax,%r8,1),%rcx
addsd  (%rdx,%rcx,8),%xmm0
mulsd  0x1c3a(%rip),%xmm0
movsd  %xmm0,-0x8(%r14,%rax,8)
add    $0x1,%rax
add    %r15,%rbp
je     1560 <odebz_+0x460>
add    %r13,%r8
lea    (%rbx,%r8,8),%rdx
mov    -0x78(%rsp),%rcx
add    %r13,%rcx
lea    (%rbx,%rcx,8),%rcx
movsd  0x1c0b(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rcx,%rax,8),%xmm1
addsd  (%rdx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r14,%rax,8)
movsd  0x8(%rcx,%rax,8),%xmm1
addsd  0x8(%rdx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r14,%rax,8)
add    $0x2,%rax
cmp    %rax,%r15
jne    1430 <odebz_+0x330>
jmp    1560 <odebz_+0x460>
lea    (%r14,%r15,8),%rdx
add    $0xfffffffffffffff8,%rdx
mov    %r8,-0x68(%rsp)
lea    (%r8,%r13,1),%rcx
lea    0x8(%rbx,%rcx,8),%r9
mov    %rcx,-0x60(%rsp)
lea    (%rcx,%r15,1),%rbp
mov    %rbx,%r11
lea    (%rbx,%rbp,8),%rbx
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r13,1),%rbp
lea    (%r15,%rbp,1),%r8
lea    (%r11,%r8,8),%rcx
cmp    %r14,%rbx
seta   %r8b
cmp    %rdx,%r9
setb   %r9b
cmp    %r14,%rcx
seta   %bl
lea    (%r11,%rbp,8),%rcx
add    $0x8,%rcx
cmp    %rdx,%rcx
setb   %dl
test   %r9b,%r8b
jne    2116 <odebz_+0x1016>
and    %dl,%bl
mov    0xc0(%rsp),%rbx
mov    -0x68(%rsp),%r8
jne    13c7 <odebz_+0x2c7>
mov    %rbx,%rcx
mov    -0x80(%rsp),%rbx
and    $0xfffffffc,%ebx
lea    0x1(%rbx),%rax
lea    (%rcx,%rbp,8),%rbp
add    $0x18,%rbp
mov    -0x60(%rsp),%rdx
lea    (%rcx,%rdx,8),%rdx
add    $0x18,%rdx
xor    %ecx,%ecx
movapd 0x1af2(%rip),%xmm0
xchg   %ax,%ax
movupd -0x10(%rbp,%rcx,8),%xmm1
movupd 0x0(%rbp,%rcx,8),%xmm2
movupd -0x10(%rdx,%rcx,8),%xmm3
addpd  %xmm1,%xmm3
movupd (%rdx,%rcx,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm1
movupd %xmm3,(%r14,%rcx,8)
movupd %xmm1,0x10(%r14,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbx
jne    1510 <odebz_+0x410>
cmp    %rbx,-0x80(%rsp)
mov    0xc0(%rsp),%rbx
jne    13c7 <odebz_+0x2c7>
mov    (%rsi),%eax
mov    %eax,-0x14(%rsp)
test   %eax,%eax
jle    20c5 <odebz_+0xfc5>
mov    0xe8(%rsp),%rax
mov    0xe0(%rsp),%r9
mov    0xb8(%rsp),%rdx
mov    -0x78(%rsp),%rcx
lea    (%rcx,%rcx,1),%ebp
mov    %rbp,%rsi
mov    %rbp,-0x20(%rsp)
movslq %ebp,%r15
lea    -0x8(%r14),%rsi
mov    %rsi,-0x28(%rsp)
lea    0x8(%rbx,%r13,8),%rsi
mov    %rsi,(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x10(%rsp)
lea    -0x4(%rdx),%rax
mov    %rax,-0x8(%rsp)
lea    0x8(%r14),%rax
mov    %rax,0x20(%rsp)
lea    (%r15,%r13,1),%rax
lea    (%rbx,%rax,8),%rax
mov    %rax,0x30(%rsp)
add    %rcx,%r13
lea    (%rbx,%r13,8),%rax
mov    %rax,0x28(%rsp)
mov    $0x1,%ecx
movapd 0x1a23(%rip),%xmm11
movsd  0x1a3a(%rip),%xmm9
movapd 0x1a01(%rip),%xmm8
movapd 0x1a18(%rip),%xmm10
mov    $0x1,%r11d
mov    %rdi,0x18(%rsp)
mov    0x98(%rsp),%r13
mov    %r15,-0x50(%rsp)
mov    -0x80(%rsp),%rax
mov    %eax,%r8d
sub    %r11d,%r8d
add    $0x1,%r8d
mov    0x38(%rsp),%rax
mov    (%rax),%eax
cmp    %eax,%r8d
mov    %r11,-0x58(%rsp)
mov    %rcx,0x40(%rsp)
jl     1670 <odebz_+0x570>
test   %eax,%eax
jle    1670 <odebz_+0x570>
mov    -0x80(%rsp),%rax
cmp    %eax,%r11d
jle    18b0 <odebz_+0x7b0>
cmpl   $0x3,(%rdi)
jl     19f4 <odebz_+0x8f4>
jmp    1c20 <odebz_+0xb20>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x80(%rsp),%rax
cmp    %eax,%r11d
jg     1c20 <odebz_+0xb20>
movslq %r11d,%rcx
lea    0x1(%rax),%r11d
jmp    16af <odebz_+0x5af>
nopw   0x0(%rax,%rax,1)
mov    -0x70(%rsp),%rdx
movsd  %xmm4,(%rdx,%rax,8)
mov    0xc8(%rsp),%r14
add    $0x1,%rcx
cmp    %ecx,%r11d
je     1c20 <odebz_+0xb20>
movsd  -0x8(%r14,%rcx,8),%xmm4
movsd  (%r10),%xmm6
subsd  %xmm4,%xmm6
movsd  0x0(%r13),%xmm5
xor    %edx,%edx
ucomisd %xmm6,%xmm5
jb     16fc <odebz_+0x5fc>
movapd %xmm5,%xmm1
xorpd  %xmm11,%xmm1
movapd %xmm6,%xmm2
cmpunordsd %xmm6,%xmm2
movapd %xmm2,%xmm7
andpd  %xmm1,%xmm7
minsd  %xmm6,%xmm1
andnpd %xmm1,%xmm2
orpd   %xmm7,%xmm2
mov    $0x1,%edx
movapd %xmm2,%xmm6
mov    -0x40(%rsp),%rbx
mov    -0x30(%rsp),%rax
mov    (%rax),%eax
cmp    $0x2,%eax
jge    1760 <odebz_+0x660>
cmpl   $0x2,(%rdi)
jg     17d0 <odebz_+0x6d0>
mov    -0x78(%rsp),%rax
lea    (%rcx,%rax,1),%rsi
mov    (%rbx,%rsi,4),%ebp
lea    (%rcx,%r15,1),%rax
cmp    %edx,%ebp
cmovg  %ebp,%edx
mov    (%rbx,%rax,4),%r14d
cmp    %edx,%r14d
cmovl  %r14d,%edx
jle    1690 <odebz_+0x590>
cmp    %ebp,%edx
jne    181f <odebz_+0x71f>
mov    -0x70(%rsp),%rax
movsd  %xmm4,(%rax,%rsi,8)
jmp    169a <odebz_+0x59a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm5,%xmm2
xorpd  %xmm11,%xmm2
add    $0xffffffffffffffff,%rax
xor    %ebp,%ebp
jmp    178d <odebz_+0x68d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
movapd %xmm1,%xmm6
cmp    %rbp,%rax
je     170d <odebz_+0x60d>
movsd  0x8(%r10,%rbp,8),%xmm1
movsd  (%r12,%rbp,8),%xmm7
divsd  %xmm6,%xmm7
subsd  %xmm7,%xmm1
subsd  %xmm4,%xmm1
ucomisd %xmm1,%xmm5
jb     1780 <odebz_+0x680>
add    $0x1,%edx
movapd %xmm2,%xmm6
minsd  %xmm1,%xmm6
cmpunordsd %xmm1,%xmm1
movapd %xmm1,%xmm7
andpd  %xmm2,%xmm7
andnpd %xmm6,%xmm1
orpd   %xmm7,%xmm1
jmp    1780 <odebz_+0x680>
xchg   %ax,%ax
mov    0xb8(%rsp),%rax
mov    -0x4(%rax,%rcx,4),%eax
cmp    %eax,%edx
jg     1801 <odebz_+0x701>
mov    -0x78(%rsp),%rax
add    %rcx,%rax
mov    -0x70(%rsp),%rsi
movsd  %xmm4,(%rsi,%rax,8)
mov    %edx,(%rbx,%rax,4)
mov    0xb8(%rsp),%rax
mov    -0x4(%rax,%rcx,4),%eax
cmp    %eax,%edx
jl     16a2 <odebz_+0x5a2>
lea    (%rcx,%r15,1),%rax
mov    -0x70(%rsp),%rsi
movsd  %xmm4,(%rsi,%rax,8)
mov    %edx,(%rbx,%rax,4)
jmp    16a2 <odebz_+0x5a2>
mov    0x8(%rsp),%rsi
mov    (%rsi),%esi
mov    -0x80(%rsp),%rdi
cmp    %esi,%edi
jge    2107 <odebz_+0x1007>
mov    -0x70(%rsp),%r13
movsd  0x0(%r13,%rax,8),%xmm1
mov    -0x20(%rsp),%rsi
lea    (%rdi,%rsi,1),%r8d
add    $0x1,%r8d
mov    -0x78(%rsp),%rsi
lea    (%rdi,%rsi,1),%r15d
add    $0x1,%r15d
mov    %edi,%esi
add    $0x1,%esi
movslq %r8d,%rbp
movsd  %xmm1,0x0(%r13,%rbp,8)
mov    %r14d,(%rbx,%rbp,4)
movslq %r15d,%rdi
mov    -0x50(%rsp),%r15
movsd  %xmm4,0x0(%r13,%rdi,8)
mov    %edx,(%rbx,%rdi,4)
movsd  %xmm4,0x0(%r13,%rax,8)
mov    0x98(%rsp),%r13
mov    0x18(%rsp),%rdi
mov    %edx,(%rbx,%rax,4)
mov    %esi,%eax
mov    %rax,-0x80(%rsp)
jmp    169a <odebz_+0x59a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %r11d,%rdx
add    $0x1,%eax
mov    %rdx,-0x48(%rsp)
mov    -0x40(%rsp),%r11
mov    0xe8(%rsp),%rsi
jmp    18dc <odebz_+0x7dc>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %edx,%eax
je     19e0 <odebz_+0x8e0>
movsd  (%r10),%xmm2
subsd  -0x8(%r14,%rdx,8),%xmm2
movsd  %xmm2,-0x8(%r9,%rdx,8)
movl   $0x0,-0x4(%rsi,%rdx,4)
movsd  0x0(%r13),%xmm1
xor    %ebp,%ebp
ucomisd %xmm2,%xmm1
jb     193f <odebz_+0x83f>
movl   $0x1,-0x4(%rsi,%rdx,4)
xorpd  %xmm11,%xmm1
movapd %xmm2,%xmm4
cmpunordsd %xmm2,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm1,%xmm5
minsd  %xmm2,%xmm1
andnpd %xmm1,%xmm4
orpd   %xmm5,%xmm4
movlpd %xmm4,-0x8(%r9,%rdx,8)
mov    $0x1,%ebp
movapd %xmm4,%xmm2
mov    -0x30(%rsp),%rcx
mov    (%rcx),%ecx
cmp    $0x2,%ecx
jl     18d0 <odebz_+0x7d0>
add    $0xffffffffffffffff,%rcx
xor    %ebx,%ebx
jmp    1971 <odebz_+0x871>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
movapd %xmm1,%xmm2
cmp    %rbx,%rcx
je     18d0 <odebz_+0x7d0>
movsd  0x8(%r10,%rbx,8),%xmm1
movsd  (%r12,%rbx,8),%xmm4
divsd  %xmm2,%xmm4
subsd  %xmm4,%xmm1
subsd  -0x8(%r14,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r9,%rdx,8)
movsd  0x0(%r13),%xmm2
ucomisd %xmm1,%xmm2
jb     1960 <odebz_+0x860>
add    $0x1,%ebp
mov    %ebp,-0x4(%rsi,%rdx,4)
xorpd  %xmm11,%xmm2
movapd %xmm1,%xmm4
cmpunordsd %xmm1,%xmm4
movapd %xmm4,%xmm5
andpd  %xmm2,%xmm5
minsd  %xmm1,%xmm2
andnpd %xmm2,%xmm4
orpd   %xmm5,%xmm4
movlpd %xmm4,-0x8(%r9,%rdx,8)
movapd %xmm4,%xmm1
jmp    1960 <odebz_+0x860>
cs nopw 0x0(%rax,%rax,1)
cmpl   $0x3,(%rdi)
jge    1a0a <odebz_+0x90a>
mov    -0x58(%rsp),%rax
cmp    -0x80(%rsp),%eax
jle    1ab6 <odebz_+0x9b6>
mov    0xf0(%rsp),%rax
cmpl   $0x0,(%rax)
je     1c20 <odebz_+0xb20>
jmp    20f6 <odebz_+0xff6>
mov    -0x58(%rsp),%rax
cmp    -0x80(%rsp),%eax
jg     1c20 <odebz_+0xb20>
mov    -0x48(%rsp),%rbx
lea    (%r15,%rbx,1),%rax
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%r14
lea    (%r11,%rax,4),%rbp
mov    -0x78(%rsp),%rax
add    %rbx,%rax
lea    (%rcx,%rax,8),%rcx
mov    %rcx,-0x68(%rsp)
mov    %r11,%rsi
lea    (%r11,%rax,4),%r15
mov    -0x10(%rsp),%rax
lea    (%rax,%rbx,4),%rcx
mov    -0x8(%rsp),%rax
lea    (%rax,%rbx,4),%rdx
mov    -0x28(%rsp),%rax
lea    (%rax,%rbx,8),%r11
mov    %r8d,%ebx
mov    %rbp,%r8
xor    %eax,%eax
jmp    1a7c <odebz_+0x97c>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %eax,%ebx
je     1c10 <odebz_+0xb10>
mov    (%rcx,%rax,4),%ebp
mov    (%rdx,%rax,4),%esi
cmp    %esi,%ebp
jg     1aa0 <odebz_+0x9a0>
movsd  (%r11,%rax,8),%xmm1
mov    -0x68(%rsp),%rsi
movsd  %xmm1,(%rsi,%rax,8)
mov    %ebp,(%r15,%rax,4)
mov    (%rcx,%rax,4),%ebp
mov    (%rdx,%rax,4),%esi
cmp    %esi,%ebp
jl     1a70 <odebz_+0x970>
movsd  (%r11,%rax,8),%xmm1
movsd  %xmm1,(%r14,%rax,8)
mov    %ebp,(%r8,%rax,4)
jmp    1a70 <odebz_+0x970>
mov    -0x48(%rsp),%rsi
lea    (%r15,%rsi,1),%rax
lea    (%r11,%rax,4),%rdx
mov    -0x70(%rsp),%rcx
lea    (%rcx,%rax,8),%r14
mov    -0x10(%rsp),%rax
lea    (%rax,%rsi,4),%rbp
mov    -0x28(%rsp),%rax
lea    (%rax,%rsi,8),%rax
mov    %rax,-0x60(%rsp)
add    -0x78(%rsp),%rsi
lea    (%r11,%rsi,4),%rbx
lea    (%rcx,%rsi,8),%r11
mov    %r8d,%eax
mov    %rax,-0x68(%rsp)
xor    %r8d,%r8d
mov    %r14,-0x38(%rsp)
mov    %r11,-0x48(%rsp)
jmp    1b30 <odebz_+0xa30>
nopw   0x0(%rax,%rax,1)
mov    -0x60(%rsp),%rax
movsd  (%rax,%r8,8),%xmm1
movsd  %xmm1,(%r14,%r8,8)
add    $0x1,%r8
cmp    %r8d,-0x68(%rsp)
je     19f4 <odebz_+0x8f4>
mov    (%rbx,%r8,4),%esi
mov    0x0(%rbp,%r8,4),%eax
cmp    %eax,%esi
cmovg  %esi,%eax
mov    (%rdx,%r8,4),%esi
cmp    %eax,%esi
cmovl  %esi,%eax
mov    %eax,0x0(%rbp,%r8,4)
mov    (%rdx,%r8,4),%ecx
cmp    %ecx,%eax
je     1b10 <odebz_+0xa10>
cmp    (%rbx,%r8,4),%eax
jne    1b70 <odebz_+0xa70>
mov    -0x60(%rsp),%rax
movsd  (%rax,%r8,8),%xmm1
movsd  %xmm1,(%r11,%r8,8)
jmp    1b21 <odebz_+0xa21>
nopl   (%rax)
mov    -0x80(%rsp),%rax
lea    0x1(%rax),%r15d
mov    0x8(%rsp),%rsi
mov    (%rsi),%esi
cmp    %esi,%eax
jge    1bf1 <odebz_+0xaf1>
movsd  (%r14,%r8,8),%xmm1
mov    -0x20(%rsp),%rax
lea    (%r15,%rax,1),%esi
movslq %esi,%rsi
mov    -0x70(%rsp),%r14
movsd  %xmm1,(%r14,%rsi,8)
mov    -0x40(%rsp),%r11
mov    %ecx,(%r11,%rsi,4)
mov    -0x60(%rsp),%rax
movsd  (%rax,%r8,8),%xmm1
mov    -0x78(%rsp),%rcx
lea    (%rcx,%r15,1),%esi
movslq %esi,%rsi
movsd  %xmm1,(%r14,%rsi,8)
mov    -0x38(%rsp),%r14
mov    0x0(%rbp,%r8,4),%ecx
mov    %ecx,(%r11,%rsi,4)
mov    -0x48(%rsp),%r11
movsd  (%rax,%r8,8),%xmm1
movsd  %xmm1,(%r14,%r8,8)
mov    0x0(%rbp,%r8,4),%ecx
mov    %ecx,(%rdx,%r8,4)
jmp    1bfe <odebz_+0xafe>
add    $0x1,%esi
mov    0xf0(%rsp),%rcx
mov    %esi,(%rcx)
mov    %r15d,%eax
mov    %rax,-0x80(%rsp)
mov    -0x50(%rsp),%r15
jmp    1b21 <odebz_+0xa21>
mov    -0x50(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x80(%rsp),%rsi
mov    -0x58(%rsp),%r11
cmp    %esi,%r11d
jle    1c60 <odebz_+0xb60>
mov    -0x80(%rsp),%rcx
sub    %r11d,%ecx
mov    %r11,%rax
mov    0xc8(%rsp),%r14
jl     20cd <odebz_+0xfcd>
movslq %eax,%rbx
cmp    $0x3,%ecx
mov    %rax,%r11
jae    1eb0 <odebz_+0xdb0>
mov    %rbx,%r15
jmp    1fd8 <odebz_+0xed8>
nop
movslq %r11d,%rbx
mov    0x88(%rsp),%rax
movsd  (%rax),%xmm13
movsd  0x0(%r13),%xmm5
mov    0x90(%rsp),%rax
movsd  (%rax),%xmm12
mov    -0x78(%rsp),%rax
add    %rbx,%rax
mov    -0x70(%rsp),%rdx
lea    (%rdx,%rax,8),%rcx
mov    %rcx,-0x68(%rsp)
mov    -0x40(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,-0x48(%rsp)
lea    (%r15,%rbx,1),%rax
lea    (%rdx,%rax,8),%rdx
mov    %rdx,-0x60(%rsp)
lea    (%rcx,%rax,4),%rax
mov    %rax,-0x38(%rsp)
mov    -0x8(%rsp),%rax
lea    (%rax,%rbx,4),%rax
mov    %rax,0x48(%rsp)
mov    %esi,%edx
sub    %r11d,%edx
add    $0x1,%edx
xor    %r15d,%r15d
mov    %rdx,0x10(%rsp)
jmp    1d07 <odebz_+0xc07>
nopl   (%rax)
mov    %r9,%rbx
mov    %r14,%r9
mov    %r10,%r12
mov    0xa0(%rsp),%r10
mov    0x10(%rsp),%rdx
add    $0x1,%r11d
add    $0x1,%r15
cmp    %r15d,%edx
je     1c2f <odebz_+0xb2f>
mov    -0x60(%rsp),%rax
movsd  (%rax,%r15,8),%xmm6
mov    -0x68(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
movapd %xmm6,%xmm7
subsd  %xmm0,%xmm7
andpd  %xmm10,%xmm7
movapd %xmm6,%xmm3
andpd  %xmm10,%xmm3
movapd %xmm0,%xmm2
andpd  %xmm10,%xmm2
movapd %xmm3,%xmm1
cmpunordsd %xmm3,%xmm1
movapd %xmm1,%xmm4
andpd  %xmm2,%xmm4
maxsd  %xmm3,%xmm2
andnpd %xmm2,%xmm1
orpd   %xmm4,%xmm1
movapd %xmm13,%xmm2
cmpunordsd %xmm13,%xmm2
movapd %xmm2,%xmm3
andpd  %xmm5,%xmm3
movapd %xmm5,%xmm4
maxsd  %xmm13,%xmm4
andnpd %xmm4,%xmm2
orpd   %xmm3,%xmm2
mulsd  %xmm12,%xmm1
movapd %xmm2,%xmm3
cmpunordsd %xmm2,%xmm3
movapd %xmm3,%xmm4
andpd  %xmm1,%xmm4
maxsd  %xmm2,%xmm1
andnpd %xmm1,%xmm3
orpd   %xmm4,%xmm3
ucomisd %xmm7,%xmm3
ja     1dbd <odebz_+0xcbd>
mov    -0x48(%rsp),%rax
mov    (%rax,%r15,4),%eax
mov    -0x38(%rsp),%rcx
cmp    (%rcx,%r15,4),%eax
jl     1cfa <odebz_+0xbfa>
lea    (%rbx,%r15,1),%rsi
movslq %r11d,%rax
cmp    %rax,%rsi
jle    1cf6 <odebz_+0xbf6>
mov    %r12,%r10
mov    %r9,%r14
mov    %rbx,%r9
mov    -0x48(%rsp),%r8
mov    (%r8,%r15,4),%esi
mov    -0x78(%rsp),%rcx
mov    -0x38(%rsp),%r12
mov    (%r12,%r15,4),%r13d
mov    %r11,%rdi
add    %ecx,%r11d
movslq %r11d,%rdx
mov    %rdi,%r11
mov    -0x70(%rsp),%rbp
movsd  0x0(%rbp,%rdx,8),%xmm1
mov    -0x68(%rsp),%rcx
movsd  %xmm1,(%rcx,%r15,8)
mov    -0x20(%rsp),%rcx
lea    (%rdi,%rcx,1),%ecx
movslq %ecx,%rcx
movsd  0x0(%rbp,%rcx,8),%xmm1
mov    -0x60(%rsp),%rdi
movsd  %xmm1,(%rdi,%r15,8)
mov    -0x40(%rsp),%rbx
mov    (%rbx,%rdx,4),%edi
mov    %edi,(%r8,%r15,4)
mov    (%rbx,%rcx,4),%edi
mov    %edi,(%r12,%r15,4)
movsd  %xmm0,0x0(%rbp,%rdx,8)
movsd  %xmm6,0x0(%rbp,%rcx,8)
mov    %esi,(%rbx,%rdx,4)
mov    %r13d,(%rbx,%rcx,4)
mov    0x98(%rsp),%r13
mov    0x18(%rsp),%rdi
cmpl   $0x3,(%rdi)
mov    0x88(%rsp),%rcx
movsd  (%rcx),%xmm13
movsd  0x0(%r13),%xmm5
mov    0x90(%rsp),%rcx
movsd  (%rcx),%xmm12
jne    1ce0 <odebz_+0xbe0>
mov    0x48(%rsp),%rbp
mov    0x0(%rbp,%r15,4),%ecx
mov    0xb8(%rsp),%rsi
mov    -0x4(%rsi,%rax,4),%edx
mov    %edx,0x0(%rbp,%r15,4)
mov    %ecx,-0x4(%rsi,%rax,4)
jmp    1ce0 <odebz_+0xbe0>
nopl   0x0(%rax,%rax,1)
mov    %r11,-0x58(%rsp)
mov    -0x28(%rsp),%rax
lea    (%rax,%rbx,8),%r13
lea    (%rbx,%rcx,1),%rdx
lea    (%r14,%rdx,8),%rsi
mov    -0x50(%rsp),%rax
lea    (%rax,%rbx,1),%r8
mov    -0x70(%rsp),%rax
lea    (%rax,%r8,8),%r14
lea    (%r8,%rcx,1),%rdx
mov    (%rsp),%r11
lea    (%r11,%rdx,8),%rbp
mov    -0x78(%rsp),%rdx
add    %rbx,%rdx
cmp    %rbp,%r13
setb   %r15b
cmp    %rsi,%r14
lea    (%rdx,%rcx,1),%rbp
lea    (%r11,%rbp,8),%rbp
setb   %r14b
cmp    %rbp,%r13
lea    (%rax,%rdx,8),%rbp
setb   %al
cmp    %rsi,%rbp
setb   %sil
test   %r14b,%r15b
jne    1fc0 <odebz_+0xec0>
and    %sil,%al
jne    1fc0 <odebz_+0xec0>
add    $0x1,%rcx
mov    %rcx,%rax
and    $0xfffffffffffffffc,%rax
lea    (%rax,%rbx,1),%r15
mov    (%rsp),%rsi
lea    (%rsi,%rdx,8),%rbp
add    $0x8,%rbp
lea    (%rsi,%r8,8),%rdx
add    $0x8,%rdx
mov    0x20(%rsp),%rsi
lea    (%rsi,%rbx,8),%rbx
xor    %esi,%esi
mov    0x98(%rsp),%r13
mov    0xc8(%rsp),%r14
mov    -0x58(%rsp),%r11
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rbp,%rsi,8),%xmm1
movupd 0x0(%rbp,%rsi,8),%xmm2
movupd -0x10(%rdx,%rsi,8),%xmm4
addpd  %xmm1,%xmm4
movupd (%rdx,%rsi,8),%xmm1
addpd  %xmm2,%xmm1
mulpd  %xmm8,%xmm4
mulpd  %xmm8,%xmm1
movupd %xmm4,-0x10(%rbx,%rsi,8)
movupd %xmm1,(%rbx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    1f70 <odebz_+0xe70>
cmp    %rax,%rcx
jne    1fd8 <odebz_+0xed8>
jmp    20a3 <odebz_+0xfa3>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%r15
mov    0x98(%rsp),%r13
mov    0xc8(%rsp),%r14
mov    -0x58(%rsp),%r11
mov    -0x80(%rsp),%rax
sub    %r15d,%eax
add    $0x1,%eax
test   $0x1,%al
jne    2000 <odebz_+0xf00>
mov    %r15,%rsi
cmp    %r15d,-0x80(%rsp)
jne    2039 <odebz_+0xf39>
jmp    20a3 <odebz_+0xfa3>
cs nopw 0x0(%rax,%rax,1)
mov    -0x78(%rsp),%rax
add    %r15,%rax
mov    -0x70(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
mov    -0x50(%rsp),%rax
add    %r15,%rax
addsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm9,%xmm1
movsd  %xmm1,-0x8(%r14,%r15,8)
mov    %r15,%rsi
add    $0x1,%rsi
cmp    %r15d,-0x80(%rsp)
je     20a3 <odebz_+0xfa3>
mov    -0x80(%rsp),%rax
sub    %esi,%eax
add    $0x1,%eax
lea    (%r14,%rsi,8),%rcx
mov    0x30(%rsp),%rdx
lea    (%rdx,%rsi,8),%rdx
mov    0x28(%rsp),%rbp
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rbp,8),%xmm0
addsd  (%rdx,%rbp,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  %xmm0,-0x8(%rcx,%rbp,8)
movsd  0x8(%rsi,%rbp,8),%xmm0
addsd  0x8(%rdx,%rbp,8),%xmm0
mulsd  %xmm9,%xmm0
movsd  %xmm0,(%rcx,%rbp,8)
add    $0x2,%rbp
cmp    %ebp,%eax
jne    2070 <odebz_+0xf70>
cmp    %r11d,-0x80(%rsp)
jl     20d0 <odebz_+0xfd0>
mov    0x40(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    -0x14(%rsp),%ecx
mov    %eax,%ecx
mov    -0x50(%rsp),%r15
jne    1620 <odebz_+0x520>
jmp    20d0 <odebz_+0xfd0>
mov    $0x1,%r11d
jmp    20d0 <odebz_+0xfd0>
mov    %rax,%r11
mov    -0x80(%rsp),%rdx
mov    %edx,%eax
sub    %r11d,%eax
xor    %ecx,%ecx
add    $0x1,%eax
cmovs  %ecx,%eax
mov    0xf0(%rsp),%rcx
mov    %eax,(%rcx)
mov    0xd0(%rsp),%rax
mov    %edx,(%rax)
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%esi
mov    0xf0(%rsp),%rax
mov    %esi,(%rax)
jmp    20f6 <odebz_+0xff6>
mov    0xc0(%rsp),%rbx
mov    -0x68(%rsp),%r8
jmp    13c7 <odebz_+0x2c7>

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

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