void rkck(y, dydx, n, x, h, yout, yerr, derivs) float dydx[], h, x, y[], yerr[],
    yout[];
int n;
void (*derivs)();
{
  int i;
  static float 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.0 / 14336.0;
  float dc1 = c1 - 2825.0 / 27648.0, dc3 = c3 - 18575.0 / 48384.0,
        dc4 = c4 - 13525.0 / 55296.0, dc6 = c6 - 0.25;
  float *ak2, *ak3, *ak4, *ak5, *ak6, *ytemp;
  ak2 = vector(1, n);
  ak3 = vector(1, n);
  ak4 = vector(1, n);
  ak5 = vector(1, n);
  ak6 = vector(1, n);
  ytemp = vector(1, n);
  for (i = 1; i <= n; i++)
    ytemp[i] = y[i] + b21 * h * dydx[i];
  (*derivs)(x + a2 * h, ytemp, ak2);
  for (i = 1; i <= n; i++)
    ytemp[i] = y[i] + h * (b31 * dydx[i] + b32 * ak2[i]);
  (*derivs)(x + a3 * h, ytemp, ak3);
  for (i = 1; i <= n; i++)
    ytemp[i] = y[i] + h * (b41 * dydx[i] + b42 * ak2[i] + b43 * ak3[i]);
  (*derivs)(x + a4 * h, ytemp, ak4);
  for (i = 1; i <= n; i++)
    ytemp[i] =
        y[i] + h * (b51 * dydx[i] + b52 * ak2[i] + b53 * ak3[i] + b54 * ak4[i]);
  (*derivs)(x + a5 * h, ytemp, ak5);
  for (i = 1; i <= n; i++)
    ytemp[i] = y[i] + h * (b61 * dydx[i] + b62 * ak2[i] + b63 * ak3[i] +
                           b64 * ak4[i] + b65 * ak5[i]);
  (*derivs)(x + a6 * h, ytemp, ak6);
  for (i = 1; i <= n; i++)
    yout[i] =
        y[i] + h * (c1 * dydx[i] + c3 * ak3[i] + c4 * ak4[i] + c6 * ak6[i]);
  for (i = 1; i <= n; i++)
    yerr[i] = h * (dc1 * dydx[i] + dc3 * ak3[i] + dc4 * ak4[i] + dc5 * ak5[i] +
                   dc6 * ak6[i]);
  free_vector(ytemp, 1, n);
  free_vector(ak6, 1, n);
  free_vector(ak5, 1, n);
  free_vector(ak4, 1, n);
  free_vector(ak3, 1, n);
  free_vector(ak2, 1, n);
}


