#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*/ my_rhs(double, double *, double *, int);
void rkck(double *y, double *dydx, int n, double x, double h, double *yout,
          double *yerr, double *work) {
  int i;
  static double a2 = 0.2, a3 = 0.3, a4 = 0.6, a5 = 1.0, a6 = 0.875, b21 = 0.2,
                b31 = 3.0 / 40.0, b32 = 9.0 / 40.0, b41 = 0.3, b42 = -0.9,
                b43 = 1.2, b51 = -11.0 / 54.0, b52 = 2.5, b53 = -70.0 / 27.0,
                b54 = 35.0 / 27.0, b61 = 1631.0 / 55296.0, b62 = 175.0 / 512.0,
                b63 = 575.0 / 13824.0, b64 = 44275.0 / 110592.0,
                b65 = 253.0 / 4096.0, c1 = 37.0 / 378.0, c3 = 250.0 / 621.0,
                c4 = 125.0 / 594.0, c6 = 512.0 / 1771.0,
                dc5 = -277.00 / 14336.0;
  double dc1 = c1 - 2825.0 / 27648.0, dc3 = c3 - 18575.0 / 48384.0,
         dc4 = c4 - 13525.0 / 55296.0, dc6 = c6 - 0.25;
  double *ak2, *ak3, *ak4, *ak5, *ak6, *ytemp;
  ak2 = work;
  ak3 = work + n;
  ak4 = ak3 + n;
  ak5 = ak4 + n;
  ak6 = ak5 + n;
  ytemp = ak6 + n;
  for (i = 0; i < n; i++)
    ytemp[i] = y[i] + b21 * h * dydx[i];
  my_rhs(x + a2 * h, ytemp, ak2, n);
  for (i = 0; i < n; i++)
    ytemp[i] = y[i] + h * (b31 * dydx[i] + b32 * ak2[i]);
  my_rhs(x + a3 * h, ytemp, ak3, n);
  for (i = 0; i < n; i++)
    ytemp[i] = y[i] + h * (b41 * dydx[i] + b42 * ak2[i] + b43 * ak3[i]);
  my_rhs(x + a4 * h, ytemp, ak4, n);
  for (i = 0; i < n; i++)
    ytemp[i] =
        y[i] + h * (b51 * dydx[i] + b52 * ak2[i] + b53 * ak3[i] + b54 * ak4[i]);
  my_rhs(x + a5 * h, ytemp, ak5, n);
  for (i = 0; i < n; i++)
    ytemp[i] = y[i] + h * (b61 * dydx[i] + b62 * ak2[i] + b63 * ak3[i] +
                           b64 * ak4[i] + b65 * ak5[i]);
  my_rhs(x + a6 * h, ytemp, ak6, n);
  for (i = 0; i < n; i++)
    yout[i] =
        y[i] + h * (c1 * dydx[i] + c3 * ak3[i] + c4 * ak4[i] + c6 * ak6[i]);
  for (i = 0; i < n; i++)
    yerr[i] = h * (dc1 * dydx[i] + dc3 * ak3[i] + dc4 * ak4[i] + dc5 * ak5[i] +
                   dc6 * ak6[i]);
}


