void rk4(double *y, double *dydx, int n, double x, double h, double *yout,
         void (*derivs)(double, double *, double *)) {
  char *func = {"rk4(): "};
  int i;
  double xh, hh, h6, *dym, *dyt, *yt;
  dym = (double *)mem_alloc((n) * sizeof(double), func, "dym[]");
  dyt = (double *)mem_alloc((n) * sizeof(double), func, "dyt[]");
  yt = (double *)mem_alloc((n) * sizeof(double), func, "yt[]");
  hh = h * 0.5;
  h6 = h / 6.0;
  xh = x + hh;
  for (i = 0; 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 = 0; i < n; i++) {
    yout[i] = y[i] + h6 * (dydx[i] + dyt[i] + 2.0 * dym[i]);
  }
  free(yt);
  free(dyt);
  free(dym);
}


x86 assembly (clang, -O0):
<rk4>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movsd  %xmm0,-0x20(%rbp)
movsd  %xmm1,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
lea    0xec1(%rip),%rax
mov    %rax,-0x40(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
mov    -0x40(%rbp),%rsi
lea    0xeb2(%rip),%rdx
mov    $0x0,%al
call   1040 <mem_alloc@plt>
cltq
mov    %rax,-0x68(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
mov    -0x40(%rbp),%rsi
lea    0xe98(%rip),%rdx
mov    $0x0,%al
call   1040 <mem_alloc@plt>
cltq
mov    %rax,-0x70(%rbp)
movslq -0x14(%rbp),%rdi
shl    $0x3,%rdi
mov    -0x40(%rbp),%rsi
lea    0xe79(%rip),%rdx
mov    $0x0,%al
call   1040 <mem_alloc@plt>
cltq
mov    %rax,-0x78(%rbp)
movsd  0xe4d(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  0xe2e(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x20(%rbp),%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    123f <rk4+0x11f>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11f1 <rk4+0xd1>
mov    -0x38(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
mov    -0x78(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12a7 <rk4+0x187>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1259 <rk4+0x139>
mov    -0x38(%rbp),%rax
movsd  -0x50(%rbp),%xmm0
mov    -0x78(%rbp),%rdi
mov    -0x68(%rbp),%rsi
call   *%rax
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    132e <rk4+0x20e>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12c1 <rk4+0x1a1>
mov    -0x38(%rbp),%rax
movsd  -0x20(%rbp),%xmm0
addsd  -0x28(%rbp),%xmm0
mov    -0x78(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13bd <rk4+0x29d>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm3
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
addsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    134d <rk4+0x22d>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rk4>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r8,0x10(%rsp)
mov    %rcx,0x18(%rsp)
movaps %xmm1,0x50(%rsp)
movsd  %xmm0,0x28(%rsp)
mov    %edx,%r15d
mov    %rsi,%r13
mov    %rdi,%rbx
movslq %edx,%r14
lea    0x0(,%r14,8),%rbp
lea    0xeb2(%rip),%r12
lea    0xeb3(%rip),%rdx
mov    %rbp,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <mem_alloc@plt>
cltq
mov    %rax,0x20(%rsp)
lea    0xe9e(%rip),%rdx
mov    %rbp,%rdi
mov    %r12,%rsi
xor    %eax,%eax
call   1040 <mem_alloc@plt>
movslq %eax,%r12
lea    0xe88(%rip),%rdx
mov    %rbp,%rdi
lea    0xe6f(%rip),%rsi
xor    %eax,%eax
call   1040 <mem_alloc@plt>
movsd  0x28(%rsp),%xmm1
movapd 0x50(%rsp),%xmm2
movslq %eax,%rbp
movsd  0xe41(%rip),%xmm7
mulsd  %xmm2,%xmm7
movapd %xmm7,%xmm0
addsd  %xmm1,%xmm0
test   %r14d,%r14d
movapd %xmm0,0x40(%rsp)
jle    11f8 <rk4+0xd8>
mov    0x20(%rsp),%rsi
mov    %r15d,%edi
mov    %r15d,0xc(%rsp)
cmp    $0x4,%r15d
mov    0x10(%rsp),%r14
jae    1230 <rk4+0x110>
xor    %eax,%eax
mov    %rsi,%r15
jmp    1364 <rk4+0x244>
mov    %rbp,%rdi
mov    %r12,%rsi
mov    0x10(%rsp),%rbx
call   *%rbx
movaps 0x40(%rsp),%xmm0
mov    %rbp,%rdi
mov    0x20(%rsp),%r15
mov    %r15,%rsi
call   *%rbx
movsd  0x28(%rsp),%xmm0
addsd  0x50(%rsp),%xmm0
mov    %rbp,%rdi
mov    %r12,%rsi
call   *%rbx
jmp    1a98 <rk4+0x978>
lea    0x0(,%rdi,8),%rax
add    %rbp,%rax
lea    (%rbx,%rdi,8),%rcx
cmp    %rcx,%rbp
setb   %r9b
cmp    %rbx,%rax
seta   %dl
lea    0x0(,%rdi,8),%rcx
add    %r13,%rcx
cmp    %rcx,%rbp
setb   %cl
cmp    %r13,%rax
seta   %r10b
xor    %eax,%eax
test   %dl,%r9b
mov    %rsi,%r15
jne    1364 <rk4+0x244>
and    %r10b,%cl
jne    1364 <rk4+0x244>
mov    %edi,%eax
and    $0xfffffffc,%eax
movapd %xmm7,%xmm6
unpcklpd %xmm7,%xmm6
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     182f <rk4+0x70f>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax)
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd 0x0(%r13,%rcx,8),%xmm3
movupd 0x10(%r13,%rcx,8),%xmm4
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm6,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x0(%rbp,%rcx,8)
movupd %xmm4,0x10(%rbp,%rcx,8)
movupd 0x20(%rbx,%rcx,8),%xmm1
movupd 0x30(%rbx,%rcx,8),%xmm2
movupd 0x20(%r13,%rcx,8),%xmm3
movupd 0x30(%r13,%rcx,8),%xmm4
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm6,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%rbp,%rcx,8)
movupd %xmm4,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    12b0 <rk4+0x190>
test   $0x1,%dl
je     135f <rk4+0x23f>
movupd (%rbx,%rcx,8),%xmm1
movupd 0x10(%rbx,%rcx,8),%xmm2
movupd 0x0(%r13,%rcx,8),%xmm3
movupd 0x10(%r13,%rcx,8),%xmm4
mulpd  %xmm6,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm6,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x0(%rbp,%rcx,8)
movupd %xmm4,0x10(%rbp,%rcx,8)
cmp    %rdi,%rax
je     13c6 <rk4+0x2a6>
mov    %rax,%rcx
not    %rcx
test   $0x1,%dil
je     138a <rk4+0x26a>
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
or     $0x1,%rax
add    %rdi,%rcx
je     13c6 <rk4+0x2a6>
nop
movsd  0x0(%r13,%rax,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    1390 <rk4+0x270>
movapd %xmm7,0x30(%rsp)
mov    %rdi,0x20(%rsp)
mov    %rbp,%rdi
mov    %r12,%rsi
call   *%r14
cmpl   $0x1,0xc(%rsp)
jle    147a <rk4+0x35a>
movaps 0x40(%rsp),%xmm0
mov    0x20(%rsp),%r14
lea    -0x1(%r14),%r10
mov    $0x1,%eax
cmp    $0x4,%r10
jae    149e <rk4+0x37e>
mov    0x10(%rsp),%r8
movapd 0x30(%rsp),%xmm6
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
jne    1432 <rk4+0x312>
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
add    %r14,%rcx
je     15f0 <rk4+0x4d0>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1440 <rk4+0x320>
jmp    15f0 <rk4+0x4d0>
movaps 0x40(%rsp),%xmm0
mov    %rbp,%rdi
mov    %r15,%rsi
call   *%r14
movapd 0x50(%rsp),%xmm3
mov    0x20(%rsp),%r14
movsd  0x28(%rsp),%xmm0
jmp    18a4 <rk4+0x784>
lea    0x8(%rbp),%rcx
lea    0x0(,%r14,8),%rdx
add    %rbp,%rdx
lea    0x8(%rbx),%r9
lea    (%rbx,%r14,8),%rdi
lea    0x8(%r12),%r8
lea    (%r12,%r14,8),%rsi
cmp    %rdi,%rcx
setb   %dil
cmp    %rdx,%r9
setb   %r9b
cmp    %rsi,%rcx
setb   %cl
cmp    %rdx,%r8
setb   %dl
test   %r9b,%dil
movapd 0x30(%rsp),%xmm6
jne    183f <rk4+0x71f>
and    %dl,%cl
mov    0x10(%rsp),%r8
jne    140d <rk4+0x2ed>
mov    %r10,%rax
and    $0xfffffffffffffffc,%rax
movapd %xmm6,%xmm5
unpcklpd %xmm6,%xmm5
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1852 <rk4+0x732>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd 0x8(%rbx,%rcx,8),%xmm1
movupd 0x18(%rbx,%rcx,8),%xmm2
movupd 0x8(%r12,%rcx,8),%xmm3
movupd 0x18(%r12,%rcx,8),%xmm4
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x8(%rbp,%rcx,8)
movupd %xmm4,0x18(%rbp,%rcx,8)
movupd 0x28(%rbx,%rcx,8),%xmm1
movupd 0x38(%rbx,%rcx,8),%xmm2
movupd 0x28(%r12,%rcx,8),%xmm3
movupd 0x38(%r12,%rcx,8),%xmm4
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x28(%rbp,%rcx,8)
movupd %xmm4,0x38(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1530 <rk4+0x410>
test   $0x1,%dl
je     15e7 <rk4+0x4c7>
shl    $0x3,%rcx
or     $0x8,%rcx
movupd (%rbx,%rcx,1),%xmm1
movupd 0x10(%rbx,%rcx,1),%xmm2
movupd (%r12,%rcx,1),%xmm3
movupd 0x10(%r12,%rcx,1),%xmm4
mulpd  %xmm5,%xmm3
addpd  %xmm1,%xmm3
mulpd  %xmm5,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x0(%rbp,%rcx,1)
movupd %xmm4,0x10(%rbp,%rcx,1)
cmp    %rax,%r10
jne    1849 <rk4+0x729>
mov    %r10,0x30(%rsp)
mov    %rbp,%rdi
mov    %r15,%rsi
call   *%r8
cmpl   $0x2,0xc(%rsp)
movapd 0x50(%rsp),%xmm3
movsd  0x28(%rsp),%xmm0
jl     18a4 <rk4+0x784>
mov    $0x1,%eax
cmpq   $0x2,0x30(%rsp)
jae    16d1 <rk4+0x5b1>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
jne    165d <rk4+0x53d>
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  (%r12,%rax,8),%xmm1
addsd  (%r15,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
add    $0x1,%rax
add    %r14,%rcx
je     18a4 <rk4+0x784>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
movsd  (%r12,%rax,8),%xmm1
addsd  (%r15,%rax,8),%xmm1
movsd  %xmm1,(%r15,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm3,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rbp,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm1
addsd  0x8(%r15,%rax,8),%xmm1
movsd  %xmm1,0x8(%r15,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1670 <rk4+0x550>
jmp    18a4 <rk4+0x784>
lea    0x8(%rbp),%rdx
lea    0x0(,%r14,8),%rsi
add    %rbp,%rsi
lea    0x8(%r15),%rdi
lea    (%r15,%r14,8),%r11
lea    0x8(%rbx),%r10
lea    (%rbx,%r14,8),%r9
lea    0x8(%r12),%rcx
mov    %rcx,0x60(%rsp)
lea    (%r12,%r14,8),%r8
cmp    %r11,%rdx
setb   0x40(%rsp)
cmp    %rsi,%rdi
setb   0xb(%rsp)
cmp    %r9,%rdx
setb   %cl
cmp    %rsi,%r10
setb   0xa(%rsp)
cmp    %r8,%rdx
setb   0x9(%rsp)
mov    0x60(%rsp),%rdx
cmp    %rsi,%rdx
setb   0x8(%rsp)
cmp    %r9,%rdi
setb   %sil
cmp    %r11,%r10
setb   %r10b
cmp    %r8,%rdi
setb   %dil
cmp    %r11,%rdx
setb   %r8b
mov    0xb(%rsp),%dl
test   %dl,0x40(%rsp)
jne    1626 <rk4+0x506>
and    0xa(%rsp),%cl
jne    1626 <rk4+0x506>
mov    0x8(%rsp),%dl
and    %dl,0x9(%rsp)
jne    1626 <rk4+0x506>
and    %r10b,%sil
jne    1626 <rk4+0x506>
and    %r8b,%dil
jne    1626 <rk4+0x506>
mov    0x30(%rsp),%rdi
mov    %rdi,%rax
and    $0xfffffffffffffffe,%rax
movapd %xmm3,%xmm4
unpcklpd %xmm3,%xmm4
lea    -0x2(%rax),%rcx
mov    %rcx,%rdx
shr    %rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1862 <rk4+0x742>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0x1,%ecx
nopl   0x0(%rax)
movupd (%rbx,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm4,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd (%r12,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
addpd  %xmm1,%xmm2
movupd 0x10(%r15,%rcx,8),%xmm1
movupd %xmm2,(%r15,%rcx,8)
movupd 0x10(%rbx,%rcx,8),%xmm2
mulpd  %xmm4,%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,0x10(%rbp,%rcx,8)
movupd 0x10(%r12,%rcx,8),%xmm1
movupd 0x10(%r15,%rcx,8),%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x10(%r15,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rsi
jne    17c0 <rk4+0x6a0>
jmp    1867 <rk4+0x747>
xor    %ecx,%ecx
test   $0x1,%dl
jne    132a <rk4+0x20a>
jmp    135f <rk4+0x23f>
mov    0x10(%rsp),%r8
jmp    140d <rk4+0x2ed>
or     $0x1,%rax
jmp    140d <rk4+0x2ed>
xor    %ecx,%ecx
test   $0x1,%dl
jne    15ab <rk4+0x48b>
jmp    15e7 <rk4+0x4c7>
mov    $0x1,%ecx
test   $0x1,%dl
je     189b <rk4+0x77b>
movupd (%rbx,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
mulpd  %xmm2,%xmm4
addpd  %xmm1,%xmm4
movupd %xmm4,0x0(%rbp,%rcx,8)
movupd (%r12,%rcx,8),%xmm2
movupd (%r15,%rcx,8),%xmm1
addpd  %xmm2,%xmm1
movupd %xmm1,(%r15,%rcx,8)
cmp    %rax,%rdi
jne    1ac8 <rk4+0x9a8>
addsd  %xmm3,%xmm0
mov    %rbp,%rdi
mov    %r12,%rsi
call   *0x10(%rsp)
movapd 0x50(%rsp),%xmm7
mov    0xc(%rsp),%eax
test   %eax,%eax
mov    0x18(%rsp),%rdi
jle    1a98 <rk4+0x978>
divsd  0x737(%rip),%xmm7
cmp    $0x4,%eax
jae    1984 <rk4+0x864>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%r14b
je     1915 <rk4+0x7f5>
movsd  0x0(%r13,%rax,8),%xmm0
addsd  (%r12,%rax,8),%xmm0
movsd  (%r15,%rax,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
or     $0x1,%rax
add    %r14,%rcx
je     1a98 <rk4+0x978>
xchg   %ax,%ax
movsd  0x0(%r13,%rax,8),%xmm0
addsd  (%r12,%rax,8),%xmm0
movsd  (%r15,%rax,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rbx,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rax,8)
movsd  0x8(%r13,%rax,8),%xmm0
addsd  0x8(%r12,%rax,8),%xmm0
movsd  0x8(%r15,%rax,8),%xmm1
addsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
mulsd  %xmm7,%xmm1
addsd  0x8(%rbx,%rax,8),%xmm1
movsd  %xmm1,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r14
jne    1920 <rk4+0x800>
jmp    1a98 <rk4+0x978>
lea    (%rdi,%r14,8),%rax
lea    (%rbx,%r14,8),%rcx
cmp    %rdi,%rcx
seta   %r10b
lea    0x0(,%r14,8),%rcx
add    %r13,%rcx
cmp    %rbx,%rax
seta   %r11b
lea    (%r12,%r14,8),%rdx
cmp    %rdi,%rcx
seta   %cl
lea    (%r15,%r14,8),%rsi
cmp    %r13,%rax
seta   %r9b
cmp    %rdi,%rdx
seta   %dl
cmp    %rax,%r12
setb   %r8b
cmp    %rdi,%rsi
seta   %sil
cmp    %rax,%r15
setb   %dil
xor    %eax,%eax
test   %r11b,%r10b
jne    1abe <rk4+0x99e>
and    %r9b,%cl
jne    1abe <rk4+0x99e>
and    %r8b,%dl
jne    1abe <rk4+0x99e>
and    %dil,%sil
mov    0x18(%rsp),%rdi
jne    18dc <rk4+0x7bc>
mov    %r14d,%eax
and    $0xfffffffc,%eax
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
lea    0x0(,%r14,8),%rcx
and    $0xffffffffffffffe0,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movupd (%rbx,%rdx,1),%xmm1
movupd 0x10(%rbx,%rdx,1),%xmm2
movupd 0x0(%r13,%rdx,1),%xmm3
movupd 0x10(%r13,%rdx,1),%xmm4
movupd (%r12,%rdx,1),%xmm5
addpd  %xmm3,%xmm5
movupd 0x10(%r12,%rdx,1),%xmm3
addpd  %xmm4,%xmm3
movupd (%r15,%rdx,1),%xmm4
movupd 0x10(%r15,%rdx,1),%xmm6
addpd  %xmm4,%xmm4
addpd  %xmm5,%xmm4
addpd  %xmm6,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm0,%xmm4
addpd  %xmm1,%xmm4
mulpd  %xmm0,%xmm6
addpd  %xmm2,%xmm6
movupd %xmm4,(%rdi,%rdx,1)
movupd %xmm6,0x10(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rcx
jne    1a20 <rk4+0x900>
cmp    %r14,%rax
jne    18dc <rk4+0x7bc>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    0x18(%rsp),%rdi
jmp    18dc <rk4+0x7bc>
mov    0x30(%rsp),%rax
or     $0x1,%rax
jmp    1626 <rk4+0x506>

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

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