#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*/ printf(char *, ...);
void stub1(double, double *, double *, char);
void stub10(double, double *, double *, char);
void stub2(double, double *, double *, char);
void stub3(double, double *, double *, char);
void stub4(double, double *, double *, char);
void stub5(double, double *, double *, char);
void stub6(double, double *, double *, char);
void stub7(double, double *, double *, char);
void stub8(double, double *, double *, char);
void stub9(double, double *, double *, char);
int kutta(void (*eqns)(double, double *, double *, char), int numy, double y[],
          double *t, double integstp, double abserr, double relerr, char com) {
  static double f0[100], f1[100], f2[100], y1[100], y2[100];
  static int numcuts = 20;
  static double hc = 0;
  char entry = 1;
  char stepdouble;
  double tfinal = *t + integstp;
  double tt, h;
  int i;
  if (numy >= 100) {
    printf("\nERROR: INCREASE THE STATIC DOUBLE ARRAY SIZE IN kutta.\n");
    return 0;
  }
  if (!com) {
    (*eqns)(*t, y, f0, 1);
    return 1;
  }
  if (numy == 0) {
    hc = integstp;
    return 1;
  }
  if (integstp == 0)
    return 0;
  if (hc * integstp < 0)
    hc = -hc;
  else if (hc == 0)
    hc = integstp;
  h = hc;
  tt = *t + h;
  *t = tfinal;
beginning:
  while (tt + h != tt) {
    double h2 = h * 0.5;
    double h3 = h / 3.0;
    double h6 = h / 6.0;
    double h8 = h * 0.125;
    if (com == 2 || entry) {
      (*eqns)(tt - h, y, f0, 1);
      entry = 0;
    }
    for (i = 0; i < numy; i++)
      y1[i] = y[i] + h3 * f0[i];
    (*eqns)(tt - 2 * h3, y1, f1, 0);
    for (i = 0; i < numy; i++)
      y1[i] = y[i] + h6 * (f0[i] + f1[i]);
    (*eqns)(tt - 2 * h3, y1, f1, 0);
    for (i = 0; i < numy; i++)
      y1[i] = y[i] + h8 * (f0[i] + 3 * f1[i]);
    (*eqns)(tt - h2, y1, f2, 0);
    for (i = 0; i < numy; i++)
      y1[i] = y[i] + h2 * (f0[i] - 3 * f1[i] + 4 * f2[i]);
    (*eqns)(tt, y1, f1, 0);
    for (i = 0; i < numy; i++)
      y2[i] = y[i] + h6 * (f0[i] + 4 * f2[i] + f1[i]);
    stepdouble = 1;
    for (i = 0; i < numy; i++) {
      double error = fabs(y1[i] - y2[i]) * 0.2;
      double test = fabs(y1[i]) * relerr;
      if (error >= test && error >= abserr) {
        hc = h = h2;
        tt -= h2;
        if (numcuts-- > 0)
          goto beginning;
        printf("\n THE STEPSIZE HAS BEEN HALVED TOO MANY TIMES; T = %15.8E"
               "\n NUMERICAL INTEGRATION FAILED TO CONVERGE.\n",
               *t = tt - h);
        (*eqns)(*t, y, f0, 0);
        return 0;
      }
      if (stepdouble && 64 * error > test && 64 * error > abserr)
        stepdouble = 0;
    }
    for (i = 0; i < numy; i++)
      y[i] = y2[i];
    if (stepdouble && fabs(h + h) <= fabs(integstp) &&
        fabs(tt + h + h) <= fabs(tfinal)) {
      hc = (h += h);
      numcuts++;
    }
    if (tt == tfinal) {
      (*eqns)(tfinal, y, f0, 2);
      return 1;
    }
    tt += h;
    if ((h > 0 && tt > tfinal - 0.1 * h) || (h < 0 && tt < tfinal - 0.1 * h)) {
      h = tfinal - (tt - h);
      tt = tfinal;
    }
    if (com == 1)
      for (i = 0; i < numy; i++)
        f0[i] = f1[i];
    if (com == 3)
      (*eqns)(tt - h, y, f0, 0);
  }
  printf("\nTHE STEPSIZE OF %15.7E IS TOO SMALL RELATIVE TO THE TERMINAL TIME"
         "\nOF %15.7E.  INTEGRATION HALTED BECAUSE OF NUMERICAL ROUND-OFF.\n"
         "\nTHE STEPSIZE MAY HAVE BEEN CUT TOO MANY TIMES.\n\n",
         h, *t = tt);
  (*eqns)(*t, y, f0, 0);
  return 0;
}


