void rkck(float y[], float dydx[], int n, float x, float h, float yout[],
          float yerr[], void (*derivs)(float, float[], float[])) {
  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.00 / 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    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movss  %xmm0,-0x18(%rbp)
movss  %xmm1,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movss  0x2f2c(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xeb8(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movss  0x2f0f(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe8f(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
movss  0x2ef2(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe66(%rip),%xmm1
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
movss  0x2ed5(%rip),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe3d(%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     12ab <rkck+0x18b>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  0x2dce(%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    1255 <rkck+0x135>
mov    -0x38(%rbp),%rax
movss  -0x18(%rbp),%xmm1
movss  0x2d74(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x58(%rbp),%rsi
call   *%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     134d <rkck+0x22d>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2d48(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2d37(%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    12da <rkck+0x1ba>
mov    -0x38(%rbp),%rax
movss  -0x18(%rbp),%xmm1
movss  0x2cd6(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x60(%rbp),%rsi
call   *%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     140c <rkck+0x2ec>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2cae(%rip),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2c9d(%rip),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2c84(%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    137c <rkck+0x25c>
mov    -0x38(%rbp),%rax
movss  -0x18(%rbp),%xmm1
movss  0x2c1b(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x68(%rbp),%rsi
call   *%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14e8 <rkck+0x3c8>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2bfb(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2bea(%rip),%xmm3
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0x2bd1(%rip),%xmm3
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2bb8(%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    143b <rkck+0x31b>
mov    -0x38(%rbp),%rax
movss  -0x18(%rbp),%xmm1
movss  0x2b43(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x70(%rbp),%rsi
call   *%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     15e1 <rkck+0x4c1>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2b2f(%rip),%xmm3
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2b1e(%rip),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2b05(%rip),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0x2aec(%rip),%xmm3
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2ad3(%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    1517 <rkck+0x3f7>
mov    -0x38(%rbp),%rax
movss  -0x18(%rbp),%xmm1
movss  0x2a4e(%rip),%xmm0
movss  -0x1c(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x80(%rbp),%rdi
mov    -0x78(%rbp),%rsi
call   *%rax
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     16bd <rkck+0x59d>
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x1c(%rbp),%xmm0
movss  0x2a4a(%rip),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
movss  0x2a39(%rip),%xmm3
mov    -0x60(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm3
mulss  %xmm4,%xmm2
addss  %xmm3,%xmm2
movss  0x2a20(%rip),%xmm3
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm4
mulss  %xmm4,%xmm3
addss  %xmm2,%xmm3
movss  0x2a07(%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    1610 <rkck+0x4f0>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1771 <rkck+0x651>
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  0x296d(%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    16c4 <rkck+0x5a4>
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    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rkck>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%r14
mov    %r8,0x70(%rsp)
mov    %rcx,0x50(%rsp)
movaps %xmm1,0x60(%rsp)
movss  %xmm0,0xc(%rsp)
mov    %edx,%ebp
mov    %rsi,%r12
mov    %rdi,%r15
mov    $0x1,%edi
mov    %edx,%esi
xor    %eax,%eax
call   1040 <vector@plt>
movslq %eax,%rbx
mov    $0x1,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <vector@plt>
cltq
mov    %rax,0x20(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <vector@plt>
cltq
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <vector@plt>
cltq
mov    %rax,0x40(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <vector@plt>
cltq
mov    %rax,0x48(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <vector@plt>
movslq %eax,%r13
test   %ebp,%ebp
mov    %ebp,0x38(%rsp)
mov    %rbx,0x18(%rsp)
jle    120d <rkck+0xed>
mov    %r14,0x58(%rsp)
movss  0x1e22(%rip),%xmm0
movaps 0x60(%rsp),%xmm1
mulss  %xmm1,%xmm0
mov    %ebp,%r8d
lea    0x1(%r8),%rbx
mov    $0x1,%eax
cmp    $0x8,%ebp
mov    %rbx,0x10(%rsp)
jae    122f <rkck+0x10f>
mov    0x18(%rsp),%rsi
movss  0xc(%rsp),%xmm7
jmp    1376 <rkck+0x256>
movss  0x1deb(%rip),%xmm0
mulss  0x60(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
mov    %r13,%rdi
mov    %rbx,%rsi
call   *%r14
jmp    1431 <rkck+0x311>
lea    0x4(%r13),%rdx
lea    0x0(,%rbx,4),%rsi
add    %r13,%rsi
lea    0x4(%r15),%rdi
lea    (%r15,%rbx,4),%rbp
lea    0x4(%r12),%r9
lea    (%r12,%rbx,4),%rcx
cmp    %rbp,%rdx
setb   %r10b
cmp    %rsi,%rdi
setb   %bl
cmp    %rcx,%rdx
setb   %dl
cmp    %rsi,%r9
setb   %cl
test   %bl,%r10b
mov    0x18(%rsp),%rsi
movss  0xc(%rsp),%xmm7
jne    1371 <rkck+0x251>
and    %cl,%dl
mov    0x10(%rsp),%rbx
jne    1376 <rkck+0x256>
mov    %r8d,%eax
and    $0xfffffff8,%eax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1633 <rkck+0x513>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x4(%r15,%rdx,4),%xmm2
movups 0x14(%r15,%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(%r15,%rdx,4),%xmm2
movups 0x34(%r15,%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    12c0 <rkck+0x1a0>
test   $0x1,%r9b
je     1366 <rkck+0x246>
shl    $0x2,%rdx
or     $0x4,%rdx
movups (%r15,%rdx,1),%xmm2
movups 0x10(%r15,%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    %rax,%r8
je     13e9 <rkck+0x2c9>
or     $0x1,%rax
jmp    1376 <rkck+0x256>
mov    0x10(%rsp),%rbx
mov    %rax,%rcx
not    %rcx
test   $0x1,%bl
jne    139c <rkck+0x27c>
movss  (%r12,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r15,%rax,4),%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
add    $0x1,%rax
add    %rbx,%rcx
je     13e9 <rkck+0x2c9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r12,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%r15,%rax,4),%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
movss  0x4(%r12,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  0x4(%r15,%rax,4),%xmm1
movss  %xmm1,0x4(%r13,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbx
jne    13b0 <rkck+0x290>
addss  %xmm7,%xmm0
mov    %r13,%rdi
mov    0x58(%rsp),%r14
call   *%r14
cmpl   $0x0,0x38(%rsp)
jle    1431 <rkck+0x311>
mov    0x10(%rsp),%rbx
lea    -0x1(%rbx),%rcx
mov    $0x1,%eax
mov    %rcx,0x30(%rsp)
cmp    $0x8,%rcx
movaps 0x60(%rsp),%xmm9
jae    1526 <rkck+0x406>
mov    0x18(%rsp),%rdi
mov    0x20(%rsp),%rsi
jmp    164e <rkck+0x52e>
movss  0x1bd3(%rip),%xmm0
mulss  0x60(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
mov    %r13,%rdi
mov    0x20(%rsp),%rsi
call   *%r14
movss  0x1bc0(%rip),%xmm0
mulss  0x60(%rsp),%xmm0
addss  0xc(%rsp),%xmm0
mov    %r13,%rdi
mov    0x28(%rsp),%rsi
call   *%r14
movss  0xc(%rsp),%xmm0
addss  0x60(%rsp),%xmm0
mov    %r13,%rdi
mov    0x40(%rsp),%rsi
call   *%r14
movaps 0x60(%rsp),%xmm0
mulss  0x1bad(%rip),%xmm0
addss  0xc(%rsp),%xmm0
mov    %r13,%rdi
mov    0x48(%rsp),%rsi
call   *%r14
mov    %r13,%rdi
mov    $0x1,%esi
mov    0x38(%rsp),%ebx
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <free_vector@plt>
mov    0x48(%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    0x28(%rsp),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1030 <free_vector@plt>
mov    0x20(%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
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_vector@plt>
lea    0x4(%r13),%rdx
lea    0x0(,%rbx,4),%rsi
add    %r13,%rsi
lea    0x4(%r15),%r10
lea    (%r15,%rbx,4),%rcx
lea    0x4(%r12),%r9
lea    (%r12,%rbx,4),%rbp
mov    0x18(%rsp),%rdi
lea    0x4(%rdi),%r8
lea    (%rdi,%rbx,4),%rbx
cmp    %rcx,%rdx
setb   %r11b
cmp    %rsi,%r10
setb   %r10b
cmp    %rbp,%rdx
setb   %cl
cmp    %rsi,%r9
setb   %r9b
cmp    %rbx,%rdx
setb   %dl
cmp    %rsi,%r8
setb   %bl
test   %r10b,%r11b
jne    1644 <rkck+0x524>
and    %r9b,%cl
mov    0x20(%rsp),%rsi
jne    1649 <rkck+0x529>
and    %bl,%dl
mov    0x10(%rsp),%rbx
jne    164e <rkck+0x52e>
mov    0x30(%rsp),%rcx
and    $0xfffffffffffffff8,%rcx
lea    0x1(%rcx),%rax
movaps %xmm9,%xmm0
shufps $0x0,%xmm9,%xmm0
xor    %edx,%edx
movaps 0x1ab2(%rip),%xmm8
movaps 0x1abb(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x4(%r15,%rdx,4),%xmm3
movups 0x14(%r15,%rdx,4),%xmm4
movups 0x4(%r12,%rdx,4),%xmm5
movups 0x14(%r12,%rdx,4),%xmm6
movups 0x4(%rdi,%rdx,4),%xmm7
movups 0x14(%rdi,%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    15d0 <rkck+0x4b0>
cmp    %rcx,0x30(%rsp)
jne    164e <rkck+0x52e>
jmp    170e <rkck+0x5ee>
xor    %edx,%edx
test   $0x1,%r9b
jne    1330 <rkck+0x210>
jmp    1366 <rkck+0x246>
mov    0x20(%rsp),%rsi
mov    0x10(%rsp),%rbx
mov    %rax,%rcx
not    %rcx
test   $0x1,%bl
jne    168e <rkck+0x56e>
movss  (%r12,%rax,4),%xmm0
movss  (%rdi,%rax,4),%xmm1
mulss  0x1998(%rip),%xmm1
mulss  0x1994(%rip),%xmm0
addss  %xmm1,%xmm0
mulss  %xmm9,%xmm0
addss  (%r15,%rax,4),%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
add    $0x1,%rax
add    %rbx,%rcx
je     170e <rkck+0x5ee>
movss  0x1969(%rip),%xmm0
movss  0x1965(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rdi,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  (%r12,%rax,4),%xmm3
mulss  %xmm1,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm9,%xmm3
addss  (%r15,%rax,4),%xmm3
movss  %xmm3,0x0(%r13,%rax,4)
movss  0x4(%rdi,%rax,4),%xmm2
mulss  %xmm0,%xmm2
movss  0x4(%r12,%rax,4),%xmm3
mulss  %xmm1,%xmm3
addss  %xmm2,%xmm3
mulss  %xmm9,%xmm3
addss  0x4(%r15,%rax,4),%xmm3
movss  %xmm3,0x4(%r13,%rax,4)
add    $0x2,%rax
cmp    %rax,%rbx
jne    16b0 <rkck+0x590>
movss  0x18f6(%rip),%xmm0
mulss  %xmm9,%xmm0
addss  0xc(%rsp),%xmm0
mov    %r13,%rdi
mov    %rsi,%rbp
mov    0x58(%rsp),%r14
call   *%r14
cmpl   $0x0,0x38(%rsp)
jle    1450 <rkck+0x330>
mov    $0x1,%eax
cmpq   $0x4,0x30(%rsp)
movaps 0x60(%rsp),%xmm7
movss  0xc(%rsp),%xmm8
jae    1c36 <rkck+0xb16>
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%rdi
mov    0x18(%rsp),%rbx
movss  0x18a2(%rip),%xmm0
movss  0x1896(%rip),%xmm1
movss  0x1896(%rip),%xmm2
xchg   %ax,%ax
movss  (%rbx,%rax,4),%xmm3
mulss  %xmm0,%xmm3
movss  (%r12,%rax,4),%xmm4
mulss  %xmm1,%xmm4
addss  %xmm3,%xmm4
movss  0x0(%rbp,%rax,4),%xmm3
mulss  %xmm2,%xmm3
addss  %xmm4,%xmm3
mulss  %xmm7,%xmm3
addss  (%r15,%rax,4),%xmm3
movss  %xmm3,0x0(%r13,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1780 <rkck+0x660>
movss  0x1851(%rip),%xmm0
mulss  %xmm7,%xmm0
addss  %xmm8,%xmm0
mov    %r13,%rdi
mov    0x58(%rsp),%r14
call   *%r14
cmpl   $0x0,0x38(%rsp)
jle    146f <rkck+0x34f>
mov    $0x1,%r8d
cmpq   $0x4,0x30(%rsp)
movaps 0x60(%rsp),%xmm8
movss  0xc(%rsp),%xmm9
jae    1d5a <rkck+0xc3a>
mov    0x28(%rsp),%rbx
mov    0x40(%rsp),%rsi
mov    0x18(%rsp),%rdi
lea    0x0(,%r8,4),%r9
add    %r13,%r9
lea    (%rbx,%r8,4),%r10
mov    0x20(%rsp),%rax
lea    (%rax,%r8,4),%rdx
lea    (%rdi,%r8,4),%rdi
lea    (%r12,%r8,4),%rbp
lea    (%r15,%r8,4),%rbx
mov    0x10(%rsp),%rax
sub    %r8,%rax
xor    %ecx,%ecx
movss  0x17d2(%rip),%xmm0
movss  0x17ce(%rip),%xmm1
movss  0x17ca(%rip),%xmm2
movss  0x17c6(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%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    1870 <rkck+0x750>
movaps %xmm9,%xmm0
addss  %xmm8,%xmm0
mov    %r13,%rdi
mov    0x58(%rsp),%r14
call   *%r14
cmpl   $0x0,0x38(%rsp)
jle    1486 <rkck+0x366>
mov    $0x1,%r8d
cmpq   $0x4,0x30(%rsp)
movaps 0x60(%rsp),%xmm9
jae    1eb5 <rkck+0xd95>
mov    0x28(%rsp),%rbp
mov    0x40(%rsp),%rdi
mov    0x48(%rsp),%rsi
lea    0x0(,%r8,4),%r9
add    %r13,%r9
lea    (%rdi,%r8,4),%r10
lea    0x0(%rbp,%r8,4),%r11
mov    0x20(%rsp),%rax
lea    (%rax,%r8,4),%rdi
mov    0x18(%rsp),%rax
lea    (%rax,%r8,4),%rax
lea    (%r12,%r8,4),%rbp
lea    (%r15,%r8,4),%rbx
mov    0x10(%rsp),%rcx
sub    %r8,%rcx
xor    %edx,%edx
movss  0x16eb(%rip),%xmm0
movss  0x16e7(%rip),%xmm1
movss  0x16e3(%rip),%xmm2
movss  0x16df(%rip),%xmm3
movss  0x16db(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm5
mulss  %xmm0,%xmm5
movss  0x0(%rbp,%rdx,4),%xmm6
mulss  %xmm1,%xmm6
addss  %xmm5,%xmm6
movss  (%rdi,%rdx,4),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm6,%xmm5
movss  (%r11,%rdx,4),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
movss  (%r10,%rdx,4),%xmm5
mulss  %xmm4,%xmm5
addss  %xmm6,%xmm5
mulss  %xmm9,%xmm5
addss  (%rbx,%rdx,4),%xmm5
movss  %xmm5,(%r9,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1970 <rkck+0x850>
movss  0x166f(%rip),%xmm0
mulss  %xmm9,%xmm0
addss  0xc(%rsp),%xmm0
mov    %r13,%rdi
call   *0x58(%rsp)
movaps 0x60(%rsp),%xmm8
cmpl   $0x0,0x38(%rsp)
mov    0x10(%rsp),%r10
jle    14a4 <rkck+0x384>
mov    $0x1,%r8d
cmpq   $0x4,0x30(%rsp)
jae    2061 <rkck+0xf41>
mov    0x28(%rsp),%rsi
mov    0x48(%rsp),%rbx
mov    0x50(%rsp),%rdi
lea    (%rdi,%r8,4),%r9
lea    (%rbx,%r8,4),%rdx
lea    (%rsi,%r8,4),%rsi
mov    0x20(%rsp),%rax
lea    (%rax,%r8,4),%rdi
lea    (%r12,%r8,4),%rbp
lea    (%r15,%r8,4),%rbx
mov    %r10,%rax
sub    %r8,%rax
xor    %ecx,%ecx
movss  0x15fd(%rip),%xmm0
movss  0x15f9(%rip),%xmm1
movss  0x15f5(%rip),%xmm2
movss  0x15f1(%rip),%xmm3
nop
movss  (%rdi,%rcx,4),%xmm4
mulss  %xmm0,%xmm4
movss  0x0(%rbp,%rcx,4),%xmm5
mulss  %xmm1,%xmm5
addss  %xmm4,%xmm5
movss  (%rsi,%rcx,4),%xmm4
mulss  %xmm2,%xmm4
addss  %xmm5,%xmm4
movss  (%rdx,%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    1a60 <rkck+0x940>
cmpl   $0x0,0x38(%rsp)
jle    14a4 <rkck+0x384>
mov    $0x1,%r11d
cmpq   $0x4,0x30(%rsp)
jb     21dd <rkck+0x10bd>
mov    0x70(%rsp),%rax
lea    0x4(%rax),%rsi
lea    (%rax,%r10,4),%rbp
lea    0x4(%r12),%rcx
lea    (%r12,%r10,4),%rdx
mov    0x20(%rsp),%rbx
lea    0x4(%rbx),%r9
lea    (%rbx,%r10,4),%rbx
mov    0x28(%rsp),%rdi
lea    0x4(%rdi),%r8
cmp    %rdx,%rsi
setb   %r14b
cmp    %rbp,%rcx
lea    (%rdi,%r10,4),%rdx
setb   %r15b
cmp    %rbx,%rsi
setb   %cl
cmp    %rbp,%r9
mov    0x40(%rsp),%rbx
lea    0x4(%rbx),%rdi
mov    %r10,%rax
setb   %r10b
cmp    %rdx,%rsi
setb   %dl
cmp    %rbp,%r8
lea    (%rbx,%rax,4),%rbx
setb   %r8b
cmp    %rbx,%rsi
setb   %bl
cmp    %rbp,%rdi
mov    0x48(%rsp),%r9
lea    (%r9,%rax,4),%rdi
setb   %al
cmp    %rdi,%rsi
lea    0x4(%r9),%rdi
setb   %sil
cmp    %rbp,%rdi
setb   %dil
test   %r15b,%r14b
jne    21d8 <rkck+0x10b8>
and    %r10b,%cl
jne    21d8 <rkck+0x10b8>
and    %r8b,%dl
mov    0x10(%rsp),%r10
jne    21dd <rkck+0x10bd>
and    %al,%bl
jne    21dd <rkck+0x10bd>
and    %dil,%sil
jne    21dd <rkck+0x10bd>
mov    0x30(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
lea    0x1(%rcx),%r11
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
xor    %edx,%edx
movaps 0x15ea(%rip),%xmm1
movaps 0x15f3(%rip),%xmm2
movaps 0x15fc(%rip),%xmm3
movaps 0x1605(%rip),%xmm4
movaps 0x160e(%rip),%xmm5
mov    0x20(%rsp),%rsi
mov    0x28(%rsp),%rdi
mov    0x40(%rsp),%rbp
mov    0x48(%rsp),%rbx
mov    0x70(%rsp),%rax
nopl   0x0(%rax,%rax,1)
movups 0x4(%r12,%rdx,4),%xmm6
movups 0x4(%rsi,%rdx,4),%xmm7
mulps  %xmm1,%xmm7
mulps  %xmm2,%xmm6
addps  %xmm7,%xmm6
movups 0x4(%rdi,%rdx,4),%xmm7
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
movups 0x4(%rbp,%rdx,4),%xmm6
mulps  %xmm4,%xmm6
addps  %xmm7,%xmm6
movups 0x4(%rbx,%rdx,4),%xmm7
mulps  %xmm5,%xmm7
addps  %xmm6,%xmm7
mulps  %xmm0,%xmm7
movups %xmm7,0x4(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1be0 <rkck+0xac0>
cmp    %rcx,0x30(%rsp)
je     14a4 <rkck+0x384>
jmp    21dd <rkck+0x10bd>
mov    %rbp,%r11
lea    0x4(%r13),%rbp
mov    0x10(%rsp),%rbx
lea    0x0(,%rbx,4),%rdi
add    %r13,%rdi
lea    0x4(%r15),%rsi
lea    (%r15,%rbx,4),%rdx
lea    0x4(%r12),%r8
lea    (%r12,%rbx,4),%rcx
cmp    %rdx,%rbp
setb   %r10b
cmp    %rdi,%rsi
mov    0x18(%rsp),%rdx
lea    0x4(%rdx),%rsi
setb   %r9b
cmp    %rcx,%rbp
setb   %cl
cmp    %rdi,%r8
lea    (%rdx,%rbx,4),%rdx
setb   %r8b
cmp    %rdx,%rbp
setb   %dl
cmp    %rdi,%rsi
lea    (%r11,%rbx,4),%rbx
setb   %r14b
cmp    %rbx,%rbp
lea    0x4(%r11),%rbp
setb   %bl
cmp    %rdi,%rbp
setb   %r11b
test   %r9b,%r10b
jne    21c4 <rkck+0x10a4>
and    %r8b,%cl
mov    0x28(%rsp),%rsi
jne    21ce <rkck+0x10ae>
and    %r14b,%dl
mov    0x20(%rsp),%rbp
mov    0x10(%rsp),%rdi
jne    1761 <rkck+0x641>
and    %r11b,%bl
mov    0x18(%rsp),%rbx
jne    1766 <rkck+0x646>
mov    0x30(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
lea    0x1(%rcx),%rax
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
xor    %edx,%edx
movaps 0x1393(%rip),%xmm1
movaps 0x139c(%rip),%xmm2
movaps 0x13a5(%rip),%xmm3
nopl   0x0(%rax,%rax,1)
movups 0x4(%r15,%rdx,4),%xmm4
movups 0x4(%r12,%rdx,4),%xmm5
movups 0x4(%rbx,%rdx,4),%xmm6
mulps  %xmm1,%xmm6
mulps  %xmm2,%xmm5
addps  %xmm6,%xmm5
movups 0x4(%rbp,%rdx,4),%xmm6
mulps  %xmm3,%xmm6
addps  %xmm5,%xmm6
mulps  %xmm0,%xmm6
addps  %xmm4,%xmm6
movups %xmm6,0x4(%r13,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1d10 <rkck+0xbf0>
cmp    %rcx,0x30(%rsp)
jne    1766 <rkck+0x646>
jmp    17bf <rkck+0x69f>
lea    0x4(%r13),%rbp
mov    0x10(%rsp),%rsi
lea    0x0(,%rsi,4),%rdi
add    %r13,%rdi
lea    0x4(%r15),%rax
lea    (%r15,%rsi,4),%rcx
lea    0x4(%r12),%r10
lea    (%r12,%rsi,4),%rbx
mov    0x18(%rsp),%rdx
lea    0x4(%rdx),%r14
cmp    %rcx,%rbp
setb   0xb(%rsp)
cmp    %rdi,%rax
lea    (%rdx,%rsi,4),%rcx
setb   %r9b
cmp    %rbx,%rbp
setb   %al
cmp    %rdi,%r10
mov    0x20(%rsp),%rdx
lea    0x4(%rdx),%r11
setb   %r10b
cmp    %rcx,%rbp
setb   %cl
cmp    %rdi,%r14
lea    (%rdx,%rsi,4),%rdx
setb   %r14b
cmp    %rdx,%rbp
setb   %dl
cmp    %rdi,%r11
mov    0x28(%rsp),%rbx
lea    (%rbx,%rsi,4),%rsi
setb   0xa(%rsp)
cmp    %rsi,%rbp
lea    0x4(%rbx),%rbp
setb   %r11b
cmp    %rdi,%rbp
setb   %dil
test   %r9b,0xb(%rsp)
jne    180a <rkck+0x6ea>
and    %r10b,%al
mov    0x40(%rsp),%rsi
jne    180f <rkck+0x6ef>
and    %r14b,%cl
jne    180f <rkck+0x6ef>
and    0xa(%rsp),%dl
jne    180f <rkck+0x6ef>
and    %dil,%r11b
mov    0x18(%rsp),%rdi
jne    1814 <rkck+0x6f4>
mov    0x30(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
lea    0x1(%rcx),%r8
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
xor    %eax,%eax
movaps 0x127c(%rip),%xmm1
movaps 0x1285(%rip),%xmm2
movaps 0x128e(%rip),%xmm3
movaps 0x1297(%rip),%xmm4
mov    0x20(%rsp),%rdx
xchg   %ax,%ax
movups 0x4(%r15,%rax,4),%xmm5
movups 0x4(%r12,%rax,4),%xmm6
movups 0x4(%rdi,%rax,4),%xmm7
mulps  %xmm1,%xmm7
mulps  %xmm2,%xmm6
addps  %xmm7,%xmm6
movups 0x4(%rdx,%rax,4),%xmm7
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
movups 0x4(%rbx,%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    1e60 <rkck+0xd40>
cmp    %rcx,0x30(%rsp)
jne    1814 <rkck+0x6f4>
jmp    18bb <rkck+0x79b>
lea    0x4(%r13),%rcx
mov    0x10(%rsp),%rbx
lea    0x0(,%rbx,4),%rax
add    %r13,%rax
lea    0x4(%r15),%rdx
lea    (%r15,%rbx,4),%rsi
lea    0x4(%r12),%r9
lea    (%r12,%rbx,4),%rbp
mov    0x18(%rsp),%rdi
lea    0x4(%rdi),%r10
lea    (%rdi,%rbx,4),%r14
cmp    %rsi,%rcx
setb   0xb(%rsp)
cmp    %rax,%rdx
mov    0x20(%rsp),%rsi
lea    0x4(%rsi),%rdi
setb   %r11b
cmp    %rbp,%rcx
setb   %dl
cmp    %rax,%r9
lea    (%rsi,%rbx,4),%rsi
setb   0xa(%rsp)
cmp    %r14,%rcx
setb   %r14b
cmp    %rax,%r10
mov    0x28(%rsp),%r10
lea    0x4(%r10),%rbp
setb   0x3f(%rsp)
cmp    %rsi,%rcx
setb   %r9b
cmp    %rax,%rdi
lea    (%r10,%rbx,4),%rdi
setb   %sil
cmp    %rdi,%rcx
setb   %r10b
cmp    %rax,%rbp
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbx,4),%rbp
setb   %bl
cmp    %rbp,%rcx
lea    0x4(%rdi),%rbp
setb   %cl
cmp    %rax,%rbp
setb   %al
test   %r11b,0xb(%rsp)
jne    18f2 <rkck+0x7d2>
mov    %eax,%r11d
mov    %ebx,%eax
mov    %esi,%ebx
and    0xa(%rsp),%dl
mov    0x28(%rsp),%rbp
mov    0x40(%rsp),%rdi
mov    0x48(%rsp),%rsi
jne    1901 <rkck+0x7e1>
and    0x3f(%rsp),%r14b
jne    1901 <rkck+0x7e1>
and    %bl,%r9b
jne    1901 <rkck+0x7e1>
and    %al,%r10b
jne    1901 <rkck+0x7e1>
and    %r11b,%cl
jne    1901 <rkck+0x7e1>
mov    0x30(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
lea    0x1(%rcx),%r8
movaps %xmm9,%xmm0
shufps $0x0,%xmm9,%xmm0
xor    %eax,%eax
movaps 0x112e(%rip),%xmm8
movaps 0x1137(%rip),%xmm2
movaps 0x1140(%rip),%xmm3
movaps 0x1149(%rip),%xmm4
movaps 0x1152(%rip),%xmm5
mov    0x20(%rsp),%rdx
mov    0x18(%rsp),%rbx
nopl   0x0(%rax,%rax,1)
movups 0x4(%r15,%rax,4),%xmm6
movups 0x4(%r12,%rax,4),%xmm7
movups 0x4(%rbx,%rax,4),%xmm1
mulps  %xmm8,%xmm1
mulps  %xmm2,%xmm7
addps  %xmm1,%xmm7
movups 0x4(%rdx,%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,%rcx
jne    2000 <rkck+0xee0>
cmp    %rcx,0x30(%rsp)
jne    1901 <rkck+0x7e1>
jmp    19c9 <rkck+0x8a9>
mov    0x50(%rsp),%rax
lea    0x4(%rax),%rbp
lea    (%rax,%r10,4),%rdi
lea    0x4(%r15),%rax
lea    (%r15,%r10,4),%rcx
lea    0x4(%r12),%r11
lea    (%r12,%r10,4),%rdx
mov    0x20(%rsp),%rbx
mov    %r10,%rsi
lea    0x4(%rbx),%r10
cmp    %rcx,%rbp
setb   %r14b
cmp    %rdi,%rax
lea    (%rbx,%rsi,4),%rcx
setb   %r9b
cmp    %rdx,%rbp
setb   %al
cmp    %rdi,%r11
mov    0x28(%rsp),%rdx
lea    0x4(%rdx),%r11
setb   0xc(%rsp)
cmp    %rcx,%rbp
setb   %cl
cmp    %rdi,%r10
lea    (%rdx,%rsi,4),%rdx
setb   %r10b
cmp    %rdx,%rbp
setb   %dl
cmp    %rdi,%r11
mov    0x48(%rsp),%rbx
lea    (%rbx,%rsi,4),%rsi
setb   0x58(%rsp)
cmp    %rsi,%rbp
lea    0x4(%rbx),%rbp
setb   %r11b
cmp    %rdi,%rbp
setb   %dil
test   %r9b,%r14b
jne    2296 <rkck+0x1176>
and    0xc(%rsp),%al
mov    0x28(%rsp),%rsi
jne    229b <rkck+0x117b>
and    %r10b,%cl
jne    229b <rkck+0x117b>
and    0x58(%rsp),%dl
mov    0x10(%rsp),%r10
jne    1a15 <rkck+0x8f5>
and    %dil,%r11b
mov    0x50(%rsp),%rdi
jne    1a1a <rkck+0x8fa>
mov    0x30(%rsp),%rcx
and    $0xfffffffffffffffc,%rcx
lea    0x1(%rcx),%r8
movaps %xmm8,%xmm0
shufps $0x0,%xmm8,%xmm0
xor    %eax,%eax
movaps 0x1005(%rip),%xmm1
movaps 0x100e(%rip),%xmm2
movaps 0x1017(%rip),%xmm3
movaps 0x1020(%rip),%xmm4
mov    0x20(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movups 0x4(%r15,%rax,4),%xmm5
movups 0x4(%r12,%rax,4),%xmm6
movups 0x4(%rdx,%rax,4),%xmm7
mulps  %xmm1,%xmm7
mulps  %xmm2,%xmm6
addps  %xmm7,%xmm6
movups 0x4(%rsi,%rax,4),%xmm7
mulps  %xmm3,%xmm7
addps  %xmm6,%xmm7
movups 0x4(%rbx,%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,%rcx
jne    2170 <rkck+0x1050>
cmp    %rcx,0x30(%rsp)
jne    1a1a <rkck+0x8fa>
jmp    1aaa <rkck+0x98a>
mov    0x20(%rsp),%rbp
jmp    1757 <rkck+0x637>
mov    0x20(%rsp),%rbp
jmp    175c <rkck+0x63c>
mov    0x10(%rsp),%r10
mov    0x70(%rsp),%rax
lea    (%rax,%r11,4),%rcx
mov    0x48(%rsp),%rdx
lea    (%rdx,%r11,4),%rdx
mov    0x40(%rsp),%rsi
lea    (%rsi,%r11,4),%rsi
mov    0x28(%rsp),%rdi
lea    (%rdi,%r11,4),%rdi
mov    0x20(%rsp),%rbp
lea    0x0(%rbp,%r11,4),%rbp
lea    (%r12,%r11,4),%rbx
sub    %r11,%r10
xor    %eax,%eax
movss  0xe38(%rip),%xmm0
movss  0xe34(%rip),%xmm1
movss  0xe30(%rip),%xmm2
movss  0xe2c(%rip),%xmm3
movss  0xe28(%rip),%xmm4
nopl   0x0(%rax)
movss  0x0(%rbp,%rax,4),%xmm5
mulss  %xmm0,%xmm5
movss  (%rbx,%rax,4),%xmm6
mulss  %xmm1,%xmm6
addss  %xmm5,%xmm6
movss  (%rdi,%rax,4),%xmm5
mulss  %xmm2,%xmm5
addss  %xmm6,%xmm5
movss  (%rsi,%rax,4),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm5,%xmm6
movss  (%rdx,%rax,4),%xmm5
mulss  %xmm4,%xmm5
addss  %xmm6,%xmm5
mulss  %xmm8,%xmm5
movss  %xmm5,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r10
jne    2240 <rkck+0x1120>
jmp    14a4 <rkck+0x384>
mov    0x28(%rsp),%rsi
mov    0x10(%rsp),%r10
jmp    1a15 <rkck+0x8f5>

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

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