#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);
scalar_t__ malloc(int);
double pow(double, double);
scalar_t__ realloc(double *, int);
int NUM_rkf(int (*f)(int neq, double time, double *y, double *dy, void *data),
            int neq, double step, double duration, double *ic, double **y,
            double epsil, void *data) {
  int i;
  int n;
  int col;
  double h;
  double t = 0.0;
  double *a;
  double *tmp;
  double *dy;
  double *K1, *K2, *K3, *K4, *K5, *K6;
  double *E;
  double err;
  double beta;
  tmp = (double *)malloc(sizeof(double) * neq);
  dy = (double *)malloc(sizeof(double) * neq);
  E = (double *)malloc(sizeof(double) * neq);
  K1 = (double *)malloc(sizeof(double) * neq);
  K2 = (double *)malloc(sizeof(double) * neq);
  K3 = (double *)malloc(sizeof(double) * neq);
  K4 = (double *)malloc(sizeof(double) * neq);
  K5 = (double *)malloc(sizeof(double) * neq);
  K6 = (double *)malloc(sizeof(double) * neq);
  h = step;
  n = 0;
  col = neq + 1;
  a = *y = (double *)malloc(sizeof(double) * col * (n + 1));
  for (i = 0; i < neq; i++) {
    tmp[i] = a[i + col * 0] = ic[i];
  }
  while (t < duration) {
    a = *y = (double *)realloc(*y, sizeof(double) * col * (n + 2));
    for (i = 0; i < neq; i++) {
      f(neq, t, tmp, dy, data);
      K1[i] = h * dy[i];
      tmp[i] = a[i + col * n] + K1[i] / 4.0;
    }
    for (i = 0; i < neq; i++) {
      f(neq, t + h / 4.0, tmp, dy, data);
      K2[i] = h * dy[i];
      tmp[i] = a[i + col * n] + 3.0 * K1[i] / 32.0 + 9.0 * K2[i] / 32.0;
    }
    for (i = 0; i < neq; i++) {
      f(neq, t + 3.0 * h / 8.0, tmp, dy, data);
      K3[i] = h * dy[i];
      tmp[i] = a[i + col * n] + 1932.0 * K1[i] / 2197.0 -
               7200.0 * K2[i] / 2197.0 + 7296.0 * K3[i] / 2197.0;
    }
    for (i = 0; i < neq; i++) {
      f(neq, t + 12.0 * h / 13.0, tmp, dy, data);
      K4[i] = h * dy[i];
      tmp[i] = a[i + col * n] + 439.0 * K1[i] / 216.0 - 8.0 * K2[i] +
               3680.0 * K3[i] / 513.0 - 845.0 * K4[i] / 4104.0;
    }
    for (i = 0; i < neq; i++) {
      f(neq, t + h, tmp, dy, data);
      K5[i] = h * dy[i];
      tmp[i] = a[i + col * n] - 8.0 * K1[i] / 27.0 + 2.0 * K2[i] -
               3544.0 * K3[i] / 2565.0 + 1859.0 * K4[i] / 4104.0 -
               11.0 * K5[i] / 40.0;
    }
    for (i = 0; i < neq; i++) {
      f(neq, t + h / 2.0, tmp, dy, data);
      K6[i] = h * dy[i];
    }
    err = 0.0;
    for (i = 0; i < neq; i++) {
      E[i] = fabs(K1[i] / 360.0 - 128.0 * K3[i] / 4275.0 -
                  2197.0 * K4[i] / 75240.0 + K5[i] / 50.0 + 2.0 * K6[i] / 55.0);
      err = ((E[i] > err) ? E[i] : err);
    }
    if ((err < epsil) || (h <= step / 1000)) {
      t += h;
      for (i = 0; i < neq; i++) {
        a[i + col * (n + 1)] = a[i + col * n] + 25.0 * K1[i] / 216.0 +
                               1408.0 * K3[i] / 2565.0 +
                               2197.0 * K4[i] / 4104.0 - 0.2 * K5[i];
      }
      a[neq + col * (n + 1)] = t;
      n++;
    }
    beta = pow(epsil / (2 * err), 0.25);
    if (beta < 0.1) {
      h = 0.1 * h;
    } else if (beta > 4) {
      h = 4.0 * h;
    } else {
      h = beta * h;
    }
    if (h < step / 1000)
      h = step / 1000;
    if (h > duration / 16)
      h = duration / 16;
    if (t + h > duration) {
      h = duration - t;
    }
  }
  return n + 1;
}


