#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*/ free_vector(float *, int, int);
void stub1(float, float *, float *);
void stub2(float, float *, float *);
void stub3(float, float *, float *);
float *vector(int, int);
void rk4(float y[], float dydx[], int n, float x, float h, float yout[],
         void (*derivs)(float, float[], float[])) {
  int i;
  float xh, hh, h6, *dym, *dyt, *yt;
  dym = vector(1, n);
  dyt = vector(1, n);
  yt = vector(1, n);
  hh = h * 0.5;
  h6 = h / 6.0;
  xh = x + hh;
  for (i = 1; i <= n; i++)
    yt[i] = y[i] + hh * dydx[i];
  (*derivs)(xh, yt, dyt);
  for (i = 1; i <= n; i++)
    yt[i] = y[i] + hh * dyt[i];
  (*derivs)(xh, yt, dym);
  for (i = 1; i <= n; i++) {
    yt[i] = y[i] + h * dym[i];
    dym[i] += dyt[i];
  }
  (*derivs)(x + h, yt, dyt);
  for (i = 1; i <= n; i++)
    yout[i] = y[i] + h6 * (dydx[i] + dyt[i] + 2.0 * dym[i]);
  free_vector(yt, 1, n);
  free_vector(dyt, 1, n);
  free_vector(dym, 1, n);
}


