#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);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
int LL98(double psi[], const int two_nmin, const int two_nmax, void *params,
         double (*X)(const double, const void *),
         double (*Y)(const double, const void *),
         double (*Z)(const double, const void *),
         void (*normalize)(double *, const double, const int, const void *)) {
  int nmax_idx = (two_nmax - two_nmin) / 2;
  int ndim = nmax_idx + 1, nminus_idx = 0, nplus_idx = nmax_idx, i;
  bool iter_up = true, iter_down = true;
  double y;
  double nmin = two_nmin / 2.0, nmax = two_nmax / 2.0;
  double rs[ndim];
  if (ndim == 1) {
    psi[0] = 1.0;
    normalize(psi, nmin, nmax_idx, params);
    return 0;
  }
  y = Y(nmin, params);
  if (fabs(y) > 1.0e-15) {
    rs[0] = -X(nmin, params) / y;
    for (i = 1; i <= nmax_idx; i++) {
      double n, denom;
      if (rs[i - 1] > 1.0) {
        nminus_idx = i - 1;
        break;
      }
      n = nmin + i;
      denom = Y(n, params) + Z(n, params) * rs[i - 1];
      if (fabs(denom) > 1.0e-15)
        rs[i] = -X(n, params) / denom;
      else {
        nminus_idx = i - 1;
        break;
      }
    }
    if (nminus_idx > 0) {
      psi[nminus_idx - 1] = rs[nminus_idx - 1];
      for (i = nminus_idx - 2; i >= 0; i--)
        psi[i] = psi[i + 1] * rs[i];
    }
  } else {
    nminus_idx = 0;
    if (fabs(X(nmin, params)) < 1.0e-15)
      iter_up = false;
  }
  y = Y(nmax, params);
  if (fabs(y) > 1.0e-15) {
    rs[nmax_idx] = -Z(nmax, params) / y;
    for (i = nmax_idx - 1; i > nminus_idx; i--) {
      double n, denom;
      if (rs[i + 1] > 1.0) {
        nplus_idx = i + 1;
        break;
      }
      n = nmin + i;
      denom = Y(n, params) + X(n, params) * rs[i + 1];
      if (fabs(denom) > 1.0e-15)
        rs[i] = -Z(n, params) / denom;
      else {
        nplus_idx = i + 1;
        break;
      }
    }
    if (nplus_idx < nmax_idx) {
      psi[nplus_idx + 1] = rs[nplus_idx + 1];
      for (i = nplus_idx + 2; i <= nmax_idx; i++)
        psi[i] = psi[i - 1] * rs[i];
    }
  } else {
    nplus_idx = nmax_idx;
    if (fabs(Z(nmax, params)) < 1.0e-15)
      iter_down = false;
  }
  if (iter_up) {
    double a;
    int iter_up_start_idx;
    if (nminus_idx < 2) {
      psi[0] = 1.0;
      psi[1] = -Y(nmin, params) / X(nmin, params);
      iter_up_start_idx = 2;
    } else {
      psi[nminus_idx] = 1.0;
      iter_up_start_idx = nminus_idx + 1;
    }
    for (i = iter_up_start_idx; i <= nplus_idx; i++) {
      double nn = nmin - 1.0 + i;
      psi[i] = -(Y(nn, params) * psi[i - 1] + Z(nn, params) * psi[i - 2]) /
               X(nn, params);
    }
    a = 1.0 / psi[nplus_idx];
    for (i = 0; i <= nplus_idx; i++)
      psi[i] *= a;
    normalize(psi, nmin, nmax_idx, params);
    return 0;
  }
  if (iter_down) {
    double a;
    int iter_down_start_idx;
    if (nplus_idx > nmax_idx - 2) {
      psi[nplus_idx] = 1.0;
      psi[nplus_idx - 1] = -Y(nmax, params) / Z(nmax, params);
      iter_down_start_idx = nplus_idx - 2;
    } else {
      psi[nplus_idx] = 1.0;
      iter_down_start_idx = nplus_idx - 1;
    }
    for (i = iter_down_start_idx; i >= nminus_idx; i--) {
      double nn = nmin + 1.0 + i;
      psi[i] = -(X(nn, params) * psi[i + 2] + Y(nn, params) * psi[i + 1]) /
               Z(nn, params);
    }
    a = 1.0 / psi[nminus_idx];
    for (i = nmax_idx; i >= nminus_idx; i--)
      psi[i] *= a;
    normalize(psi, nmin, nmax_idx, params);
    return 0;
  }
  fprintf(stderr, "LL98: Could not iterate in either direction\n");
  return 1;
}