x86 assembly (clang, -O0):
<rkck>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%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)
mov    %r9,-0x40(%rbp)
movsd  0x2f84(%rip),%xmm0
movsd  0xecc(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  0x2f73(%rip),%xmm0
movsd  0xeab(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  0x2f62(%rip),%xmm0
movsd  0xe8a(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0x2f51(%rip),%xmm0
movsd  0xe69(%rip),%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x78(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x98(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1276 <rkck+0x166>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  0x2e12(%rip),%xmm0
mulsd  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    121d <rkck+0x10d>
movsd  -0x20(%rbp),%xmm1
movsd  0x2da5(%rip),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1030 <my_rhs@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1320 <rkck+0x210>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0x2d88(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x2d7b(%rip),%xmm3
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12aa <rkck+0x19a>
movsd  -0x20(%rbp),%xmm1
movsd  0x2d03(%rip),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1030 <my_rhs@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13e7 <rkck+0x2d7>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0x2cee(%rip),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x2ce1(%rip),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x2ccc(%rip),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1354 <rkck+0x244>
movsd  -0x20(%rbp),%xmm1
movsd  0x2c44(%rip),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rdi
mov    -0x80(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1030 <my_rhs@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    14cb <rkck+0x3bb>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0x2c3f(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x2c32(%rip),%xmm3
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  0x2c1d(%rip),%xmm3
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x2c08(%rip),%xmm2
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    141b <rkck+0x30b>
movsd  -0x20(%rbp),%xmm1
movsd  0x2b68(%rip),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rdi
mov    -0x88(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1030 <my_rhs@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15d2 <rkck+0x4c2>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0x2b78(%rip),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x2b6b(%rip),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x2b56(%rip),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  0x2b41(%rip),%xmm3
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x2b2c(%rip),%xmm2
mov    -0x88(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1502 <rkck+0x3f2>
movsd  -0x20(%rbp),%xmm1
movsd  0x2a69(%rip),%xmm0
movsd  -0x28(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rdi
mov    -0x90(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1030 <my_rhs@plt>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16b9 <rkck+0x5a9>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x28(%rbp),%xmm0
movsd  0x2a99(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movsd  0x2a8c(%rip),%xmm3
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
movsd  0x2a77(%rip),%xmm3
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%xmm3
addsd  %xmm2,%xmm3
movsd  0x2a62(%rip),%xmm2
mov    -0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
mulsd  %xmm4,%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    1609 <rkck+0x4f9>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1773 <rkck+0x663>
movsd  -0x28(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movsd  -0x58(%rbp),%xmm1
mov    -0x78(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x60(%rbp),%xmm1
mov    -0x80(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
movsd  0x29c9(%rip),%xmm2
mov    -0x88(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  -0x68(%rbp),%xmm1
mov    -0x90(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    16c0 <rkck+0x5b0>
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rkck>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%r12
mov    %rcx,0x70(%rsp)
movapd %xmm0,%xmm6
mov    %edx,%ebp
movslq %edx,%r10
lea    (%r9,%r10,8),%rax
mov    %rax,0x28(%rsp)
lea    (%rax,%r10,8),%rax
mov    %rax,0x30(%rsp)
lea    (%rax,%r10,8),%rax
lea    (%rax,%r10,8),%rcx
lea    (%rcx,%r10,8),%rbx
test   %r10d,%r10d
movapd %xmm1,0x50(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rax,0x48(%rsp)
movsd  %xmm0,0x20(%rsp)
jle    1192 <rkck+0x82>
mov    %rsi,%r15
mov    %rdi,%r14
mov    %rbx,0x10(%rsp)
movsd  0x1e85(%rip),%xmm0
mulsd  %xmm1,%xmm0
mov    %ebp,%r13d
mov    %ebp,0x1c(%rsp)
cmp    $0x4,%ebp
jae    11b4 <rkck+0xa4>
xor    %eax,%eax
jmp    12fb <rkck+0x1eb>
movsd  0x1e66(%rip),%xmm0
mulsd  %xmm1,%xmm0
addsd  %xmm6,%xmm0
mov    %rbx,%rdi
mov    %r12,%rsi
mov    %ebp,%edx
call   1030 <my_rhs@plt>
jmp    13bf <rkck+0x2af>
lea    (%r10,%r10,4),%rdi
lea    (%rdi,%r13,1),%rax
lea    (%r12,%rax,8),%rax
lea    (%r14,%r13,8),%rdx
mov    0x10(%rsp),%rsi
cmp    %rdx,%rsi
setb   %r9b
cmp    %r14,%rax
seta   %cl
lea    (%r15,%r13,8),%rdx
cmp    %rdx,%rsi
setb   %dl
cmp    %r15,%rax
seta   %sil
xor    %eax,%eax
test   %cl,%r9b
jne    12fb <rkck+0x1eb>
and    %sil,%dl
jne    12fb <rkck+0x1eb>
mov    %r13d,%eax
and    $0xfffffffc,%eax
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rax),%rcx
mov    %rcx,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     156d <rkck+0x45d>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r12,%rdi,8),%rdi
add    $0x30,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%r14,%rcx,8),%xmm2
movupd 0x10(%r14,%rcx,8),%xmm3
movupd (%r15,%rcx,8),%xmm4
movupd 0x10(%r15,%rcx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%rdi,%rcx,8)
movupd %xmm5,-0x20(%rdi,%rcx,8)
movupd 0x20(%r14,%rcx,8),%xmm2
movupd 0x30(%r14,%rcx,8),%xmm3
movupd 0x20(%r15,%rcx,8),%xmm4
movupd 0x30(%r15,%rcx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%rdi,%rcx,8)
movupd %xmm5,(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1240 <rkck+0x130>
test   $0x1,%dl
je     12f6 <rkck+0x1e6>
movupd (%r14,%rcx,8),%xmm2
movupd 0x10(%r14,%rcx,8),%xmm3
movupd (%r15,%rcx,8),%xmm4
movupd 0x10(%r15,%rcx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
mov    0x10(%rsp),%rdx
movupd %xmm4,(%rdx,%rcx,8)
movupd %xmm5,0x10(%rdx,%rcx,8)
cmp    %r13,%rax
je     1376 <rkck+0x266>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r13b
je     1325 <rkck+0x215>
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rax,8),%xmm1
mov    0x10(%rsp),%rdx
movsd  %xmm1,(%rdx,%rax,8)
or     $0x1,%rax
add    %r13,%rcx
je     1376 <rkck+0x266>
lea    (%r10,%r10,4),%rcx
lea    (%r12,%rcx,8),%rcx
add    $0x8,%rcx
cs nopw 0x0(%rax,%rax,1)
movsd  (%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rcx,%rax,8)
movsd  0x8(%r15,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    1340 <rkck+0x230>
mov    %r8,0x68(%rsp)
mov    %r10,0x8(%rsp)
addsd  %xmm6,%xmm0
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
mov    %r12,%rsi
mov    0x1c(%rsp),%ebp
mov    %ebp,%edx
call   1030 <my_rhs@plt>
test   %ebp,%ebp
jle    13bf <rkck+0x2af>
cmp    $0x4,%ebp
movapd 0x50(%rsp),%xmm9
mov    0x28(%rsp),%rsi
jae    1451 <rkck+0x341>
xor    %eax,%eax
mov    0x8(%rsp),%r10
jmp    1582 <rkck+0x472>
movsd  0x1c41(%rip),%xmm0
mulsd  0x50(%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
mov    %rbx,%rdi
mov    0x28(%rsp),%rsi
mov    %ebp,%edx
call   1030 <my_rhs@plt>
movsd  0x1c36(%rip),%xmm0
mulsd  0x50(%rsp),%xmm0
addsd  0x20(%rsp),%xmm0
mov    %rbx,%rdi
mov    0x30(%rsp),%rsi
mov    %ebp,%edx
call   1030 <my_rhs@plt>
movsd  0x20(%rsp),%xmm0
addsd  0x50(%rsp),%xmm0
mov    %rbx,%rdi
mov    0x48(%rsp),%rsi
mov    %ebp,%edx
call   1030 <my_rhs@plt>
mov    0x38(%rsp),%rsi
movapd 0x50(%rsp),%xmm0
mulsd  0x1c25(%rip),%xmm0
addsd  0x20(%rsp),%xmm0
mov    %rbx,%rdi
mov    %ebp,%edx
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <my_rhs@plt>
mov    0x8(%rsp),%r10
lea    (%r10,%r10,4),%rbp
mov    %rbp,%rax
add    %r13,%rax
lea    (%r12,%rax,8),%rax
lea    (%r14,%r13,8),%rcx
lea    (%r15,%r13,8),%rdx
cmp    %rcx,%rbx
setb   %r8b
cmp    %r14,%rax
seta   %r9b
cmp    %rdx,%rbx
setb   %cl
cmp    %r15,%rax
seta   %dl
lea    (%r12,%r13,8),%rdi
cmp    %rdi,%rbx
setb   %bl
cmp    %r12,%rax
seta   %dil
xor    %eax,%eax
test   %r9b,%r8b
jne    157d <rkck+0x46d>
and    %dl,%cl
jne    157d <rkck+0x46d>
and    %dil,%bl
mov    0x10(%rsp),%rbx
jne    1582 <rkck+0x472>
mov    %r13d,%eax
and    $0xfffffffc,%eax
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
lea    0x10(%r12),%rcx
lea    (%r12,%rbp,8),%rdx
add    $0x10,%rdx
lea    0x0(,%r13,8),%rbp
and    $0xffffffffffffffe0,%rbp
xor    %edi,%edi
movapd 0x1be4(%rip),%xmm8
movapd 0x1bec(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd (%r14,%rdi,1),%xmm3
movupd 0x10(%r14,%rdi,1),%xmm4
movupd (%r15,%rdi,1),%xmm5
movupd 0x10(%r15,%rdi,1),%xmm6
movupd -0x10(%rcx,%rdi,1),%xmm7
movupd (%rcx,%rdi,1),%xmm1
mulpd  %xmm8,%xmm7
mulpd  %xmm8,%xmm1
mulpd  %xmm2,%xmm5
addpd  %xmm7,%xmm5
mulpd  %xmm2,%xmm6
addpd  %xmm1,%xmm6
mulpd  %xmm0,%xmm5
addpd  %xmm3,%xmm5
mulpd  %xmm0,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm5,-0x10(%rdx,%rdi,1)
movupd %xmm6,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rbp
jne    1500 <rkck+0x3f0>
cmp    %r13,%rax
jne    1582 <rkck+0x472>
jmp    164d <rkck+0x53d>
xor    %ecx,%ecx
test   $0x1,%dl
jne    12bc <rkck+0x1ac>
jmp    12f6 <rkck+0x1e6>
mov    0x10(%rsp),%rbx
mov    %rax,%rcx
not    %rcx
test   $0x1,%r13b
je     15c2 <rkck+0x4b2>
movsd  (%r15,%rax,8),%xmm0
movsd  (%r12,%rax,8),%xmm1
mulsd  0x1a6e(%rip),%xmm1
mulsd  0x1a6e(%rip),%xmm0
addsd  %xmm1,%xmm0
mulsd  %xmm9,%xmm0
addsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
or     $0x1,%rax
add    %r13,%rcx
je     164d <rkck+0x53d>
lea    (%r10,%r10,4),%rcx
lea    (%r12,%rcx,8),%rcx
add    $0x8,%rcx
movsd  0x1a31(%rip),%xmm0
movsd  0x1a31(%rip),%xmm1
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  (%r15,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm9,%xmm3
addsd  (%r14,%rax,8),%xmm3
movsd  %xmm3,-0x8(%rcx,%rax,8)
movsd  0x8(%r12,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
movsd  0x8(%r15,%rax,8),%xmm3
mulsd  %xmm1,%xmm3
addsd  %xmm2,%xmm3
mulsd  %xmm9,%xmm3
addsd  0x8(%r14,%rax,8),%xmm3
movsd  %xmm3,(%rcx,%rax,8)
add    $0x2,%rax
cmp    %rax,%r13
jne    15f0 <rkck+0x4e0>
movsd  0x19b3(%rip),%xmm0
mulsd  %xmm9,%xmm0
addsd  0x20(%rsp),%xmm0
mov    %rbx,%rdi
mov    0x1c(%rsp),%ebp
mov    %ebp,%edx
call   1030 <my_rhs@plt>
test   %ebp,%ebp
jle    13e2 <rkck+0x2d2>
cmp    $0x1,%ebp
movapd 0x50(%rsp),%xmm7
movsd  0x20(%rsp),%xmm8
jne    1694 <rkck+0x584>
xor    %eax,%eax
mov    0x28(%rsp),%rbp
jmp    1866 <rkck+0x756>
mov    0x8(%rsp),%rsi
lea    (%rsi,%rsi,4),%rcx
mov    %rcx,%rax
mov    %rcx,0x40(%rsp)
lea    (%rcx,%r13,1),%rax
lea    (%r12,%rax,8),%rax
lea    (%r14,%r13,8),%rcx
lea    (%r15,%r13,8),%rdx
lea    (%r12,%r13,8),%rdi
lea    (%rsi,%r13,1),%rbp
cmp    %rcx,%rbx
setb   %r9b
cmp    %r14,%rax
seta   %r10b
cmp    %rdx,%rbx
setb   %dl
cmp    %r15,%rax
seta   %sil
lea    (%r12,%rbp,8),%rcx
cmp    %rdi,%rbx
setb   %r11b
cmp    %r12,%rax
seta   %dil
cmp    %rcx,%rbx
setb   %cl
mov    0x28(%rsp),%rbp
cmp    %rax,%rbp
setb   %r8b
xor    %eax,%eax
test   %r10b,%r9b
jne    1861 <rkck+0x751>
and    %sil,%dl
jne    1861 <rkck+0x751>
and    %dil,%r11b
jne    1861 <rkck+0x751>
and    %r8b,%cl
mov    0x10(%rsp),%rbx
jne    1866 <rkck+0x756>
mov    %r13d,%eax
and    $0xfffffffe,%eax
movapd %xmm7,%xmm0
unpcklpd %xmm7,%xmm0
lea    -0x2(%rax),%rcx
mov    %rcx,%r8
shr    %r8
add    $0x1,%r8
test   %rcx,%rcx
je     2120 <rkck+0x1010>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x8(%rsp),%rcx
lea    (%r12,%rcx,8),%rdi
add    $0x10,%rdi
mov    0x40(%rsp),%rcx
lea    (%r12,%rcx,8),%rdx
add    $0x10,%rdx
xor    %ecx,%ecx
movapd 0x1979(%rip),%xmm1
movapd 0x1981(%rip),%xmm2
movapd 0x1989(%rip),%xmm3
nopw   0x0(%rax,%rax,1)
movupd (%r14,%rcx,8),%xmm4
movupd (%r15,%rcx,8),%xmm5
movupd (%r12,%rcx,8),%xmm6
mulpd  %xmm1,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movupd -0x10(%rdi,%rcx,8),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,-0x10(%rdx,%rcx,8)
movupd 0x10(%r14,%rcx,8),%xmm4
movupd 0x10(%r15,%rcx,8),%xmm5
movupd 0x10(%r12,%rcx,8),%xmm6
mulpd  %xmm1,%xmm6
mulpd  %xmm2,%xmm5
addpd  %xmm6,%xmm5
movupd (%rdi,%rcx,8),%xmm6
mulpd  %xmm3,%xmm6
addpd  %xmm5,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm4,%xmm6
movupd %xmm6,(%rdx,%rcx,8)
add    $0x4,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1790 <rkck+0x680>
test   $0x1,%r8b
je     185a <rkck+0x74a>
movupd (%r14,%rcx,8),%xmm1
movupd (%r15,%rcx,8),%xmm2
movupd (%r12,%rcx,8),%xmm3
mulpd  0x18c1(%rip),%xmm3
mulpd  0x18c9(%rip),%xmm2
addpd  %xmm3,%xmm2
movupd 0x0(%rbp,%rcx,8),%xmm3
mulpd  0x18c7(%rip),%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm3,%xmm0
addpd  %xmm1,%xmm0
movupd %xmm0,(%rbx,%rcx,8)
cmp    %r13,%rax
jne    1866 <rkck+0x756>
jmp    18be <rkck+0x7ae>
mov    0x10(%rsp),%rbx
movsd  0x17ba(%rip),%xmm0
movsd  0x1792(%rip),%xmm1
movsd  0x17b2(%rip),%xmm2
xchg   %ax,%ax
movsd  (%r12,%rax,8),%xmm3
mulsd  %xmm0,%xmm3
movsd  (%r15,%rax,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movsd  0x0(%rbp,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
mulsd  %xmm7,%xmm3
addsd  (%r14,%rax,8),%xmm3
movsd  %xmm3,(%rbx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    1880 <rkck+0x770>
movsd  0x175a(%rip),%xmm0
mulsd  %xmm7,%xmm0
addsd  %xmm8,%xmm0
mov    %rbx,%rdi
mov    0x30(%rsp),%rsi
mov    0x1c(%rsp),%ebp
mov    %ebp,%edx
call   1030 <my_rhs@plt>
test   %ebp,%ebp
jle    1405 <rkck+0x2f5>
cmp    $0x1,%ebp
movapd 0x50(%rsp),%xmm8
movsd  0x20(%rsp),%xmm9
jne    190a <rkck+0x7fa>
xor    %r8d,%r8d
mov    0x8(%rsp),%r10
jmp    1a7c <rkck+0x96c>
mov    0x8(%rsp),%rdi
lea    (%rdi,%rdi,4),%rax
add    %r13,%rax
lea    (%r12,%rax,8),%rbp
lea    (%r14,%r13,8),%rax
lea    (%r15,%r13,8),%rcx
lea    (%r12,%r13,8),%rdx
lea    (%rdi,%r13,1),%rsi
lea    (%r12,%rsi,8),%rbx
lea    0x0(,%rdi,2),%rdi
add    %r13,%rdi
mov    0x10(%rsp),%rsi
cmp    %rax,%rsi
setb   0x40(%rsp)
cmp    %r14,%rbp
seta   %r10b
cmp    %rcx,%rsi
setb   %al
cmp    %r15,%rbp
seta   %r11b
lea    (%r12,%rdi,8),%rdi
cmp    %rdx,%rsi
setb   %cl
cmp    %r12,%rbp
seta   %r9b
cmp    %rbx,%rsi
setb   %dl
cmp    %rbp,0x28(%rsp)
setb   0x7(%rsp)
cmp    %rdi,%rsi
setb   %bl
cmp    %rbp,0x30(%rsp)
setb   %bpl
xor    %r8d,%r8d
test   %r10b,0x40(%rsp)
jne    229f <rkck+0x118f>
and    %r11b,%al
mov    0x8(%rsp),%r10
jne    1a7c <rkck+0x96c>
and    %r9b,%cl
jne    1a7c <rkck+0x96c>
and    0x7(%rsp),%dl
jne    1a7c <rkck+0x96c>
and    %bpl,%bl
jne    1a7c <rkck+0x96c>
mov    %r13d,%r8d
and    $0xfffffffe,%r8d
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
mov    %r10,%rcx
shl    $0x4,%rcx
lea    0x0(,%r10,8),%rax
lea    (%rax,%rax,4),%rdx
movapd 0x1732(%rip),%xmm1
movapd 0x173a(%rip),%xmm2
movapd 0x1742(%rip),%xmm3
movapd 0x174a(%rip),%xmm4
mov    %r8,%rsi
mov    %r12,%rdi
mov    %r15,%rbp
mov    %r14,%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd (%rbx),%xmm5
movupd 0x0(%rbp),%xmm6
movupd (%rdi),%xmm7
mulpd  %xmm1,%xmm7
mulpd  %xmm2,%xmm6
addpd  %xmm7,%xmm6
movupd (%rdi,%r10,8),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movupd (%rdi,%rcx,1),%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm7,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%rdi,%rdx,1)
add    $0x10,%rbx
add    $0x10,%rbp
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1a20 <rkck+0x910>
cmp    %r13,%r8
je     1b1a <rkck+0xa0a>
lea    (%r10,%r10,4),%rax
add    %r8,%rax
lea    (%r12,%rax,8),%r9
lea    (%r8,%r10,2),%rax
lea    (%r12,%rax,8),%rdx
lea    (%r8,%r10,1),%rax
lea    (%r12,%rax,8),%rsi
lea    (%r12,%r8,8),%rdi
lea    (%r15,%r8,8),%rbp
lea    (%r14,%r8,8),%rbx
mov    %r13,%rax
sub    %r8,%rax
xor    %ecx,%ecx
movsd  0x1585(%rip),%xmm0
movsd  0x1585(%rip),%xmm1
movsd  0x1585(%rip),%xmm2
movsd  0x1585(%rip),%xmm3
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rcx,8),%xmm4
mulsd  %xmm0,%xmm4
movsd  0x0(%rbp,%rcx,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rsi,%rcx,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rdx,%rcx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm8,%xmm5
addsd  (%rbx,%rcx,8),%xmm5
movsd  %xmm5,(%r9,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1ad0 <rkck+0x9c0>
movapd %xmm9,%xmm0
addsd  %xmm8,%xmm0
mov    0x10(%rsp),%rbx
mov    %rbx,%rdi
mov    0x48(%rsp),%rsi
mov    0x1c(%rsp),%ebp
mov    %ebp,%edx
call   1030 <my_rhs@plt>
test   %ebp,%ebp
mov    0x38(%rsp),%rsi
jle    1425 <rkck+0x315>
cmp    $0x1,%ebp
movapd 0x50(%rsp),%xmm9
jne    1c8f <rkck+0xb7f>
xor    %r8d,%r8d
mov    0x8(%rsp),%rbp
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
add    %r8,%rax
lea    (%r12,%rax,8),%r9
lea    0x0(,%rbp,2),%rax
add    %rbp,%rax
add    %r8,%rax
lea    (%r12,%rax,8),%r10
lea    (%r8,%rbp,2),%rax
lea    (%r12,%rax,8),%rsi
lea    (%r8,%rbp,1),%rax
lea    (%r12,%rax,8),%rax
lea    (%r12,%r8,8),%rdi
lea    (%r15,%r8,8),%rbx
lea    (%r14,%r8,8),%rbp
mov    %r13,%rcx
sub    %r8,%rcx
xor    %edx,%edx
movsd  0x14af(%rip),%xmm0
movsd  0x14af(%rip),%xmm1
movsd  0x14af(%rip),%xmm2
movsd  0x14af(%rip),%xmm3
movsd  0x14af(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rdx,8),%xmm5
mulsd  %xmm0,%xmm5
movsd  (%rbx,%rdx,8),%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm5,%xmm6
movsd  (%rax,%rdx,8),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
movsd  (%rsi,%rdx,8),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  (%r10,%rdx,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm9,%xmm5
addsd  0x0(%rbp,%rdx,8),%xmm5
movsd  %xmm5,(%r9,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1be0 <rkck+0xad0>
movsd  0x1418(%rip),%xmm0
mulsd  %xmm9,%xmm0
addsd  0x20(%rsp),%xmm0
mov    0x10(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    0x1c(%rsp),%ebx
mov    %ebx,%edx
call   1030 <my_rhs@plt>
mov    0x8(%rsp),%r10
movapd 0x50(%rsp),%xmm8
test   %ebx,%ebx
mov    0x28(%rsp),%r11
jle    2111 <rkck+0x1001>
cmp    $0x1,%ebx
jne    1e3e <rkck+0xd2e>
xor    %r8d,%r8d
mov    0x70(%rsp),%rdi
jmp    1f97 <rkck+0xe87>
mov    0x8(%rsp),%rbx
lea    (%rbx,%rbx,4),%rax
add    %r13,%rax
lea    (%r12,%rax,8),%rax
lea    (%r14,%r13,8),%rcx
lea    (%r15,%r13,8),%rdx
lea    (%r12,%r13,8),%rsi
lea    (%rbx,%r13,1),%rdi
lea    (%r12,%rdi,8),%rdi
lea    0x0(,%rbx,2),%rbp
add    %r13,%rbp
lea    (%r12,%rbp,8),%r8
lea    (%rbx,%rbx,2),%rbx
add    %r13,%rbx
mov    0x10(%rsp),%r10
cmp    %rcx,%r10
setb   0x40(%rsp)
cmp    %r14,%rax
seta   %r11b
cmp    %rdx,%r10
setb   %cl
cmp    %r15,%rax
seta   %r9b
lea    (%r12,%rbx,8),%rbp
cmp    %rsi,%r10
setb   %dl
cmp    %r12,%rax
seta   0x7(%rsp)
cmp    %rdi,%r10
setb   %bl
cmp    %rax,0x28(%rsp)
setb   0x1b(%rsp)
cmp    %r8,%r10
setb   %sil
cmp    %rax,0x30(%rsp)
setb   0x1a(%rsp)
cmp    %rbp,%r10
setb   %dil
cmp    %rax,0x48(%rsp)
setb   %al
xor    %r8d,%r8d
test   %r11b,0x40(%rsp)
jne    1b5c <rkck+0xa4c>
and    %r9b,%cl
mov    0x8(%rsp),%rbp
jne    1b61 <rkck+0xa51>
and    0x7(%rsp),%dl
jne    1b61 <rkck+0xa51>
and    0x1b(%rsp),%bl
jne    1b61 <rkck+0xa51>
and    0x1a(%rsp),%sil
jne    1b61 <rkck+0xa51>
and    %al,%dil
jne    1b61 <rkck+0xa51>
mov    %r13d,%r8d
and    $0xfffffffe,%r8d
movapd %xmm9,%xmm0
unpcklpd %xmm9,%xmm0
mov    %rbp,%rcx
shl    $0x4,%rcx
lea    0x0(,%rbp,8),%rax
lea    (%rax,%rax,2),%r9
lea    (%rax,%rax,4),%rsi
movapd 0x13bf(%rip),%xmm8
movapd 0x13c7(%rip),%xmm2
movapd 0x13cf(%rip),%xmm3
movapd 0x13d7(%rip),%xmm4
movapd 0x13df(%rip),%xmm5
mov    %r8,%rdi
mov    %r12,%rax
mov    %r15,%rbx
mov    %r14,%rdx
nopl   (%rax)
movupd (%rdx),%xmm6
movupd (%rbx),%xmm7
movupd (%rax),%xmm1
mulpd  %xmm8,%xmm1
mulpd  %xmm2,%xmm7
addpd  %xmm1,%xmm7
movupd (%rax,%rbp,8),%xmm1
mulpd  %xmm3,%xmm1
addpd  %xmm7,%xmm1
movupd (%rax,%rcx,1),%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm1,%xmm7
movupd (%rax,%r9,1),%xmm1
mulpd  %xmm5,%xmm1
addpd  %xmm7,%xmm1
mulpd  %xmm0,%xmm1
addpd  %xmm6,%xmm1
movupd %xmm1,(%rax,%rsi,1)
add    $0x10,%rdx
add    $0x10,%rbx
add    $0x10,%rax
add    $0xfffffffffffffffe,%rdi
jne    1dd0 <rkck+0xcc0>
cmp    %r13,%r8
jne    1b61 <rkck+0xa51>
jmp    1c38 <rkck+0xb28>
mov    0x70(%rsp),%rdi
lea    (%rdi,%r13,8),%rbp
lea    (%r14,%r13,8),%rax
lea    (%r15,%r13,8),%rcx
lea    0x0(,%r10,4),%rdx
add    %r13,%rdx
lea    (%r12,%rdx,8),%rdx
lea    0x0(,%r10,2),%rsi
add    %r13,%rsi
lea    (%r12,%rsi,8),%rbx
cmp    %rdi,%rax
mov    %r11,%r8
seta   0x20(%rsp)
lea    (%r10,%r13,1),%rax
cmp    %r14,%rbp
seta   %r10b
lea    (%r12,%rax,8),%rsi
cmp    %rdi,%rcx
seta   %al
cmp    %r15,%rbp
seta   %r11b
cmp    %rdi,%rdx
seta   %cl
cmp    %rbp,0x38(%rsp)
setb   %r9b
cmp    %rdi,%rbx
seta   %dl
cmp    %rbp,0x30(%rsp)
setb   0x10(%rsp)
cmp    %rdi,%rsi
seta   %bl
cmp    %rbp,%r8
setb   %bpl
xor    %r8d,%r8d
test   %r10b,0x20(%rsp)
jne    22a9 <rkck+0x1199>
and    %r11b,%al
mov    0x8(%rsp),%r10
mov    0x28(%rsp),%r11
jne    1f97 <rkck+0xe87>
and    %r9b,%cl
jne    1f97 <rkck+0xe87>
and    0x10(%rsp),%dl
jne    1f97 <rkck+0xe87>
and    %bpl,%bl
jne    1f97 <rkck+0xe87>
mov    %r13d,%r8d
and    $0xfffffffe,%r8d
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
xor    %eax,%eax
movapd 0x1298(%rip),%xmm1
movapd 0x12a0(%rip),%xmm2
movapd 0x12a8(%rip),%xmm3
movapd 0x12b0(%rip),%xmm4
mov    0x38(%rsp),%rcx
mov    0x30(%rsp),%rdx
nopw   0x0(%rax,%rax,1)
movupd (%r14,%rax,8),%xmm5
movupd (%r15,%rax,8),%xmm6
movupd (%r11,%rax,8),%xmm7
mulpd  %xmm1,%xmm7
mulpd  %xmm2,%xmm6
addpd  %xmm7,%xmm6
movupd (%rdx,%rax,8),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movupd (%rcx,%rax,8),%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm7,%xmm6
mulpd  %xmm0,%xmm6
addpd  %xmm5,%xmm6
movupd %xmm6,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    1f40 <rkck+0xe30>
cmp    %r13,%r8
je     203a <rkck+0xf2a>
lea    (%rdi,%r8,8),%r9
lea    (%r8,%r10,4),%rax
lea    (%r12,%rax,8),%rdx
lea    (%r8,%r10,2),%rax
lea    (%r12,%rax,8),%rsi
lea    (%r8,%r10,1),%rax
lea    (%r12,%rax,8),%rdi
lea    (%r15,%r8,8),%rbp
lea    (%r14,%r8,8),%rbx
mov    %r13,%rax
sub    %r8,%rax
xor    %ecx,%ecx
movsd  0x10bd(%rip),%xmm0
movsd  0x10bd(%rip),%xmm1
movsd  0x10bd(%rip),%xmm2
movsd  0x10bd(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rdi,%rcx,8),%xmm4
mulsd  %xmm0,%xmm4
movsd  0x0(%rbp,%rcx,8),%xmm5
mulsd  %xmm1,%xmm5
addsd  %xmm4,%xmm5
movsd  (%rsi,%rcx,8),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm5,%xmm4
movsd  (%rdx,%rcx,8),%xmm5
mulsd  %xmm3,%xmm5
addsd  %xmm4,%xmm5
mulsd  %xmm8,%xmm5
addsd  (%rbx,%rcx,8),%xmm5
movsd  %xmm5,(%r9,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1ff0 <rkck+0xee0>
mov    0x1c(%rsp),%eax
test   %eax,%eax
mov    0x38(%rsp),%rbp
jle    2111 <rkck+0x1001>
cmp    $0x1,%eax
jne    2131 <rkck+0x1021>
xor    %eax,%eax
mov    0x68(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
lea    (%rax,%r10,4),%rdx
lea    (%r12,%rdx,8),%rdx
lea    (%r10,%r10,2),%rsi
add    %rax,%rsi
lea    (%r12,%rsi,8),%rsi
lea    (%rax,%r10,2),%rdi
lea    (%r12,%rdi,8),%rdi
add    %rax,%r10
lea    (%r12,%r10,8),%rbp
lea    (%r15,%rax,8),%rbx
sub    %rax,%r13
xor    %eax,%eax
movsd  0x1016(%rip),%xmm0
movsd  0x1016(%rip),%xmm1
movsd  0x1016(%rip),%xmm2
movsd  0x1016(%rip),%xmm3
movsd  0x1016(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm5
mulsd  %xmm0,%xmm5
movsd  (%rbx,%rax,8),%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm5,%xmm6
movsd  (%rdi,%rax,8),%xmm5
mulsd  %xmm2,%xmm5
addsd  %xmm6,%xmm5
movsd  (%rsi,%rax,8),%xmm6
mulsd  %xmm3,%xmm6
addsd  %xmm5,%xmm6
movsd  (%rdx,%rax,8),%xmm5
mulsd  %xmm4,%xmm5
addsd  %xmm6,%xmm5
mulsd  %xmm8,%xmm5
movsd  %xmm5,(%rcx,%rax,8)
add    $0x1,%rax
cmp    %rax,%r13
jne    20c0 <rkck+0xfb0>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%r8b
jne    1815 <rkck+0x705>
jmp    185a <rkck+0x74a>
mov    0x68(%rsp),%r9
lea    (%r9,%r13,8),%rax
lea    (%r15,%r13,8),%rcx
lea    0x0(,%r10,4),%rdx
add    %r13,%rdx
lea    (%r12,%rdx,8),%rdx
lea    (%r10,%r10,2),%rsi
add    %r13,%rsi
lea    (%r12,%rsi,8),%rsi
lea    0x0(,%r10,2),%rdi
add    %r13,%rdi
cmp    %r9,%rcx
seta   0x20(%rsp)
lea    (%r12,%rdi,8),%rbx
cmp    %r15,%rax
seta   %r14b
lea    (%r10,%r13,1),%rdi
cmp    %r9,%rdx
seta   %cl
lea    (%r12,%rdi,8),%rdi
cmp    %rax,%rbp
setb   %r10b
cmp    %r9,%rsi
seta   %dl
cmp    %rax,0x48(%rsp)
setb   %r8b
cmp    %r9,%rbx
seta   %bl
cmp    %rax,0x30(%rsp)
setb   %bpl
cmp    %r9,%rdi
seta   %sil
cmp    %rax,%r11
setb   %dil
xor    %eax,%eax
test   %r14b,0x20(%rsp)
jne    22b8 <rkck+0x11a8>
and    %r10b,%cl
mov    0x8(%rsp),%r10
jne    2056 <rkck+0xf46>
and    %r8b,%dl
jne    2056 <rkck+0xf46>
and    %bpl,%bl
jne    2056 <rkck+0xf46>
and    %dil,%sil
mov    0x38(%rsp),%rdx
mov    0x28(%rsp),%rbx
jne    2056 <rkck+0xf46>
mov    %r13d,%eax
and    $0xfffffffe,%eax
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
xor    %ecx,%ecx
movapd 0xfdf(%rip),%xmm1
movapd 0xfe7(%rip),%xmm2
movapd 0xfef(%rip),%xmm3
movapd 0xff7(%rip),%xmm4
movapd 0xfff(%rip),%xmm5
mov    0x48(%rsp),%rsi
mov    0x30(%rsp),%rdi
mov    0x68(%rsp),%rbp
movupd (%r15,%rcx,8),%xmm6
movupd (%rbx,%rcx,8),%xmm7
mulpd  %xmm1,%xmm7
mulpd  %xmm2,%xmm6
addpd  %xmm7,%xmm6
movupd (%rdi,%rcx,8),%xmm7
mulpd  %xmm3,%xmm7
addpd  %xmm6,%xmm7
movupd (%rsi,%rcx,8),%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm7,%xmm6
movupd (%rdx,%rcx,8),%xmm7
mulpd  %xmm5,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm0,%xmm7
movupd %xmm7,0x0(%rbp,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    2240 <rkck+0x1130>
cmp    %r13,%rax
jne    2056 <rkck+0xf46>
jmp    2111 <rkck+0x1001>
mov    0x8(%rsp),%r10
jmp    1a7c <rkck+0x96c>
mov    0x8(%rsp),%r10
mov    0x28(%rsp),%r11
jmp    1f97 <rkck+0xe87>
mov    0x8(%rsp),%r10
jmp    2056 <rkck+0xf46>

LLVM IR (-O0):
@rkck.a2 = internal global double 2.000000e-01
@rkck.a3 = internal global double 3.000000e-01
@rkck.a4 = internal global double 6.000000e-01
@rkck.a5 = internal global double 1.000000e+00
@rkck.a6 = internal global double 8.750000e-01
@rkck.b21 = internal global double 2.000000e-01
@rkck.b31 = internal global double 0x3FB3333333333333
@rkck.b32 = internal global double 2.250000e-01
@rkck.b41 = internal global double 3.000000e-01
@rkck.b42 = internal global double -9.000000e-01
@rkck.b43 = internal global double 1.200000e+00
@rkck.b51 = internal global double 0xBFCA12F684BDA12F
@rkck.b52 = internal global double 2.500000e+00
@rkck.b53 = internal global double 0xC004BDA12F684BDA
@rkck.b54 = internal global double 0x3FF4BDA12F684BDA
@rkck.b61 = internal global double 0x3F9E3425ED097B42
@rkck.b62 = internal global double 0x3FD5E00000000000
@rkck.b63 = internal global double 0x3FA54BDA12F684BE
@rkck.b64 = internal global double 0x3FD99F425ED097B4
@rkck.b65 = internal global double 0x3FAFA00000000000
@rkck.c1 = internal global double 0x3FB90EE643B990EE
@rkck.c3 = internal global double 0x3FD9C3D02E2BB280
@rkck.c4 = internal global double 0x3FCAEF9F76166929
@rkck.c6 = internal global double 0x3FD280A685DAB4B0
@rkck.dc5 = internal global double 0xBF93C92492492492
define void @rkck(double* %0, double* %1, i32 %2, double %3, double %4, double* %5, double* %6, double* %7) {
%9 = alloca double*
%10 = alloca double*
%11 = alloca i32
%12 = alloca double
%13 = alloca double
%14 = alloca double*
%15 = alloca double*
%16 = alloca double*
%17 = alloca i32
%18 = alloca double
%19 = alloca double
%20 = alloca double
%21 = alloca double
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
store double* %0, double** %9
store double* %1, double** %10
store i32 %2, i32* %11
store double %3, double* %12
store double %4, double* %13
store double* %5, double** %14
store double* %6, double** %15
store double* %7, double** %16
%28 = load double, double* @rkck.c1
%29 = fsub double %28, 0x3FBA284BDA12F685
store double %29, double* %18
%30 = load double, double* @rkck.c3
%31 = fsub double %30, 0x3FD891F2747C9D1F
store double %31, double* %19
%32 = load double, double* @rkck.c4
%33 = fsub double %32, 0x3FCF4ED097B425ED
store double %33, double* %20
%34 = load double, double* @rkck.c6
%35 = fsub double %34, 2.500000e-01
store double %35, double* %21
%36 = load double*, double** %16
store double* %36, double** %22
%37 = load double*, double** %16
%38 = load i32, i32* %11
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %37, i64 %39
store double* %40, double** %23
%41 = load double*, double** %23
%42 = load i32, i32* %11
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds double, double* %41, i64 %43
store double* %44, double** %24
%45 = load double*, double** %24
%46 = load i32, i32* %11
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %45, i64 %47
store double* %48, double** %25
%49 = load double*, double** %25
%50 = load i32, i32* %11
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds double, double* %49, i64 %51
store double* %52, double** %26
%53 = load double*, double** %26
%54 = load i32, i32* %11
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double, double* %53, i64 %55
store double* %56, double** %27
store i32 0, i32* %17
br label %57
57: ; preds = %80, %8
%58 = load i32, i32* %17
%59 = load i32, i32* %11
%60 = icmp slt i32 %58, %59
br i1 %60, label %61, label %83
61: ; preds = %57
%62 = load double*, double** %9
%63 = load i32, i32* %17
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds double, double* %62, i64 %64
%66 = load double, double* %65
%67 = load double, double* @rkck.b21
%68 = load double, double* %13
%69 = fmul double %67, %68
%70 = load double*, double** %10
%71 = load i32, i32* %17
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds double, double* %70, i64 %72
%74 = load double, double* %73
%75 = call double @llvm.fmuladd.f64(double %69, double %74, double %66)
%76 = load double*, double** %27
%77 = load i32, i32* %17
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds double, double* %76, i64 %78
store double %75, double* %79
br label %80
80: ; preds = %61
%81 = load i32, i32* %17
%82 = add nsw i32 %81, 1
store i32 %82, i32* %17
br label %57
83: ; preds = %57
%84 = load double, double* %12
%85 = load double, double* @rkck.a2
%86 = load double, double* %13
%87 = call double @llvm.fmuladd.f64(double %85, double %86, double %84)
%88 = load double*, double** %27
%89 = load double*, double** %22
%90 = load i32, i32* %11
%91 = call i32 @my_rhs(double %87, double* %88, double* %89, i32 %90)
store i32 0, i32* %17
br label %92
92: ; preds = %122, %83
%93 = load i32, i32* %17
%94 = load i32, i32* %11
%95 = icmp slt i32 %93, %94
br i1 %95, label %96, label %125
96: ; preds = %92
%97 = load double*, double** %9
%98 = load i32, i32* %17
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds double, double* %97, i64 %99
%101 = load double, double* %100
%102 = load double, double* %13
%103 = load double, double* @rkck.b31
%104 = load double*, double** %10
%105 = load i32, i32* %17
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %104, i64 %106
%108 = load double, double* %107
%109 = load double, double* @rkck.b32
%110 = load double*, double** %22
%111 = load i32, i32* %17
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %110, i64 %112
%114 = load double, double* %113
%115 = fmul double %109, %114
%116 = call double @llvm.fmuladd.f64(double %103, double %108, double %115)
%117 = call double @llvm.fmuladd.f64(double %102, double %116, double %101)
%118 = load double*, double** %27
%119 = load i32, i32* %17
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
store double %117, double* %121
br label %122
122: ; preds = %96
%123 = load i32, i32* %17
%124 = add nsw i32 %123, 1
store i32 %124, i32* %17
br label %92
125: ; preds = %92
%126 = load double, double* %12
%127 = load double, double* @rkck.a3
%128 = load double, double* %13
%129 = call double @llvm.fmuladd.f64(double %127, double %128, double %126)
%130 = load double*, double** %27
%131 = load double*, double** %23
%132 = load i32, i32* %11
%133 = call i32 @my_rhs(double %129, double* %130, double* %131, i32 %132)
store i32 0, i32* %17
br label %134
134: ; preds = %171, %125
%135 = load i32, i32* %17
%136 = load i32, i32* %11
%137 = icmp slt i32 %135, %136
br i1 %137, label %138, label %174
138: ; preds = %134
%139 = load double*, double** %9
%140 = load i32, i32* %17
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double, double* %139, i64 %141
%143 = load double, double* %142
%144 = load double, double* %13
%145 = load double, double* @rkck.b41
%146 = load double*, double** %10
%147 = load i32, i32* %17
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
%150 = load double, double* %149
%151 = load double, double* @rkck.b42
%152 = load double*, double** %22
%153 = load i32, i32* %17
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds double, double* %152, i64 %154
%156 = load double, double* %155
%157 = fmul double %151, %156
%158 = call double @llvm.fmuladd.f64(double %145, double %150, double %157)
%159 = load double, double* @rkck.b43
%160 = load double*, double** %23
%161 = load i32, i32* %17
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds double, double* %160, i64 %162
%164 = load double, double* %163
%165 = call double @llvm.fmuladd.f64(double %159, double %164, double %158)
%166 = call double @llvm.fmuladd.f64(double %144, double %165, double %143)
%167 = load double*, double** %27
%168 = load i32, i32* %17
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds double, double* %167, i64 %169
store double %166, double* %170
br label %171
171: ; preds = %138
%172 = load i32, i32* %17
%173 = add nsw i32 %172, 1
store i32 %173, i32* %17
br label %134
174: ; preds = %134
%175 = load double, double* %12
%176 = load double, double* @rkck.a4
%177 = load double, double* %13
%178 = call double @llvm.fmuladd.f64(double %176, double %177, double %175)
%179 = load double*, double** %27
%180 = load double*, double** %24
%181 = load i32, i32* %11
%182 = call i32 @my_rhs(double %178, double* %179, double* %180, i32 %181)
store i32 0, i32* %17
br label %183
183: ; preds = %227, %174
%184 = load i32, i32* %17
%185 = load i32, i32* %11
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %230
187: ; preds = %183
%188 = load double*, double** %9
%189 = load i32, i32* %17
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %188, i64 %190
%192 = load double, double* %191
%193 = load double, double* %13
%194 = load double, double* @rkck.b51
%195 = load double*, double** %10
%196 = load i32, i32* %17
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds double, double* %195, i64 %197
%199 = load double, double* %198
%200 = load double, double* @rkck.b52
%201 = load double*, double** %22
%202 = load i32, i32* %17
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %201, i64 %203
%205 = load double, double* %204
%206 = fmul double %200, %205
%207 = call double @llvm.fmuladd.f64(double %194, double %199, double %206)
%208 = load double, double* @rkck.b53
%209 = load double*, double** %23
%210 = load i32, i32* %17
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds double, double* %209, i64 %211
%213 = load double, double* %212
%214 = call double @llvm.fmuladd.f64(double %208, double %213, double %207)
%215 = load double, double* @rkck.b54
%216 = load double*, double** %24
%217 = load i32, i32* %17
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds double, double* %216, i64 %218
%220 = load double, double* %219
%221 = call double @llvm.fmuladd.f64(double %215, double %220, double %214)
%222 = call double @llvm.fmuladd.f64(double %193, double %221, double %192)
%223 = load double*, double** %27
%224 = load i32, i32* %17
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double, double* %223, i64 %225
store double %222, double* %226
br label %227
227: ; preds = %187
%228 = load i32, i32* %17
%229 = add nsw i32 %228, 1
store i32 %229, i32* %17
br label %183
230: ; preds = %183
%231 = load double, double* %12
%232 = load double, double* @rkck.a5
%233 = load double, double* %13
%234 = call double @llvm.fmuladd.f64(double %232, double %233, double %231)
%235 = load double*, double** %27
%236 = load double*, double** %25
%237 = load i32, i32* %11
%238 = call i32 @my_rhs(double %234, double* %235, double* %236, i32 %237)
store i32 0, i32* %17
br label %239
239: ; preds = %290, %230
%240 = load i32, i32* %17
%241 = load i32, i32* %11
%242 = icmp slt i32 %240, %241
br i1 %242, label %243, label %293
243: ; preds = %239
%244 = load double*, double** %9
%245 = load i32, i32* %17
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds double, double* %244, i64 %246
%248 = load double, double* %247
%249 = load double, double* %13
%250 = load double, double* @rkck.b61
%251 = load double*, double** %10
%252 = load i32, i32* %17
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds double, double* %251, i64 %253
%255 = load double, double* %254
%256 = load double, double* @rkck.b62
%257 = load double*, double** %22
%258 = load i32, i32* %17
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double, double* %257, i64 %259
%261 = load double, double* %260
%262 = fmul double %256, %261
%263 = call double @llvm.fmuladd.f64(double %250, double %255, double %262)
%264 = load double, double* @rkck.b63
%265 = load double*, double** %23
%266 = load i32, i32* %17
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds double, double* %265, i64 %267
%269 = load double, double* %268
%270 = call double @llvm.fmuladd.f64(double %264, double %269, double %263)
%271 = load double, double* @rkck.b64
%272 = load double*, double** %24
%273 = load i32, i32* %17
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds double, double* %272, i64 %274
%276 = load double, double* %275
%277 = call double @llvm.fmuladd.f64(double %271, double %276, double %270)
%278 = load double, double* @rkck.b65
%279 = load double*, double** %25
%280 = load i32, i32* %17
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds double, double* %279, i64 %281
%283 = load double, double* %282
%284 = call double @llvm.fmuladd.f64(double %278, double %283, double %277)
%285 = call double @llvm.fmuladd.f64(double %249, double %284, double %248)
%286 = load double*, double** %27
%287 = load i32, i32* %17
%288 = sext i32 %287 to i64
%289 = getelementptr inbounds double, double* %286, i64 %288
store double %285, double* %289
br label %290
290: ; preds = %243
%291 = load i32, i32* %17
%292 = add nsw i32 %291, 1
store i32 %292, i32* %17
br label %239
293: ; preds = %239
%294 = load double, double* %12
%295 = load double, double* @rkck.a6
%296 = load double, double* %13
%297 = call double @llvm.fmuladd.f64(double %295, double %296, double %294)
%298 = load double*, double** %27
%299 = load double*, double** %26
%300 = load i32, i32* %11
%301 = call i32 @my_rhs(double %297, double* %298, double* %299, i32 %300)
store i32 0, i32* %17
br label %302
302: ; preds = %346, %293
%303 = load i32, i32* %17
%304 = load i32, i32* %11
%305 = icmp slt i32 %303, %304
br i1 %305, label %306, label %349
306: ; preds = %302
%307 = load double*, double** %9
%308 = load i32, i32* %17
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %307, i64 %309
%311 = load double, double* %310
%312 = load double, double* %13
%313 = load double, double* @rkck.c1
%314 = load double*, double** %10
%315 = load i32, i32* %17
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %314, i64 %316
%318 = load double, double* %317
%319 = load double, double* @rkck.c3
%320 = load double*, double** %23
%321 = load i32, i32* %17
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds double, double* %320, i64 %322
%324 = load double, double* %323
%325 = fmul double %319, %324
%326 = call double @llvm.fmuladd.f64(double %313, double %318, double %325)
%327 = load double, double* @rkck.c4
%328 = load double*, double** %24
%329 = load i32, i32* %17
%330 = sext i32 %329 to i64
%331 = getelementptr inbounds double, double* %328, i64 %330
%332 = load double, double* %331
%333 = call double @llvm.fmuladd.f64(double %327, double %332, double %326)
%334 = load double, double* @rkck.c6
%335 = load double*, double** %26
%336 = load i32, i32* %17
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds double, double* %335, i64 %337
%339 = load double, double* %338
%340 = call double @llvm.fmuladd.f64(double %334, double %339, double %333)
%341 = call double @llvm.fmuladd.f64(double %312, double %340, double %311)
%342 = load double*, double** %14
%343 = load i32, i32* %17
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %342, i64 %344
store double %341, double* %345
br label %346
346: ; preds = %306
%347 = load i32, i32* %17
%348 = add nsw i32 %347, 1
store i32 %348, i32* %17
br label %302
349: ; preds = %302
store i32 0, i32* %17
br label %350
350: ; preds = %396, %349
%351 = load i32, i32* %17
%352 = load i32, i32* %11
%353 = icmp slt i32 %351, %352
br i1 %353, label %354, label %399
354: ; preds = %350
%355 = load double, double* %13
%356 = load double, double* %18
%357 = load double*, double** %10
%358 = load i32, i32* %17
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds double, double* %357, i64 %359
%361 = load double, double* %360
%362 = load double, double* %19
%363 = load double*, double** %23
%364 = load i32, i32* %17
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds double, double* %363, i64 %365
%367 = load double, double* %366
%368 = fmul double %362, %367
%369 = call double @llvm.fmuladd.f64(double %356, double %361, double %368)
%370 = load double, double* %20
%371 = load double*, double** %24
%372 = load i32, i32* %17
%373 = sext i32 %372 to i64
%374 = getelementptr inbounds double, double* %371, i64 %373
%375 = load double, double* %374
%376 = call double @llvm.fmuladd.f64(double %370, double %375, double %369)
%377 = load double, double* @rkck.dc5
%378 = load double*, double** %25
%379 = load i32, i32* %17
%380 = sext i32 %379 to i64
%381 = getelementptr inbounds double, double* %378, i64 %380
%382 = load double, double* %381
%383 = call double @llvm.fmuladd.f64(double %377, double %382, double %376)
%384 = load double, double* %21
%385 = load double*, double** %26
%386 = load i32, i32* %17
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds double, double* %385, i64 %387
%389 = load double, double* %388
%390 = call double @llvm.fmuladd.f64(double %384, double %389, double %383)
%391 = fmul double %355, %390
%392 = load double*, double** %15
%393 = load i32, i32* %17
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds double, double* %392, i64 %394
store double %391, double* %395
br label %396
396: ; preds = %354
%397 = load i32, i32* %17
%398 = add nsw i32 %397, 1
store i32 %398, i32* %17
br label %350
399: ; preds = %350
ret void
}

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