x86 assembly (clang, -O0):
<rk4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
call   1040 <vector@plt>
mov    %rax,-0x58(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe7f(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x1c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe59(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  -0x18(%rbp),%xmm0
addss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1218 <rk4+0xf8>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11ca <rk4+0xaa>
mov    -0x30(%rbp),%rax
movss  -0x38(%rbp),%xmm0
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   *%rax
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1280 <rk4+0x160>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x3c(%rbp),%xmm0
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1232 <rk4+0x112>
mov    -0x30(%rbp),%rax
movss  -0x38(%rbp),%xmm0
mov    -0x58(%rbp),%rdi
mov    -0x48(%rbp),%rsi
call   *%rax
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1307 <rk4+0x1e7>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x58(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    129a <rk4+0x17a>
mov    -0x30(%rbp),%rax
movss  -0x18(%rbp),%xmm0
addss  -0x1c(%rbp),%xmm0
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rsi
call   *%rax
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     13aa <rk4+0x28a>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x50(%rbp),%rax
movslq -0x34(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm3
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1326 <rk4+0x206>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_vector@plt>
mov    -0x50(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_vector@plt>
mov    -0x48(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_vector@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rk4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r8,%r15
mov    %rcx,0x30(%rsp)
movaps %xmm1,0x40(%rsp)
movss  %xmm0,0x2c(%rsp)
mov    %edx,%ebp
mov    %rsi,%r13
mov    %rdi,%r12
mov    $0x1,%edi
mov    %edx,%esi
call   1040 <vector@plt>
mov    %rax,0x38(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
call   1040 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    %ebp,%esi
call   1040 <vector@plt>
movaps 0x40(%rsp),%xmm1
mov    %rax,%rbx
movss  0xe7b(%rip),%xmm6
mulss  %xmm1,%xmm6
movaps %xmm6,%xmm0
addss  0x2c(%rsp),%xmm0
test   %ebp,%ebp
mov    %ebp,0x1c(%rsp)
movaps %xmm0,0x60(%rsp)
jle    122c <rk4+0x10c>
mov    %r15,0x10(%rsp)
mov    %ebp,%r8d
mov    %ebp,%ecx
lea    0x1(%r8),%rbp
mov    $0x1,%eax
cmp    $0x8,%ecx
jae    123a <rk4+0x11a>
mov    0x10(%rsp),%r15
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
jne    11e6 <rk4+0xc6>
movss  0x0(%r13,%rax,4),%xmm1
mulss  %xmm6,%xmm1
addss  (%r12,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rax
add    %rbp,%rcx
je     1369 <rk4+0x249>
nop
movss  0x0(%r13,%rax,4),%xmm1
mulss  %xmm6,%xmm1
addss  (%r12,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
movss  0x4(%r13,%rax,4),%xmm1
mulss  %xmm6,%xmm1
addss  0x4(%r12,%rax,4),%xmm1
movss  %xmm1,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    11f0 <rk4+0xd0>
jmp    1369 <rk4+0x249>
mov    %rbx,%rdi
mov    %r14,%rsi
call   *%r15
jmp    14df <rk4+0x3bf>
lea    0x4(%rbx),%rcx
lea    (%rbx,%rbp,4),%rsi
lea    0x4(%r12),%r10
lea    (%r12,%rbp,4),%rdi
lea    0x4(%r13),%r9
lea    0x0(,%rbp,4),%rdx
add    %r13,%rdx
cmp    %rdi,%rcx
setb   %dil
cmp    %rsi,%r10
setb   %r10b
cmp    %rdx,%rcx
setb   %dl
cmp    %rsi,%r9
setb   %cl
test   %r10b,%dil
mov    0x10(%rsp),%r15
jne    11c0 <rk4+0xa0>
and    %cl,%dl
jne    11c0 <rk4+0xa0>
mov    %r8d,%eax
and    $0xfffffff8,%eax
movaps %xmm6,%xmm5
shufps $0x0,%xmm6,%xmm5
lea    -0x8(%rax),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rcx,%rcx
je     19e9 <rk4+0x8c9>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups 0x4(%r12,%rdx,4),%xmm1
movups 0x14(%r12,%rdx,4),%xmm2
movups 0x4(%r13,%rdx,4),%xmm3
movups 0x14(%r13,%rdx,4),%xmm4
mulps  %xmm5,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm5,%xmm4
addps  %xmm2,%xmm4
movups %xmm3,0x4(%rbx,%rdx,4)
movups %xmm4,0x14(%rbx,%rdx,4)
movups 0x24(%r12,%rdx,4),%xmm1
movups 0x34(%r12,%rdx,4),%xmm2
movups 0x24(%r13,%rdx,4),%xmm3
movups 0x34(%r13,%rdx,4),%xmm4
mulps  %xmm5,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm5,%xmm4
addps  %xmm2,%xmm4
movups %xmm3,0x24(%rbx,%rdx,4)
movups %xmm4,0x34(%rbx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    12c0 <rk4+0x1a0>
test   $0x1,%sil
je     1360 <rk4+0x240>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%r12,%rdx,1),%xmm1
movups 0x10(%r12,%rdx,1),%xmm2
movups 0x0(%r13,%rdx,1),%xmm3
movups 0x10(%r13,%rdx,1),%xmm4
mulps  %xmm5,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm5,%xmm4
addps  %xmm2,%xmm4
movups %xmm3,(%rbx,%rdx,1)
movups %xmm4,0x10(%rbx,%rdx,1)
cmp    %rax,%r8
jne    18af <rk4+0x78f>
movaps %xmm6,0x50(%rsp)
mov    %rbp,0x8(%rsp)
mov    %rbx,%rdi
mov    %r14,%rsi
call   *%r15
cmpl   $0x0,0x1c(%rsp)
jle    14df <rk4+0x3bf>
movaps 0x60(%rsp),%xmm0
mov    0x8(%rsp),%rbp
lea    -0x1(%rbp),%rcx
mov    $0x1,%eax
mov    %rcx,0x20(%rsp)
cmp    $0x8,%rcx
jb     154b <rk4+0x42b>
lea    0x4(%rbx),%rcx
lea    (%rbx,%rbp,4),%rdx
lea    0x4(%r12),%r9
lea    (%r12,%rbp,4),%rdi
lea    0x4(%r14),%r8
lea    (%r14,%rbp,4),%rsi
cmp    %rdi,%rcx
setb   %dil
cmp    %rdx,%r9
setb   %r9b
cmp    %rsi,%rcx
setb   %cl
cmp    %rdx,%r8
setb   %dl
test   %r9b,%dil
jne    154b <rk4+0x42b>
and    %dl,%cl
mov    0x10(%rsp),%r15
movaps 0x50(%rsp),%xmm6
jne    1555 <rk4+0x435>
mov    0x20(%rsp),%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm6,%xmm5
shufps $0x0,%xmm6,%xmm5
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     19fa <rk4+0x8da>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups 0x4(%r12,%rcx,4),%xmm1
movups 0x14(%r12,%rcx,4),%xmm2
movups 0x4(%r14,%rcx,4),%xmm3
movups 0x14(%r14,%rcx,4),%xmm4
mulps  %xmm5,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm5,%xmm4
addps  %xmm2,%xmm4
movups %xmm3,0x4(%rbx,%rcx,4)
movups %xmm4,0x14(%rbx,%rcx,4)
movups 0x24(%r12,%rcx,4),%xmm1
movups 0x34(%r12,%rcx,4),%xmm2
movups 0x24(%r14,%rcx,4),%xmm3
movups 0x34(%r14,%rcx,4),%xmm4
mulps  %xmm5,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm5,%xmm4
addps  %xmm2,%xmm4
movups %xmm3,0x24(%rbx,%rcx,4)
movups %xmm4,0x34(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1430 <rk4+0x310>
test   $0x1,%dl
je     14ce <rk4+0x3ae>
shl    $0x2,%rcx
or     $0x4,%rcx
movups (%r12,%rcx,1),%xmm1
movups 0x10(%r12,%rcx,1),%xmm2
movups (%r14,%rcx,1),%xmm3
movups 0x10(%r14,%rcx,1),%xmm4
mulps  %xmm5,%xmm3
addps  %xmm1,%xmm3
mulps  %xmm5,%xmm4
addps  %xmm2,%xmm4
movups %xmm3,(%rbx,%rcx,1)
movups %xmm4,0x10(%rbx,%rcx,1)
cmp    %rax,0x20(%rsp)
je     15b6 <rk4+0x496>
or     $0x1,%rax
jmp    1555 <rk4+0x435>
movaps 0x60(%rsp),%xmm0
mov    %rbx,%rdi
mov    0x38(%rsp),%rsi
call   *%r15
movaps 0x40(%rsp),%xmm3
movss  0x2c(%rsp),%xmm0
addss  %xmm3,%xmm0
mov    %rbx,%rdi
mov    %r14,%rsi
call   *%r15
mov    0x38(%rsp),%rbp
mov    %rbx,%rdi
mov    $0x1,%esi
mov    0x1c(%rsp),%ebx
mov    %ebx,%edx
call   1030 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1030 <free_vector@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>
mov    0x10(%rsp),%r15
movaps 0x50(%rsp),%xmm6
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
jne    157a <rk4+0x45a>
movss  (%r14,%rax,4),%xmm1
mulss  %xmm6,%xmm1
addss  (%r12,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rax
add    %rbp,%rcx
je     15b6 <rk4+0x496>
nop
movss  (%r14,%rax,4),%xmm1
mulss  %xmm6,%xmm1
addss  (%r12,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
movss  0x4(%r14,%rax,4),%xmm1
mulss  %xmm6,%xmm1
addss  0x4(%r12,%rax,4),%xmm1
movss  %xmm1,0x4(%rbx,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1580 <rk4+0x460>
mov    %rbx,%rdi
mov    0x38(%rsp),%rsi
call   *%r15
cmpl   $0x0,0x1c(%rsp)
movaps 0x40(%rsp),%xmm3
jle    14f4 <rk4+0x3d4>
mov    $0x1,%eax
cmpq   $0x4,0x20(%rsp)
jae    15f2 <rk4+0x4d2>
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%rbp
mov    0x8(%rsp),%rdx
jmp    1784 <rk4+0x664>
mov    0x8(%rsp),%rcx
lea    (%rbx,%rcx,4),%rsi
mov    %rbx,%rdx
add    $0x4,%rdx
mov    0x38(%rsp),%rbp
lea    0x4(%rbp),%r11
lea    0x0(,%rcx,4),%r15
add    %rbp,%r15
lea    0x4(%r12),%r10
lea    (%r12,%rcx,4),%r9
lea    0x4(%r14),%rdi
mov    %rdi,0x70(%rsp)
lea    (%r14,%rcx,4),%r8
cmp    %r15,%rdx
setb   0x60(%rsp)
cmp    %rsi,%r11
setb   0x50(%rsp)
cmp    %r9,%rdx
setb   %dil
cmp    %rsi,%r10
setb   0x7(%rsp)
cmp    %r8,%rdx
setb   %dl
mov    0x70(%rsp),%rcx
cmp    %rsi,%rcx
setb   0x6(%rsp)
cmp    %r9,%r11
setb   %sil
cmp    %r15,%r10
setb   %r10b
cmp    %r8,%r11
setb   %r11b
cmp    %r15,%rcx
setb   %r9b
mov    0x50(%rsp),%cl
test   %cl,0x60(%rsp)
jne    1a2d <rk4+0x90d>
and    0x7(%rsp),%dil
jne    1a2d <rk4+0x90d>
and    0x6(%rsp),%dl
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%rdx
jne    1784 <rk4+0x664>
and    %r10b,%sil
jne    1784 <rk4+0x664>
and    %r9b,%r11b
jne    1784 <rk4+0x664>
mov    0x20(%rsp),%rax
and    $0xfffffffffffffffc,%rax
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
lea    -0x4(%rax),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     1a0a <rk4+0x8ea>
mov    %rdi,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%ecx
nopl   (%rax)
movups (%r12,%rcx,4),%xmm1
movups 0x0(%rbp,%rcx,4),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rbx,%rcx,4)
movups (%r14,%rcx,4),%xmm1
movups 0x0(%rbp,%rcx,4),%xmm2
addps  %xmm1,%xmm2
movups 0x10(%rbp,%rcx,4),%xmm1
movups %xmm2,0x0(%rbp,%rcx,4)
movups 0x10(%r12,%rcx,4),%xmm2
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movups %xmm1,0x10(%rbx,%rcx,4)
movups 0x10(%r14,%rcx,4),%xmm1
movups 0x10(%rbp,%rcx,4),%xmm2
addps  %xmm1,%xmm2
movups %xmm2,0x10(%rbp,%rcx,4)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    16f0 <rk4+0x5d0>
test   $0x1,%dil
je     1775 <rk4+0x655>
movups (%r12,%rcx,4),%xmm1
movups 0x0(%rbp,%rcx,4),%xmm2
mulps  %xmm2,%xmm0
addps  %xmm1,%xmm0
movups %xmm0,(%rbx,%rcx,4)
movups (%r14,%rcx,4),%xmm0
movups 0x0(%rbp,%rcx,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,0x0(%rbp,%rcx,4)
cmp    %rax,0x20(%rsp)
je     181a <rk4+0x6fa>
or     $0x1,%rax
mov    %rax,%rcx
not    %rcx
test   $0x1,%dl
jne    17ba <rk4+0x69a>
movss  0x0(%rbp,%rax,4),%xmm0
mulss  %xmm3,%xmm0
addss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  (%r14,%rax,4),%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%rax
add    %rdx,%rcx
je     181a <rk4+0x6fa>
nop
movss  0x0(%rbp,%rax,4),%xmm0
mulss  %xmm3,%xmm0
addss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
movss  (%r14,%rax,4),%xmm0
addss  0x0(%rbp,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp,%rax,4)
movss  0x4(%rbp,%rax,4),%xmm0
mulss  %xmm3,%xmm0
addss  0x4(%r12,%rax,4),%xmm0
movss  %xmm0,0x4(%rbx,%rax,4)
movss  0x4(%r14,%rax,4),%xmm0
addss  0x4(%rbp,%rax,4),%xmm0
movss  %xmm0,0x4(%rbp,%rax,4)
add    $0x2,%rax
cmp    %rax,%rdx
jne    17c0 <rk4+0x6a0>
movss  0x2c(%rsp),%xmm0
addss  %xmm3,%xmm0
mov    %rbx,%rdi
mov    %r14,%rsi
call   *%r8
mov    0x8(%rsp),%rsi
cmpl   $0x0,0x1c(%rsp)
mov    0x30(%rsp),%rdi
jle    150c <rk4+0x3ec>
movaps 0x40(%rsp),%xmm0
divss  0x7b5(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
mov    $0x1,%eax
cmpq   $0x4,0x20(%rsp)
jae    18b8 <rk4+0x798>
movss  (%r12,%rax,4),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x0(%r13,%rax,4),%xmm2
addss  (%r14,%rax,4),%xmm2
cvtss2sd %xmm2,%xmm2
movss  0x0(%rbp,%rax,4),%xmm3
cvtss2sd %xmm3,%xmm3
addsd  %xmm3,%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,(%rdi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rsi
jne    1860 <rk4+0x740>
jmp    150c <rk4+0x3ec>
or     $0x1,%rax
jmp    11c0 <rk4+0xa0>
lea    0x4(%rdi),%rcx
lea    (%rdi,%rsi,4),%rdi
lea    0x4(%r12),%r9
lea    (%r12,%rsi,4),%r8
lea    0x4(%r13),%r11
mov    %r14,%rdx
add    $0x4,%rdx
mov    %rbp,%r10
add    $0x4,%r10
cmp    %r8,%rcx
setb   %r15b
cmp    %rdi,%r9
lea    0x0(%r13,%rsi,4),%r8
setb   %r9b
cmp    %r8,%rcx
setb   %r8b
cmp    %rdi,%r11
lea    (%r14,%rsi,4),%r11
setb   0x40(%rsp)
cmp    %r11,%rcx
setb   %r11b
cmp    %rdi,%rdx
lea    0x0(%rbp,%rsi,4),%rsi
setb   %dl
cmp    %rsi,%rcx
setb   %sil
cmp    %rdi,%r10
setb   %dil
test   %r9b,%r15b
jne    1a1e <rk4+0x8fe>
and    0x40(%rsp),%r8b
jne    1a1e <rk4+0x8fe>
and    %dl,%r11b
jne    1a1e <rk4+0x8fe>
and    %dil,%sil
mov    0x30(%rsp),%rdi
mov    0x8(%rsp),%rsi
jne    1860 <rk4+0x740>
mov    0x20(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
lea    0x1(%rcx),%rax
movaps %xmm0,%xmm1
movlhps %xmm0,%xmm1
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
cvtps2pd 0x4(%r12,%rdx,4),%xmm2
cvtps2pd 0xc(%r12,%rdx,4),%xmm3
movups 0x4(%r13,%rdx,4),%xmm4
movups 0x4(%r14,%rdx,4),%xmm5
addps  %xmm4,%xmm5
cvtps2pd %xmm5,%xmm4
movhlps %xmm5,%xmm5
cvtps2pd %xmm5,%xmm5
cvtps2pd 0xc(%rbp,%rdx,4),%xmm6
cvtps2pd 0x4(%rbp,%rdx,4),%xmm7
addpd  %xmm7,%xmm7
addpd  %xmm4,%xmm7
addpd  %xmm6,%xmm6
addpd  %xmm5,%xmm6
mulpd  %xmm1,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm1,%xmm7
addpd  %xmm2,%xmm7
cvtpd2ps %xmm7,%xmm2
cvtpd2ps %xmm6,%xmm3
unpcklpd %xmm3,%xmm2
movupd %xmm2,0x4(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1970 <rk4+0x850>
cmp    %rcx,0x20(%rsp)
jne    1860 <rk4+0x740>
jmp    150c <rk4+0x3ec>
xor    %edx,%edx
test   $0x1,%sil
jne    132c <rk4+0x20c>
jmp    1360 <rk4+0x240>
xor    %ecx,%ecx
test   $0x1,%dl
jne    149b <rk4+0x37b>
jmp    14ce <rk4+0x3ae>
mov    $0x1,%ecx
test   $0x1,%dil
jne    174f <rk4+0x62f>
jmp    1775 <rk4+0x655>
mov    0x30(%rsp),%rdi
mov    0x8(%rsp),%rsi
jmp    1860 <rk4+0x740>
mov    0x10(%rsp),%r8
mov    0x8(%rsp),%rdx
jmp    1784 <rk4+0x664>

LLVM IR (-O0):
define void @rk4(float* %0, float* %1, i32 %2, float %3, float %4, float* %5, void (float, float*, float*)* %6) {
%8 = alloca float*
%9 = alloca float*
%10 = alloca i32
%11 = alloca float
%12 = alloca float
%13 = alloca float*
%14 = alloca void (float, float*, float*)*
%15 = alloca i32
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float*
%20 = alloca float*
%21 = alloca float*
store float* %0, float** %8
store float* %1, float** %9
store i32 %2, i32* %10
store float %3, float* %11
store float %4, float* %12
store float* %5, float** %13
store void (float, float*, float*)* %6, void (float, float*, float*)** %14
%22 = load i32, i32* %10
%23 = call float* @vector(i32 1, i32 %22)
store float* %23, float** %19
%24 = load i32, i32* %10
%25 = call float* @vector(i32 1, i32 %24)
store float* %25, float** %20
%26 = load i32, i32* %10
%27 = call float* @vector(i32 1, i32 %26)
store float* %27, float** %21
%28 = load float, float* %12
%29 = fpext float %28 to double
%30 = fmul double %29, 5.000000e-01
%31 = fptrunc double %30 to float
store float %31, float* %17
%32 = load float, float* %12
%33 = fpext float %32 to double
%34 = fdiv double %33, 6.000000e+00
%35 = fptrunc double %34 to float
store float %35, float* %18
%36 = load float, float* %11
%37 = load float, float* %17
%38 = fadd float %36, %37
store float %38, float* %16
store i32 1, i32* %15
br label %39
39: ; preds = %60, %7
%40 = load i32, i32* %15
%41 = load i32, i32* %10
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %63
43: ; preds = %39
%44 = load float*, float** %8
%45 = load i32, i32* %15
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds float, float* %44, i64 %46
%48 = load float, float* %47
%49 = load float, float* %17
%50 = load float*, float** %9
%51 = load i32, i32* %15
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %50, i64 %52
%54 = load float, float* %53
%55 = call float @llvm.fmuladd.f32(float %49, float %54, float %48)
%56 = load float*, float** %21
%57 = load i32, i32* %15
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
store float %55, float* %59
br label %60
60: ; preds = %43
%61 = load i32, i32* %15
%62 = add nsw i32 %61, 1
store i32 %62, i32* %15
br label %39
63: ; preds = %39
%64 = load void (float, float*, float*)*, void (float, float*, float*)** %14
%65 = load float, float* %16
%66 = load float*, float** %21
%67 = load float*, float** %20
store i32 1, i32* %15
br label %68
68: ; preds = %89, %63
%69 = load i32, i32* %15
%70 = load i32, i32* %10
%71 = icmp sle i32 %69, %70
br i1 %71, label %72, label %92
72: ; preds = %68
%73 = load float*, float** %8
%74 = load i32, i32* %15
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float, float* %73, i64 %75
%77 = load float, float* %76
%78 = load float, float* %17
%79 = load float*, float** %20
%80 = load i32, i32* %15
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %79, i64 %81
%83 = load float, float* %82
%84 = call float @llvm.fmuladd.f32(float %78, float %83, float %77)
%85 = load float*, float** %21
%86 = load i32, i32* %15
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds float, float* %85, i64 %87
store float %84, float* %88
br label %89
89: ; preds = %72
%90 = load i32, i32* %15
%91 = add nsw i32 %90, 1
store i32 %91, i32* %15
br label %68
92: ; preds = %68
%93 = load void (float, float*, float*)*, void (float, float*, float*)** %14
%94 = load float, float* %16
%95 = load float*, float** %21
%96 = load float*, float** %19
store i32 1, i32* %15
br label %97
97: ; preds = %129, %92
%98 = load i32, i32* %15
%99 = load i32, i32* %10
%100 = icmp sle i32 %98, %99
br i1 %100, label %101, label %132
101: ; preds = %97
%102 = load float*, float** %8
%103 = load i32, i32* %15
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %102, i64 %104
%106 = load float, float* %105
%107 = load float, float* %12
%108 = load float*, float** %19
%109 = load i32, i32* %15
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds float, float* %108, i64 %110
%112 = load float, float* %111
%113 = call float @llvm.fmuladd.f32(float %107, float %112, float %106)
%114 = load float*, float** %21
%115 = load i32, i32* %15
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %114, i64 %116
store float %113, float* %117
%118 = load float*, float** %20
%119 = load i32, i32* %15
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds float, float* %118, i64 %120
%122 = load float, float* %121
%123 = load float*, float** %19
%124 = load i32, i32* %15
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %123, i64 %125
%127 = load float, float* %126
%128 = fadd float %127, %122
store float %128, float* %126
br label %129
129: ; preds = %101
%130 = load i32, i32* %15
%131 = add nsw i32 %130, 1
store i32 %131, i32* %15
br label %97
132: ; preds = %97
%133 = load void (float, float*, float*)*, void (float, float*, float*)** %14
%134 = load float, float* %11
%135 = load float, float* %12
%136 = fadd float %134, %135
%137 = load float*, float** %21
%138 = load float*, float** %20
store i32 1, i32* %15
br label %139
139: ; preds = %177, %132
%140 = load i32, i32* %15
%141 = load i32, i32* %10
%142 = icmp sle i32 %140, %141
br i1 %142, label %143, label %180
143: ; preds = %139
%144 = load float*, float** %8
%145 = load i32, i32* %15
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds float, float* %144, i64 %146
%148 = load float, float* %147
%149 = fpext float %148 to double
%150 = load float, float* %18
%151 = fpext float %150 to double
%152 = load float*, float** %9
%153 = load i32, i32* %15
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = load float*, float** %20
%158 = load i32, i32* %15
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %157, i64 %159
%161 = load float, float* %160
%162 = fadd float %156, %161
%163 = fpext float %162 to double
%164 = load float*, float** %19
%165 = load i32, i32* %15
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float, float* %164, i64 %166
%168 = load float, float* %167
%169 = fpext float %168 to double
%170 = call double @llvm.fmuladd.f64(double 2.000000e+00, double %169, double %163)
%171 = call double @llvm.fmuladd.f64(double %151, double %170, double %149)
%172 = fptrunc double %171 to float
%173 = load float*, float** %13
%174 = load i32, i32* %15
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds float, float* %173, i64 %175
store float %172, float* %176
br label %177
177: ; preds = %143
%178 = load i32, i32* %15
%179 = add nsw i32 %178, 1
store i32 %179, i32* %15
br label %139
180: ; preds = %139
%181 = load float*, float** %21
%182 = load i32, i32* %10
%183 = call i32 @free_vector(float* %181, i32 1, i32 %182)
%184 = load float*, float** %20
%185 = load i32, i32* %10
%186 = call i32 @free_vector(float* %184, i32 1, i32 %185)
%187 = load float*, float** %19
%188 = load i32, i32* %10
%189 = call i32 @free_vector(float* %187, i32 1, i32 %188)
ret void
}

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