x86 assembly (clang, -O0):
<LL98>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %ecx,%eax
sar    %eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x1,-0x48(%rbp)
movl   $0x1,-0x4c(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  0xe82(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
cvtsi2sdl -0x18(%rbp),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x38(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x70(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x78(%rbp)
cmpl   $0x1,-0x38(%rbp)
jne    1202 <LL98+0xf2>
mov    -0x10(%rbp),%rax
movsd  0xe3b(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%rdi
movsd  -0x60(%rbp),%xmm0
mov    -0x34(%rbp),%esi
mov    -0x20(%rbp),%rdx
call   *%rax
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x7c(%rbp)
jmp    1b97 <LL98+0xa87>
mov    -0x30(%rbp),%rax
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movaps 0xdfe(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xdda(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    143c <LL98+0x32c>
mov    -0x28(%rbp),%rax
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
mov    -0xd8(%rbp),%rax
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,(%rax)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     13b1 <LL98+0x2a1>
mov    -0xd8(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xd72(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    12b6 <LL98+0x1a6>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13b1 <LL98+0x2a1>
movsd  -0x60(%rbp),%xmm0
cvtsi2sdl -0x44(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    -0x30(%rbp),%rax
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0xe0(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
mov    -0xd8(%rbp),%rax
movsd  -0xe0(%rbp),%xmm1
ff
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
movaps 0xcec(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xcc8(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1390 <LL98+0x280>
mov    -0x28(%rbp),%rax
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
mov    -0xd8(%rbp),%rax
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
divsd  -0x90(%rbp),%xmm0
ff
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    139e <LL98+0x28e>
mov    -0x44(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13b1 <LL98+0x2a1>
jmp    13a3 <LL98+0x293>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1275 <LL98+0x165>
cmpl   $0x0,-0x3c(%rbp)
jle    1437 <LL98+0x327>
mov    -0xd8(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x0,-0x44(%rbp)
jl     1432 <LL98+0x322>
mov    -0xd8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x44(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    13eb <LL98+0x2db>
jmp    1437 <LL98+0x327>
jmp    147e <LL98+0x36e>
movl   $0x0,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
movaps %xmm0,%xmm1
movaps 0xbc4(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xba0(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1479 <LL98+0x369>
movl   $0x0,-0x48(%rbp)
jmp    147e <LL98+0x36e>
mov    -0x30(%rbp),%rax
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movaps 0xb82(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xb5e(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    16c3 <LL98+0x5b3>
mov    0x10(%rbp),%rax
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
mov    -0xd8(%rbp),%rax
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
divsd  -0x58(%rbp),%xmm0
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1634 <LL98+0x524>
mov    -0xd8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xaef(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1539 <LL98+0x429>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1634 <LL98+0x524>
movsd  -0x60(%rbp),%xmm0
cvtsi2sdl -0x44(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0x30(%rbp),%rax
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0xe8(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
mov    -0xd8(%rbp),%rax
movsd  -0xe8(%rbp),%xmm1
ff
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movaps 0xa69(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xa45(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1613 <LL98+0x503>
mov    0x10(%rbp),%rax
movsd  -0x98(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
mov    -0xd8(%rbp),%rax
movq   %xmm0,%rcx
movabs $0x8000000000000000,%rdx
xor    %rdx,%rcx
movq   %rcx,%xmm0
divsd  -0xa0(%rbp),%xmm0
ff
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1621 <LL98+0x511>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1634 <LL98+0x524>
jmp    1626 <LL98+0x516>
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    14f8 <LL98+0x3e8>
mov    -0x40(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    16be <LL98+0x5ae>
mov    -0xd8(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     16b9 <LL98+0x5a9>
mov    -0xd8(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x44(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsd  (%rcx,%rdx,8),%xmm0
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1670 <LL98+0x560>
jmp    16be <LL98+0x5ae>
jmp    1704 <LL98+0x5f4>
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    0x10(%rbp),%rax
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
movaps %xmm0,%xmm1
movaps 0x93e(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x91a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16ff <LL98+0x5ef>
movl   $0x0,-0x4c(%rbp)
jmp    1704 <LL98+0x5f4>
cmpl   $0x0,-0x48(%rbp)
je     1933 <LL98+0x823>
cmpl   $0x2,-0x3c(%rbp)
jge    178c <LL98+0x67c>
mov    -0x10(%rbp),%rax
movsd  0x8ec(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
movaps %xmm0,%xmm1
movsd  -0xf0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movl   $0x2,-0xac(%rbp)
jmp    17ad <LL98+0x69d>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0x874(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     18b2 <LL98+0x7a2>
movsd  -0x60(%rbp),%xmm0
movsd  0x841(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsi2sdl -0x44(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x30(%rbp),%rax
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
movsd  -0x108(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  -0xb8(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
movaps %xmm0,%xmm1
movsd  -0xf8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17b6 <LL98+0x6a6>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  0x74e(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x40(%rbp),%eax
jg     190a <LL98+0x7fa>
movsd  -0xa8(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    18d6 <LL98+0x7c6>
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%rdi
movsd  -0x60(%rbp),%xmm0
mov    -0x34(%rbp),%esi
mov    -0x20(%rbp),%rdx
call   *%rax
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x7c(%rbp)
jmp    1b97 <LL98+0xa87>
cmpl   $0x0,-0x4c(%rbp)
je     1b74 <LL98+0xa64>
mov    -0x40(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jle    19d2 <LL98+0x8c2>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  0x6b2(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
call   *%rax
movaps %xmm0,%xmm1
movsd  -0x110(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0xc4(%rbp)
jmp    19f3 <LL98+0x8e3>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  0x62e(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc4(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jl     1af4 <LL98+0x9e4>
movsd  0x600(%rip),%xmm0
addsd  -0x60(%rbp),%xmm0
cvtsi2sdl -0x44(%rbp),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
mov    -0x28(%rbp),%rax
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
movsd  %xmm0,-0x120(%rbp)
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x128(%rbp)
ff
mov    -0x30(%rbp),%rax
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
movsd  -0x128(%rbp),%xmm2
ff
movaps %xmm0,%xmm1
movsd  -0x120(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
mov    0x10(%rbp),%rax
movsd  -0xd0(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rdi
call   *%rax
movaps %xmm0,%xmm1
movsd  -0x118(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    19fc <LL98+0x8ec>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  0x50c(%rip),%xmm0
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jl     1b4b <LL98+0xa3b>
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
jmp    1b17 <LL98+0xa07>
mov    0x18(%rbp),%rax
mov    -0x10(%rbp),%rdi
movsd  -0x60(%rbp),%xmm0
mov    -0x34(%rbp),%esi
mov    -0x20(%rbp),%rdx
call   *%rax
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x7c(%rbp)
jmp    1b97 <LL98+0xa87>
mov    0x2465(%rip),%rax
mov    (%rax),%edi
lea    0x4ac(%rip),%rsi
call   1030 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
movl   $0x1,-0x7c(%rbp)
mov    -0x70(%rbp),%rax
mov    %rax,%rsp
mov    -0x4(%rbp),%eax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LL98>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rcx,%r15
mov    %rdi,%r13
mov    %edx,%ebx
sub    %esi,%ebx
mov    %ebx,%ecx
shr    $0x1f,%ecx
add    %ebx,%ecx
sar    %ecx
lea    0x1(%rcx),%r12d
cvtsi2sd %esi,%xmm0
movsd  0xeb9(%rip),%xmm1
mulsd  %xmm1,%xmm0
lea    0xf(,%r12,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rsi
sub    %rax,%rsi
mov    %rsi,%rsp
lea    0x1(%rbx),%eax
cmp    $0x2,%eax
ja     1180 <LL98+0x70>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x0(%r13)
mov    %r13,%rdi
mov    %ecx,%esi
jmp    1ad2 <LL98+0x9c2>
mov    %r8,%r14
mov    %rsi,-0x70(%rbp)
mov    %rcx,-0x60(%rbp)
cvtsi2sd %edx,%xmm2
mulsd  %xmm1,%xmm2
movsd  %xmm2,-0xa0(%rbp)
ff
mov    %r15,%rdi
movsd  %xmm0,-0x38(%rbp)
mov    %r9,-0x30(%rbp)
call   *%r9
movapd 0xe6e(%rip),%xmm1
movapd %xmm0,-0x90(%rbp)
ff
andpd  %xmm0,%xmm1
movapd %xmm1,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    %r15,%rdi
call   *%r14
movapd %xmm0,%xmm1
movapd -0x50(%rbp),%xmm0
ucomisd 0xe29(%rip),%xmm0
jbe    12d4 <LL98+0x1c4>
xorpd  0xe43(%rip),%xmm1
divsd  -0x90(%rbp),%xmm1
ff
mov    -0x70(%rbp),%rax
movsd  %xmm1,(%rax)
xor    %eax,%eax
mov    $0x0,%esi
cmp    $0x2,%ebx
mov    -0x30(%rbp),%rbx
jl     1394 <LL98+0x284>
mov    %r14,%rbx
add    $0xffffffffffffffff,%r12
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
ucomisd 0xde8(%rip),%xmm1
ja     12f7 <LL98+0x1e7>
lea    0x1(%rsi),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    %rsi,%r14
mov    %r15,%rdi
movapd %xmm1,-0x90(%rbp)
ff
call   *-0x30(%rbp)
movsd  %xmm0,-0x78(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    %r15,%rdi
call   *0x10(%rbp)
mov    %r14,%rsi
movapd %xmm0,%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
addsd  -0x78(%rbp),%xmm1
movapd %xmm1,%xmm0
andpd  0xd9d(%rip),%xmm0
ucomisd 0xd7d(%rip),%xmm0
jbe    12f7 <LL98+0x1e7>
movsd  -0x50(%rbp),%xmm0
mov    %r15,%rdi
movapd %xmm1,-0x50(%rbp)
call   *%rbx
mov    %r14,%rsi
movapd %xmm0,%xmm1
xorpd  0xd85(%rip),%xmm1
divsd  -0x50(%rbp),%xmm1
mov    -0x70(%rbp),%rax
movsd  %xmm1,0x8(%rax,%r14,8)
add    $0x1,%rsi
cmp    %rsi,%r12
jne    1220 <LL98+0x110>
xor    %eax,%eax
xor    %esi,%esi
mov    %rbx,%r14
jmp    1390 <LL98+0x280>
andpd  0xd44(%rip),%xmm1
xor    %esi,%esi
movsd  0xd22(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    138e <LL98+0x27e>
mov    $0x1,%al
jmp    1390 <LL98+0x280>
lea    0x1(%rsi),%rcx
cmp    $0x1,%ecx
jbe    131d <LL98+0x20d>
lea    -0x1(%rsi),%eax
mov    -0x70(%rbp),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
cmp    $0x1,%esi
jne    1324 <LL98+0x214>
mov    $0x1,%esi
xor    %eax,%eax
mov    %rbx,%r14
jmp    1390 <LL98+0x280>
mov    $0xfffffffe,%edx
add    %esi,%edx
mov    %rdx,%rax
test   $0x1,%cl
je     134a <LL98+0x23a>
movsd  0x8(%r13,%rdx,8),%xmm0
mulsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rdx,8)
lea    -0x1(%rdx),%rax
test   %rdx,%rdx
mov    %rbx,%r14
je     138e <LL98+0x27e>
mov    -0x30(%rbp),%rbx
cs nopw 0x0(%rax,%rax,1)
movsd  0x8(%r13,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
mulsd  -0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,-0x8(%r13,%rax,8)
add    $0xfffffffffffffffe,%rax
cmp    $0xffffffffffffffff,%rax
jne    1360 <LL98+0x250>
xor    %eax,%eax
jmp    1394 <LL98+0x284>
xor    %eax,%eax
mov    -0x30(%rbp),%rbx
mov    %eax,-0x94(%rbp)
mov    %rsi,-0x58(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    %r15,%rdi
call   *%rbx
movaps 0xc6e(%rip),%xmm1
movaps %xmm0,-0x90(%rbp)
andps  %xmm0,%xmm1
movaps %xmm1,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    %r15,%rdi
mov    0x10(%rbp),%r12
call   *%r12
movapd -0x50(%rbp),%xmm1
ucomisd 0xc29(%rip),%xmm1
jbe    14f8 <LL98+0x3e8>
xorpd  0xc43(%rip),%xmm0
divsd  -0x90(%rbp),%xmm0
ff
mov    -0x60(%rbp),%rsi
movslq %esi,%rcx
mov    -0x70(%rbp),%rdi
movsd  %xmm0,(%rdi,%rcx,8)
lea    -0x1(%rsi),%eax
mov    %esi,%edx
mov    -0x58(%rbp),%r8
cmp    %r8d,%eax
movsd  -0x38(%rbp),%xmm6
jle    15d6 <LL98+0x4c6>
ucomisd 0xbec(%rip),%xmm0
mov    %rcx,-0xb0(%rbp)
mov    %rcx,%rdx
ja     155b <LL98+0x44b>
movslq -0x58(%rbp),%rbx
mov    -0xb0(%rbp),%rdx
nop
movapd %xmm0,-0x90(%rbp)
ff
lea    -0x1(%rdx),%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
addsd  %xmm6,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    %r15,%rdi
mov    %rdx,%r12
call   *-0x30(%rbp)
movsd  %xmm0,-0x78(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    %r15,%rdi
call   *%r14
movapd %xmm0,%xmm1
mulsd  -0x90(%rbp),%xmm1
ff
addsd  -0x78(%rbp),%xmm1
movapd %xmm1,%xmm0
andpd  0xb8f(%rip),%xmm0
ucomisd 0xb6f(%rip),%xmm0
jbe    154f <LL98+0x43f>
movsd  -0x50(%rbp),%xmm0
mov    %r15,%rdi
movapd %xmm1,-0x50(%rbp)
call   *0x10(%rbp)
xorpd  0xb79(%rip),%xmm0
divsd  -0x50(%rbp),%xmm0
mov    -0x70(%rbp),%rdi
movsd  %xmm0,-0x8(%rdi,%r12,8)
lea    -0x2(%r12),%rax
cmp    %rbx,%rax
jle    17f0 <LL98+0x6e0>
mov    %r12,%rdx
movsd  -0x8(%rdi,%r12,8),%xmm0
add    $0xffffffffffffffff,%rdx
ucomisd 0xb25(%rip),%xmm0
movsd  -0x38(%rbp),%xmm6
jbe    1440 <LL98+0x330>
jmp    155b <LL98+0x44b>
andpd  0xb20(%rip),%xmm0
movsd  0xb00(%rip),%xmm1
ucomisd %xmm0,%xmm1
mov    -0x60(%rbp),%rsi
mov    %esi,%edx
movsd  -0x38(%rbp),%xmm6
mov    -0x58(%rbp),%r8
jbe    15d6 <LL98+0x4c6>
mov    %esi,%edx
cmpb   $0x0,-0x94(%rbp)
je     1810 <LL98+0x700>
mov    0x2aa9(%rip),%rax
mov    (%rax),%edi
lea    0xb00(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%eax
jmp    1ada <LL98+0x9ca>
movsd  -0x38(%rbp),%xmm6
mov    -0x70(%rbp),%rdi
mov    %r12,%rdx
mov    -0x60(%rbp),%rsi
cmp    %edx,%esi
jle    17fb <LL98+0x6eb>
mov    %rdx,%rax
shl    $0x20,%rax
mov    $0xfffffffe,%ecx
add    %rax,%rcx
add    $0x2,%rcx
sar    $0x1d,%rcx
movsd  (%rdi,%rcx,1),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,1)
lea    0x2(%rdx),%ecx
cmp    %esi,%ecx
jg     17fb <LL98+0x6eb>
sar    $0x20,%rax
movsd  0x8(%r13,%rax,8),%xmm0
add    $0x1,%rax
mov    -0x30(%rbp),%rbx
mov    -0x58(%rbp),%r8
mov    -0xb0(%rbp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mulsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x1,%rax
cmp    %rcx,%rax
jl     15c0 <LL98+0x4b0>
cmpb   $0x0,-0x94(%rbp)
je     1810 <LL98+0x700>
lea    -0x2(%rsi),%eax
movslq %edx,%r12
movabs $0x3ff0000000000000,%rcx
mov    %rcx,0x0(%r13,%r12,8)
mov    $0xffffffff,%ebx
cmp    %eax,%edx
jle    1650 <LL98+0x540>
movsd  -0xa0(%rbp),%xmm0
ff
mov    %r15,%rdi
mov    %rdx,%rbx
call   *-0x30(%rbp)
xorps  0xa17(%rip),%xmm0
movaps %xmm0,-0x50(%rbp)
movsd  -0xa0(%rbp),%xmm0
ff
mov    %r15,%rdi
call   *0x10(%rbp)
mov    %rbx,%rdx
mov    -0x58(%rbp),%r8
movsd  -0x38(%rbp),%xmm6
mov    -0x60(%rbp),%rsi
movapd -0x50(%rbp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r13,%r12,8)
mov    $0xfffffffe,%ebx
add    %edx,%ebx
cmp    %r8d,%ebx
jge    1668 <LL98+0x558>
movslq %r8d,%r10
cmp    %r8d,%esi
jge    1720 <LL98+0x610>
jmp    1acb <LL98+0x9bb>
movsd  0x9a0(%rip),%xmm0
addsd  %xmm6,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movslq %ebx,%r12
movslq %r8d,%r10
add    $0x1,%r12
mov    %r14,-0xa8(%rbp)
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
mov    %r15,%rdi
mov    %r10,%r14
call   *-0xa8(%rbp)
mulsd  0x8(%r13,%r12,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    %r15,%rdi
call   *-0x30(%rbp)
mulsd  0x0(%r13,%r12,8),%xmm0
addsd  -0x70(%rbp),%xmm0
xorpd  0x955(%rip),%xmm0
movapd %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    %r15,%rdi
call   *0x10(%rbp)
mov    %r14,%r10
movapd -0x70(%rbp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r13,%r12,8)
add    $0xffffffffffffffff,%r12
add    $0xffffffff,%ebx
cmp    %r14,%r12
jg     1690 <LL98+0x580>
mov    -0x60(%rbp),%rsi
movsd  -0x38(%rbp),%xmm6
mov    -0x58(%rbp),%r8
cmp    %r8d,%esi
jl     1acb <LL98+0x9bb>
movsd  0x8e8(%rip),%xmm0
divsd  0x0(%r13,%r10,8),%xmm0
movslq %esi,%rax
cmp    %rax,%r10
mov    %rax,%rcx
cmovl  %r10,%rcx
neg    %rcx
lea    (%rax,%rcx,1),%r9
add    $0x1,%r9
cmp    $0x4,%r9
jb     1aa9 <LL98+0x999>
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%r8),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
shufpd $0x1,%xmm1,%xmm1
test   %rdx,%rdx
je     1a70 <LL98+0x960>
mov    %rcx,%rbx
and    $0xfffffffffffffffe,%rbx
lea    -0x8(,%rax,8),%rdx
ff
add    %r13,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rdx,%rdi,8),%xmm2
movupd -0x20(%rdx,%rdi,8),%xmm3
movupd -0x10(%rdx,%rdi,8),%xmm4
movupd (%rdx,%rdi,8),%xmm5
mulpd  %xmm1,%xmm5
movupd %xmm5,(%rdx,%rdi,8)
mulpd  %xmm1,%xmm4
movupd %xmm4,-0x10(%rdx,%rdi,8)
mulpd  %xmm1,%xmm3
movupd %xmm3,-0x20(%rdx,%rdi,8)
mulpd  %xmm1,%xmm2
movupd %xmm2,-0x30(%rdx,%rdi,8)
add    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    17a0 <LL98+0x690>
neg    %rdi
jmp    1a72 <LL98+0x962>
mov    -0x60(%rbp),%rsi
mov    %esi,%edx
movsd  -0x38(%rbp),%xmm6
mov    -0x30(%rbp),%rbx
mov    -0x58(%rbp),%r8
cmpb   $0x0,-0x94(%rbp)
jne    15e3 <LL98+0x4d3>
cmp    $0x1,%r8d
jg     186d <LL98+0x75d>
movabs $0x3ff0000000000000,%rax
mov    %rax,0x0(%r13)
movapd %xmm6,%xmm0
mov    %r15,%rdi
mov    %rbx,%rax
mov    %r14,%rbx
mov    %rdx,%r14
call   *%rax
xorpd  0x7f2(%rip),%xmm0
movapd %xmm0,-0x50(%rbp)
movsd  -0x38(%rbp),%xmm0
mov    %r15,%r12
mov    %r15,%rdi
mov    %rbx,%r15
call   *%rbx
mov    %r14,%rdx
movapd -0x50(%rbp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r13)
mov    $0x2,%r8d
jmp    1889 <LL98+0x779>
mov    %r15,%r12
mov    %r14,%r15
mov    %r8d,%eax
movabs $0x3ff0000000000000,%rcx
mov    %rcx,0x0(%r13,%rax,8)
add    $0x1,%r8d
mov    %r15,-0xa8(%rbp)
mov    %rdx,-0x78(%rbp)
cmp    %edx,%r8d
mov    -0x30(%rbp),%r14
jg     1941 <LL98+0x831>
movsd  0x76f(%rip),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    %r8d,%ebx
mov    -0x78(%rbp),%rax
lea    0x1(%rax),%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm0,%xmm0
cvtsi2sd %ebx,%xmm0
addsd  -0x90(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
mov    %r12,%rdi
call   *%r14
mulsd  -0x8(%r13,%rbx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    %r12,%rdi
call   *0x10(%rbp)
mulsd  -0x10(%r13,%rbx,8),%xmm0
addsd  -0x70(%rbp),%xmm0
xorpd  0x71b(%rip),%xmm0
movapd %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    %r12,%rdi
call   *-0xa8(%rbp)
movapd -0x70(%rbp),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x0(%r13,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    18d0 <LL98+0x7c0>
mov    -0x78(%rbp),%rcx
test   %ecx,%ecx
mov    0x18(%rbp),%r8
mov    -0x60(%rbp),%rsi
movsd  -0x38(%rbp),%xmm0
js     1a5b <LL98+0x94b>
movslq %ecx,%rax
movsd  0x6ab(%rip),%xmm6
divsd  0x0(%r13,%rax,8),%xmm6
lea    0x1(%rcx),%eax
cmp    $0x3,%ecx
jae    197b <LL98+0x86b>
xor    %ecx,%ecx
jmp    1a40 <LL98+0x930>
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm6,%xmm1
unpcklpd %xmm6,%xmm1
lea    -0x4(%rcx),%rdi
mov    %rdi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdi,%rdi
je     1a66 <LL98+0x956>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd 0x0(%r13,%rbx,8),%xmm2
movupd 0x10(%r13,%rbx,8),%xmm3
movupd 0x20(%r13,%rbx,8),%xmm4
movupd 0x30(%r13,%rbx,8),%xmm5
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rbx,8)
movupd %xmm3,0x10(%r13,%rbx,8)
mulpd  %xmm1,%xmm4
mulpd  %xmm1,%xmm5
movupd %xmm4,0x20(%r13,%rbx,8)
movupd %xmm5,0x30(%r13,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    19b0 <LL98+0x8a0>
test   $0x1,%r9b
je     1a2c <LL98+0x91c>
movupd 0x0(%r13,%rbx,8),%xmm2
movupd 0x10(%r13,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,0x0(%r13,%rbx,8)
movupd %xmm3,0x10(%r13,%rbx,8)
cmp    %rax,%rcx
je     1a5b <LL98+0x94b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x0(%r13,%rcx,8),%xmm1
mulsd  %xmm6,%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1a40 <LL98+0x930>
mov    %r13,%rdi
mov    %r12,%rdx
call   *%r8
jmp    1ad8 <LL98+0x9c8>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    1a08 <LL98+0x8f8>
jmp    1a2c <LL98+0x91c>
xor    %edi,%edi
test   $0x1,%cl
je     1aa1 <LL98+0x991>
mov    %rax,%rdx
sub    %rdi,%rdx
movupd -0x18(%r13,%rdx,8),%xmm2
movupd -0x8(%r13,%rdx,8),%xmm3
mulpd  %xmm1,%xmm3
movupd %xmm3,-0x8(%r13,%rdx,8)
mulpd  %xmm1,%xmm2
movupd %xmm2,-0x18(%r13,%rdx,8)
cmp    %r8,%r9
je     1acb <LL98+0x9bb>
sub    %r8,%rax
add    $0x1,%rax
nopl   (%rax)
movsd  -0x8(%r13,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,-0x8(%r13,%rax,8)
add    $0xffffffffffffffff,%rax
cmp    %r10,%rax
jg     1ab0 <LL98+0x9a0>
mov    %r13,%rdi
movapd %xmm6,%xmm0
mov    %r15,%rdx
call   *0x18(%rbp)
xor    %eax,%eax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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