x86 assembly (clang, -O0):
<NUM_rkf>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movsd  %xmm0,-0x18(%rbp)
movsd  %xmm1,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
movsd  %xmm2,-0x38(%rbp)
mov    %r8,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0xb0(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x88(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x90(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movslq -0x4c(%rbp),%rax
shl    $0x3,%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    -0x30(%rbp),%rcx
mov    %rax,(%rcx)
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12b3 <NUM_rkf+0x183>
mov    -0x28(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x44(%rbp),%ecx
imul   $0x0,-0x4c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    126a <NUM_rkf+0x13a>
jmp    12b8 <NUM_rkf+0x188>
movsd  -0x60(%rbp),%xmm1
movsd  -0x20(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1c57 <NUM_rkf+0xb27>
mov    -0x30(%rbp),%rax
mov    (%rax),%rdi
movslq -0x4c(%rbp),%rax
shl    $0x3,%rax
mov    -0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
imul   %rcx,%rax
mov    %eax,%esi
call   1040 <realloc@plt>
mov    -0x30(%rbp),%rcx
mov    %rax,(%rcx)
mov    %rax,-0x68(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1396 <NUM_rkf+0x266>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   *%rax
movsd  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x48(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0xcad(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1301 <NUM_rkf+0x1d1>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    147a <NUM_rkf+0x34a>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  0xc5e(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   *%rax
movsd  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x88(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x48(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xcf6(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xcf1(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xcde(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xcc9(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    139d <NUM_rkf+0x26d>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    158e <NUM_rkf+0x45e>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
movsd  0xc77(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
movsd  0xc12(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   *%rax
movsd  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x48(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xc02(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xb25(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xbd2(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xafd(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xba2(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xad5(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1481 <NUM_rkf+0x351>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16c2 <NUM_rkf+0x592>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
movsd  0xb43(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
movsd  0xb2e(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   *%rax
movsd  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x48(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xac6(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  0xa29(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    -0x88(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xa91(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xa6e(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xa59(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0xa36(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x999(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1595 <NUM_rkf+0x465>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17fe <NUM_rkf+0x6ce>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   *%rax
movsd  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x48(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x982(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x96d(%rip),%xmm2
divsd  %xmm2,%xmm0
subsd  %xmm0,%xmm1
mov    -0x88(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x932(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x8bd(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x902(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x885(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x8d2(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x8bd(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    16c9 <NUM_rkf+0x599>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1870 <NUM_rkf+0x740>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edi
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
movsd  0x7ee(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0x70(%rbp),%rsi
mov    -0x78(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   *%rax
movsd  -0x58(%rbp),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1805 <NUM_rkf+0x6d5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19c3 <NUM_rkf+0x893>
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x7ed(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x7ce(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x7b9(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x75e(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x789(%rip),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x761(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x6ee(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x731(%rip),%xmm2
divsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
movaps 0x7ea(%rip),%xmm1
pand   %xmm1,%xmm0
mov    -0xb0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xb0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0xb8(%rbp),%xmm0
ff
jbe    1995 <NUM_rkf+0x865>
mov    -0xb0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    19a5 <NUM_rkf+0x875>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1882 <NUM_rkf+0x752>
movsd  -0xb8(%rbp),%xmm1
ff
movsd  -0x38(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     19fa <NUM_rkf+0x8ca>
movsd  -0x58(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm0
movsd  0x614(%rip),%xmm2
divsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     1b1f <NUM_rkf+0x9ef>
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1af4 <NUM_rkf+0x9c4>
mov    -0x68(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%edx
imul   -0x48(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x61c(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x607(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    -0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x5e4(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x5cf(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  0x5ac(%rip),%xmm0
mulsd  (%rax,%rcx,8),%xmm0
movsd  0x597(%rip),%xmm2
divsd  %xmm2,%xmm0
addsd  %xmm0,%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0x56f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x4c(%rbp),%edx
mov    -0x48(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1a10 <NUM_rkf+0x8e0>
movsd  -0x60(%rbp),%xmm0
mov    -0x68(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x4c(%rbp),%edx
mov    -0x48(%rbp),%esi
add    $0x1,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
movsd  -0x38(%rbp),%xmm0
movsd  0x4ec(%rip),%xmm1
mulsd  -0xb8(%rbp),%xmm1
ff
divsd  %xmm1,%xmm0
movsd  0x4d0(%rip),%xmm1
call   1050 <pow@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  0x4b3(%rip),%xmm0
ucomisd -0xc0(%rbp),%xmm0
ff
jbe    1b7a <NUM_rkf+0xa4a>
movsd  0x49d(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1bc2 <NUM_rkf+0xa92>
movsd  -0xc0(%rbp),%xmm0
ff
movsd  0x496(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1bab <NUM_rkf+0xa7b>
movsd  0x484(%rip),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1bbd <NUM_rkf+0xa8d>
movsd  -0xc0(%rbp),%xmm0
ff
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1bc2 <NUM_rkf+0xa92>
movsd  -0x58(%rbp),%xmm1
movsd  -0x18(%rbp),%xmm0
movsd  0x42c(%rip),%xmm2
divsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1bf8 <NUM_rkf+0xac8>
movsd  -0x18(%rbp),%xmm0
movsd  0x411(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  -0x20(%rbp),%xmm1
movsd  0x41e(%rip),%xmm2
divsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    1c2e <NUM_rkf+0xafe>
movsd  -0x20(%rbp),%xmm0
movsd  0x403(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
ucomisd -0x20(%rbp),%xmm0
jbe    1c52 <NUM_rkf+0xb22>
movsd  -0x20(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    12b8 <NUM_rkf+0x188>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NUM_rkf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x108,%rsp
mov    %r8,0x80(%rsp)
movsd  %xmm2,0x48(%rsp)
mov    %rcx,%rbp
mov    %rdx,%r15
movsd  %xmm1,0xb0(%rsp)
movaps %xmm0,0x90(%rsp)
mov    %esi,%r12d
mov    %rdi,0x88(%rsp)
lea    0x0(,%r12,8),%r13d
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,%rbx
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0x78(%rsp)
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0x100(%rsp)
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,%r14
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0xc0(%rsp)
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0x18(%rsp)
mov    %r13d,%edi
call   1030 <malloc@plt>
mov    %rax,0xd0(%rsp)
lea    0x8(,%r12,8),%edi
mov    %edi,0xac(%rsp)
call   1030 <malloc@plt>
mov    %rax,%rdi
mov    %rax,0x0(%rbp)
mov    %r12d,%eax
mov    %rax,(%rsp)
test   %r12d,%r12d
jle    13cc <NUM_rkf+0x29c>
cmp    $0x4,%r12d
jae    12c7 <NUM_rkf+0x197>
xor    %eax,%eax
mov    (%rsp),%rdx
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
and    $0x3,%rdx
je     125a <NUM_rkf+0x12a>
nopl   (%rax)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  %xmm0,(%rbx,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1240 <NUM_rkf+0x110>
cmp    $0x3,%rcx
mov    (%rsp),%rcx
jb     13cc <NUM_rkf+0x29c>
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rax,8)
movsd  %xmm0,0x8(%rbx,%rax,8)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rax,8)
movsd  %xmm0,0x10(%rbx,%rax,8)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rax,8)
movsd  %xmm0,0x18(%rbx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1270 <NUM_rkf+0x140>
jmp    13cc <NUM_rkf+0x29c>
mov    %rbp,%r11
mov    (%rsp),%rcx
lea    (%rdi,%rcx,8),%rax
lea    (%rbx,%rcx,8),%rsi
lea    (%r15,%rcx,8),%rdx
cmp    %rsi,%rdi
setb   %r9b
cmp    %rax,%rbx
setb   %bpl
cmp    %rdx,%rdi
setb   %cl
cmp    %r15,%rax
mov    %r15,%rax
seta   %r8b
cmp    %rdx,%rbx
setb   %dl
cmp    %r15,%rsi
seta   %sil
xor    %eax,%eax
test   %bpl,%r9b
jne    2007 <NUM_rkf+0xed7>
and    %r8b,%cl
jne    2007 <NUM_rkf+0xed7>
and    %sil,%dl
mov    (%rsp),%rdx
mov    %r11,%rbp
jne    122e <NUM_rkf+0xfe>
mov    %edx,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     2013 <NUM_rkf+0xee3>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %edx,%edx
nop
movups (%r15,%rdx,8),%xmm0
movups 0x10(%r15,%rdx,8),%xmm1
movups %xmm0,(%rdi,%rdx,8)
movups %xmm1,0x10(%rdi,%rdx,8)
movups %xmm0,(%rbx,%rdx,8)
movups %xmm1,0x10(%rbx,%rdx,8)
movups 0x20(%r15,%rdx,8),%xmm0
movupd 0x30(%r15,%rdx,8),%xmm1
movups %xmm0,0x20(%rdi,%rdx,8)
movupd %xmm1,0x30(%rdi,%rdx,8)
movups %xmm0,0x20(%rbx,%rdx,8)
movupd %xmm1,0x30(%rbx,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1350 <NUM_rkf+0x220>
test   $0x1,%cl
je     13bf <NUM_rkf+0x28f>
movups (%r15,%rdx,8),%xmm0
movupd 0x10(%r15,%rdx,8),%xmm1
movups %xmm0,(%rdi,%rdx,8)
movupd %xmm1,0x10(%rdi,%rdx,8)
movups %xmm0,(%rbx,%rdx,8)
movupd %xmm1,0x10(%rbx,%rdx,8)
mov    (%rsp),%rdx
cmp    %rdx,%rax
jne    122e <NUM_rkf+0xfe>
xor    %r13d,%r13d
xorpd  %xmm1,%xmm1
movsd  0xb0(%rsp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1fee <NUM_rkf+0xebe>
mov    %rbx,0xa0(%rsp)
xorpd  %xmm1,%xmm1
movsd  %xmm1,0x38(%rsp)
mov    %r12,%rbx
lea    0x1(%r12),%eax
mov    %eax,0x5c(%rsp)
movapd 0x90(%rsp),%xmm1
divsd  0x1beb(%rip),%xmm1
movsd  %xmm1,0xb8(%rsp)
movsd  0x1be2(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0xf8(%rsp)
mov    (%rsp),%rcx
lea    (%r14,%rcx,8),%rax
mov    %rax,0xf0(%rsp)
mov    0x8(%rsp),%r15
lea    (%r15,%rcx,8),%rdx
mov    %rdx,0xe8(%rsp)
mov    0x20(%rsp),%rdx
lea    (%rdx,%rcx,8),%rdx
mov    %rdx,0xe0(%rsp)
mov    0x18(%rsp),%r12
lea    (%r12,%rcx,8),%rdx
mov    %rdx,0xd8(%rsp)
and    $0xfffffffe,%ecx
mov    %rcx,0xc8(%rsp)
xor    %r13d,%r13d
mov    %rbp,0x40(%rsp)
mov    %r14,0x10(%rsp)
mov    %rbx,0x50(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x2(%r13),%esi
imul   0xac(%rsp),%esi
call   1040 <realloc@plt>
mov    %rax,%r10
mov    %rax,0x0(%rbp)
xorpd  %xmm8,%xmm8
mov    %rbx,%rdi
test   %edi,%edi
jle    1ac0 <NUM_rkf+0x990>
mov    %r13,0x30(%rsp)
mov    %r13d,%eax
imul   0x5c(%rsp),%eax
cltq
mov    0x78(%rsp),%r13
mov    %r10,0x28(%rsp)
lea    (%r10,%rax,8),%rax
mov    0xa0(%rsp),%rbp
xor    %ebx,%ebx
mov    (%rsp),%r15
mov    0x80(%rsp),%r14
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rdi
movsd  0x38(%rsp),%xmm0
mov    %rbp,%rsi
mov    %r13,%rdx
mov    %r14,%rcx
mov    %rax,%r12
call   *0x88(%rsp)
mov    %r12,%rax
movsd  0x0(%r13,%rbx,8),%xmm0
mulsd  0x90(%rsp),%xmm0
mov    0x10(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbx,8)
mulsd  0x1acd(%rip),%xmm0
addsd  (%r12,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1500 <NUM_rkf+0x3d0>
mov    0x50(%rsp),%rdi
test   %edi,%edi
movapd 0x90(%rsp),%xmm5
movsd  0x1aa0(%rip),%xmm1
jle    1b00 <NUM_rkf+0x9d0>
mulsd  %xmm1,%xmm5
addsd  0x38(%rsp),%xmm5
movsd  %xmm5,0x60(%rsp)
xor    %ebx,%ebx
mov    0x78(%rsp),%r15
mov    0xa0(%rsp),%r14
mov    (%rsp),%r13
mov    0x80(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rdi
movsd  0x60(%rsp),%xmm0
mov    %r14,%rsi
mov    %r15,%rdx
mov    %rbp,%rcx
call   *0x88(%rsp)
mov    %r12,%rax
movapd 0x90(%rsp),%xmm5
movsd  (%r15,%rbx,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0xc0(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbx,8)
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rbx,8),%xmm1
mulsd  0x1a18(%rip),%xmm1
movsd  0x1a18(%rip),%xmm2
mulsd  %xmm2,%xmm1
addsd  (%r12,%rbx,8),%xmm1
mulsd  0x1a0e(%rip),%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%r13
jne    15b0 <NUM_rkf+0x480>
mov    0x50(%rsp),%rdi
test   %edi,%edi
mov    0x18(%rsp),%rax
movsd  0x19cf(%rip),%xmm0
jle    1b2e <NUM_rkf+0x9fe>
mulsd  %xmm0,%xmm5
mulsd  0x19d5(%rip),%xmm5
addsd  0x38(%rsp),%xmm5
movsd  %xmm5,0x60(%rsp)
xor    %ebp,%ebp
mov    0xa0(%rsp),%r13
mov    0xc0(%rsp),%rax
nopl   0x0(%rax)
movsd  0x60(%rsp),%xmm0
mov    %r13,%rsi
mov    0x78(%rsp),%r15
mov    %r15,%rdx
mov    0x80(%rsp),%rcx
mov    %rdi,%r14
mov    %rax,%rbx
call   *0x88(%rsp)
mov    %r12,%rax
mov    %r14,%rdi
movsd  0x198c(%rip),%xmm7
movapd 0x90(%rsp),%xmm5
movsd  (%r15,%rbp,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0x8(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm1
mulsd  0x1955(%rip),%xmm1
divsd  %xmm7,%xmm1
addsd  (%r12,%rbp,8),%xmm1
mov    %rbx,%rax
movsd  (%rbx,%rbp,8),%xmm2
mulsd  0x194b(%rip),%xmm2
divsd  %xmm7,%xmm2
addsd  %xmm1,%xmm2
mulsd  0x1943(%rip),%xmm0
divsd  %xmm7,%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,(%rsp)
jne    1680 <NUM_rkf+0x550>
test   %edi,%edi
jle    1b76 <NUM_rkf+0xa46>
mulsd  0x191e(%rip),%xmm5
divsd  0x191e(%rip),%xmm5
addsd  0x38(%rsp),%xmm5
movsd  %xmm5,0x60(%rsp)
xor    %ebp,%ebp
mov    0x78(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nop
movsd  0x60(%rsp),%xmm0
mov    %r13,%rsi
mov    %r15,%rdx
mov    0x80(%rsp),%rcx
call   *0x88(%rsp)
mov    %r12,%rax
mov    %r14,%rdi
movapd 0x90(%rsp),%xmm5
movsd  (%r15,%rbp,8),%xmm0
mulsd  %xmm5,%xmm0
mov    0x20(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
mov    0x10(%rsp),%rcx
movsd  (%rcx,%rbp,8),%xmm1
mulsd  0x18b8(%rip),%xmm1
divsd  0x18b8(%rip),%xmm1
addsd  (%r12,%rbp,8),%xmm1
mov    %rbx,%rax
movsd  (%rbx,%rbp,8),%xmm2
mulsd  0x18aa(%rip),%xmm2
addsd  %xmm1,%xmm2
mov    0x8(%rsp),%rax
movsd  (%rax,%rbp,8),%xmm1
mulsd  0x189c(%rip),%xmm1
divsd  0x189c(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  0x1898(%rip),%xmm0
divsd  0x1898(%rip),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,(%rsp)
jne    1760 <NUM_rkf+0x630>
test   %edi,%edi
mov    0x40(%rsp),%rbp
movsd  0x17e8(%rip),%xmm1
jle    1bce <NUM_rkf+0xa9e>
movsd  0x38(%rsp),%xmm0
addsd  %xmm5,%xmm0
movsd  %xmm0,0x60(%rsp)
xor    %r14d,%r14d
mov    0xa0(%rsp),%r13
mov    0x78(%rsp),%r15
mov    0x18(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x50(%rsp),%rdi
movsd  0x60(%rsp),%xmm0
mov    %r13,%rsi
mov    %r15,%rdx
mov    0x80(%rsp),%rcx
call   *0x88(%rsp)
mov    %r12,%rax
movapd 0x90(%rsp),%xmm5
movsd  (%r15,%r14,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,0x0(%rbp,%r14,8)
mov    0x10(%rsp),%rcx
movsd  (%rcx,%r14,8),%xmm1
mulsd  0x17c8(%rip),%xmm1
divsd  0x17e8(%rip),%xmm1
addsd  (%r12,%r14,8),%xmm1
mov    %rbx,%rax
movsd  (%rbx,%r14,8),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm1,%xmm2
mov    0x8(%rsp),%rax
movsd  (%rax,%r14,8),%xmm1
mulsd  0x17c6(%rip),%xmm1
divsd  0x17c6(%rip),%xmm1
addsd  %xmm2,%xmm1
mov    0x20(%rsp),%rax
movsd  (%rax,%r14,8),%xmm2
mulsd  0x17b7(%rip),%xmm2
divsd  0x178f(%rip),%xmm2
addsd  %xmm1,%xmm2
mulsd  0x17ab(%rip),%xmm0
divsd  0x17ab(%rip),%xmm0
addsd  %xmm2,%xmm0
movsd  %xmm0,0x0(%r13,%r14,8)
add    $0x1,%r14
cmp    %r14,(%rsp)
jne    1860 <NUM_rkf+0x730>
mov    0x50(%rsp),%rdi
test   %edi,%edi
jle    1bf2 <NUM_rkf+0xac2>
mulsd  0x1785(%rip),%xmm5
addsd  0x38(%rsp),%xmm5
movsd  %xmm5,0x60(%rsp)
mov    %rdi,%r15
xor    %ebx,%ebx
mov    0x88(%rsp),%r12
mov    0xd0(%rsp),%r14
mov    (%rsp),%rbp
mov    0x78(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15d,%edi
movsd  0x60(%rsp),%xmm0
mov    0xa0(%rsp),%rsi
mov    %r13,%rdx
mov    0x80(%rsp),%rcx
call   *%r12
movapd 0x90(%rsp),%xmm5
movsd  0x0(%r13,%rbx,8),%xmm0
mulsd  %xmm5,%xmm0
movsd  %xmm0,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1980 <NUM_rkf+0x850>
test   %r15d,%r15d
movsd  0x48(%rsp),%xmm4
mov    %r15,%rdi
mov    %r14,%rdx
mov    0x10(%rsp),%r14
mov    0x18(%rsp),%r12
mov    0x30(%rsp),%r13
movsd  0x1628(%rip),%xmm1
movsd  0x1650(%rip),%xmm7
mov    0x40(%rsp),%rbp
mov    0x20(%rsp),%r11
mov    0x28(%rsp),%r10
xorpd  %xmm8,%xmm8
mov    0x8(%rsp),%r15
jle    1bac <NUM_rkf+0xa7c>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rax,8),%xmm6
mulsd  0x16aa(%rip),%xmm6
divsd  0x16aa(%rip),%xmm6
movsd  (%r11,%rax,8),%xmm2
mulsd  %xmm7,%xmm2
movsd  (%r14,%rax,8),%xmm3
unpcklpd %xmm2,%xmm3
divpd  0x16be(%rip),%xmm3
addsd  %xmm3,%xmm6
unpckhpd %xmm3,%xmm3
subsd  %xmm3,%xmm6
movsd  (%rdx,%rax,8),%xmm2
addsd  %xmm2,%xmm2
movsd  (%r12,%rax,8),%xmm8
unpcklpd %xmm2,%xmm8
divpd  0x16a5(%rip),%xmm8
addsd  %xmm8,%xmm6
unpckhpd %xmm8,%xmm8
addsd  %xmm6,%xmm8
andpd  0x169d(%rip),%xmm8
mov    0x100(%rsp),%rcx
movlpd %xmm8,(%rcx,%rax,8)
maxsd  %xmm0,%xmm8
add    $0x1,%rax
movapd %xmm8,%xmm0
cmp    %rax,(%rsp)
jne    1a20 <NUM_rkf+0x8f0>
jmp    1bac <NUM_rkf+0xa7c>
xchg   %ax,%ax
movsd  0x48(%rsp),%xmm4
movapd 0x90(%rsp),%xmm5
movsd  0x1539(%rip),%xmm1
movsd  0x1561(%rip),%xmm7
mov    0x20(%rsp),%r11
ucomisd %xmm8,%xmm4
jbe    1bb7 <NUM_rkf+0xa87>
jmp    1c40 <NUM_rkf+0xb10>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x48(%rsp),%xmm4
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%r15
mov    0x20(%rsp),%r11
mov    0x18(%rsp),%r12
mov    0x30(%rsp),%r13
movsd  0x1519(%rip),%xmm7
mov    0x40(%rsp),%rbp
jmp    1ba2 <NUM_rkf+0xa72>
movsd  0x48(%rsp),%xmm4
mov    0x40(%rsp),%rbp
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%r15
mov    0x20(%rsp),%r11
mov    0x30(%rsp),%r13
movsd  0x14bb(%rip),%xmm1
movsd  0x14e3(%rip),%xmm7
mov    0x28(%rsp),%r10
xorpd  %xmm8,%xmm8
mov    %rax,%r12
ucomisd %xmm8,%xmm4
jbe    1bb7 <NUM_rkf+0xa87>
jmp    1c40 <NUM_rkf+0xb10>
movsd  0x48(%rsp),%xmm4
mov    0x40(%rsp),%rbp
mov    0x8(%rsp),%r15
mov    0x20(%rsp),%r11
mov    0x18(%rsp),%r12
mov    0x10(%rsp),%r14
mov    0x30(%rsp),%r13
movsd  0x146e(%rip),%xmm1
mov    0x28(%rsp),%r10
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm4
ja     1c40 <NUM_rkf+0xb10>
movsd  0xb8(%rsp),%xmm0
ucomisd %xmm5,%xmm0
jae    1c40 <NUM_rkf+0xb10>
mov    %rdi,%rbx
jmp    1d82 <NUM_rkf+0xc52>
movsd  0x48(%rsp),%xmm4
mov    0x8(%rsp),%r15
mov    0x20(%rsp),%r11
mov    0x10(%rsp),%r14
mov    0x30(%rsp),%r13
movsd  0x1450(%rip),%xmm7
jmp    1c21 <NUM_rkf+0xaf1>
movsd  0x48(%rsp),%xmm4
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%r15
mov    0x20(%rsp),%r11
mov    0x30(%rsp),%r13
movsd  0x13fc(%rip),%xmm1
movsd  0x1424(%rip),%xmm7
mov    0x40(%rsp),%rbp
mov    0x28(%rsp),%r10
xorpd  %xmm8,%xmm8
mov    0x18(%rsp),%r12
ucomisd %xmm8,%xmm4
jbe    1bb7 <NUM_rkf+0xa87>
nopw   0x0(%rax,%rax,1)
test   %edi,%edi
movsd  0x1425(%rip),%xmm9
movsd  0x1444(%rip),%xmm10
movsd  0x1454(%rip),%xmm4
movsd  0x1483(%rip),%xmm11
movsd  0x1483(%rip),%xmm6
movsd  0x1483(%rip),%xmm3
movapd 0x14c2(%rip),%xmm12
movapd 0x14ca(%rip),%xmm2
movapd 0x14d1(%rip),%xmm14
movapd 0x14d9(%rip),%xmm0
jle    1d50 <NUM_rkf+0xc20>
mov    %r13d,%eax
mov    0x5c(%rsp),%ecx
imul   %ecx,%eax
add    $0x1,%r13d
mov    %r13d,%r8d
imul   %ecx,%r8d
movslq %eax,%rcx
movslq %r8d,%rbp
cmp    $0x1,%edi
jne    1e31 <NUM_rkf+0xd01>
xor    %edx,%edx
add    %rdx,%rbp
lea    (%r10,%rbp,8),%r9
add    %rdx,%rcx
lea    (%r10,%rcx,8),%rcx
lea    (%r12,%rdx,8),%rsi
lea    (%r11,%rdx,8),%rdi
lea    (%r15,%rdx,8),%rbp
lea    (%r14,%rdx,8),%rax
mov    (%rsp),%rbx
sub    %rdx,%rbx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
mulsd  %xmm11,%xmm0
divsd  %xmm9,%xmm0
addsd  (%rcx,%rdx,8),%xmm0
movsd  0x0(%rbp,%rdx,8),%xmm2
mulsd  %xmm6,%xmm2
divsd  %xmm4,%xmm2
addsd  %xmm0,%xmm2
movsd  (%rdi,%rdx,8),%xmm0
mulsd  %xmm7,%xmm0
divsd  %xmm10,%xmm0
addsd  %xmm2,%xmm0
movsd  (%rsi,%rdx,8),%xmm2
mulsd  %xmm3,%xmm2
addsd  %xmm0,%xmm2
movsd  %xmm2,(%r9,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    1cf0 <NUM_rkf+0xbc0>
mov    0x40(%rsp),%rbp
mov    0x50(%rsp),%rdi
jmp    1d5d <NUM_rkf+0xc2d>
add    $0x1,%r13d
mov    %r13d,%r8d
imul   0x5c(%rsp),%r8d
movsd  0x38(%rsp),%xmm0
addsd  %xmm5,%xmm0
mov    %rdi,%rbx
add    %edi,%r8d
movslq %r8d,%rax
movsd  %xmm0,0x38(%rsp)
movsd  %xmm0,(%r10,%rax,8)
movsd  0x48(%rsp),%xmm4
addsd  %xmm8,%xmm8
movapd %xmm4,%xmm0
divsd  %xmm8,%xmm0
call   1050 <pow@plt>
movsd  0xb0(%rsp),%xmm3
movsd  0x38(%rsp),%xmm4
ucomisd %xmm4,%xmm3
jbe    1fee <NUM_rkf+0xebe>
movsd  0x134a(%rip),%xmm1
minsd  %xmm0,%xmm1
movsd  0x1346(%rip),%xmm5
cmpltsd %xmm5,%xmm0
movapd %xmm0,%xmm2
andnpd %xmm1,%xmm2
andpd  %xmm5,%xmm0
orpd   %xmm2,%xmm0
movapd 0x90(%rsp),%xmm1
mulsd  %xmm0,%xmm1
movsd  0xb8(%rsp),%xmm0
maxsd  %xmm1,%xmm0
movsd  0xf8(%rsp),%xmm1
minsd  %xmm0,%xmm1
movapd %xmm4,%xmm0
addsd  %xmm1,%xmm0
movapd %xmm3,%xmm2
subsd  %xmm4,%xmm2
cmpltsd %xmm0,%xmm3
andpd  %xmm3,%xmm2
andnpd %xmm1,%xmm3
orpd   %xmm2,%xmm3
movapd %xmm3,0x90(%rsp)
mov    0x0(%rbp),%rdi
jmp    14a0 <NUM_rkf+0x370>
mov    %r13,0x30(%rsp)
lea    (%r10,%rbp,8),%rsi
mov    (%rsp),%rax
lea    (%r10,%rax,8),%rax
lea    (%rax,%rbp,8),%rbx
mov    %r10,0x28(%rsp)
lea    (%r10,%rcx,8),%rdi
lea    (%rax,%rcx,8),%rax
cmp    %rax,%rsi
setb   0x60(%rsp)
cmp    %rbx,%rdi
mov    %r14,%rax
mov    %r11,%r9
setb   %r14b
cmp    0xf0(%rsp),%rsi
setb   %dl
cmp    %rbx,%rax
setb   %r11b
cmp    0xe8(%rsp),%rsi
setb   %r10b
cmp    %rbx,%r15
setb   %r13b
cmp    0xe0(%rsp),%rsi
setb   %al
cmp    %rbx,%r9
setb   %r15b
cmp    0xd8(%rsp),%rsi
setb   %r9b
cmp    %rbx,%r12
setb   %bl
test   %r14b,0x60(%rsp)
jne    1fc9 <NUM_rkf+0xe99>
and    %r11b,%dl
mov    0x10(%rsp),%r14
mov    0x20(%rsp),%r11
jne    1fc0 <NUM_rkf+0xe90>
and    %r13b,%r10b
jne    1fc0 <NUM_rkf+0xe90>
and    %r15b,%al
mov    0x8(%rsp),%r15
mov    0x18(%rsp),%r12
mov    0x30(%rsp),%r13
mov    0x28(%rsp),%r10
jne    1cc1 <NUM_rkf+0xb91>
mov    $0x0,%edx
and    %bl,%r9b
jne    1cc3 <NUM_rkf+0xb93>
movapd %xmm8,0x60(%rsp)
xor    %eax,%eax
mov    0xc8(%rsp),%rbx
movapd %xmm14,%xmm15
movapd %xmm0,%xmm8
movapd %xmm12,%xmm13
movapd 0x1264(%rip),%xmm12
movapd 0x126c(%rip),%xmm1
mov    %r15,%rdx
movapd %xmm2,%xmm14
nopl   0x0(%rax)
movupd (%rdi,%rax,8),%xmm0
movupd (%r14,%rax,8),%xmm2
mulpd  %xmm13,%xmm2
divpd  %xmm14,%xmm2
addpd  %xmm0,%xmm2
movupd (%rdx,%rax,8),%xmm0
mulpd  %xmm15,%xmm0
divpd  %xmm8,%xmm0
addpd  %xmm2,%xmm0
movupd (%r11,%rax,8),%xmm2
mulpd  0x1206(%rip),%xmm2
divpd  %xmm12,%xmm2
addpd  %xmm0,%xmm2
movupd (%r12,%rax,8),%xmm0
mulpd  %xmm1,%xmm0
addpd  %xmm2,%xmm0
movupd %xmm0,(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rbx
jne    1f40 <NUM_rkf+0xe10>
mov    %rbx,%rdx
cmp    (%rsp),%rbx
movapd 0x60(%rsp),%xmm8
movsd  0x105b(%rip),%xmm1
jne    1cc3 <NUM_rkf+0xb93>
jmp    1d44 <NUM_rkf+0xc14>
xor    %edx,%edx
mov    0x8(%rsp),%r15
jmp    1fda <NUM_rkf+0xeaa>
xor    %edx,%edx
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%r15
mov    0x20(%rsp),%r11
mov    0x18(%rsp),%r12
mov    0x30(%rsp),%r13
mov    0x28(%rsp),%r10
jmp    1cc3 <NUM_rkf+0xb93>
add    $0x1,%r13d
mov    %r13d,%eax
add    $0x108,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    (%rsp),%rdx
mov    %r11,%rbp
jmp    122e <NUM_rkf+0xfe>
xor    %edx,%edx
test   $0x1,%cl
jne    139f <NUM_rkf+0x26f>
jmp    13bf <NUM_rkf+0x28f>

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

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