x86 assembly (clang, -O0):
<kutta>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %r8b,%al
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movsd  %xmm0,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
movsd  %xmm2,-0x40(%rbp)
mov    %al,-0x41(%rbp)
movb   $0x1,-0x42(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
cmpl   $0x64,-0x14(%rbp)
jl     1179 <kutta+0x69>
lea    0xefa(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    1a45 <kutta+0x935>
cmpb   $0x0,-0x41(%rbp)
jne    11ad <kutta+0x9d>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    -0x20(%rbp),%rdi
lea    0x2ea6(%rip),%rsi
mov    $0x1,%edx
call   *%rax
movl   $0x1,-0x4(%rbp)
jmp    1a45 <kutta+0x935>
cmpl   $0x0,-0x14(%rbp)
jne    11d0 <kutta+0xc0>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,0x3e1c(%rip)
movl   $0x1,-0x4(%rbp)
jmp    1a45 <kutta+0x935>
movsd  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    11f4 <kutta+0xe4>
jp     11f4 <kutta+0xe4>
movl   $0x0,-0x4(%rbp)
jmp    1a45 <kutta+0x935>
movsd  0x3de4(%rip),%xmm1
mulsd  -0x30(%rbp),%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    123a <kutta+0x12a>
movsd  0x3dca(%rip),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,0x3dab(%rip)
jmp    1267 <kutta+0x157>
movsd  0x3d9e(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1262 <kutta+0x152>
jp     1262 <kutta+0x152>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,0x3d7e(%rip)
jmp    1267 <kutta+0x157>
movsd  0x3d71(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1298 <kutta+0x188>
movsd  -0x58(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
ucomisd -0x58(%rbp),%xmm0
jne    12b8 <kutta+0x1a8>
jp     12b8 <kutta+0x1a8>
jmp    1a03 <kutta+0x8f3>
movsd  0xd58(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xd39(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  0xd1b(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xd02(%rip),%xmm0
mulsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsbl -0x41(%rbp),%eax
cmp    $0x2,%eax
je     1325 <kutta+0x215>
movsbl -0x42(%rbp),%eax
cmp    $0x0,%eax
je     1349 <kutta+0x239>
mov    -0x10(%rbp),%rax
movsd  -0x58(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
lea    0x2d02(%rip),%rsi
mov    $0x1,%edx
call   *%rax
movb   $0x0,-0x42(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13a4 <kutta+0x294>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x78(%rbp),%xmm0
movslq -0x64(%rbp),%rcx
lea    0x2cc7(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x64(%rbp),%rcx
lea    0x360f(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1350 <kutta+0x240>
mov    -0x10(%rbp),%rax
movsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
lea    0x35df(%rip),%rdi
lea    0x2f98(%rip),%rsi
xor    %edx,%edx
call   *%rax
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1437 <kutta+0x327>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
movslq -0x64(%rbp),%rcx
lea    0x2c44(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movslq -0x64(%rbp),%rcx
lea    0x2f54(%rip),%rax
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x64(%rbp),%rcx
lea    0x357c(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13d3 <kutta+0x2c3>
mov    -0x10(%rbp),%rax
movsd  -0x58(%rbp),%xmm0
movsd  -0x78(%rbp),%xmm1
addsd  %xmm1,%xmm1
subsd  %xmm1,%xmm0
lea    0x354c(%rip),%rdi
lea    0x2f05(%rip),%rsi
xor    %edx,%edx
call   *%rax
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14dd <kutta+0x3cd>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
movslq -0x64(%rbp),%rcx
lea    0x2bae(%rip),%rax
movsd  (%rax,%rcx,8),%xmm3
movslq -0x64(%rbp),%rcx
lea    0x2ebe(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0xb61(%rip),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x64(%rbp),%rcx
lea    0x34d6(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1466 <kutta+0x356>
mov    -0x10(%rbp),%rax
movsd  -0x58(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
lea    0x34ae(%rip),%rdi
lea    0x3187(%rip),%rsi
xor    %edx,%edx
call   *%rax
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1598 <kutta+0x488>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x70(%rbp),%xmm0
movslq -0x64(%rbp),%rcx
lea    0x2b13(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movslq -0x64(%rbp),%rcx
lea    0x2e23(%rip),%rax
movsd  (%rax,%rcx,8),%xmm3
movsd  0xaf6(%rip),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movslq -0x64(%rbp),%rcx
lea    0x3123(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0xace(%rip),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x64(%rbp),%rcx
lea    0x341b(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1504 <kutta+0x3f4>
mov    -0x10(%rbp),%rax
movsd  -0x58(%rbp),%xmm0
lea    0x33f8(%rip),%rdi
lea    0x2db1(%rip),%rsi
xor    %edx,%edx
call   *%rax
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    163e <kutta+0x52e>
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
movslq -0x64(%rbp),%rcx
lea    0x2a5d(%rip),%rax
movsd  (%rax,%rcx,8),%xmm3
movslq -0x64(%rbp),%rcx
lea    0x308d(%rip),%rax
movsd  (%rax,%rcx,8),%xmm2
movsd  0xa38(%rip),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movslq -0x64(%rbp),%rcx
lea    0x2d4d(%rip),%rax
addsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0x64(%rbp),%rcx
lea    0x3695(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    15ba <kutta+0x4aa>
movb   $0x1,-0x43(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17cd <kutta+0x6bd>
movslq -0x64(%rbp),%rcx
lea    0x3340(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
movslq -0x64(%rbp),%rcx
lea    0x3650(%rip),%rax
subsd  (%rax,%rcx,8),%xmm0
movaps 0x9d4(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0x9a0(%rip),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movslq -0x64(%rbp),%rcx
lea    0x3301(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
movaps 0x9a5(%rip),%xmm1
pand   %xmm1,%xmm0
mulsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jb     1770 <kutta+0x660>
movsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x38(%rbp),%xmm0
jb     1770 <kutta+0x660>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  %xmm0,0x38e9(%rip)
movsd  -0x70(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    0x2918(%rip),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,0x290d(%rip)
cmp    $0x0,%eax
jle    1729 <kutta+0x619>
jmp    1293 <kutta+0x183>
movsd  -0x58(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
lea    0x957(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    -0x20(%rbp),%rdi
lea    0x28e0(%rip),%rsi
xor    %edx,%edx
call   *%rax
movl   $0x0,-0x4(%rbp)
jmp    1a45 <kutta+0x935>
movsbl -0x43(%rbp),%eax
cmp    $0x0,%eax
je     17ba <kutta+0x6aa>
movsd  0x8ab(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x98(%rbp),%xmm0
ff
jbe    17ba <kutta+0x6aa>
movsd  0x88d(%rip),%xmm0
mulsd  -0x90(%rbp),%xmm0
ff
ucomisd -0x38(%rbp),%xmm0
jbe    17ba <kutta+0x6aa>
movb   $0x0,-0x43(%rbp)
jmp    17bf <kutta+0x6af>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1649 <kutta+0x539>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    180b <kutta+0x6fb>
movslq -0x64(%rbp),%rcx
lea    0x34d5(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17d4 <kutta+0x6c4>
movsbl -0x43(%rbp),%eax
cmp    $0x0,%eax
je     18a1 <kutta+0x791>
movsd  -0x60(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
movaps 0x827(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x30(%rbp),%xmm0
movaps 0x817(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     18a1 <kutta+0x791>
movsd  -0x58(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
addsd  -0x60(%rbp),%xmm1
movaps 0x7f3(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
movaps 0x7e3(%rip),%xmm2
pand   %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     18a1 <kutta+0x791>
movsd  -0x60(%rbp),%xmm0
addsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  %xmm0,0x374e(%rip)
mov    0x2790(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2787(%rip)
movsd  -0x58(%rbp),%xmm0
ucomisd -0x50(%rbp),%xmm0
jne    18de <kutta+0x7ce>
jp     18de <kutta+0x7ce>
mov    -0x10(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
lea    0x2775(%rip),%rsi
mov    $0x2,%edx
call   *%rax
movl   $0x1,-0x4(%rbp)
jmp    1a45 <kutta+0x935>
movsd  -0x60(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1928 <kutta+0x818>
movsd  -0x58(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm1
movsd  0x70a(%rip),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
ja     195f <kutta+0x84f>
xorps  %xmm0,%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1981 <kutta+0x871>
movsd  -0x58(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x60(%rbp),%xmm0
movsd  0x6d3(%rip),%xmm3
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    1981 <kutta+0x871>
movsd  -0x50(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
subsd  -0x60(%rbp),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsbl -0x41(%rbp),%eax
cmp    $0x1,%eax
jne    19d4 <kutta+0x8c4>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19cf <kutta+0x8bf>
movslq -0x64(%rbp),%rcx
lea    0x29b4(%rip),%rax
movsd  (%rax,%rcx,8),%xmm0
movslq -0x64(%rbp),%rcx
lea    0x2684(%rip),%rax
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1995 <kutta+0x885>
jmp    19d4 <kutta+0x8c4>
movsbl -0x41(%rbp),%eax
cmp    $0x3,%eax
jne    19fe <kutta+0x8ee>
mov    -0x10(%rbp),%rax
movsd  -0x58(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rdi
lea    0x2646(%rip),%rsi
xor    %edx,%edx
call   *%rax
jmp    1298 <kutta+0x188>
movsd  -0x60(%rbp),%xmm0
movsd  -0x58(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movsd  %xmm1,(%rax)
lea    0x6e3(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movsd  (%rcx),%xmm0
mov    -0x20(%rbp),%rdi
lea    0x2606(%rip),%rsi
xor    %edx,%edx
call   *%rax
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<kutta>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
cmp    $0x64,%esi
jl     115a <kutta+0x2a>
lea    0x1075(%rip),%rdi
call   1030 <puts@plt>
xor    %r14d,%r14d
jmp    1ebe <kutta+0xd8e>
mov    %rdx,%rbx
mov    %rdi,%rbp
movsd  (%rcx),%xmm5
test   %r8b,%r8b
je     11bd <kutta+0x8d>
test   %esi,%esi
je     11dd <kutta+0xad>
mov    %esi,0x18(%rsp)
xor    %r14d,%r14d
xorpd  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
jne    1184 <kutta+0x54>
jnp    1ebe <kutta+0xd8e>
movsd  %xmm1,0xa8(%rsp)
movapd %xmm5,%xmm4
addsd  %xmm0,%xmm4
movsd  0x3e53(%rip),%xmm6
movapd %xmm6,%xmm1
mulsd  %xmm0,%xmm1
ucomisd %xmm1,%xmm3
jbe    11ea <kutta+0xba>
xorpd  0xe4d(%rip),%xmm6
movapd %xmm6,%xmm1
mov    0x18(%rsp),%eax
jmp    11fe <kutta+0xce>
lea    0x2e8c(%rip),%rsi
mov    $0x1,%r14d
movapd %xmm5,%xmm0
mov    %rbx,%rdi
mov    $0x1,%edx
call   *%rbp
jmp    1ebe <kutta+0xd8e>
movsd  %xmm0,0x3e0b(%rip)
jmp    1eb8 <kutta+0xd88>
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm6
movapd %xmm0,%xmm1
mov    0x18(%rsp),%eax
jne    120a <kutta+0xda>
jp     120a <kutta+0xda>
movsd  %xmm1,0x3dea(%rip)
movapd %xmm1,%xmm6
addsd  %xmm6,%xmm5
mov    %rcx,0x98(%rsp)
movsd  %xmm4,(%rcx)
movapd 0xdee(%rip),%xmm1
andpd  %xmm1,%xmm0
movapd %xmm0,0xc0(%rsp)
andpd  %xmm4,%xmm1
movapd %xmm1,0x110(%rsp)
mov    %eax,%esi
lea    0x376b(%rip),%r13
lea    0x0(%r13,%rsi,8),%rdi
lea    (%rbx,%rsi,8),%rcx
lea    0x2dfb(%rip),%r15
lea    (%r15,%rsi,8),%rax
lea    0x3110(%rip),%r12
mov    %esi,%edx
and    $0xfffffffc,%edx
mov    %rdx,0x28(%rsp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,0xf8(%rsp)
shr    $0x2,%rdx
add    $0x1,%rdx
cmp    %r13,%rcx
seta   %r10b
lea    (%r12,%rsi,8),%r9
cmp    %rbx,%rdi
seta   %cl
and    %r10b,%cl
cmp    %r13,%rax
seta   %r10b
lea    0x33f0(%rip),%r11
cmp    %r15,%rdi
seta   %al
lea    (%r11,%rsi,8),%r14
and    %r10b,%al
or     %cl,%al
mov    %rdx,%rcx
mov    %rdx,0xf0(%rsp)
and    $0xfffffffffffffffe,%rdx
mov    %rdx,0xe8(%rsp)
mov    %rsi,%rcx
neg    %rcx
mov    %rcx,0x60(%rsp)
cmp    %r13,%r9
seta   %cl
cmp    %r12,%rdi
seta   %dl
and    %cl,%dl
mov    %al,0xf(%rsp)
or     %al,%dl
cmp    %r13,%r14
seta   %r9b
mov    %rsi,0x20(%rsp)
lea    0x0(,%rsi,8),%rax
cmp    %r11,%rdi
seta   %cl
and    %r9b,%cl
mov    %dl,0xd(%rsp)
or     %dl,%cl
mov    %cl,0xe(%rsp)
movapd 0xd0c(%rip),%xmm0
unpcklpd %xmm2,%xmm0
movapd %xmm0,0x120(%rsp)
mov    %rax,0x68(%rsp)
and    $0xffffffffffffffe0,%rax
mov    %rax,0x48(%rsp)
mov    $0x1,%r14b
movsd  0xd2e(%rip),%xmm3
mov    %rbp,0xa0(%rsp)
mov    %r8d,0x1c(%rsp)
movapd %xmm4,0xb0(%rsp)
movapd %xmm6,%xmm0
addsd  %xmm5,%xmm0
ucomisd %xmm5,%xmm0
jne    1364 <kutta+0x234>
jnp    1ed3 <kutta+0xda3>
movapd %xmm0,0x100(%rsp)
movapd %xmm5,%xmm1
jmp    13d7 <kutta+0x2a7>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movapd %xmm1,%xmm0
subsd  %xmm6,%xmm0
mov    %rbx,%rdi
mov    %r15,%rsi
xor    %edx,%edx
movsd  %xmm1,0x10(%rsp)
movapd %xmm6,0x70(%rsp)
call   *%rbp
movapd 0x70(%rsp),%xmm6
movsd  0x10(%rsp),%xmm1
movsd  0xcb6(%rip),%xmm3
mov    0x1c(%rsp),%r8d
movapd %xmm6,%xmm0
addsd  %xmm1,%xmm0
xor    %r14d,%r14d
movapd %xmm0,0x100(%rsp)
ucomisd %xmm1,%xmm0
jne    13d7 <kutta+0x2a7>
jnp    1ed7 <kutta+0xda7>
movapd %xmm6,%xmm0
mulsd  0xc7d(%rip),%xmm0
movapd %xmm0,0x50(%rsp)
movapd %xmm6,%xmm5
divsd  %xmm3,%xmm5
movapd %xmm6,%xmm0
divsd  0xc73(%rip),%xmm0
movapd %xmm0,0x80(%rsp)
movapd %xmm6,%xmm0
mulsd  0xc66(%rip),%xmm0
movapd %xmm0,0xd0(%rsp)
cmp    $0x2,%r8b
movsd  %xmm1,0x10(%rsp)
movapd %xmm6,0x70(%rsp)
je     1432 <kutta+0x302>
test   %r14b,%r14b
je     1459 <kutta+0x329>
movapd %xmm1,%xmm0
subsd  %xmm6,%xmm0
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x1,%edx
movapd %xmm5,0x30(%rsp)
call   *%rbp
movapd 0x30(%rsp),%xmm5
movsd  0x10(%rsp),%xmm1
mov    0x18(%rsp),%r14d
test   %r14d,%r14d
jle    1480 <kutta+0x350>
cmp    $0x4,%r14d
setb   %al
or     0xf(%rsp),%al
je     14b0 <kutta+0x380>
xor    %ecx,%ecx
mov    0x20(%rsp),%rdx
jmp    15a1 <kutta+0x471>
nopl   0x0(%rax)
addsd  %xmm5,%xmm5
movapd %xmm1,%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %r13,%rdi
mov    %r12,%rsi
xor    %edx,%edx
call   *%rbp
jmp    1660 <kutta+0x530>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
cmpq   $0x0,0xf8(%rsp)
mov    0x20(%rsp),%rdx
je     1aa1 <kutta+0x971>
mov    0xe8(%rsp),%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movupd (%rbx,%rax,8),%xmm4
movupd 0x10(%rbx,%rax,8),%xmm2
movapd (%r15,%rax,8),%xmm3
mulpd  %xmm0,%xmm3
addpd  %xmm4,%xmm3
movapd 0x10(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movapd %xmm3,0x0(%r13,%rax,8)
movapd %xmm4,0x10(%r13,%rax,8)
movupd 0x20(%rbx,%rax,8),%xmm4
movupd 0x30(%rbx,%rax,8),%xmm2
movapd 0x20(%r15,%rax,8),%xmm3
mulpd  %xmm0,%xmm3
addpd  %xmm4,%xmm3
movapd 0x30(%r15,%rax,8),%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movapd %xmm3,0x20(%r13,%rax,8)
movapd %xmm4,0x30(%r13,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    14e0 <kutta+0x3b0>
testb  $0x1,0xf0(%rsp)
01
je     1594 <kutta+0x464>
movupd (%rbx,%rax,8),%xmm4
movupd 0x10(%rbx,%rax,8),%xmm2
movapd (%r15,%rax,8),%xmm3
mulpd  %xmm0,%xmm3
mulpd  0x10(%r15,%rax,8),%xmm0
addpd  %xmm4,%xmm3
addpd  %xmm2,%xmm0
movapd %xmm3,0x0(%r13,%rax,8)
movapd %xmm0,0x10(%r13,%rax,8)
mov    0x28(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
je     1607 <kutta+0x4d7>
mov    %rcx,%rax
test   $0x1,%dl
je     15c6 <kutta+0x496>
movsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x60(%rsp),%rcx
je     1607 <kutta+0x4d7>
movsd  (%r15,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,0x0(%r13,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  0x8(%rbx,%rax,8),%xmm0
movsd  %xmm0,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    15d0 <kutta+0x4a0>
addsd  %xmm5,%xmm5
movapd %xmm1,%xmm0
subsd  %xmm5,%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %r13,%rdi
mov    %r12,%rsi
xor    %edx,%edx
call   *%rbp
test   %r14d,%r14d
jle    1660 <kutta+0x530>
cmp    $0x4,%r14d
setb   %al
or     0xd(%rsp),%al
mov    0x48(%rsp),%rcx
je     17c8 <kutta+0x698>
xor    %ecx,%ecx
mov    0x20(%rsp),%rdx
movapd 0x80(%rsp),%xmm5
movsd  0x30(%rsp),%xmm0
jmp    1847 <kutta+0x717>
nopl   0x0(%rax)
movsd  0x30(%rsp),%xmm0
mov    %r13,%rdi
mov    %r12,%rsi
xor    %edx,%edx
call   *%rbp
movsd  0x10(%rsp),%xmm0
subsd  0x50(%rsp),%xmm0
mov    %r13,%rdi
lea    0x300a(%rip),%rsi
xor    %edx,%edx
call   *%rbp
movsd  0x10(%rsp),%xmm0
mov    %r13,%rdi
mov    %r12,%rsi
xor    %edx,%edx
call   *%rbp
mov    0x1c(%rsp),%r8d
movapd 0xc0(%rsp),%xmm5
movapd 0x960(%rip),%xmm3
movapd 0x70(%rsp),%xmm6
movapd %xmm6,%xmm2
addsd  %xmm6,%xmm2
movapd %xmm2,%xmm1
andpd  %xmm3,%xmm1
ucomisd %xmm1,%xmm5
jae    16f0 <kutta+0x5c0>
movapd 0xb0(%rsp),%xmm0
movsd  0x98b(%rip),%xmm3
movsd  0x10(%rsp),%xmm1
jmp    173a <kutta+0x60a>
cs nopw 0x0(%rax,%rax,1)
nop
movapd 0x100(%rsp),%xmm1
addsd  %xmm6,%xmm1
andpd  %xmm3,%xmm1
movapd 0x110(%rsp),%xmm0
ucomisd %xmm1,%xmm0
movapd 0xb0(%rsp),%xmm0
movsd  0x949(%rip),%xmm3
movsd  0x10(%rsp),%xmm1
jb     173a <kutta+0x60a>
movsd  %xmm2,0x38c1(%rip)
addl   $0x1,0x2902(%rip)
movapd %xmm2,%xmm6
ucomisd %xmm0,%xmm1
jne    1746 <kutta+0x616>
jnp    1ea7 <kutta+0xd77>
addsd  %xmm6,%xmm1
ucomisd 0x94e(%rip),%xmm6
movapd %xmm6,%xmm4
mulsd  0x93a(%rip),%xmm4
addsd  %xmm0,%xmm4
jbe    176a <kutta+0x63a>
ucomisd %xmm4,%xmm1
ja     177a <kutta+0x64a>
xorpd  %xmm2,%xmm2
ucomisd %xmm6,%xmm2
jbe    178a <kutta+0x65a>
ucomisd %xmm1,%xmm4
jbe    178a <kutta+0x65a>
subsd  %xmm6,%xmm1
movapd %xmm0,%xmm6
subsd  %xmm1,%xmm6
movapd %xmm0,%xmm1
cmp    $0x3,%r8b
je     1380 <kutta+0x250>
cmp    $0x1,%r8b
jne    13b7 <kutta+0x287>
test   %r14d,%r14d
jle    13b7 <kutta+0x287>
mov    %r15,%rdi
mov    %r12,%rsi
mov    0x68(%rsp),%rdx
movsd  %xmm1,0x10(%rsp)
movapd %xmm6,0x70(%rsp)
call   1050 <memcpy@plt>
jmp    139e <kutta+0x26e>
movapd 0x80(%rsp),%xmm5
movapd %xmm5,%xmm0
unpcklpd %xmm5,%xmm0
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movupd (%rbx,%rax,1),%xmm1
movupd 0x10(%rbx,%rax,1),%xmm2
movapd (%rax,%r15,1),%xmm3
movapd 0x10(%rax,%r15,1),%xmm4
addpd  (%rax,%r12,1),%xmm3
addpd  0x10(%rax,%r12,1),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movapd %xmm3,(%rax,%r13,1)
movapd %xmm4,0x10(%rax,%r13,1)
add    $0x20,%rax
cmp    %rax,%rcx
jne    17e0 <kutta+0x6b0>
mov    0x28(%rsp),%rax
mov    %rax,%rcx
mov    0x20(%rsp),%rdx
cmp    %rdx,%rax
movsd  0x30(%rsp),%xmm0
je     18c4 <kutta+0x794>
mov    %rcx,%rax
test   $0x1,%dl
je     1872 <kutta+0x742>
movsd  (%r15,%rcx,8),%xmm1
addsd  (%r12,%rcx,8),%xmm1
mulsd  %xmm5,%xmm1
addsd  (%rbx,%rcx,8),%xmm1
movsd  %xmm1,0x0(%r13,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x60(%rsp),%rcx
je     18c4 <kutta+0x794>
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm2
movsd  0x8(%r15,%rax,8),%xmm1
addsd  (%r12,%rax,8),%xmm2
mulsd  %xmm5,%xmm2
addsd  (%rbx,%rax,8),%xmm2
addsd  0x8(%r12,%rax,8),%xmm1
movsd  %xmm2,0x0(%r13,%rax,8)
mulsd  %xmm5,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1880 <kutta+0x750>
mov    %r13,%rdi
mov    %r12,%rsi
xor    %edx,%edx
call   *%rbp
test   %r14d,%r14d
jle    1670 <kutta+0x540>
cmp    $0x4,%r14d
setb   %al
or     0xd(%rsp),%al
je     190d <kutta+0x7dd>
xor    %ecx,%ecx
mov    0x20(%rsp),%rdx
movsd  0x775(%rip),%xmm5
movsd  0x10(%rsp),%xmm2
movapd 0x50(%rsp),%xmm3
movapd 0xd0(%rsp),%xmm4
jmp    19b9 <kutta+0x889>
movapd 0xd0(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
mov    0x20(%rsp),%rdx
mov    0x48(%rsp),%rcx
movsd  0x73a(%rip),%xmm5
movapd 0x6fa(%rip),%xmm6
cs nopw 0x0(%rax,%rax,1)
movupd (%rbx,%rax,1),%xmm1
movupd 0x10(%rbx,%rax,1),%xmm2
movapd (%rax,%r12,1),%xmm3
mulpd  %xmm6,%xmm3
addpd  (%rax,%r15,1),%xmm3
movapd 0x10(%rax,%r12,1),%xmm4
mulpd  %xmm6,%xmm4
addpd  0x10(%rax,%r15,1),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movapd %xmm3,(%rax,%r13,1)
movapd %xmm4,0x10(%rax,%r13,1)
add    $0x20,%rax
cmp    %rax,%rcx
jne    1940 <kutta+0x810>
mov    0x28(%rsp),%rax
mov    %rax,%rcx
cmp    %rdx,%rax
movsd  0x10(%rsp),%xmm2
movapd 0x50(%rsp),%xmm3
movapd 0xd0(%rsp),%xmm4
je     1a4c <kutta+0x91c>
mov    %rcx,%rax
test   $0x1,%dl
je     19e8 <kutta+0x8b8>
movsd  (%r12,%rcx,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%r15,%rcx,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x0(%r13,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x60(%rsp),%rcx
je     1a4c <kutta+0x91c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rax,8),%xmm0
mulsd  %xmm5,%xmm0
addsd  (%r15,%rax,8),%xmm0
mulsd  %xmm4,%xmm0
addsd  (%rbx,%rax,8),%xmm0
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm5,%xmm1
addsd  0x8(%r15,%rax,8),%xmm1
movsd  %xmm0,0x0(%r13,%rax,8)
mulsd  %xmm4,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    1a00 <kutta+0x8d0>
movapd %xmm2,%xmm0
subsd  %xmm3,%xmm0
movsd  %xmm0,0x30(%rsp)
mov    %r13,%rdi
lea    0x2c2c(%rip),%rsi
xor    %edx,%edx
call   *%rbp
test   %r14d,%r14d
jle    168a <kutta+0x55a>
cmp    $0x4,%r14d
setb   %al
or     0xe(%rsp),%al
je     1ab6 <kutta+0x986>
xor    %eax,%eax
movsd  0x5f8(%rip),%xmm2
movsd  0x5f8(%rip),%xmm3
movsd  0x10(%rsp),%xmm0
movapd 0x50(%rsp),%xmm5
jmp    1b79 <kutta+0xa49>
xor    %eax,%eax
testb  $0x1,0xf0(%rsp)
01
jne    1562 <kutta+0x432>
jmp    1594 <kutta+0x464>
movapd 0x50(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
lea    0x2bc7(%rip),%rcx
mov    0x48(%rsp),%rdx
movapd 0x57a(%rip),%xmm6
movapd 0x562(%rip),%xmm7
xchg   %ax,%ax
movupd (%rbx,%rax,1),%xmm1
movupd 0x10(%rbx,%rax,1),%xmm2
movapd (%rax,%r12,1),%xmm3
mulpd  %xmm7,%xmm3
addpd  (%rax,%r15,1),%xmm3
movapd 0x10(%rax,%r12,1),%xmm4
mulpd  %xmm7,%xmm4
addpd  0x10(%rax,%r15,1),%xmm4
movapd (%rax,%rcx,1),%xmm5
mulpd  %xmm6,%xmm5
addpd  %xmm3,%xmm5
movapd 0x10(%rax,%rcx,1),%xmm3
mulpd  %xmm6,%xmm3
addpd  %xmm4,%xmm3
mulpd  %xmm0,%xmm5
addpd  %xmm1,%xmm5
mulpd  %xmm0,%xmm3
addpd  %xmm2,%xmm3
movapd %xmm5,(%rax,%r13,1)
movapd %xmm3,0x10(%rax,%r13,1)
add    $0x20,%rax
cmp    %rax,%rdx
jne    1ae0 <kutta+0x9b0>
mov    0x28(%rsp),%rcx
mov    %rcx,%rax
cmp    0x20(%rsp),%rcx
movsd  0x51d(%rip),%xmm2
movsd  0x51d(%rip),%xmm3
movsd  0x10(%rsp),%xmm0
movapd 0x50(%rsp),%xmm5
je     1be3 <kutta+0xab3>
lea    0x0(,%rax,8),%r8
add    %r13,%r8
lea    0x2b05(%rip),%rcx
lea    (%rcx,%rax,8),%rcx
lea    (%r12,%rax,8),%rdx
lea    (%r15,%rax,8),%rsi
lea    (%rbx,%rax,8),%rdi
mov    0x20(%rsp),%rbp
sub    %rax,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rax,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  (%rsi,%rax,8),%xmm4
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm4,%xmm1
mulsd  %xmm5,%xmm1
addsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%r8,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1bb0 <kutta+0xa80>
mov    %r13,%rdi
mov    %r12,%rsi
xor    %edx,%edx
mov    0xa0(%rsp),%rbp
call   *%rbp
test   %r14d,%r14d
mov    0x1c(%rsp),%r8d
movapd 0xc0(%rsp),%xmm5
movapd 0x402(%rip),%xmm3
movapd 0x43a(%rip),%xmm6
jle    16b0 <kutta+0x580>
cmp    $0x4,%r14d
jae    1c3a <kutta+0xb0a>
xor    %eax,%eax
movsd  0x45c(%rip),%xmm1
movapd 0x80(%rsp),%xmm2
jmp    1ce4 <kutta+0xbb4>
movapd 0x80(%rsp),%xmm0
unpcklpd %xmm0,%xmm0
xor    %eax,%eax
lea    0x2a40(%rip),%rcx
mov    0x48(%rsp),%rdx
lea    0x3074(%rip),%rsi
nopl   0x0(%rax)
movupd (%rbx,%rax,1),%xmm1
movupd 0x10(%rbx,%rax,1),%xmm2
movapd (%rax,%rcx,1),%xmm3
mulpd  %xmm6,%xmm3
addpd  (%rax,%r15,1),%xmm3
movapd 0x10(%rax,%rcx,1),%xmm4
mulpd  %xmm6,%xmm4
addpd  0x10(%rax,%r15,1),%xmm4
addpd  (%rax,%r12,1),%xmm3
addpd  0x10(%rax,%r12,1),%xmm4
mulpd  %xmm0,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm0,%xmm4
addpd  %xmm2,%xmm4
movapd %xmm3,(%rax,%rsi,1)
movapd %xmm4,0x10(%rax,%rsi,1)
add    $0x20,%rax
cmp    %rax,%rdx
jne    1c60 <kutta+0xb30>
mov    0x28(%rsp),%rcx
mov    %rcx,%rax
cmp    0x20(%rsp),%rcx
movsd  0x3b7(%rip),%xmm1
movapd 0x337(%rip),%xmm3
movapd 0x80(%rsp),%xmm2
je     1d3b <kutta+0xc0b>
lea    0x2fe5(%rip),%rcx
lea    (%rcx,%rax,8),%r9
lea    (%r12,%rax,8),%rcx
lea    0x2996(%rip),%rdx
lea    (%rdx,%rax,8),%rdx
lea    (%r15,%rax,8),%rsi
lea    (%rbx,%rax,8),%rdi
mov    0x20(%rsp),%rbp
sub    %rax,%rbp
xor    %eax,%eax
movsd  (%rdx,%rax,8),%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rsi,%rax,8),%xmm0
addsd  (%rcx,%rax,8),%xmm0
mulsd  %xmm2,%xmm0
addsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1d10 <kutta+0xbe0>
test   %r14d,%r14d
mov    0xa0(%rsp),%rbp
jle    16b0 <kutta+0x580>
mov    $0x1,%r14b
xor    %eax,%eax
movapd 0x50(%rsp),%xmm6
jmp    1d73 <kutta+0xc43>
nopl   0x0(%rax)
ucomisd %xmm1,%xmm0
cmova  %ecx,%r14d
add    $0x8,%rax
cmp    %rax,0x68(%rsp)
je     1de5 <kutta+0xcb5>
movsd  (%rax,%r13,1),%xmm1
movapd %xmm1,%xmm0
lea    0x2f4c(%rip),%rcx
subsd  (%rax,%rcx,1),%xmm0
unpcklpd %xmm1,%xmm0
andpd  %xmm3,%xmm0
mulpd  0x120(%rsp),%xmm0
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
ucomisd %xmm1,%xmm0
jb     1db7 <kutta+0xc87>
ucomisd 0xa8(%rsp),%xmm0
jae    1e46 <kutta+0xd16>
xor    %ecx,%ecx
test   %r14b,%r14b
je     1de0 <kutta+0xcb0>
mulsd  0x2ca(%rip),%xmm0
ucomisd 0xa8(%rsp),%xmm0
movzbl %r14b,%r14d
ja     1d60 <kutta+0xc30>
mov    %r14d,%ecx
jmp    1d60 <kutta+0xc30>
nopw   0x0(%rax,%rax,1)
xor    %r14d,%r14d
jmp    1d68 <kutta+0xc38>
cmpl   $0x0,0x18(%rsp)
jle    1e16 <kutta+0xce6>
mov    %rbx,%rdi
lea    0x2eda(%rip),%rsi
mov    0x68(%rsp),%rdx
call   1050 <memcpy@plt>
movapd 0x208(%rip),%xmm3
movapd 0xc0(%rsp),%xmm5
mov    0x1c(%rsp),%r8d
test   %r14b,%r14b
mov    0x18(%rsp),%r14d
jne    16b0 <kutta+0x580>
movapd 0xb0(%rsp),%xmm0
movsd  0x233(%rip),%xmm3
movsd  0x10(%rsp),%xmm1
movapd 0x70(%rsp),%xmm6
jmp    173a <kutta+0x60a>
movsd  %xmm6,0x31a2(%rip)
mov    0x21e4(%rip),%eax
lea    -0x1(%rax),%ecx
mov    %ecx,0x21db(%rip)
xor    %r14d,%r14d
test   %eax,%eax
movsd  0x1fe(%rip),%xmm3
movsd  0x30(%rsp),%xmm5
jg     1350 <kutta+0x220>
subsd  %xmm6,%xmm5
mov    0x98(%rsp),%r15
movsd  %xmm5,(%r15)
lea    0x21a(%rip),%rdi
movapd %xmm5,%xmm0
mov    $0x1,%al
call   1040 <printf@plt>
movsd  (%r15),%xmm0
lea    0x21ab(%rip),%rsi
jmp    1f05 <kutta+0xdd5>
lea    0x21a2(%rip),%rsi
mov    %rbx,%rdi
mov    $0x2,%edx
call   *%rbp
mov    $0x1,%r14d
mov    %r14d,%eax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movapd %xmm5,%xmm1
mov    0x98(%rsp),%r14
movsd  %xmm1,(%r14)
lea    0x223(%rip),%rdi
movapd %xmm6,%xmm0
mov    $0x2,%al
call   1040 <printf@plt>
movsd  (%r14),%xmm0
lea    0x214e(%rip),%rsi
xor    %r14d,%r14d
mov    %rbx,%rdi
xor    %edx,%edx
jmp    11d6 <kutta+0xa6>

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

LLVM IR (-O2):
@kutta.f0 = internal global [100 x double] zeroinitializer
@kutta.f1 = internal global [100 x double] zeroinitializer
@kutta.f2 = internal global [100 x double] zeroinitializer
@kutta.y1 = internal global [100 x double] zeroinitializer
@kutta.y2 = internal unnamed_addr global [100 x double] zeroinitializer
@kutta.numcuts = internal unnamed_addr global i32 20
@kutta.hc = internal unnamed_addr global double 0.000000e+00
@.str.1 = [102 x i8] c"\0A THE STEPSIZE HAS BEEN HALVED TOO MANY TIMES; T = %15.8E\0A NUMERICAL INTEGRATION FAILED TO CONVERGE.\0A\00"
@.str.2 = [180 x i8] c"\0ATHE STEPSIZE OF %15.7E IS TOO SMALL RELATIVE TO THE TERMINAL TIME\0AOF %15.7E. INTEGRATION HALTED BECAUSE OF NUMERICAL ROUND-OFF.\0A\0ATHE STEPSIZE MAY HAVE BEEN CUT TOO MANY TIMES.\0A\0A\00"
@str = [56 x i8] c"\0AERROR: INCREASE THE STATIC DOUBLE ARRAY SIZE IN kutta.\00"
define i32 @kutta(void (double, double*, double*, i8)* nocapture %0, i32 %1, double* %2, double* nocapture %3, double %4, double %5, double %6, i8 signext %7) {
%9 = bitcast double* %2 to i8*
%10 = load double, double* %3
%11 = fadd double %10, %4
%12 = icmp sgt i32 %1, 99
br i1 %12, label %13, label %15
13: ; preds = %8
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([56 x i8], [56 x i8]* @str, i64 0, i64 0))
br label %639
15: ; preds = %8
%16 = icmp eq i8 %7, 0
br i1 %16, label %17, label %18
17: ; preds = %15
tail call void %0(double %10, double* %2, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0), i8 signext 1)
br label %639
18: ; preds = %15
%19 = icmp eq i32 %1, 0
br i1 %19, label %20, label %21
20: ; preds = %18
store double %4, double* @kutta.hc
br label %639
21: ; preds = %18
%22 = fcmp oeq double %4, 0.000000e+00
br i1 %22, label %639, label %23
23: ; preds = %21
%24 = load double, double* @kutta.hc
%25 = fmul double %24, %4
%26 = fcmp olt double %25, 0.000000e+00
br i1 %26, label %27, label %29
27: ; preds = %23
%28 = fneg double %24
br label %31
29: ; preds = %23
%30 = fcmp oeq double %24, 0.000000e+00
br i1 %30, label %31, label %33
31: ; preds = %29, %27
%32 = phi double [ %28, %27 ], [ %4, %29 ]
store double %32, double* @kutta.hc
br label %33
33: ; preds = %31, %29
%34 = phi double [ %24, %29 ], [ %32, %31 ]
%35 = fadd double %10, %34
store double %11, double* %3
%36 = icmp eq i8 %7, 2
%37 = icmp sgt i32 %1, 0
%38 = tail call double @llvm.fabs.f64(double %4)
%39 = tail call double @llvm.fabs.f64(double %11)
%40 = zext i32 %1 to i64
%41 = shl nuw nsw i64 %40, 3
%42 = getelementptr [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %40
%43 = getelementptr double, double* %2, i64 %40
%44 = getelementptr [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %40
%45 = getelementptr [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %40
%46 = getelementptr [100 x double], [100 x double]* @kutta.f2, i64 0, i64 %40
%47 = getelementptr [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %40
%48 = getelementptr double, double* %2, i64 %40
%49 = getelementptr [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %40
%50 = getelementptr [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %40
%51 = getelementptr [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %40
%52 = getelementptr double, double* %2, i64 %40
%53 = getelementptr [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %40
%54 = getelementptr [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %40
%55 = getelementptr [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %40
%56 = getelementptr double, double* %2, i64 %40
%57 = getelementptr [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %40
%58 = and i64 %40, 4294967292
%59 = add nsw i64 %58, -4
%60 = lshr exact i64 %59, 2
%61 = add nuw nsw i64 %60, 1
%62 = icmp ult i32 %1, 4
%63 = icmp ugt double* %56, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%64 = icmp ugt double* %55, %2
%65 = and i1 %63, %64
%66 = icmp ugt double* %57, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%67 = icmp ugt double* %55, getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0)
%68 = and i1 %66, %67
%69 = or i1 %65, %68
%70 = and i64 %40, 4294967292
%71 = and i64 %61, 1
%72 = icmp eq i64 %59, 0
%73 = and i64 %61, 9223372036854775806
%74 = icmp eq i64 %71, 0
%75 = icmp eq i64 %70, %40
%76 = and i64 %40, 1
%77 = icmp eq i64 %76, 0
%78 = sub nsw i64 0, %40
%79 = icmp ult i32 %1, 4
%80 = icmp ugt double* %52, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%81 = icmp ugt double* %51, %2
%82 = and i1 %80, %81
%83 = icmp ugt double* %53, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%84 = icmp ugt double* %51, getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0)
%85 = and i1 %83, %84
%86 = or i1 %82, %85
%87 = icmp ugt double* %54, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%88 = icmp ugt double* %51, getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0)
%89 = and i1 %87, %88
%90 = or i1 %86, %89
%91 = and i64 %40, 4294967292
%92 = icmp eq i64 %91, %40
%93 = and i64 %40, 1
%94 = icmp eq i64 %93, 0
%95 = sub nsw i64 0, %40
%96 = icmp ult i32 %1, 4
%97 = icmp ugt double* %48, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%98 = icmp ugt double* %47, %2
%99 = and i1 %97, %98
%100 = icmp ugt double* %49, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%101 = icmp ugt double* %47, getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0)
%102 = and i1 %100, %101
%103 = or i1 %99, %102
%104 = icmp ugt double* %50, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%105 = icmp ugt double* %47, getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0)
%106 = and i1 %104, %105
%107 = or i1 %103, %106
%108 = and i64 %40, 4294967292
%109 = icmp eq i64 %108, %40
%110 = and i64 %40, 1
%111 = icmp eq i64 %110, 0
%112 = sub nsw i64 0, %40
%113 = icmp ult i32 %1, 4
%114 = icmp ugt double* %43, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%115 = icmp ugt double* %42, %2
%116 = and i1 %114, %115
%117 = icmp ugt double* %44, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%118 = icmp ugt double* %42, getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0)
%119 = and i1 %117, %118
%120 = or i1 %116, %119
%121 = icmp ugt double* %45, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%122 = icmp ugt double* %42, getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0)
%123 = and i1 %121, %122
%124 = or i1 %120, %123
%125 = icmp ugt double* %46, getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0)
%126 = icmp ugt double* %42, getelementptr inbounds ([100 x double], [100 x double]* @kutta.f2, i64 0, i64 0)
%127 = and i1 %125, %126
%128 = or i1 %124, %127
%129 = and i64 %40, 4294967292
%130 = icmp eq i64 %129, %40
%131 = icmp ult i32 %1, 4
%132 = and i64 %40, 4294967292
%133 = icmp eq i64 %132, %40
%134 = insertelement <2 x double> <double 2.000000e-01, double poison>, double %6, i64 1
br label %135
135: ; preds = %574, %33
%136 = phi double [ %34, %33 ], [ %146, %574 ]
%137 = phi double [ %35, %33 ], [ %424, %574 ]
%138 = phi i8 [ 1, %33 ], [ 0, %574 ]
%139 = fadd double %136, %137
%140 = fcmp une double %139, %137
br i1 %140, label %141, label %634
141: ; preds = %135, %631
%142 = phi double [ %632, %631 ], [ %139, %135 ]
%143 = phi i8 [ 0, %631 ], [ %138, %135 ]
%144 = phi double [ %626, %631 ], [ %137, %135 ]
%145 = phi double [ %625, %631 ], [ %136, %135 ]
%146 = fmul double %145, 5.000000e-01
%147 = fdiv double %145, 3.000000e+00
%148 = fdiv double %145, 6.000000e+00
%149 = fmul double %145, 1.250000e-01
%150 = icmp ne i8 %143, 0
%151 = or i1 %36, %150
br i1 %151, label %152, label %154
152: ; preds = %141
%153 = fsub double %144, %145
tail call void %0(double %153, double* %2, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0), i8 signext 1)
br label %154
154: ; preds = %141, %152
br i1 %37, label %155, label %241
155: ; preds = %154
%156 = or i1 %62, %69
br i1 %156, label %227, label %157
157: ; preds = %155
%158 = insertelement <2 x double> poison, double %147, i64 0
%159 = shufflevector <2 x double> %158, <2 x double> poison, <2 x i32> zeroinitializer
%160 = insertelement <2 x double> poison, double %147, i64 0
%161 = shufflevector <2 x double> %160, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %72, label %205, label %162
162: ; preds = %157, %162
%163 = phi i64 [ %202, %162 ], [ 0, %157 ]
%164 = phi i64 [ %203, %162 ], [ 0, %157 ]
%165 = getelementptr inbounds double, double* %2, i64 %163
%166 = bitcast double* %165 to <2 x double>*
%167 = load <2 x double>, <2 x double>* %166
%168 = getelementptr inbounds double, double* %165, i64 2
%169 = bitcast double* %168 to <2 x double>*
%170 = load <2 x double>, <2 x double>* %169
%171 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %163
%172 = bitcast double* %171 to <2 x double>*
%173 = load <2 x double>, <2 x double>* %172
%174 = getelementptr inbounds double, double* %171, i64 2
%175 = bitcast double* %174 to <2 x double>*
%176 = load <2 x double>, <2 x double>* %175
%177 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> %173, <2 x double> %167)
%178 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %161, <2 x double> %176, <2 x double> %170)
%179 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %163
%180 = bitcast double* %179 to <2 x double>*
store <2 x double> %177, <2 x double>* %180
%181 = getelementptr inbounds double, double* %179, i64 2
%182 = bitcast double* %181 to <2 x double>*
store <2 x double> %178, <2 x double>* %182
%183 = or i64 %163, 4
%184 = getelementptr inbounds double, double* %2, i64 %183
%185 = bitcast double* %184 to <2 x double>*
%186 = load <2 x double>, <2 x double>* %185
%187 = getelementptr inbounds double, double* %184, i64 2
%188 = bitcast double* %187 to <2 x double>*
%189 = load <2 x double>, <2 x double>* %188
%190 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %183
%191 = bitcast double* %190 to <2 x double>*
%192 = load <2 x double>, <2 x double>* %191
%193 = getelementptr inbounds double, double* %190, i64 2
%194 = bitcast double* %193 to <2 x double>*
%195 = load <2 x double>, <2 x double>* %194
%196 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> %192, <2 x double> %186)
%197 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %161, <2 x double> %195, <2 x double> %189)
%198 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %183
%199 = bitcast double* %198 to <2 x double>*
store <2 x double> %196, <2 x double>* %199
%200 = getelementptr inbounds double, double* %198, i64 2
%201 = bitcast double* %200 to <2 x double>*
store <2 x double> %197, <2 x double>* %201
%202 = add nuw i64 %163, 8
%203 = add i64 %164, 2
%204 = icmp eq i64 %203, %73
br i1 %204, label %205, label %162
205: ; preds = %162, %157
%206 = phi i64 [ 0, %157 ], [ %202, %162 ]
br i1 %74, label %226, label %207
207: ; preds = %205
%208 = getelementptr inbounds double, double* %2, i64 %206
%209 = bitcast double* %208 to <2 x double>*
%210 = load <2 x double>, <2 x double>* %209
%211 = getelementptr inbounds double, double* %208, i64 2
%212 = bitcast double* %211 to <2 x double>*
%213 = load <2 x double>, <2 x double>* %212
%214 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %206
%215 = bitcast double* %214 to <2 x double>*
%216 = load <2 x double>, <2 x double>* %215
%217 = getelementptr inbounds double, double* %214, i64 2
%218 = bitcast double* %217 to <2 x double>*
%219 = load <2 x double>, <2 x double>* %218
%220 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %159, <2 x double> %216, <2 x double> %210)
%221 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %161, <2 x double> %219, <2 x double> %213)
%222 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %206
%223 = bitcast double* %222 to <2 x double>*
store <2 x double> %220, <2 x double>* %223
%224 = getelementptr inbounds double, double* %222, i64 2
%225 = bitcast double* %224 to <2 x double>*
store <2 x double> %221, <2 x double>* %225
br label %226
226: ; preds = %205, %207
br i1 %75, label %260, label %227
227: ; preds = %155, %226
%228 = phi i64 [ 0, %155 ], [ %70, %226 ]
%229 = xor i64 %228, -1
br i1 %77, label %238, label %230
230: ; preds = %227
%231 = getelementptr inbounds double, double* %2, i64 %228
%232 = load double, double* %231
%233 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %228
%234 = load double, double* %233
%235 = tail call double @llvm.fmuladd.f64(double %147, double %234, double %232)
%236 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %228
store double %235, double* %236
%237 = or i64 %228, 1
br label %238
238: ; preds = %230, %227
%239 = phi i64 [ %228, %227 ], [ %237, %230 ]
%240 = icmp eq i64 %229, %78
br i1 %240, label %260, label %243
241: ; preds = %154
%242 = tail call double @llvm.fmuladd.f64(double %147, double -2.000000e+00, double %144)
tail call void %0(double %242, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0), double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0), i8 signext 0)
br label %340
243: ; preds = %238, %243
%244 = phi i64 [ %258, %243 ], [ %239, %238 ]
%245 = getelementptr inbounds double, double* %2, i64 %244
%246 = load double, double* %245
%247 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %244
%248 = load double, double* %247
%249 = tail call double @llvm.fmuladd.f64(double %147, double %248, double %246)
%250 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %244
store double %249, double* %250
%251 = add nuw nsw i64 %244, 1
%252 = getelementptr inbounds double, double* %2, i64 %251
%253 = load double, double* %252
%254 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %251
%255 = load double, double* %254
%256 = tail call double @llvm.fmuladd.f64(double %147, double %255, double %253)
%257 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %251
store double %256, double* %257
%258 = add nuw nsw i64 %244, 2
%259 = icmp eq i64 %258, %40
br i1 %259, label %260, label %243
260: ; preds = %238, %243, %226
%261 = tail call double @llvm.fmuladd.f64(double %147, double -2.000000e+00, double %144)
tail call void %0(double %261, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0), double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0), i8 signext 0)
br i1 %37, label %262, label %340
262: ; preds = %260
%263 = or i1 %79, %90
br i1 %263, label %300, label %264
264: ; preds = %262
%265 = insertelement <2 x double> poison, double %148, i64 0
%266 = shufflevector <2 x double> %265, <2 x double> poison, <2 x i32> zeroinitializer
%267 = insertelement <2 x double> poison, double %148, i64 0
%268 = shufflevector <2 x double> %267, <2 x double> poison, <2 x i32> zeroinitializer
br label %269
269: ; preds = %269, %264
%270 = phi i64 [ 0, %264 ], [ %297, %269 ]
%271 = getelementptr inbounds double, double* %2, i64 %270
%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 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %270
%278 = bitcast double* %277 to <2 x double>*
%279 = load <2 x double>, <2 x double>* %278
%280 = getelementptr inbounds double, double* %277, i64 2
%281 = bitcast double* %280 to <2 x double>*
%282 = load <2 x double>, <2 x double>* %281
%283 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %270
%284 = bitcast double* %283 to <2 x double>*
%285 = load <2 x double>, <2 x double>* %284
%286 = getelementptr inbounds double, double* %283, i64 2
%287 = bitcast double* %286 to <2 x double>*
%288 = load <2 x double>, <2 x double>* %287
%289 = fadd <2 x double> %279, %285
%290 = fadd <2 x double> %282, %288
%291 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %266, <2 x double> %289, <2 x double> %273)
%292 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %268, <2 x double> %290, <2 x double> %276)
%293 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %270
%294 = bitcast double* %293 to <2 x double>*
store <2 x double> %291, <2 x double>* %294
%295 = getelementptr inbounds double, double* %293, i64 2
%296 = bitcast double* %295 to <2 x double>*
store <2 x double> %292, <2 x double>* %296
%297 = add nuw i64 %270, 4
%298 = icmp eq i64 %297, %91
br i1 %298, label %299, label %269
299: ; preds = %269
br i1 %92, label %342, label %300
300: ; preds = %262, %299
%301 = phi i64 [ 0, %262 ], [ %91, %299 ]
%302 = xor i64 %301, -1
br i1 %94, label %314, label %303
303: ; preds = %300
%304 = getelementptr inbounds double, double* %2, i64 %301
%305 = load double, double* %304
%306 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %301
%307 = load double, double* %306
%308 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %301
%309 = load double, double* %308
%310 = fadd double %307, %309
%311 = tail call double @llvm.fmuladd.f64(double %148, double %310, double %305)
%312 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %301
store double %311, double* %312
%313 = or i64 %301, 1
br label %314
314: ; preds = %303, %300
%315 = phi i64 [ %301, %300 ], [ %313, %303 ]
%316 = icmp eq i64 %302, %95
br i1 %316, label %342, label %317
317: ; preds = %314, %317
%318 = phi i64 [ %338, %317 ], [ %315, %314 ]
%319 = getelementptr inbounds double, double* %2, i64 %318
%320 = load double, double* %319
%321 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %318
%322 = load double, double* %321
%323 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %318
%324 = load double, double* %323
%325 = fadd double %322, %324
%326 = tail call double @llvm.fmuladd.f64(double %148, double %325, double %320)
%327 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %318
store double %326, double* %327
%328 = add nuw nsw i64 %318, 1
%329 = getelementptr inbounds double, double* %2, i64 %328
%330 = load double, double* %329
%331 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %328
%332 = load double, double* %331
%333 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %328
%334 = load double, double* %333
%335 = fadd double %332, %334
%336 = tail call double @llvm.fmuladd.f64(double %148, double %335, double %330)
%337 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %328
store double %336, double* %337
%338 = add nuw nsw i64 %318, 2
%339 = icmp eq i64 %338, %40
br i1 %339, label %342, label %317
340: ; preds = %241, %260
%341 = phi double [ %261, %260 ], [ %242, %241 ]
tail call void %0(double %341, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0), double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0), i8 signext 0)
br label %421
342: ; preds = %314, %317, %299
tail call void %0(double %261, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0), double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0), i8 signext 0)
br i1 %37, label %343, label %421
343: ; preds = %342
%344 = or i1 %96, %107
br i1 %344, label %381, label %345
345: ; preds = %343
%346 = insertelement <2 x double> poison, double %149, i64 0
%347 = shufflevector <2 x double> %346, <2 x double> poison, <2 x i32> zeroinitializer
%348 = insertelement <2 x double> poison, double %149, i64 0
%349 = shufflevector <2 x double> %348, <2 x double> poison, <2 x i32> zeroinitializer
br label %350
350: ; preds = %350, %345
%351 = phi i64 [ 0, %345 ], [ %378, %350 ]
%352 = getelementptr inbounds double, double* %2, i64 %351
%353 = bitcast double* %352 to <2 x double>*
%354 = load <2 x double>, <2 x double>* %353
%355 = getelementptr inbounds double, double* %352, i64 2
%356 = bitcast double* %355 to <2 x double>*
%357 = load <2 x double>, <2 x double>* %356
%358 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %351
%359 = bitcast double* %358 to <2 x double>*
%360 = load <2 x double>, <2 x double>* %359
%361 = getelementptr inbounds double, double* %358, i64 2
%362 = bitcast double* %361 to <2 x double>*
%363 = load <2 x double>, <2 x double>* %362
%364 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %351
%365 = bitcast double* %364 to <2 x double>*
%366 = load <2 x double>, <2 x double>* %365
%367 = getelementptr inbounds double, double* %364, i64 2
%368 = bitcast double* %367 to <2 x double>*
%369 = load <2 x double>, <2 x double>* %368
%370 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %366, <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double> %360)
%371 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %369, <2 x double> <double 3.000000e+00, double 3.000000e+00>, <2 x double> %363)
%372 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %347, <2 x double> %370, <2 x double> %354)
%373 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %349, <2 x double> %371, <2 x double> %357)
%374 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %351
%375 = bitcast double* %374 to <2 x double>*
store <2 x double> %372, <2 x double>* %375
%376 = getelementptr inbounds double, double* %374, i64 2
%377 = bitcast double* %376 to <2 x double>*
store <2 x double> %373, <2 x double>* %377
%378 = add nuw i64 %351, 4
%379 = icmp eq i64 %378, %108
br i1 %379, label %380, label %350
380: ; preds = %350
br i1 %109, label %423, label %381
381: ; preds = %343, %380
%382 = phi i64 [ 0, %343 ], [ %108, %380 ]
%383 = xor i64 %382, -1
br i1 %111, label %395, label %384
384: ; preds = %381
%385 = getelementptr inbounds double, double* %2, i64 %382
%386 = load double, double* %385
%387 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %382
%388 = load double, double* %387
%389 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %382
%390 = load double, double* %389
%391 = tail call double @llvm.fmuladd.f64(double %390, double 3.000000e+00, double %388)
%392 = tail call double @llvm.fmuladd.f64(double %149, double %391, double %386)
%393 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %382
store double %392, double* %393
%394 = or i64 %382, 1
br label %395
395: ; preds = %384, %381
%396 = phi i64 [ %382, %381 ], [ %394, %384 ]
%397 = icmp eq i64 %383, %112
br i1 %397, label %423, label %398
398: ; preds = %395, %398
%399 = phi i64 [ %419, %398 ], [ %396, %395 ]
%400 = getelementptr inbounds double, double* %2, i64 %399
%401 = load double, double* %400
%402 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %399
%403 = load double, double* %402
%404 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %399
%405 = load double, double* %404
%406 = tail call double @llvm.fmuladd.f64(double %405, double 3.000000e+00, double %403)
%407 = tail call double @llvm.fmuladd.f64(double %149, double %406, double %401)
%408 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %399
store double %407, double* %408
%409 = add nuw nsw i64 %399, 1
%410 = getelementptr inbounds double, double* %2, i64 %409
%411 = load double, double* %410
%412 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %409
%413 = load double, double* %412
%414 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %409
%415 = load double, double* %414
%416 = tail call double @llvm.fmuladd.f64(double %415, double 3.000000e+00, double %413)
%417 = tail call double @llvm.fmuladd.f64(double %149, double %416, double %411)
%418 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %409
store double %417, double* %418
%419 = add nuw nsw i64 %399, 2
%420 = icmp eq i64 %419, %40
br i1 %420, label %423, label %398
421: ; preds = %340, %342
%422 = fsub double %144, %146
tail call void %0(double %422, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0), double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f2, i64 0, i64 0), i8 signext 0)
br label %489
423: ; preds = %395, %398, %380
%424 = fsub double %144, %146
tail call void %0(double %424, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0), double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f2, i64 0, i64 0), i8 signext 0)
br i1 %37, label %425, label %489
425: ; preds = %423
%426 = or i1 %113, %128
br i1 %426, label %471, label %427
427: ; preds = %425
%428 = insertelement <2 x double> poison, double %146, i64 0
%429 = shufflevector <2 x double> %428, <2 x double> poison, <2 x i32> zeroinitializer
%430 = insertelement <2 x double> poison, double %146, i64 0
%431 = shufflevector <2 x double> %430, <2 x double> poison, <2 x i32> zeroinitializer
br label %432
432: ; preds = %432, %427
%433 = phi i64 [ 0, %427 ], [ %468, %432 ]
%434 = getelementptr inbounds double, double* %2, i64 %433
%435 = bitcast double* %434 to <2 x double>*
%436 = load <2 x double>, <2 x double>* %435
%437 = getelementptr inbounds double, double* %434, i64 2
%438 = bitcast double* %437 to <2 x double>*
%439 = load <2 x double>, <2 x double>* %438
%440 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %433
%441 = bitcast double* %440 to <2 x double>*
%442 = load <2 x double>, <2 x double>* %441
%443 = getelementptr inbounds double, double* %440, i64 2
%444 = bitcast double* %443 to <2 x double>*
%445 = load <2 x double>, <2 x double>* %444
%446 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %433
%447 = bitcast double* %446 to <2 x double>*
%448 = load <2 x double>, <2 x double>* %447
%449 = getelementptr inbounds double, double* %446, i64 2
%450 = bitcast double* %449 to <2 x double>*
%451 = load <2 x double>, <2 x double>* %450
%452 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %448, <2 x double> <double -3.000000e+00, double -3.000000e+00>, <2 x double> %442)
%453 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %451, <2 x double> <double -3.000000e+00, double -3.000000e+00>, <2 x double> %445)
%454 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f2, i64 0, i64 %433
%455 = bitcast double* %454 to <2 x double>*
%456 = load <2 x double>, <2 x double>* %455
%457 = getelementptr inbounds double, double* %454, i64 2
%458 = bitcast double* %457 to <2 x double>*
%459 = load <2 x double>, <2 x double>* %458
%460 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %456, <2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> %452)
%461 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %459, <2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> %453)
%462 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %429, <2 x double> %460, <2 x double> %436)
%463 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %431, <2 x double> %461, <2 x double> %439)
%464 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %433
%465 = bitcast double* %464 to <2 x double>*
store <2 x double> %462, <2 x double>* %465
%466 = getelementptr inbounds double, double* %464, i64 2
%467 = bitcast double* %466 to <2 x double>*
store <2 x double> %463, <2 x double>* %467
%468 = add nuw i64 %433, 4
%469 = icmp eq i64 %468, %129
br i1 %469, label %470, label %432
470: ; preds = %432
br i1 %130, label %490, label %471
471: ; preds = %425, %470
%472 = phi i64 [ 0, %425 ], [ %129, %470 ]
br label %473
473: ; preds = %471, %473
%474 = phi i64 [ %487, %473 ], [ %472, %471 ]
%475 = getelementptr inbounds double, double* %2, i64 %474
%476 = load double, double* %475
%477 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %474
%478 = load double, double* %477
%479 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %474
%480 = load double, double* %479
%481 = tail call double @llvm.fmuladd.f64(double %480, double -3.000000e+00, double %478)
%482 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f2, i64 0, i64 %474
%483 = load double, double* %482
%484 = tail call double @llvm.fmuladd.f64(double %483, double 4.000000e+00, double %481)
%485 = tail call double @llvm.fmuladd.f64(double %146, double %484, double %476)
%486 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %474
store double %485, double* %486
%487 = add nuw nsw i64 %474, 1
%488 = icmp eq i64 %487, %40
br i1 %488, label %490, label %473
489: ; preds = %421, %423
tail call void %0(double %144, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0), double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0), i8 signext 0)
br label %596
490: ; preds = %473, %470
tail call void %0(double %144, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.y1, i64 0, i64 0), double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f1, i64 0, i64 0), i8 signext 0)
br i1 %37, label %491, label %596
491: ; preds = %490
br i1 %131, label %536, label %492
492: ; preds = %491
%493 = insertelement <2 x double> poison, double %148, i64 0
%494 = shufflevector <2 x double> %493, <2 x double> poison, <2 x i32> zeroinitializer
%495 = insertelement <2 x double> poison, double %148, i64 0
%496 = shufflevector <2 x double> %495, <2 x double> poison, <2 x i32> zeroinitializer
br label %497
497: ; preds = %497, %492
%498 = phi i64 [ 0, %492 ], [ %533, %497 ]
%499 = getelementptr inbounds double, double* %2, i64 %498
%500 = bitcast double* %499 to <2 x double>*
%501 = load <2 x double>, <2 x double>* %500
%502 = getelementptr inbounds double, double* %499, i64 2
%503 = bitcast double* %502 to <2 x double>*
%504 = load <2 x double>, <2 x double>* %503
%505 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %498
%506 = bitcast double* %505 to <2 x double>*
%507 = load <2 x double>, <2 x double>* %506
%508 = getelementptr inbounds double, double* %505, i64 2
%509 = bitcast double* %508 to <2 x double>*
%510 = load <2 x double>, <2 x double>* %509
%511 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f2, i64 0, i64 %498
%512 = bitcast double* %511 to <2 x double>*
%513 = load <2 x double>, <2 x double>* %512
%514 = getelementptr inbounds double, double* %511, i64 2
%515 = bitcast double* %514 to <2 x double>*
%516 = load <2 x double>, <2 x double>* %515
%517 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %513, <2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> %507)
%518 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %516, <2 x double> <double 4.000000e+00, double 4.000000e+00>, <2 x double> %510)
%519 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %498
%520 = bitcast double* %519 to <2 x double>*
%521 = load <2 x double>, <2 x double>* %520
%522 = getelementptr inbounds double, double* %519, i64 2
%523 = bitcast double* %522 to <2 x double>*
%524 = load <2 x double>, <2 x double>* %523
%525 = fadd <2 x double> %517, %521
%526 = fadd <2 x double> %518, %524
%527 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %494, <2 x double> %525, <2 x double> %501)
%528 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %496, <2 x double> %526, <2 x double> %504)
%529 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y2, i64 0, i64 %498
%530 = bitcast double* %529 to <2 x double>*
store <2 x double> %527, <2 x double>* %530
%531 = getelementptr inbounds double, double* %529, i64 2
%532 = bitcast double* %531 to <2 x double>*
store <2 x double> %528, <2 x double>* %532
%533 = add nuw i64 %498, 4
%534 = icmp eq i64 %533, %132
br i1 %534, label %535, label %497
535: ; preds = %497
br i1 %133, label %538, label %536
536: ; preds = %491, %535
%537 = phi i64 [ 0, %491 ], [ %132, %535 ]
br label %539
538: ; preds = %539, %535
br i1 %37, label %557, label %596
539: ; preds = %536, %539
%540 = phi i64 [ %553, %539 ], [ %537, %536 ]
%541 = getelementptr inbounds double, double* %2, i64 %540
%542 = load double, double* %541
%543 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f0, i64 0, i64 %540
%544 = load double, double* %543
%545 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f2, i64 0, i64 %540
%546 = load double, double* %545
%547 = tail call double @llvm.fmuladd.f64(double %546, double 4.000000e+00, double %544)
%548 = getelementptr inbounds [100 x double], [100 x double]* @kutta.f1, i64 0, i64 %540
%549 = load double, double* %548
%550 = fadd double %547, %549
%551 = tail call double @llvm.fmuladd.f64(double %148, double %550, double %542)
%552 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y2, i64 0, i64 %540
store double %551, double* %552
%553 = add nuw nsw i64 %540, 1
%554 = icmp eq i64 %553, %40
br i1 %554, label %538, label %539
555: ; preds = %590
br i1 %37, label %556, label %594
556: ; preds = %555
br label %594
557: ; preds = %538, %590
%558 = phi i64 [ %592, %590 ], [ 0, %538 ]
%559 = phi i8 [ %591, %590 ], [ 1, %538 ]
%560 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y1, i64 0, i64 %558
%561 = load double, double* %560
%562 = getelementptr inbounds [100 x double], [100 x double]* @kutta.y2, i64 0, i64 %558
%563 = load double, double* %562
%564 = fsub double %561, %563
%565 = insertelement <2 x double> poison, double %564, i64 0
%566 = insertelement <2 x double> %565, double %561, i64 1
%567 = call <2 x double> @llvm.fabs.v2f64(<2 x double> %566)
%568 = fmul <2 x double> %567, %134
%569 = extractelement <2 x double> %568, i64 0
%570 = extractelement <2 x double> %568, i64 1
%571 = fcmp ult double %569, %570
%572 = fcmp ult double %569, %5
%573 = or i1 %571, %572
br i1 %573, label %582, label %574
574: ; preds = %557
store double %146, double* @kutta.hc
%575 = load i32, i32* @kutta.numcuts
%576 = add nsw i32 %575, -1
store i32 %576, i32* @kutta.numcuts
%577 = icmp sgt i32 %575, 0
br i1 %577, label %135, label %578
578: ; preds = %574
%579 = fsub double %424, %146
store double %579, double* %3
%580 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([102 x i8], [102 x i8]* @.str.1, i64 0, i64 0), double %579)
%581 = load double, double* %3
tail call void %0(double %581, double* %2, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0), i8 signext 0)
br label %639
582: ; preds = %557
%583 = icmp eq i8 %559, 0
br i1 %583, label %590, label %584
584: ; preds = %582
%585 = fmul double %569, 6.400000e+01
%586 = fcmp ogt double %585, %570
%587 = fcmp ogt double %585, %5
%588 = and i1 %586, %587
%589 = select i1 %588, i8 0, i8 %559
br label %590
590: ; preds = %582, %584
%591 = phi i8 [ %589, %584 ], [ 0, %582 ]
%592 = add nuw nsw i64 %558, 1
%593 = icmp eq i64 %592, %40
br i1 %593, label %555, label %557
594: ; preds = %556, %555
%595 = icmp eq i8 %591, 0
br i1 %595, label %607, label %596
596: ; preds = %538, %489, %490, %594
%597 = fadd double %145, %145
%598 = tail call double @llvm.fabs.f64(double %597)
%599 = fcmp ugt double %598, %38
br i1 %599, label %607, label %600
600: ; preds = %596
%601 = fadd double %145, %142
%602 = tail call double @llvm.fabs.f64(double %601)
%603 = fcmp ugt double %602, %39
br i1 %603, label %607, label %604
604: ; preds = %600
store double %597, double* @kutta.hc
%605 = load i32, i32* @kutta.numcuts
%606 = add nsw i32 %605, 1
store i32 %606, i32* @kutta.numcuts
br label %607
607: ; preds = %604, %600, %596, %594
%608 = phi double [ %597, %604 ], [ %145, %600 ], [ %145, %596 ], [ %145, %594 ]
%609 = fcmp oeq double %144, %11
br i1 %609, label %610, label %611
610: ; preds = %607
tail call void %0(double %11, double* %2, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0), i8 signext 2)
br label %639
611: ; preds = %607
%612 = fadd double %144, %608
%613 = fcmp ogt double %608, 0.000000e+00
%614 = tail call double @llvm.fmuladd.f64(double %608, double -1.000000e-01, double %11)
%615 = fcmp ogt double %612, %614
%616 = select i1 %613, i1 %615, i1 false
br i1 %616, label %621, label %617
617: ; preds = %611
%618 = fcmp olt double %608, 0.000000e+00
%619 = fcmp olt double %612, %614
%620 = select i1 %618, i1 %619, i1 false
br i1 %620, label %621, label %624
621: ; preds = %617, %611
%622 = fsub double %612, %608
%623 = fsub double %11, %622
br label %624
624: ; preds = %621, %617
%625 = phi double [ %623, %621 ], [ %608, %617 ]
%626 = phi double [ %11, %621 ], [ %612, %617 ]
switch i8 %7, label %631 [
i8 1, label %627
i8 3, label %629
]
627: ; preds = %624
br i1 %37, label %628, label %631
628: ; preds = %627
br label %631
629: ; preds = %624
%630 = fsub double %626, %625
tail call void %0(double %630, double* %2, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0), i8 signext 0)
br label %631
631: ; preds = %627, %628, %629, %624
%632 = fadd double %625, %626
%633 = fcmp une double %632, %626
br i1 %633, label %141, label %634
634: ; preds = %135, %631
%635 = phi double [ %625, %631 ], [ %136, %135 ]
%636 = phi double [ %626, %631 ], [ %137, %135 ]
store double %636, double* %3
%637 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([180 x i8], [180 x i8]* @.str.2, i64 0, i64 0), double %635, double %636)
%638 = load double, double* %3
tail call void %0(double %638, double* %2, double* getelementptr inbounds ([100 x double], [100 x double]* @kutta.f0, i64 0, i64 0), i8 signext 0)
br label %639
639: ; preds = %578, %610, %21, %634, %20, %17, %13
%640 = phi i32 [ 0, %13 ], [ 1, %20 ], [ 0, %634 ], [ 1, %17 ], [ 0, %21 ], [ 0, %578 ], [ 1, %610 ]
ret i32 %640
}