#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 */
int /*<<< orphan*/ arrayAdd(int, double *, double *, double *);
int /*<<< orphan*/ arrayScale(int, double *, double, double *);
scalar_t__ calloc(int, int);
int /*<<< orphan*/ copyArray(int, double *, double *);
int /*<<< orphan*/ free(double *);
void adamsBash3(int n, void (*vecField)(double *, double *), double **y_initial,
                double deltaT, int iostep, long int numPnts, double *(*y_solve),
                double *time) {
  double *tempVec1 = (double *)calloc(n, sizeof(double));
  double *tempVec2 = (double *)calloc(n, sizeof(double));
  double *yjm2 = (double *)calloc(n, sizeof(double));
  double *yjm1 = (double *)calloc(n, sizeof(double));
  double *yj = (double *)calloc(n, sizeof(double));
  double *yjp1 = (double *)calloc(n, sizeof(double));
  long int i = 0;
  int j = 0;
  int numSaved = -1;
  double tj = 0;
  time[0] = tj;
  copyArray(n, y_initial[0], yjm2);
  vecField(y_initial[0], tempVec1);
  arrayScale(n, tempVec1, deltaT, tempVec1);
  arrayAdd(n, y_initial[0], tempVec1, tempVec1);
  vecField(tempVec1, tempVec2);
  vecField(y_initial[0], tempVec1);
  arrayAdd(n, tempVec1, tempVec2, tempVec1);
  arrayScale(n, tempVec1, 0.5 * deltaT, tempVec1);
  arrayAdd(n, y_initial[0], tempVec1, yjm1);
  tj += deltaT;
  if (1 == iostep) {
    time[1] = tj;
  }
  vecField(yjm1, tempVec1);
  arrayScale(n, tempVec1, deltaT, tempVec1);
  arrayAdd(n, yjm1, tempVec1, tempVec1);
  vecField(tempVec1, tempVec2);
  vecField(yjm1, tempVec1);
  arrayAdd(n, tempVec1, tempVec2, tempVec1);
  arrayScale(n, tempVec1, 0.5 * deltaT, tempVec1);
  arrayAdd(n, tempVec1, yjm1, yj);
  tj += deltaT;
  for (j = 0; j < n; j++) {
    y_solve[j][0] = yjm2[j];
    numSaved++;
  }
  if (1 == iostep) {
    for (j = 0; j < n; j++) {
      y_solve[j][numSaved] = yjm1[j];
    }
    numSaved++;
  }
  if (2 % iostep == 0) {
    for (j = 0; j < n; j++) {
      y_solve[j][numSaved] = yj[j];
    }
    time[numSaved] = tj;
    numSaved++;
  }
  i = 3;
  while (i < numPnts) {
    tj += deltaT;
    vecField(yj, tempVec1);
    arrayScale(n, tempVec1, 23, tempVec1);
    vecField(yjm1, tempVec2);
    arrayScale(n, tempVec2, -16, tempVec2);
    arrayAdd(n, tempVec1, tempVec2, tempVec1);
    vecField(yjm2, tempVec2);
    arrayScale(n, tempVec2, 5, tempVec2);
    arrayAdd(n, tempVec1, tempVec2, tempVec1);
    arrayScale(n, tempVec1, deltaT / 12.0, tempVec1);
    arrayAdd(n, yj, tempVec1, yjp1);
    if ((i % iostep == 0) &&
        (numSaved < (numPnts - (numPnts % iostep)) / iostep)) {
      for (j = 0; j < n; j++) {
        y_solve[j][numSaved] = yjp1[j];
      }
      time[numSaved] = tj;
      numSaved++;
    }
    copyArray(n, yjm1, yjm2);
    copyArray(n, yj, yjm1);
    copyArray(n, yjp1, yj);
    i++;
  }
  if (iostep == numPnts) {
    if (iostep == 1) {
      for (j = 0; j < n; j++) {
        y_solve[j][0] = yjm2[j];
      }
      time[0] = 0;
    }
    if (iostep == 2) {
      for (j = 0; j < n; j++) {
        y_solve[j][0] = yjm1[j];
      }
      time[0] = deltaT;
    }
    if (iostep == 3) {
      for (j = 0; j < n; j++) {
        y_solve[j][0] = yj[j];
      }
      time[0] = deltaT + deltaT;
    }
    if (iostep > 3) {
      for (j = 0; j < n; j++) {
        y_solve[j][0] = yjp1[j];
      }
      time[0] = tj;
    }
  }
  free(tempVec1);
  free(tempVec2);
  free(yj);
  free(yjm1);
  free(yjm2);
  free(yjp1);
}


