#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(double);
void nextK_ak1(int N, int tFlag, double a, double b, double a1, double *a3,
               double *a7, double K[100 + 1], double qk[100 + 1],
               double qp[100 + 1]) {
  int i;
  double temp;
  if (tFlag == 3) {
    K[1] = K[0] = 0.0;
    for (i = 2; i < N; i++)
      K[i] = qk[i - 2];
    return;
  }
  temp = ((tFlag == 1) ? b : a);
  if (fabs(a1) > (10.0 * 2.2204460492503131e-016 * fabs(temp))) {
    (*a7) /= a1;
    (*a3) /= a1;
    K[0] = qp[0];
    K[1] = -((*a7) * qp[0]) + qp[1];
    for (i = 2; i < N; i++)
      K[i] = -((*a7) * qp[i - 1]) + (*a3) * qk[i - 2] + qp[i];
  } else {
    K[0] = 0.0;
    K[1] = -(*a7) * qp[0];
    for (i = 2; i < N; i++)
      K[i] = -((*a7) * qp[i - 1]) + (*a3) * qk[i - 2];
  }
  return;
}


x86 assembly (clang, -O0):
<nextK_ak1>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
movsd  %xmm0,-0x10(%rbp)
movsd  %xmm1,-0x18(%rbp)
movsd  %xmm2,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
cmpl   $0x3,-0x8(%rbp)
jne    1193 <nextK_ak1+0x93>
mov    -0x38(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
movl   $0x2,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    118e <nextK_ak1+0x8e>
mov    -0x40(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1155 <nextK_ak1+0x55>
jmp    13c2 <nextK_ak1+0x2c2>
cmpl   $0x1,-0x8(%rbp)
jne    11ac <nextK_ak1+0xac>
movsd  -0x18(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    11b6 <nextK_ak1+0xb6>
movsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x20(%rbp),%xmm0
movaps 0xe44(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  -0x50(%rbp),%xmm2
movaps 0xe34(%rip),%xmm1
pand   %xmm1,%xmm2
movsd  0xe18(%rip),%xmm1
mulsd  %xmm2,%xmm1
ucomisd %xmm1,%xmm0
jbe    12fc <nextK_ak1+0x1fc>
movsd  -0x20(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
movsd  -0x20(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax)
mov    0x10(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x10(%rbp),%rax
mulsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x10(%rbp),%rax
addsd  0x8(%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movl   $0x2,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    12f7 <nextK_ak1+0x1f7>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1270 <nextK_ak1+0x170>
jmp    13bd <nextK_ak1+0x2bd>
mov    -0x38(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x10(%rbp),%rax
mulsd  (%rax),%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movl   $0x2,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    13b8 <nextK_ak1+0x2b8>
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm0
mov    0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x28(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x40(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    133e <nextK_ak1+0x23e>
jmp    13bd <nextK_ak1+0x2bd>
jmp    13c2 <nextK_ak1+0x2c2>
pop    %rbp
ret

x86 assembly (clang, -O2):
<nextK_ak1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    $0x3,%esi
jne    1180 <nextK_ak1+0x80>
xorpd  %xmm0,%xmm0
movupd %xmm0,(%r8)
cmp    $0x3,%edi
jl     166f <nextK_ak1+0x56f>
mov    %edi,%eax
lea    -0x2(%rax),%r10
mov    $0x2,%ecx
cmp    $0x4,%r10
jb     15f9 <nextK_ak1+0x4f9>
lea    0x10(%r8),%rdx
lea    (%r9,%rax,8),%rsi
add    $0xfffffffffffffff0,%rsi
cmp    %rsi,%rdx
jae    1154 <nextK_ak1+0x54>
lea    (%r8,%rax,8),%rdx
cmp    %r9,%rdx
ja     15f9 <nextK_ak1+0x4f9>
mov    %r10,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rdi
jae    152c <nextK_ak1+0x42c>
xor    %edi,%edi
jmp    15b0 <nextK_ak1+0x4b0>
cmp    $0x1,%esi
je     1189 <nextK_ak1+0x89>
movapd %xmm0,%xmm1
mov    0x38(%rsp),%rax
movapd 0xe6a(%rip),%xmm0
movapd %xmm2,%xmm3
andpd  %xmm0,%xmm3
andpd  %xmm0,%xmm1
mulsd  0xe76(%rip),%xmm1
ucomisd %xmm1,%xmm3
jbe    1362 <nextK_ak1+0x262>
movsd  (%rcx),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rcx)
movsd  (%rdx),%xmm0
divsd  %xmm2,%xmm0
movsd  %xmm0,(%rdx)
movsd  (%rax),%xmm0
movsd  %xmm0,(%r8)
movsd  (%rcx),%xmm0
mulsd  (%rax),%xmm0
movsd  0x8(%rax),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8)
cmp    $0x3,%edi
jl     166f <nextK_ak1+0x56f>
mov    %edi,%esi
lea    -0x2(%rsi),%rbp
mov    $0x2,%edi
cmp    $0x4,%rbp
jb     1330 <nextK_ak1+0x230>
mov    %rbp,-0x8(%rsp)
lea    0x10(%r8),%rbp
lea    (%r8,%rsi,8),%rbx
lea    0x8(%rcx),%r11
lea    0x8(%rax),%r14
lea    (%rax,%rsi,8),%r15
lea    0x8(%rdx),%r12
cmp    %r11,%rbp
setb   -0x9(%rsp)
cmp    %rcx,%rbx
seta   -0xa(%rsp)
lea    (%r9,%rsi,8),%r10
add    $0xfffffffffffffff0,%r10
cmp    %r15,%rbp
setb   %r13b
cmp    %rbx,%r14
setb   %r14b
cmp    %r12,%rbp
setb   %r11b
cmp    %rdx,%rbx
seta   %r15b
cmp    %r10,%rbp
setb   %bpl
cmp    %r9,%rbx
seta   %r12b
mov    -0xa(%rsp),%bl
test   %bl,-0x9(%rsp)
jne    1330 <nextK_ak1+0x230>
and    %r14b,%r13b
jne    1330 <nextK_ak1+0x230>
and    %r15b,%r11b
jne    1330 <nextK_ak1+0x230>
and    %r12b,%bpl
jne    1330 <nextK_ak1+0x230>
mov    -0x8(%rsp),%rbp
mov    %rbp,%r11
and    $0xfffffffffffffffc,%r11
movsd  (%rcx),%xmm0
unpcklpd %xmm0,%xmm0
xorpd  0xd62(%rip),%xmm0
lea    0x2(%r11),%rdi
movsd  (%rdx),%xmm1
unpcklpd %xmm1,%xmm1
xor    %ebx,%ebx
nopl   0x0(%rax)
movupd 0x8(%rax,%rbx,8),%xmm2
movupd 0x10(%rax,%rbx,8),%xmm3
movupd 0x18(%rax,%rbx,8),%xmm4
movupd 0x20(%rax,%rbx,8),%xmm5
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm4
movupd (%r9,%rbx,8),%xmm6
movupd 0x10(%r9,%rbx,8),%xmm7
mulpd  %xmm1,%xmm6
addpd  %xmm2,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm1,%xmm7
addpd  %xmm4,%xmm7
addpd  %xmm5,%xmm7
movupd %xmm6,0x10(%r8,%rbx,8)
movupd %xmm7,0x20(%r8,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%r11
jne    12c0 <nextK_ak1+0x1c0>
cmp    %r11,%rbp
je     166f <nextK_ak1+0x56f>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  -0x8(%rax,%rdi,8),%xmm0
mulsd  (%rcx),%xmm0
movsd  (%rdx),%xmm1
mulsd  -0x10(%r9,%rdi,8),%xmm1
subsd  %xmm0,%xmm1
addsd  (%rax,%rdi,8),%xmm1
movsd  %xmm1,(%r8,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    1330 <nextK_ak1+0x230>
jmp    166f <nextK_ak1+0x56f>
movq   $0x0,(%r8)
movsd  (%rcx),%xmm0
xorpd  0xc9b(%rip),%xmm0
mulsd  (%rax),%xmm0
movsd  %xmm0,0x8(%r8)
cmp    $0x3,%edi
jl     166f <nextK_ak1+0x56f>
mov    %edi,%r11d
lea    -0x2(%r11),%rsi
mov    $0x2,%edi
cmp    $0x4,%rsi
jb     14a1 <nextK_ak1+0x3a1>
mov    %rsi,-0x8(%rsp)
lea    0x10(%r8),%rbp
lea    (%r8,%r11,8),%rsi
lea    0x8(%rcx),%rbx
lea    0x8(%rax),%r14
lea    (%rax,%r11,8),%r15
add    $0xfffffffffffffff8,%r15
lea    0x8(%rdx),%r12
cmp    %rbx,%rbp
setb   -0x9(%rsp)
cmp    %rcx,%rsi
seta   -0xa(%rsp)
lea    (%r9,%r11,8),%r10
add    $0xfffffffffffffff0,%r10
cmp    %r15,%rbp
setb   %r15b
cmp    %rsi,%r14
setb   %r14b
cmp    %r12,%rbp
setb   %r13b
cmp    %rdx,%rsi
seta   %r12b
cmp    %r10,%rbp
setb   %bpl
cmp    %r9,%rsi
seta   %sil
mov    -0xa(%rsp),%bl
test   %bl,-0x9(%rsp)
jne    14a1 <nextK_ak1+0x3a1>
and    %r14b,%r15b
jne    14a1 <nextK_ak1+0x3a1>
and    %r12b,%r13b
jne    14a1 <nextK_ak1+0x3a1>
and    %sil,%bpl
jne    14a1 <nextK_ak1+0x3a1>
mov    -0x8(%rsp),%rbp
mov    %rbp,%rsi
and    $0xfffffffffffffffc,%rsi
movsd  (%rcx),%xmm0
unpcklpd %xmm0,%xmm0
xorpd  0xbce(%rip),%xmm0
lea    0x2(%rsi),%rdi
movsd  (%rdx),%xmm1
unpcklpd %xmm1,%xmm1
xor    %ebx,%ebx
movupd 0x8(%rax,%rbx,8),%xmm2
movupd 0x18(%rax,%rbx,8),%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm3
movupd (%r9,%rbx,8),%xmm4
movupd 0x10(%r9,%rbx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,0x10(%r8,%rbx,8)
movupd %xmm5,0x20(%r8,%rbx,8)
add    $0x4,%rbx
cmp    %rbx,%rsi
jne    1450 <nextK_ak1+0x350>
cmp    %rsi,%rbp
je     166f <nextK_ak1+0x56f>
mov    %r11d,%ebp
sub    %edi,%ebp
mov    %rdi,%rsi
not    %rsi
test   $0x1,%bpl
je     14d5 <nextK_ak1+0x3d5>
movsd  -0x8(%rax,%rdi,8),%xmm0
mulsd  (%rcx),%xmm0
movsd  (%rdx),%xmm1
mulsd  -0x10(%r9,%rdi,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rdi,8)
add    $0x1,%rdi
add    %r11,%rsi
je     166f <nextK_ak1+0x56f>
xchg   %ax,%ax
movsd  -0x8(%rax,%rdi,8),%xmm0
mulsd  (%rcx),%xmm0
movsd  (%rdx),%xmm1
mulsd  -0x10(%r9,%rdi,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%rdi,8)
movsd  (%rax,%rdi,8),%xmm0
mulsd  (%rcx),%xmm0
movsd  (%rdx),%xmm1
mulsd  -0x8(%r9,%rdi,8),%xmm1
subsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r8,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%r11
jne    14e0 <nextK_ak1+0x3e0>
jmp    166f <nextK_ak1+0x56f>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r9,%rdi,8),%xmm0
movups 0x10(%r9,%rdi,8),%xmm1
movups %xmm0,0x10(%r8,%rdi,8)
movups %xmm1,0x20(%r8,%rdi,8)
movups 0x20(%r9,%rdi,8),%xmm0
movups 0x30(%r9,%rdi,8),%xmm1
movups %xmm0,0x30(%r8,%rdi,8)
movups %xmm1,0x40(%r8,%rdi,8)
movups 0x40(%r9,%rdi,8),%xmm0
movups 0x50(%r9,%rdi,8),%xmm1
movups %xmm0,0x50(%r8,%rdi,8)
movups %xmm1,0x60(%r8,%rdi,8)
movupd 0x60(%r9,%rdi,8),%xmm0
movupd 0x70(%r9,%rdi,8),%xmm1
movupd %xmm0,0x70(%r8,%rdi,8)
movupd %xmm1,0x80(%r8,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1540 <nextK_ak1+0x440>
test   %rdx,%rdx
je     15f0 <nextK_ak1+0x4f0>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x0(,%rdi,8),%rsi
movupd (%r9,%rdi,8),%xmm0
movupd 0x10(%r9,%rdi,8),%xmm1
or     $0x10,%rsi
movupd %xmm0,(%r8,%rsi,1)
movupd %xmm1,0x10(%r8,%rsi,1)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rdx
jne    15c0 <nextK_ak1+0x4c0>
cmp    %rcx,%r10
je     166f <nextK_ak1+0x56f>
or     $0x2,%rcx
mov    %eax,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
and    $0x3,%rsi
je     1627 <nextK_ak1+0x527>
nopl   0x0(%rax)
movsd  -0x10(%r9,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1610 <nextK_ak1+0x510>
cmp    $0x3,%rdx
jb     166f <nextK_ak1+0x56f>
nopl   (%rax)
movsd  -0x10(%r9,%rcx,8),%xmm0
movsd  %xmm0,(%r8,%rcx,8)
movsd  -0x8(%r9,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r8,%rcx,8)
movsd  (%r9,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r8,%rcx,8)
movsd  0x8(%r9,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r8,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1630 <nextK_ak1+0x530>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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