x86 assembly (clang, -O0):
<rkck>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movsd  %xmm1,-0x88(%rbp)
ff
movaps %xmm0,%xmm1
movsd  -0x88(%rbp),%xmm0
ff
cvtsd2ss %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm0
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm1,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movss  0x2f11(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe9d(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0x2ef4(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe74(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0x2ed7(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe4b(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0x2eba(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe22(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <vector@plt>
cltq
mov    %rax,-0x58(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <vector@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <vector@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <vector@plt>
cltq
mov    %rax,-0x70(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <vector@plt>
cltq
mov    %rax,-0x78(%rbp)
mov    -0x14(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1040 <vector@plt>
cltq
mov    %rax,-0x80(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12c6 <rkck+0x1a6>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x2db3(%rip),%xmm0
mulss  -0x1c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1270 <rkck+0x150>
mov    -0x38(%rbp),%rcx
movss  -0x18(%rbp),%xmm1
movss  0x2d59(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    $0x1,%al
call   *%rcx
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     136e <rkck+0x24e>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2d27(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2d16(%rip),%xmm3
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12fb <rkck+0x1db>
mov    -0x38(%rbp),%rcx
movss  -0x18(%rbp),%xmm1
movss  0x2cb5(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    $0x1,%al
call   *%rcx
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1433 <rkck+0x313>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2c87(%rip),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2c76(%rip),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2c5d(%rip),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13a3 <rkck+0x283>
mov    -0x38(%rbp),%rcx
movss  -0x18(%rbp),%xmm1
movss  0x2bf4(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x68(%rbp),%rsi
mov    $0x1,%al
call   *%rcx
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1515 <rkck+0x3f5>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2bce(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2bbd(%rip),%xmm3
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0x2ba4(%rip),%xmm3
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2b8b(%rip),%xmm2
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1468 <rkck+0x348>
mov    -0x38(%rbp),%rcx
movss  -0x18(%rbp),%xmm1
movss  0x2b16(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    $0x1,%al
call   *%rcx
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1614 <rkck+0x4f4>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2afc(%rip),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2aeb(%rip),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2ad2(%rip),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0x2ab9(%rip),%xmm3
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2aa0(%rip),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    154a <rkck+0x42a>
mov    -0x38(%rbp),%rcx
movss  -0x18(%rbp),%xmm1
movss  0x2a1b(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    $0x1,%al
call   *%rcx
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     16f6 <rkck+0x5d6>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2a11(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2a00(%rip),%xmm3
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0x29e7(%rip),%xmm3
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x29ce(%rip),%xmm2
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1649 <rkck+0x529>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     17aa <rkck+0x68a>
movss  -0x1c(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
movss  -0x44(%rbp),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x48(%rbp),%xmm1
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
movss  0x2934(%rip),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
movss  -0x4c(%rbp),%xmm1
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
mulss  %xmm3,%xmm1
addss  %xmm2,%xmm1
mulss  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    16fd <rkck+0x5dd>
mov    -0x80(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_vector@plt>
mov    -0x78(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_vector@plt>
mov    -0x70(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_vector@plt>
mov    -0x68(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_vector@plt>
mov    -0x60(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    -0x14(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1030 <free_vector@plt>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rkck>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,0x88(%rsp)
mov    %rcx,0x58(%rsp)
mov    %edx,%ebx
mov    %rsi,%r12
mov    %rdi,%r14
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x8(%rsp)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movaps %xmm0,0x60(%rsp)
mov    $0x1,%edi
mov    %edx,%esi
xor    %eax,%eax
call   1040 <vector@plt>
movslq %eax,%r15
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <vector@plt>
mov    %eax,%ebp
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <vector@plt>
mov    %eax,0x10(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <vector@plt>
mov    %eax,0x28(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <vector@plt>
mov    %eax,0x38(%rsp)
mov    $0x1,%edi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <vector@plt>
movaps 0x60(%rsp),%xmm6
movslq %eax,%r13
mov    %ebx,%r10d
test   %ebx,%ebx
mov    %ebx,0x24(%rsp)
jle    139f <rkck+0x27f>
movss  0x1e1b(%rip),%xmm0
mulss  %xmm6,%xmm0
lea    0x1(%r10),%rax
mov    $0x1,%ecx
cmp    $0x8,%ebx
jae    126e <rkck+0x14e>
mov    %rcx,%rdx
not    %rdx
test   $0x1,%al
jne    121c <rkck+0xfc>
movss  (%r12,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r14,%rcx,4),%xmm1
movss  %xmm1,0x0(%r13,%rcx,4)
add    $0x1,%rcx
add    %rax,%rdx
je     139f <rkck+0x27f>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r12,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r14,%rcx,4),%xmm1
movss  %xmm1,0x0(%r13,%rcx,4)
movss  0x4(%r12,%rcx,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%r14,%rcx,4),%xmm1
movss  %xmm1,0x4(%r13,%rcx,4)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1230 <rkck+0x110>
jmp    139f <rkck+0x27f>
mov    %ebp,%r11d
lea    0x4(%r13),%rdx
lea    0x0(,%rax,4),%rsi
add    %r13,%rsi
lea    0x4(%r14),%rdi
lea    (%r14,%rax,4),%rbx
lea    0x4(%r12),%r8
lea    (%r12,%rax,4),%rbp
cmp    %rbx,%rdx
setb   %r9b
cmp    %rsi,%rdi
setb   %bl
cmp    %rbp,%rdx
setb   %dl
cmp    %rsi,%r8
setb   %sil
test   %bl,%r9b
jne    1a09 <rkck+0x8e9>
and    %sil,%dl
mov    %r11d,%ebp
jne    11f7 <rkck+0xd7>
mov    %r10d,%ecx
and    $0xfffffff8,%ecx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     1a1a <rkck+0x8fa>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
xchg   %ax,%ax
movups 0x4(%r14,%rdx,4),%xmm2
movups 0x14(%r14,%rdx,4),%xmm3
movups 0x4(%r12,%rdx,4),%xmm4
movups 0x14(%r12,%rdx,4),%xmm5
mulps  %xmm1,%xmm4
addps  %xmm2,%xmm4
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,0x4(%r13,%rdx,4)
movups %xmm5,0x14(%r13,%rdx,4)
movups 0x24(%r14,%rdx,4),%xmm2
movups 0x34(%r14,%rdx,4),%xmm3
movups 0x24(%r12,%rdx,4),%xmm4
movups 0x34(%r12,%rdx,4),%xmm5
mulps  %xmm1,%xmm4
addps  %xmm2,%xmm4
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,0x24(%r13,%rdx,4)
movups %xmm5,0x34(%r13,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    12f0 <rkck+0x1d0>
test   $0x1,%sil
je     1396 <rkck+0x276>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%r14,%rdx,1),%xmm2
movups 0x10(%r14,%rdx,1),%xmm3
movups (%r12,%rdx,1),%xmm4
movups 0x10(%r12,%rdx,1),%xmm5
mulps  %xmm1,%xmm4
addps  %xmm2,%xmm4
mulps  %xmm1,%xmm5
addps  %xmm3,%xmm5
movups %xmm4,0x0(%r13,%rdx,1)
movups %xmm5,0x10(%r13,%rdx,1)
cmp    %rcx,%r10
jne    1a11 <rkck+0x8f1>
mov    %r10,0x50(%rsp)
movslq %ebp,%rbp
movslq 0x10(%rsp),%rax
mov    %rax,0x18(%rsp)
movslq 0x28(%rsp),%rax
mov    %rax,0x40(%rsp)
movslq 0x38(%rsp),%rax
mov    %rax,0x28(%rsp)
movss  0x1c33(%rip),%xmm0
mulss  %xmm6,%xmm0
addss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    %r15,%rsi
mov    $0x1,%al
mov    0x48(%rsp),%rbx
call   *%rbx
mov    0x24(%rsp),%ecx
test   %ecx,%ecx
mov    %rbp,0x10(%rsp)
jle    14e5 <rkck+0x3c5>
movaps 0x60(%rsp),%xmm9
mov    0x50(%rsp),%rax
lea    0x1(%rax),%rbp
mov    $0x1,%eax
cmp    $0x8,%ecx
jae    151d <rkck+0x3fd>
mov    0x10(%rsp),%rsi
movss  0x8(%rsp),%xmm10
mov    %rax,%rcx
not    %rcx
test   $0x1,%bpl
jne    1466 <rkck+0x346>
movss  (%r12,%rax,4),%xmm0
movss  (%r15,%rax,4),%xmm1
mulss  0x1bc0(%rip),%xmm1
mulss  0x1bbc(%rip),%xmm0
addss  %xmm1,%xmm0
mulss  %xmm9,%xmm0
addss  (%r14,%rax,4),%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
add    $0x1,%rax
add    %rbp,%rcx
je     1622 <rkck+0x502>
movss  0x1b8d(%rip),%xmm0
movss  0x1b89(%rip),%xmm1
nop
movss  (%r15,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  (%r12,%rax,4),%xmm3
mulss  %xmm1,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm9,%xmm3
addss  (%r14,%rax,4),%xmm3
movss  %xmm3,0x0(%r13,%rax,4)
movss  0x4(%r15,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  0x4(%r12,%rax,4),%xmm3
mulss  %xmm1,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm9,%xmm3
addss  0x4(%r14,%rax,4),%xmm3
movss  %xmm3,0x4(%r13,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbp
jne    1480 <rkck+0x360>
jmp    1622 <rkck+0x502>
movss  0x1b1f(%rip),%xmm0
mulss  0x60(%rsp),%xmm0
addss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    %rbp,%rsi
mov    $0x1,%al
call   *%rbx
movaps 0x60(%rsp),%xmm7
mov    0x18(%rsp),%rsi
movss  0x8(%rsp),%xmm8
jmp    16cf <rkck+0x5af>
lea    0x4(%r13),%rdx
lea    0x0(,%rbp,4),%rsi
add    %r13,%rsi
lea    0x4(%r14),%rcx
lea    (%r14,%rbp,4),%rdi
lea    0x4(%r12),%r8
lea    (%r12,%rbp,4),%rbx
lea    0x4(%r15),%r9
lea    (%r15,%rbp,4),%r10
cmp    %rdi,%rdx
setb   %dil
cmp    %rsi,%rcx
setb   %r11b
cmp    %rbx,%rdx
setb   %cl
cmp    %rsi,%r8
setb   %bl
cmp    %r10,%rdx
setb   %dl
cmp    %rsi,%r9
setb   %r8b
test   %r11b,%dil
jne    1418 <rkck+0x2f8>
and    %bl,%cl
mov    0x10(%rsp),%rsi
movss  0x8(%rsp),%xmm10
jne    1424 <rkck+0x304>
and    %r8b,%dl
mov    0x50(%rsp),%rdi
jne    1424 <rkck+0x304>
mov    %edi,%ecx
and    $0xfffffff8,%ecx
lea    0x1(%rcx),%rax
movaps %xmm9,%xmm0
shufps $0x0,%xmm9,%xmm0
xor    %edx,%edx
movaps 0x1abd(%rip),%xmm8
movaps 0x1ac6(%rip),%xmm2
nopw   0x0(%rax,%rax,1)
movups 0x4(%r14,%rdx,4),%xmm3
movups 0x14(%r14,%rdx,4),%xmm4
movups 0x4(%r12,%rdx,4),%xmm5
movups 0x14(%r12,%rdx,4),%xmm6
movups 0x4(%r15,%rdx,4),%xmm7
movups 0x14(%r15,%rdx,4),%xmm1
mulps  %xmm8,%xmm7
mulps  %xmm8,%xmm1
mulps  %xmm2,%xmm5
addps  %xmm7,%xmm5
mulps  %xmm2,%xmm6
addps  %xmm1,%xmm6
mulps  %xmm0,%xmm5
addps  %xmm3,%xmm5
mulps  %xmm0,%xmm6
addps  %xmm4,%xmm6
movups %xmm5,0x4(%r13,%rdx,4)
movups %xmm6,0x14(%r13,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%rcx
jne    15c0 <rkck+0x4a0>
cmp    %rcx,%rdi
jne    1424 <rkck+0x304>
movss  0x19e2(%rip),%xmm0
mulss  %xmm9,%xmm0
addss  %xmm10,%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    $0x1,%al
mov    0x48(%rsp),%rbx
call   *%rbx
cmpl   $0x0,0x24(%rsp)
jle    1894 <rkck+0x774>
lea    -0x1(%rbp),%rcx
mov    $0x1,%eax
cmp    $0x4,%rcx
movaps 0x60(%rsp),%xmm7
movss  0x8(%rsp),%xmm8
jae    18eb <rkck+0x7cb>
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rsi
movss  0x1990(%rip),%xmm0
movss  0x1984(%rip),%xmm1
movss  0x1984(%rip),%xmm2
movss  (%r15,%rax,4),%xmm3
mulss  %xmm0,%xmm3
movss  (%r12,%rax,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm3,%xmm4
movss  (%rdi,%rax,4),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm7,%xmm3
addss  (%r14,%rax,4),%xmm3
movss  %xmm3,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1690 <rkck+0x570>
movss  0x1941(%rip),%xmm0
mulss  %xmm7,%xmm0
addss  %xmm8,%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    $0x1,%al
mov    0x48(%rsp),%rbx
call   *%rbx
mov    0x24(%rsp),%ecx
test   %ecx,%ecx
jle    18b8 <rkck+0x798>
mov    0x50(%rsp),%rax
lea    0x1(%rax),%r11
mov    $0x1,%r8d
cmp    $0x4,%ecx
movaps 0x60(%rsp),%xmm8
movss  0x8(%rsp),%xmm9
mov    %r11,0x38(%rsp)
jae    1736 <rkck+0x616>
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rdx
mov    0x40(%rsp),%rsi
jmp    1a3c <rkck+0x91c>
lea    0x4(%r13),%rbp
lea    0x0(,%r11,4),%rdi
add    %r13,%rdi
lea    0x4(%r14),%rax
lea    (%r14,%r11,4),%rcx
lea    0x4(%r12),%rdx
lea    (%r12,%r11,4),%rsi
lea    0x4(%r15),%rbx
cmp    %rcx,%rbp
setb   0x80(%rsp)
cmp    %rdi,%rax
lea    (%r15,%r11,4),%rcx
setb   %r9b
cmp    %rsi,%rbp
setb   %al
cmp    %rdi,%rdx
mov    0x10(%rsp),%rdx
lea    0x4(%rdx),%r11
setb   %sil
cmp    %rcx,%rbp
setb   %cl
cmp    %rdi,%rbx
mov    0x38(%rsp),%rbx
lea    (%rdx,%rbx,4),%rdx
setb   0xf(%rsp)
cmp    %rdx,%rbp
setb   %r10b
cmp    %rdi,%r11
mov    0x38(%rsp),%r11
mov    0x18(%rsp),%rdx
lea    (%rdx,%r11,4),%rbx
setb   0x78(%rsp)
cmp    %rbx,%rbp
lea    0x4(%rdx),%rbp
setb   %bl
cmp    %rdi,%rbp
setb   %dil
test   %r9b,0x80(%rsp)
jne    1a32 <rkck+0x912>
and    %sil,%al
jne    1a32 <rkck+0x912>
and    0xf(%rsp),%cl
mov    0x40(%rsp),%rsi
jne    1a2b <rkck+0x90b>
and    0x78(%rsp),%r10b
jne    1a2b <rkck+0x90b>
and    %dil,%bl
mov    0x10(%rsp),%rdi
jne    1a3c <rkck+0x91c>
mov    0x50(%rsp),%rbp
mov    %ebp,%ecx
and    $0xfffffffc,%ecx
lea    0x1(%rcx),%r8
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
xor    %eax,%eax
movaps 0x1896(%rip),%xmm1
movaps 0x189f(%rip),%xmm2
movaps 0x18a8(%rip),%xmm3
movaps 0x18b1(%rip),%xmm4
nop
movups 0x4(%r14,%rax,4),%xmm5
movups 0x4(%r12,%rax,4),%xmm6
movups 0x4(%r15,%rax,4),%xmm7
mulps  %xmm1,%xmm7
mulps  %xmm2,%xmm6
addps  %xmm7,%xmm6
movups 0x4(%rdi,%rax,4),%xmm7
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
movups 0x4(%rdx,%rax,4),%xmm6
mulps  %xmm4,%xmm6
addps  %xmm7,%xmm6
mulps  %xmm0,%xmm6
addps  %xmm5,%xmm6
movups %xmm6,0x4(%r13,%rax,4)
add    $0x4,%rax
cmp    %rax,%rcx
jne    1840 <rkck+0x720>
cmp    %rcx,%rbp
jne    1a3c <rkck+0x91c>
jmp    1adb <rkck+0x9bb>
movss  0x177c(%rip),%xmm0
mulss  0x60(%rsp),%xmm0
addss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    0x18(%rsp),%rsi
mov    $0x1,%al
call   *%rbx
movss  0x8(%rsp),%xmm0
addss  0x60(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    0x40(%rsp),%rsi
mov    $0x1,%al
call   *%rbx
movaps 0x60(%rsp),%xmm9
mov    0x28(%rsp),%rsi
movss  0x8(%rsp),%xmm10
jmp    1dd8 <rkck+0xcb8>
mov    %rcx,0x80(%rsp)
lea    0x4(%r13),%rcx
lea    0x0(,%rbp,4),%rdi
add    %r13,%rdi
lea    0x4(%r14),%rdx
lea    (%r14,%rbp,4),%rsi
lea    0x4(%r12),%r8
lea    (%r12,%rbp,4),%rbx
cmp    %rsi,%rcx
setb   %r11b
cmp    %rdi,%rdx
lea    0x4(%r15),%rsi
setb   %r9b
cmp    %rbx,%rcx
setb   %dl
cmp    %rdi,%r8
lea    (%r15,%rbp,4),%rbx
setb   %r10b
cmp    %rbx,%rcx
setb   %bl
cmp    %rdi,%rsi
mov    0x10(%rsp),%r8
lea    (%r8,%rbp,4),%rsi
setb   0x38(%rsp)
cmp    %rsi,%rcx
lea    0x4(%r8),%rsi
setb   %cl
cmp    %rdi,%rsi
setb   %r8b
test   %r9b,%r11b
jne    166e <rkck+0x54e>
and    %r10b,%dl
jne    166e <rkck+0x54e>
and    0x38(%rsp),%bl
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rsi
jne    1678 <rkck+0x558>
and    %r8b,%cl
jne    1678 <rkck+0x558>
mov    0x80(%rsp),%rbx
mov    %rbx,%rdx
and    $0xfffffffffffffffc,%rdx
lea    0x1(%rdx),%rax
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
xor    %ecx,%ecx
movaps 0x16e0(%rip),%xmm1
movaps 0x16e9(%rip),%xmm2
movaps 0x16f2(%rip),%xmm3
xchg   %ax,%ax
movups 0x4(%r14,%rcx,4),%xmm4
movups 0x4(%r12,%rcx,4),%xmm5
movups 0x4(%r15,%rcx,4),%xmm6
mulps  %xmm1,%xmm6
mulps  %xmm2,%xmm5
addps  %xmm6,%xmm5
movups 0x4(%rdi,%rcx,4),%xmm6
mulps  %xmm3,%xmm6
addps  %xmm5,%xmm6
mulps  %xmm0,%xmm6
addps  %xmm4,%xmm6
movups %xmm6,0x4(%r13,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    19c0 <rkck+0x8a0>
cmp    %rdx,%rbx
jne    1678 <rkck+0x558>
jmp    16cf <rkck+0x5af>
mov    %r11d,%ebp
jmp    11f7 <rkck+0xd7>
or     $0x1,%rcx
jmp    11f7 <rkck+0xd7>
xor    %edx,%edx
test   $0x1,%sil
jne    1360 <rkck+0x240>
jmp    1396 <rkck+0x276>
mov    0x10(%rsp),%rdi
jmp    1a3c <rkck+0x91c>
mov    0x10(%rsp),%rdi
mov    0x40(%rsp),%rsi
lea    0x0(,%r8,4),%r9
add    %r13,%r9
lea    (%rdx,%r8,4),%r10
lea    (%rdi,%r8,4),%rdx
lea    (%r15,%r8,4),%rdi
lea    (%r12,%r8,4),%rbp
lea    (%r14,%r8,4),%rbx
mov    %r11,%rax
sub    %r8,%rax
xor    %ecx,%ecx
movss  0x15b1(%rip),%xmm0
movss  0x15ad(%rip),%xmm1
movss  0x15a9(%rip),%xmm2
movss  0x15a5(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdi,%rcx,4),%xmm4
mulss  %xmm0,%xmm4
movss  0x0(%rbp,%rcx,4),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
movss  (%rdx,%rcx,4),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm5,%xmm4
movss  (%r10,%rcx,4),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm8,%xmm5
addss  (%rbx,%rcx,4),%xmm5
movss  %xmm5,(%r9,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1a90 <rkck+0x970>
movaps %xmm9,%xmm0
addss  %xmm8,%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    $0x1,%al
mov    0x48(%rsp),%rbx
call   *%rbx
cmpl   $0x0,0x24(%rsp)
jle    1b27 <rkck+0xa07>
mov    0x38(%rsp),%r11
lea    -0x1(%r11),%rax
mov    $0x1,%r8d
cmp    $0x4,%rax
movaps 0x60(%rsp),%xmm9
movss  0x8(%rsp),%xmm10
jae    1b4f <rkck+0xa2f>
mov    0x28(%rsp),%rsi
jmp    1d16 <rkck+0xbf6>
movaps 0x60(%rsp),%xmm0
mulss  0x150c(%rip),%xmm0
addss  0x8(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    0x28(%rsp),%rsi
mov    $0x1,%al
call   *%rbx
jmp    1fa1 <rkck+0xe81>
mov    %rax,0x90(%rsp)
lea    0x4(%r13),%rdx
lea    0x0(,%r11,4),%rax
add    %r13,%rax
lea    0x4(%r14),%rcx
lea    (%r14,%r11,4),%rsi
lea    0x4(%r12),%r10
lea    (%r12,%r11,4),%rbp
lea    0x4(%r15),%rdi
mov    %rdi,0x78(%rsp)
lea    (%r15,%r11,4),%rdi
cmp    %rsi,%rdx
setb   0x80(%rsp)
cmp    %rax,%rcx
mov    0x10(%rsp),%rcx
lea    0x4(%rcx),%r9
setb   0xf(%rsp)
cmp    %rbp,%rdx
setb   %bl
cmp    %rax,%r10
lea    (%rcx,%r11,4),%rbp
setb   0x37(%rsp)
cmp    %rdi,%rdx
setb   %cl
cmp    %rax,0x78(%rsp)
mov    0x18(%rsp),%rdi
lea    0x4(%rdi),%r10
setb   0x78(%rsp)
cmp    %rbp,%rdx
setb   %sil
cmp    %rax,%r9
lea    (%rdi,%r11,4),%rbp
setb   0x36(%rsp)
cmp    %rbp,%rdx
setb   %r9b
cmp    %rax,%r10
mov    0x40(%rsp),%rdi
lea    (%rdi,%r11,4),%rbp
setb   %r10b
cmp    %rbp,%rdx
lea    0x4(%rdi),%rbp
setb   %dl
cmp    %rax,%rbp
setb   %dil
mov    0xf(%rsp),%al
test   %al,0x80(%rsp)
jne    1d0c <rkck+0xbec>
and    0x37(%rsp),%bl
jne    1d0c <rkck+0xbec>
and    0x78(%rsp),%cl
jne    1d0c <rkck+0xbec>
and    0x36(%rsp),%sil
jne    1d0c <rkck+0xbec>
and    %r10b,%r9b
mov    0x28(%rsp),%rsi
mov    0x38(%rsp),%r11
jne    1d16 <rkck+0xbf6>
and    %dil,%dl
jne    1d16 <rkck+0xbf6>
mov    0x90(%rsp),%rbx
mov    %rbx,%rdx
and    $0xfffffffffffffffc,%rdx
lea    0x1(%rdx),%r8
movaps %xmm9,%xmm0
shufps $0x0,%xmm9,%xmm0
xor    %eax,%eax
movaps 0x1488(%rip),%xmm8
movaps 0x1491(%rip),%xmm2
movaps 0x149a(%rip),%xmm3
movaps 0x14a3(%rip),%xmm4
movaps 0x14ac(%rip),%xmm5
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%rbp
mov    0x40(%rsp),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x4(%r14,%rax,4),%xmm6
movups 0x4(%r12,%rax,4),%xmm7
movups 0x4(%r15,%rax,4),%xmm1
mulps  %xmm8,%xmm1
mulps  %xmm2,%xmm7
addps  %xmm1,%xmm7
movups 0x4(%rcx,%rax,4),%xmm1
mulps  %xmm3,%xmm1
addps  %xmm7,%xmm1
movups 0x4(%rbp,%rax,4),%xmm7
mulps  %xmm4,%xmm7
addps  %xmm1,%xmm7
movups 0x4(%rdi,%rax,4),%xmm1
mulps  %xmm5,%xmm1
addps  %xmm7,%xmm1
mulps  %xmm0,%xmm1
addps  %xmm6,%xmm1
movups %xmm1,0x4(%r13,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1cb0 <rkck+0xb90>
cmp    %rdx,%rbx
jne    1d16 <rkck+0xbf6>
jmp    1dd8 <rkck+0xcb8>
mov    0x28(%rsp),%rsi
mov    0x38(%rsp),%r11
lea    0x0(,%r8,4),%r9
add    %r13,%r9
mov    0x40(%rsp),%rax
lea    (%rax,%r8,4),%r10
mov    0x18(%rsp),%rax
lea    (%rax,%r8,4),%rdx
mov    0x10(%rsp),%rax
lea    (%rax,%r8,4),%rdi
lea    (%r15,%r8,4),%rbp
lea    (%r12,%r8,4),%rax
lea    (%r14,%r8,4),%rbx
sub    %r8,%r11
xor    %ecx,%ecx
movss  0x12d7(%rip),%xmm0
movss  0x12d3(%rip),%xmm1
movss  0x12cf(%rip),%xmm2
movss  0x12cb(%rip),%xmm3
movss  0x12c7(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nop
movss  0x0(%rbp,%rcx,4),%xmm5
mulss  %xmm0,%xmm5
movss  (%rax,%rcx,4),%xmm6
mulss  %xmm1,%xmm6
addss  %xmm5,%xmm6
movss  (%rdi,%rcx,4),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm6,%xmm5
movss  (%rdx,%rcx,4),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
movss  (%r10,%rcx,4),%xmm5
mulss  %xmm4,%xmm5
addss  %xmm6,%xmm5
mulss  %xmm9,%xmm5
addss  (%rbx,%rcx,4),%xmm5
movss  %xmm5,(%r9,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1d80 <rkck+0xc60>
movss  0x1260(%rip),%xmm0
mulss  %xmm9,%xmm0
addss  %xmm10,%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r13,%rdi
mov    $0x1,%al
call   *0x48(%rsp)
movaps 0x60(%rsp),%xmm8
cmpl   $0x0,0x24(%rsp)
jle    1fa1 <rkck+0xe81>
mov    0x50(%rsp),%rax
lea    0x1(%rax),%r9
mov    $0x1,%r8d
cmpl   $0x4,0x24(%rsp)
jae    2024 <rkck+0xf04>
mov    0x18(%rsp),%rbp
mov    0x28(%rsp),%rsi
mov    0x58(%rsp),%rdi
lea    (%rdi,%r8,4),%r10
lea    (%rsi,%r8,4),%rsi
lea    0x0(,%r8,4),%rdi
add    %rbp,%rdi
mov    0x10(%rsp),%rax
lea    (%rax,%r8,4),%rbp
lea    (%r12,%r8,4),%rbx
lea    (%r14,%r8,4),%rax
mov    %r9,%rcx
sub    %r8,%rcx
xor    %edx,%edx
movss  0x11df(%rip),%xmm0
movss  0x11db(%rip),%xmm1
movss  0x11d7(%rip),%xmm2
movss  0x11d3(%rip),%xmm3
nopl   (%rax)
movss  0x0(%rbp,%rdx,4),%xmm4
mulss  %xmm0,%xmm4
movss  (%rbx,%rdx,4),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
movss  (%rdi,%rdx,4),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm5,%xmm4
movss  (%rsi,%rdx,4),%xmm5
mulss  %xmm3,%xmm5
addss  %xmm4,%xmm5
mulss  %xmm8,%xmm5
addss  (%rax,%rdx,4),%xmm5
movss  %xmm5,(%r10,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1e80 <rkck+0xd60>
cmpl   $0x0,0x24(%rsp)
jle    1fa1 <rkck+0xe81>
lea    -0x1(%r9),%rax
mov    $0x1,%r8d
cmp    $0x4,%rax
jae    2182 <rkck+0x1062>
mov    0x88(%rsp),%rax
lea    (%rax,%r8,4),%rdx
mov    0x28(%rsp),%rax
lea    (%rax,%r8,4),%rsi
mov    0x40(%rsp),%rax
lea    (%rax,%r8,4),%rdi
mov    0x18(%rsp),%rax
lea    (%rax,%r8,4),%rbp
mov    0x10(%rsp),%rax
lea    (%rax,%r8,4),%rbx
lea    (%r12,%r8,4),%rcx
sub    %r8,%r9
xor    %eax,%eax
movss  0x112a(%rip),%xmm0
movss  0x1126(%rip),%xmm1
movss  0x1122(%rip),%xmm2
movss  0x111e(%rip),%xmm3
movss  0x111a(%rip),%xmm4
nopw   0x0(%rax,%rax,1)
movss  (%rbx,%rax,4),%xmm5
mulss  %xmm0,%xmm5
movss  (%rcx,%rax,4),%xmm6
mulss  %xmm1,%xmm6
addss  %xmm5,%xmm6
movss  0x0(%rbp,%rax,4),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm6,%xmm5
movss  (%rdi,%rax,4),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
movss  (%rsi,%rax,4),%xmm5
mulss  %xmm4,%xmm5
addss  %xmm6,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    1f50 <rkck+0xe30>
mov    %r13,%rdi
mov    $0x1,%esi
mov    0x24(%rsp),%ebx
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <free_vector@plt>
mov    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <free_vector@plt>
mov    0x40(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <free_vector@plt>
mov    0x18(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <free_vector@plt>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <free_vector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>
mov    0x58(%rsp),%rax
lea    0x4(%rax),%rbp
lea    (%rax,%r9,4),%rdi
lea    0x4(%r14),%rax
lea    (%r14,%r9,4),%rcx
lea    0x4(%r12),%r11
lea    (%r12,%r9,4),%rsi
mov    0x10(%rsp),%rdx
lea    0x4(%rdx),%rbx
cmp    %rcx,%rbp
setb   0x8(%rsp)
cmp    %rdi,%rax
lea    (%rdx,%r9,4),%rcx
setb   %r10b
cmp    %rsi,%rbp
setb   %al
cmp    %rdi,%r11
mov    0x18(%rsp),%rdx
lea    0x4(%rdx),%r11
setb   0x48(%rsp)
cmp    %rcx,%rbp
setb   %cl
cmp    %rdi,%rbx
lea    (%rdx,%r9,4),%rdx
setb   0x38(%rsp)
cmp    %rdx,%rbp
setb   %dl
cmp    %rdi,%r11
mov    0x28(%rsp),%rsi
lea    (%rsi,%r9,4),%rbx
setb   %r11b
cmp    %rbx,%rbp
lea    0x4(%rsi),%rbp
setb   %bl
cmp    %rdi,%rbp
setb   %dil
test   %r10b,0x8(%rsp)
jne    2304 <rkck+0x11e4>
and    0x48(%rsp),%al
mov    0x18(%rsp),%rbp
jne    1e2c <rkck+0xd0c>
and    0x38(%rsp),%cl
jne    1e2c <rkck+0xd0c>
and    %r11b,%dl
jne    1e2c <rkck+0xd0c>
and    %dil,%bl
mov    0x58(%rsp),%rdi
jne    1e31 <rkck+0xd11>
mov    0x50(%rsp),%rbx
mov    %ebx,%edx
and    $0xfffffffc,%edx
lea    0x1(%rdx),%r8
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
xor    %eax,%eax
movaps 0x1047(%rip),%xmm1
movaps 0x1050(%rip),%xmm2
movaps 0x1059(%rip),%xmm3
movaps 0x1062(%rip),%xmm4
mov    0x10(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x4(%r14,%rax,4),%xmm5
movups 0x4(%r12,%rax,4),%xmm6
movups 0x4(%rcx,%rax,4),%xmm7
mulps  %xmm1,%xmm7
mulps  %xmm2,%xmm6
addps  %xmm7,%xmm6
movups 0x4(%rbp,%rax,4),%xmm7
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
movups 0x4(%rsi,%rax,4),%xmm6
mulps  %xmm4,%xmm6
addps  %xmm7,%xmm6
mulps  %xmm0,%xmm6
addps  %xmm5,%xmm6
movups %xmm6,0x4(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%rdx
jne    2130 <rkck+0x1010>
cmp    %rdx,%rbx
jne    1e31 <rkck+0xd11>
jmp    1eca <rkck+0xdaa>
mov    %rax,0x50(%rsp)
mov    0x88(%rsp),%rax
lea    0x4(%rax),%rdx
lea    (%rax,%r9,4),%rbp
lea    0x4(%r12),%rax
lea    (%r12,%r9,4),%rcx
mov    0x10(%rsp),%rdi
lea    0x4(%rdi),%rsi
lea    (%rdi,%r9,4),%rbx
mov    0x18(%rsp),%rdi
lea    0x4(%rdi),%r14
cmp    %rcx,%rdx
setb   0x8(%rsp)
cmp    %rbp,%rax
lea    (%rdi,%r9,4),%rcx
setb   %r11b
cmp    %rbx,%rdx
setb   %al
cmp    %rbp,%rsi
mov    0x40(%rsp),%rdi
lea    0x4(%rdi),%r10
setb   %sil
cmp    %rcx,%rdx
setb   %cl
cmp    %rbp,%r14
lea    (%rdi,%r9,4),%rbx
setb   %r14b
cmp    %rbx,%rdx
setb   %bl
cmp    %rbp,%r10
mov    0x28(%rsp),%rdi
lea    (%rdi,%r9,4),%r10
setb   0x48(%rsp)
cmp    %r10,%rdx
lea    0x4(%rdi),%rdi
setb   %dl
cmp    %rbp,%rdi
setb   %bpl
test   %r11b,0x8(%rsp)
jne    1ee9 <rkck+0xdc9>
and    %sil,%al
jne    1ee9 <rkck+0xdc9>
and    %r14b,%cl
jne    1ee9 <rkck+0xdc9>
and    0x48(%rsp),%bl
jne    1ee9 <rkck+0xdc9>
and    %bpl,%dl
jne    1ee9 <rkck+0xdc9>
mov    0x50(%rsp),%r10
mov    %r10,%rsi
and    $0xfffffffffffffffc,%rsi
lea    0x1(%rsi),%r8
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
xor    %eax,%eax
movaps 0xf26(%rip),%xmm1
movaps 0xf2f(%rip),%xmm2
movaps 0xf38(%rip),%xmm3
movaps 0xf41(%rip),%xmm4
movaps 0xf4a(%rip),%xmm5
mov    0x88(%rsp),%rcx
mov    0x10(%rsp),%rdx
mov    0x18(%rsp),%rdi
mov    0x40(%rsp),%rbp
mov    0x28(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x4(%r12,%rax,4),%xmm6
movups 0x4(%rdx,%rax,4),%xmm7
mulps  %xmm1,%xmm7
mulps  %xmm2,%xmm6
addps  %xmm7,%xmm6
movups 0x4(%rdi,%rax,4),%xmm7
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
movups 0x4(%rbp,%rax,4),%xmm6
mulps  %xmm4,%xmm6
addps  %xmm7,%xmm6
movups 0x4(%rbx,%rax,4),%xmm7
mulps  %xmm5,%xmm7
addps  %xmm6,%xmm7
mulps  %xmm0,%xmm7
movups %xmm7,0x4(%rcx,%rax,4)
add    $0x4,%rax
cmp    %rax,%rsi
jne    22b0 <rkck+0x1190>
cmp    %rsi,%r10
jne    1ee9 <rkck+0xdc9>
jmp    1fa1 <rkck+0xe81>
mov    0x18(%rsp),%rbp
jmp    1e2c <rkck+0xd0c>

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

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