x86 assembly (clang, -O0):
<adamsBash3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movsd  %xmm0,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0x4(%rbp),%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x68(%rbp)
movq   $0x0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0xffffffff,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x4(%rbp),%edi
mov    -0x18(%rbp),%rax
mov    (%rax),%rsi
mov    -0x50(%rbp),%rdx
call   1070 <copyArray@plt>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
movsd  -0x20(%rbp),%xmm0
mov    -0x40(%rbp),%rdx
call   1050 <arrayScale@plt>
mov    -0x4(%rbp),%edi
mov    -0x18(%rbp),%rax
mov    (%rax),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1040 <arrayAdd@plt>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   *%rax
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rcx),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1040 <arrayAdd@plt>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
movsd  0xd63(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    -0x40(%rbp),%rdx
call   1050 <arrayScale@plt>
mov    -0x4(%rbp),%edi
mov    -0x18(%rbp),%rax
mov    (%rax),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x58(%rbp),%rcx
call   1040 <arrayAdd@plt>
movsd  -0x20(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    $0x1,%eax
cmp    -0x24(%rbp),%eax
jne    12ed <adamsBash3+0x19d>
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
movsd  -0x20(%rbp),%xmm0
mov    -0x40(%rbp),%rdx
call   1050 <arrayScale@plt>
mov    -0x4(%rbp),%edi
mov    -0x58(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1040 <arrayAdd@plt>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   *%rax
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1040 <arrayAdd@plt>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
movsd  0xc9d(%rip),%xmm0
mulsd  -0x20(%rbp),%xmm0
mov    -0x40(%rbp),%rdx
call   1050 <arrayScale@plt>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x60(%rbp),%rcx
call   1040 <arrayAdd@plt>
movsd  -0x20(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13db <adamsBash3+0x28b>
mov    -0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    139b <adamsBash3+0x24b>
mov    $0x1,%eax
cmp    -0x24(%rbp),%eax
jne    1435 <adamsBash3+0x2e5>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    142c <adamsBash3+0x2dc>
mov    -0x58(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13f0 <adamsBash3+0x2a0>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    $0x2,%eax
cltd
idivl  -0x24(%rbp)
cmp    $0x0,%edx
jne    14a5 <adamsBash3+0x355>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    148a <adamsBash3+0x33a>
mov    -0x60(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    144e <adamsBash3+0x2fe>
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
movq   $0x3,-0x70(%rbp)
mov    -0x70(%rbp),%rax
cmp    -0x30(%rbp),%rax
jge    1698 <adamsBash3+0x548>
movsd  -0x20(%rbp),%xmm0
addsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x60(%rbp),%rdi
mov    -0x40(%rbp),%rsi
call   *%rax
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x40(%rbp),%rdx
movsd  0xb35(%rip),%xmm0
call   1050 <arrayScale@plt>
mov    -0x10(%rbp),%rax
mov    -0x58(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   *%rax
mov    -0x4(%rbp),%edi
mov    -0x48(%rbp),%rsi
mov    -0x48(%rbp),%rdx
movsd  0xb07(%rip),%xmm0
call   1050 <arrayScale@plt>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1040 <arrayAdd@plt>
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   *%rax
mov    -0x4(%rbp),%edi
mov    -0x48(%rbp),%rsi
mov    -0x48(%rbp),%rdx
movsd  0xac5(%rip),%xmm0
call   1050 <arrayScale@plt>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0x40(%rbp),%rcx
call   1040 <arrayAdd@plt>
mov    -0x4(%rbp),%edi
mov    -0x40(%rbp),%rsi
movsd  -0x20(%rbp),%xmm0
movsd  0xa90(%rip),%xmm1
divsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rdx
call   1050 <arrayScale@plt>
mov    -0x4(%rbp),%edi
mov    -0x60(%rbp),%rsi
mov    -0x40(%rbp),%rdx
mov    -0x68(%rbp),%rcx
call   1040 <arrayAdd@plt>
mov    -0x70(%rbp),%rax
movslq -0x24(%rbp),%rcx
cqto
idiv   %rcx
cmp    $0x0,%rdx
jne    1657 <adamsBash3+0x507>
movslq -0x78(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
cqto
idiv   %rcx
mov    -0x90(%rbp),%rax
sub    %rdx,%rax
movslq -0x24(%rbp),%rcx
cqto
idiv   %rcx
mov    %rax,%rcx
mov    -0x88(%rbp),%rax
cmp    %rcx,%rax
jge    1657 <adamsBash3+0x507>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    163c <adamsBash3+0x4ec>
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    1600 <adamsBash3+0x4b0>
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
mov    -0x4(%rbp),%edi
mov    -0x58(%rbp),%rsi
mov    -0x50(%rbp),%rdx
call   1070 <copyArray@plt>
mov    -0x4(%rbp),%edi
mov    -0x60(%rbp),%rsi
mov    -0x58(%rbp),%rdx
call   1070 <copyArray@plt>
mov    -0x4(%rbp),%edi
mov    -0x68(%rbp),%rsi
mov    -0x60(%rbp),%rdx
call   1070 <copyArray@plt>
mov    -0x70(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x70(%rbp)
jmp    14ad <adamsBash3+0x35d>
movslq -0x24(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    1802 <adamsBash3+0x6b2>
cmpl   $0x1,-0x24(%rbp)
jne    16f9 <adamsBash3+0x5a9>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16ee <adamsBash3+0x59e>
mov    -0x50(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    16b7 <adamsBash3+0x567>
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
cmpl   $0x2,-0x24(%rbp)
jne    174e <adamsBash3+0x5fe>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1741 <adamsBash3+0x5f1>
mov    -0x58(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    170a <adamsBash3+0x5ba>
movsd  -0x20(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x3,-0x24(%rbp)
jne    17a8 <adamsBash3+0x658>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1796 <adamsBash3+0x646>
mov    -0x60(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    175f <adamsBash3+0x60f>
movsd  -0x20(%rbp),%xmm0
addsd  -0x20(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
cmpl   $0x3,-0x24(%rbp)
jle    17fd <adamsBash3+0x6ad>
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    17f0 <adamsBash3+0x6a0>
mov    -0x68(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,(%rax)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    17b9 <adamsBash3+0x669>
movsd  -0x80(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
jmp    1802 <adamsBash3+0x6b2>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<adamsBash3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xa8,%rsp
mov    %r9,0x38(%rsp)
mov    %r8,0x18(%rsp)
mov    %ecx,0xc(%rsp)
movsd  %xmm0,0x10(%rsp)
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %edi,%r12d
mov    0xe0(%rsp),%r15
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%rbp
mov    %r12d,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,%r14
mov    %r12d,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,0x78(%rsp)
mov    %r12d,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,(%rsp)
mov    %r12d,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,0x70(%rsp)
mov    %r12d,%edi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,0x40(%rsp)
mov    %r15,0x28(%rsp)
movq   $0x0,(%r15)
mov    0x78(%rsp),%r15
mov    0x0(%r13),%rsi
mov    %r12d,%edi
mov    %r15,%rdx
call   1070 <copyArray@plt>
mov    0x0(%r13),%rdi
mov    %rbp,%rsi
call   *%rbx
mov    %r12d,%edi
mov    %rbp,%rsi
movsd  0x10(%rsp),%xmm0
mov    %rbp,%rdx
call   1050 <arrayScale@plt>
mov    0x0(%r13),%rsi
mov    %r12d,%edi
mov    %rbp,%rdx
mov    %rbp,%rcx
call   1040 <arrayAdd@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
call   *%rbx
mov    0x0(%r13),%rdi
mov    %rbp,%rsi
mov    %rbx,0x68(%rsp)
call   *%rbx
mov    %r12d,%edi
mov    %rbp,%rsi
mov    %r14,0x60(%rsp)
mov    %r14,%rdx
mov    (%rsp),%r14
mov    %rbp,%rcx
call   1040 <arrayAdd@plt>
movsd  0xd8f(%rip),%xmm0
mulsd  0x10(%rsp),%xmm0
mov    %r12d,%edi
mov    %rbp,%rsi
movsd  %xmm0,0x48(%rsp)
mov    %rbp,%rdx
call   1050 <arrayScale@plt>
mov    0x0(%r13),%rsi
mov    %r12,0x50(%rsp)
mov    %r12d,%edi
mov    0xc(%rsp),%r12d
mov    %rbp,0x58(%rsp)
mov    %rbp,%rdx
mov    %r14,%rcx
call   1040 <arrayAdd@plt>
xorpd  %xmm0,%xmm0
addsd  0x10(%rsp),%xmm0
cmp    $0x1,%r12d
jne    12c6 <adamsBash3+0x176>
mov    0x28(%rsp),%rax
movsd  %xmm0,0x8(%rax)
mov    %r14,%rdi
mov    0x58(%rsp),%rbp
mov    %rbp,%rsi
movsd  %xmm0,0x30(%rsp)
mov    0x68(%rsp),%r13
call   *%r13
mov    0x50(%rsp),%rbx
mov    %ebx,%edi
mov    %rbp,%rsi
movsd  0x10(%rsp),%xmm0
mov    %rbp,%rdx
call   1050 <arrayScale@plt>
mov    %ebx,%edi
mov    %r14,%rsi
mov    %rbp,%rdx
mov    %rbp,%rcx
call   1040 <arrayAdd@plt>
mov    %rbp,%rdi
mov    0x60(%rsp),%r14
mov    %r14,%rsi
call   *%r13
mov    (%rsp),%rdi
mov    %rbp,%rsi
call   *%r13
mov    %ebx,%edi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    (%rsp),%r14
mov    %rbp,%rcx
call   1040 <arrayAdd@plt>
mov    %ebx,%edi
mov    %rbp,%rsi
movsd  0x48(%rsp),%xmm0
mov    %rbp,%rdx
call   1050 <arrayScale@plt>
mov    %ebx,%edi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    0x70(%rsp),%rbp
mov    %rbp,%rcx
call   1040 <arrayAdd@plt>
movsd  0x30(%rsp),%xmm2
movsd  0x10(%rsp),%xmm1
addsd  %xmm1,%xmm2
test   %ebx,%ebx
mov    %rbx,%r11
jle    1391 <adamsBash3+0x241>
mov    %ebx,%r9d
lea    -0x1(%r9),%r8
mov    %r9d,%edx
and    $0x3,%edx
cmp    $0x3,%r8
jae    13c6 <adamsBash3+0x276>
xor    %esi,%esi
mov    0x38(%rsp),%rbx
jmp    1427 <adamsBash3+0x2d7>
mov    $0xffffffff,%ecx
cmp    $0x1,%r12d
mov    0x38(%rsp),%rbx
je     151a <adamsBash3+0x3ca>
mov    $0x2,%eax
xor    %edx,%edx
idiv   %r12d
mov    $0xffffffff,%ecx
test   %edx,%edx
mov    0x18(%rsp),%rdx
jne    1534 <adamsBash3+0x3e4>
jmp    184c <adamsBash3+0x6fc>
mov    %r9d,%edi
and    $0xfffffffc,%edi
xor    %esi,%esi
mov    0x38(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%r15,%rsi,8),%xmm0
mov    (%rbx,%rsi,8),%rcx
movsd  %xmm0,(%rcx)
movsd  0x8(%r15,%rsi,8),%xmm0
mov    0x8(%rbx,%rsi,8),%rcx
movsd  %xmm0,(%rcx)
movsd  0x10(%r15,%rsi,8),%xmm0
mov    0x10(%rbx,%rsi,8),%rcx
movsd  %xmm0,(%rcx)
movsd  0x18(%r15,%rsi,8),%xmm0
mov    0x18(%rbx,%rsi,8),%rcx
movsd  %xmm0,(%rcx)
add    $0x4,%rsi
cmp    %rsi,%rdi
jne    13e0 <adamsBash3+0x290>
test   %rdx,%rdx
je     1456 <adamsBash3+0x306>
lea    (%rbx,%rsi,8),%rdi
lea    (%r15,%rsi,8),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rsi,%rcx,8),%xmm0
mov    (%rdi,%rcx,8),%rax
movsd  %xmm0,(%rax)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1440 <adamsBash3+0x2f0>
lea    -0x1(%r11),%ecx
cmp    $0x1,%r12d
jne    151d <adamsBash3+0x3cd>
mov    %r11,%rax
test   %eax,%eax
jle    151a <adamsBash3+0x3ca>
mov    %ecx,%edx
mov    %r9d,%r10d
and    $0x3,%r10d
cmp    $0x3,%r8
jae    1485 <adamsBash3+0x335>
mov    %ecx,%r8d
xor    %ecx,%ecx
jmp    14e7 <adamsBash3+0x397>
mov    %ecx,%r8d
and    $0xfffffffc,%r9d
xor    %ecx,%ecx
mov    (%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rsi,%rcx,8),%xmm0
mov    (%rbx,%rcx,8),%rax
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x8(%rsi,%rcx,8),%xmm0
mov    0x8(%rbx,%rcx,8),%rax
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x10(%rsi,%rcx,8),%xmm0
mov    0x10(%rbx,%rcx,8),%rax
movsd  %xmm0,(%rax,%rdx,8)
movsd  0x18(%rsi,%rcx,8),%xmm0
mov    0x18(%rbx,%rcx,8),%rax
movsd  %xmm0,(%rax,%rdx,8)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    14a0 <adamsBash3+0x350>
test   %r10,%r10
je     1517 <adamsBash3+0x3c7>
lea    (%rbx,%rcx,8),%rax
mov    (%rsp),%rsi
lea    (%rsi,%rcx,8),%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movsd  (%rcx,%rdi,8),%xmm0
mov    (%rax,%rdi,8),%rsi
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x1,%rdi
cmp    %rdi,%r10
jne    1500 <adamsBash3+0x3b0>
mov    %r8d,%ecx
add    $0x1,%ecx
mov    $0x2,%eax
xor    %edx,%edx
idiv   %r12d
test   %edx,%edx
je     1826 <adamsBash3+0x6d6>
mov    0x18(%rsp),%rdx
cmp    $0x3,%rdx
jle    1907 <adamsBash3+0x7b7>
mov    %ecx,0x24(%rsp)
movsd  %xmm2,0x30(%rsp)
divsd  0xab8(%rip),%xmm1
movsd  %xmm1,0x98(%rsp)
movslq %r12d,%r13
mov    %r11,%rbx
mov    %ebx,%eax
lea    -0x1(%rax),%rcx
mov    %rcx,0x88(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0x90(%rsp)
and    $0xfffffffc,%eax
mov    %rax,0x80(%rsp)
mov    $0x3,%eax
mov    0x40(%rsp),%r12
mov    %rbp,%rdi
mov    (%rsp),%rbp
mov    %r13,0xa0(%rsp)
jmp    160f <adamsBash3+0x4bf>
mov    0x28(%rsp),%rax
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%ecx
mov    %ecx,%eax
mov    %ecx,0x24(%rsp)
mov    %r8,%rbx
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm1,0x30(%rsp)
mov    %ebx,%edi
mov    %r14,%rsi
mov    0x78(%rsp),%r15
mov    %r15,%rdx
call   1070 <copyArray@plt>
mov    %ebx,%edi
mov    %rbp,%rsi
mov    %r14,%rdx
call   1070 <copyArray@plt>
mov    %ebx,%edi
mov    %r12,%rsi
mov    %rbp,%rdx
call   1070 <copyArray@plt>
mov    0x48(%rsp),%rax
add    $0x1,%rax
mov    0x18(%rsp),%rdx
cmp    %rdx,%rax
mov    %rbp,%rdi
mov    %r14,%rbp
je     17fc <adamsBash3+0x6ac>
mov    %rax,0x48(%rsp)
mov    0x58(%rsp),%r14
mov    %r14,%rsi
mov    0x68(%rsp),%r13
call   *%r13
mov    %ebx,%edi
mov    %r14,%rsi
movsd  0x9df(%rip),%xmm0
mov    %r14,%rdx
call   1050 <arrayScale@plt>
mov    %rbp,%rdi
mov    0x60(%rsp),%rbp
mov    %rbp,%rsi
call   *%r13
mov    %ebx,%edi
mov    %rbp,%rsi
movsd  0x9c4(%rip),%xmm0
mov    %rbp,%rdx
call   1050 <arrayScale@plt>
mov    %ebx,%edi
mov    %r14,%rsi
mov    %rbp,%rdx
mov    %r14,%rcx
call   1040 <arrayAdd@plt>
mov    %r15,%rdi
mov    %rbp,%rsi
call   *%r13
mov    0xa0(%rsp),%r13
mov    %ebx,%edi
mov    %rbp,%rsi
movsd  0x996(%rip),%xmm0
mov    %rbp,%rdx
call   1050 <arrayScale@plt>
mov    %ebx,%edi
mov    %r14,%rsi
mov    %rbp,%rdx
mov    0x70(%rsp),%rbp
mov    %r14,%rcx
call   1040 <arrayAdd@plt>
mov    %ebx,%edi
mov    %r14,%rsi
movsd  0x98(%rsp),%xmm0
mov    %r14,%rdx
call   1050 <arrayScale@plt>
mov    %ebx,%edi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r12,%rcx
call   1040 <arrayAdd@plt>
mov    0x48(%rsp),%rax
mov    %rax,%rcx
or     %r13,%rcx
shr    $0x20,%rcx
je     16f0 <adamsBash3+0x5a0>
cqto
idiv   %r13
jmp    16f6 <adamsBash3+0x5a6>
cs nopw 0x0(%rax,%rax,1)
nop
xor    %edx,%edx
divl   0xc(%rsp)
mov    (%rsp),%r14
mov    0x50(%rsp),%rbx
movsd  0x10(%rsp),%xmm0
movsd  0x30(%rsp),%xmm1
addsd  %xmm0,%xmm1
test   %rdx,%rdx
jne    15c0 <adamsBash3+0x470>
mov    0x18(%rsp),%rax
mov    %rax,%rcx
or     %r13,%rcx
shr    $0x20,%rcx
je     1730 <adamsBash3+0x5e0>
cqto
idiv   %r13
jmp    1736 <adamsBash3+0x5e6>
xor    %edx,%edx
divl   0xc(%rsp)
mov    0x24(%rsp),%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jle    15c0 <adamsBash3+0x470>
mov    %rbx,%r8
test   %ebx,%ebx
mov    0x38(%rsp),%rsi
mov    0x90(%rsp),%rbx
jle    15a0 <adamsBash3+0x450>
cmpq   $0x3,0x88(%rsp)
jae    176d <adamsBash3+0x61d>
xor    %eax,%eax
jmp    17cb <adamsBash3+0x67b>
xor    %eax,%eax
mov    0x80(%rsp),%rdi
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
mov    (%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x8(%r12,%rax,8),%xmm0
mov    0x8(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x10(%r12,%rax,8),%xmm0
mov    0x10(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
movsd  0x18(%r12,%rax,8),%xmm0
mov    0x18(%rsi,%rax,8),%rdx
movsd  %xmm0,(%rdx,%rcx,8)
add    $0x4,%rax
cmp    %rax,%rdi
jne    1780 <adamsBash3+0x630>
test   %rbx,%rbx
je     15a0 <adamsBash3+0x450>
lea    (%rsi,%rax,8),%rdx
lea    (%r12,%rax,8),%rax
xor    %esi,%esi
xchg   %ax,%ax
movsd  (%rax,%rsi,8),%xmm0
mov    (%rdx,%rsi,8),%rdi
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    17e0 <adamsBash3+0x690>
jmp    15a0 <adamsBash3+0x450>
mov    %rbx,%r11
mov    0x38(%rsp),%rbx
mov    0xc(%rsp),%r12d
movsd  0x10(%rsp),%xmm1
movsd  0x30(%rsp),%xmm2
mov    %rdi,%rbp
cmp    %rdx,%r13
je     1913 <adamsBash3+0x7c3>
jmp    1bff <adamsBash3+0xaaf>
mov    %r11,%rdx
test   %edx,%edx
jle    1847 <adamsBash3+0x6f7>
movslq %ecx,%rax
mov    %edx,%edx
lea    -0x1(%rdx),%rsi
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rsi
jae    1857 <adamsBash3+0x707>
xor    %esi,%esi
jmp    18a8 <adamsBash3+0x758>
mov    0x18(%rsp),%rdx
movslq %ecx,%rax
mov    %ecx,%r9d
jmp    18ec <adamsBash3+0x79c>
and    $0xfffffffc,%edx
xor    %esi,%esi
nopl   0x0(%rax)
movsd  0x0(%rbp,%rsi,8),%xmm0
mov    (%rbx,%rsi,8),%rdi
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x8(%rbp,%rsi,8),%xmm0
mov    0x8(%rbx,%rsi,8),%rdi
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x10(%rbp,%rsi,8),%xmm0
mov    0x10(%rbx,%rsi,8),%rdi
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x18(%rbp,%rsi,8),%xmm0
mov    0x18(%rbx,%rsi,8),%rdi
movsd  %xmm0,(%rdi,%rax,8)
add    $0x4,%rsi
cmp    %rsi,%rdx
jne    1860 <adamsBash3+0x710>
mov    %ecx,%r9d
test   %r8,%r8
je     18e7 <adamsBash3+0x797>
lea    (%rbx,%rsi,8),%rdx
lea    0x0(,%rsi,8),%rsi
add    %rbp,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rdi,8),%xmm0
mov    (%rdx,%rdi,8),%rcx
movsd  %xmm0,(%rcx,%rax,8)
add    $0x1,%rdi
cmp    %rdi,%r8
jne    18d0 <adamsBash3+0x780>
mov    0x18(%rsp),%rdx
mov    0x28(%rsp),%rcx
movsd  %xmm2,(%rcx,%rax,8)
add    $0x1,%r9d
mov    %r9d,%ecx
cmp    $0x3,%rdx
jg     153e <adamsBash3+0x3ee>
movslq %r12d,%r13
cmp    %rdx,%r13
jne    1bff <adamsBash3+0xaaf>
cmp    $0x1,%r12d
jne    19d2 <adamsBash3+0x882>
test   %r11d,%r11d
jle    19c6 <adamsBash3+0x876>
mov    %r11d,%ecx
lea    -0x1(%rcx),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    193c <adamsBash3+0x7ec>
xor    %edx,%edx
jmp    1997 <adamsBash3+0x847>
and    $0xfffffffc,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r15,%rdx,8),%xmm0
mov    (%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x8(%r15,%rdx,8),%xmm0
mov    0x8(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x10(%r15,%rdx,8),%xmm0
mov    0x10(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x18(%r15,%rdx,8),%xmm0
mov    0x18(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1950 <adamsBash3+0x800>
test   %rax,%rax
je     19c6 <adamsBash3+0x876>
lea    (%rbx,%rdx,8),%rcx
lea    (%r15,%rdx,8),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
mov    (%rcx,%rsi,8),%rdi
movsd  %xmm0,(%rdi)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    19b0 <adamsBash3+0x860>
mov    0x28(%rsp),%rax
movq   $0x0,(%rax)
cmp    $0x3,%r12d
je     1a05 <adamsBash3+0x8b5>
cmp    $0x2,%r12d
jne    1b43 <adamsBash3+0x9f3>
mov    %r11,%rax
test   %eax,%eax
jle    1b3a <adamsBash3+0x9ea>
mov    %eax,%ecx
lea    -0x1(%rcx),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1a2b <adamsBash3+0x8db>
xor    %edx,%edx
jmp    1a83 <adamsBash3+0x933>
test   %r11d,%r11d
jle    1b36 <adamsBash3+0x9e6>
mov    %r11d,%ecx
lea    -0x1(%rcx),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1abb <adamsBash3+0x96b>
xor    %edx,%edx
jmp    1b04 <adamsBash3+0x9b4>
and    $0xfffffffc,%ecx
xor    %edx,%edx
mov    (%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rdx,8),%xmm0
mov    (%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x8(%rdi,%rdx,8),%xmm0
mov    0x8(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x10(%rdi,%rdx,8),%xmm0
mov    0x10(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x18(%rdi,%rdx,8),%xmm0
mov    0x18(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1a40 <adamsBash3+0x8f0>
test   %rax,%rax
je     1b3a <adamsBash3+0x9ea>
lea    (%rbx,%rdx,8),%rcx
mov    (%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
mov    (%rcx,%rsi,8),%rdi
movsd  %xmm0,(%rdi)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1aa0 <adamsBash3+0x950>
jmp    1b3a <adamsBash3+0x9ea>
and    $0xfffffffc,%ecx
xor    %edx,%edx
movsd  0x0(%rbp,%rdx,8),%xmm0
mov    (%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x8(%rbp,%rdx,8),%xmm0
mov    0x8(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x10(%rbp,%rdx,8),%xmm0
mov    0x10(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x18(%rbp,%rdx,8),%xmm0
mov    0x18(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1ac0 <adamsBash3+0x970>
test   %rax,%rax
je     1b36 <adamsBash3+0x9e6>
lea    (%rbx,%rdx,8),%rcx
lea    0x0(,%rdx,8),%rdx
add    %rbp,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
mov    (%rcx,%rsi,8),%rdi
movsd  %xmm0,(%rdi)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1b20 <adamsBash3+0x9d0>
addsd  %xmm1,%xmm1
mov    0x28(%rsp),%rax
movsd  %xmm1,(%rax)
cmp    $0x4,%r12d
jl     1bff <adamsBash3+0xaaf>
test   %r11d,%r11d
jle    1bf6 <adamsBash3+0xaa6>
mov    %r11d,%ecx
lea    -0x1(%rcx),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1b6c <adamsBash3+0xa1c>
xor    %edx,%edx
jmp    1bc3 <adamsBash3+0xa73>
and    $0xfffffffc,%ecx
xor    %edx,%edx
mov    0x40(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm0
mov    (%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x8(%rdi,%rdx,8),%xmm0
mov    0x8(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x10(%rdi,%rdx,8),%xmm0
mov    0x10(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
movsd  0x18(%rdi,%rdx,8),%xmm0
mov    0x18(%rbx,%rdx,8),%rsi
movsd  %xmm0,(%rsi)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1b80 <adamsBash3+0xa30>
test   %rax,%rax
je     1bf6 <adamsBash3+0xaa6>
lea    (%rbx,%rdx,8),%rcx
mov    0x40(%rsp),%rsi
lea    (%rsi,%rdx,8),%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movsd  (%rdx,%rsi,8),%xmm0
mov    (%rcx,%rsi,8),%rdi
movsd  %xmm0,(%rdi)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1be0 <adamsBash3+0xa90>
mov    0x28(%rsp),%rax
movsd  %xmm2,(%rax)
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x40(%rsp),%rdi
add    $0xa8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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