int extrapshc(double date, double dte1, int nmax1, double *gh1, int nmax2,
              double *gh2, int *nmax, double *gh) {
  int i, k, l;
  double factor;
  --gh;
  --gh2;
  --gh1;
  factor = date - dte1;
  if (nmax1 == nmax2) {
    k = nmax1 * (nmax1 + 2);
    *nmax = nmax1;
  } else if (nmax1 > nmax2) {
    k = nmax2 * (nmax2 + 2);
    l = nmax1 * (nmax1 + 2);
    for (i = k + 1; i <= l; ++i) {
      gh[i] = gh1[i];
    }
    *nmax = nmax1;
  } else {
    k = nmax1 * (nmax1 + 2);
    l = nmax2 * (nmax2 + 2);
    for (i = k + 1; i <= l; ++i) {
      gh[i] = factor * gh2[i];
    }
    *nmax = nmax2;
  }
  for (i = 1; i <= k; ++i) {
    gh[i] = gh1[i] + factor * gh2[i];
  }
  return 0;
}


x86 assembly (clang, -O0):
<extrapshc>:
push   %rbp
mov    %rsp,%rbp
movsd  %xmm0,-0x8(%rbp)
movsd  %xmm1,-0x10(%rbp)
mov    %edi,-0x14(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %edx,-0x24(%rbp)
mov    %rcx,-0x30(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
mov    -0x40(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x40(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
movsd  -0x8(%rbp),%xmm0
subsd  -0x10(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jne    1180 <extrapshc+0x80>
mov    -0x14(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
jmp    1263 <extrapshc+0x163>
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jle    11f5 <extrapshc+0xf5>
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     11e7 <extrapshc+0xe7>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11b3 <extrapshc+0xb3>
mov    -0x14(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
jmp    125e <extrapshc+0x15e>
mov    -0x14(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
imul   %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1255 <extrapshc+0x155>
movsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    121c <extrapshc+0x11c>
mov    -0x24(%rbp),%ecx
mov    -0x38(%rbp),%rax
mov    %ecx,(%rax)
jmp    1263 <extrapshc+0x163>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jg     12b8 <extrapshc+0x1b8>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    126a <extrapshc+0x16a>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<extrapshc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
subsd  %xmm1,%xmm0
cmp    %edx,%edi
jne    111f <extrapshc+0x1f>
lea    0x2(%rdi),%r11d
imul   %edi,%r11d
jmp    14e0 <extrapshc+0x3e0>
jle    119f <extrapshc+0x9f>
lea    0x2(%rdx),%r11d
imul   %edx,%r11d
lea    0x2(%rdi),%edx
imul   %edi,%edx
cmp    %edx,%r11d
jge    14e0 <extrapshc+0x3e0>
movslq %r11d,%rax
movslq %edx,%r10
mov    %r10,%r15
sub    %rax,%r15
cmp    $0x4,%r15
jb     1372 <extrapshc+0x272>
lea    (%r9,%rax,8),%rbx
lea    (%rsi,%r10,8),%rbp
cmp    %rbp,%rbx
jae    116c <extrapshc+0x6c>
lea    (%r9,%r10,8),%rbx
lea    (%rsi,%rax,8),%rbp
cmp    %rbx,%rbp
jb     1372 <extrapshc+0x272>
mov    %r15,%rbp
and    $0xfffffffffffffffc,%rbp
lea    -0x4(%rbp),%rbx
mov    %rbx,%r13
shr    $0x2,%r13
add    $0x1,%r13
mov    %r13d,%r12d
and    $0x3,%r12d
cmp    $0xc,%rbx
mov    %rbp,-0x8(%rsp)
jae    1282 <extrapshc+0x182>
xor    %ebx,%ebx
jmp    1315 <extrapshc+0x215>
lea    0x2(%rdi),%r11d
imul   %edi,%r11d
lea    0x2(%rdx),%eax
imul   %edx,%eax
cmp    %eax,%r11d
jge    14de <extrapshc+0x3de>
movslq %r11d,%rdi
movslq %eax,%r10
mov    %r10,%r15
sub    %rdi,%r15
cmp    $0x4,%r15
jb     143f <extrapshc+0x33f>
lea    (%r9,%rdi,8),%rbx
lea    (%rcx,%r10,8),%rbp
cmp    %rbp,%rbx
jae    11ea <extrapshc+0xea>
lea    (%r9,%r10,8),%rbx
lea    (%rcx,%rdi,8),%rbp
cmp    %rbx,%rbp
jb     143f <extrapshc+0x33f>
mov    %r15,%rbx
and    $0xfffffffffffffffc,%rbx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %rbx,-0x8(%rsp)
add    $0xfffffffffffffffc,%rbx
mov    %rbx,%r12
shr    $0x2,%r12
add    $0x1,%r12
test   %rbx,%rbx
je     1403 <extrapshc+0x303>
mov    %r12,%r13
and    $0xfffffffffffffffe,%r13
lea    (%r9,%rdi,8),%rbp
add    $0x30,%rbp
lea    (%rcx,%rdi,8),%r14
add    $0x30,%r14
xor    %ebx,%ebx
nop
movupd -0x30(%r14,%rbx,8),%xmm2
movupd -0x20(%r14,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x30(%rbp,%rbx,8)
movupd %xmm3,-0x20(%rbp,%rbx,8)
movupd -0x10(%r14,%rbx,8),%xmm2
movupd (%r14,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,-0x10(%rbp,%rbx,8)
movupd %xmm3,0x0(%rbp,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%r13
jne    1230 <extrapshc+0x130>
jmp    1405 <extrapshc+0x305>
movabs $0x7ffffffffffffffe,%rbx
ff ff 7f
add    $0xfffffffffffffffe,%rbx
and    %rbx,%r13
lea    (%r9,%rax,8),%rbp
add    $0x70,%rbp
lea    (%rsi,%rax,8),%r14
add    $0x70,%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%r14,%rbx,8),%xmm1
movups -0x60(%r14,%rbx,8),%xmm2
movups %xmm1,-0x70(%rbp,%rbx,8)
movups %xmm2,-0x60(%rbp,%rbx,8)
movups -0x50(%r14,%rbx,8),%xmm1
movups -0x40(%r14,%rbx,8),%xmm2
movups %xmm1,-0x50(%rbp,%rbx,8)
movups %xmm2,-0x40(%rbp,%rbx,8)
movups -0x30(%r14,%rbx,8),%xmm1
movups -0x20(%r14,%rbx,8),%xmm2
movups %xmm1,-0x30(%rbp,%rbx,8)
movups %xmm2,-0x20(%rbp,%rbx,8)
movupd -0x10(%r14,%rbx,8),%xmm1
movupd (%r14,%rbx,8),%xmm2
movupd %xmm1,-0x10(%rbp,%rbx,8)
movupd %xmm2,0x0(%rbp,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%r13
jne    12b0 <extrapshc+0x1b0>
test   %r12,%r12
je     1361 <extrapshc+0x261>
add    %rax,%rbx
lea    (%r9,%rbx,8),%r14
add    $0x10,%r14
lea    (%rsi,%rbx,8),%rbx
add    $0x10,%rbx
shl    $0x5,%r12
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movupd -0x10(%rbx,%rbp,1),%xmm1
movupd (%rbx,%rbp,1),%xmm2
movupd %xmm1,-0x10(%r14,%rbp,1)
movupd %xmm2,(%r14,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r12
jne    1340 <extrapshc+0x240>
mov    -0x8(%rsp),%rbx
cmp    %rbx,%r15
je     14e0 <extrapshc+0x3e0>
add    %rbx,%rax
sub    %eax,%edx
mov    %rax,%rbp
not    %rbp
add    %r10,%rbp
and    $0x3,%rdx
je     13b3 <extrapshc+0x2b3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    0x1(%rax),%rbx
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,(%r9,%rax,8)
mov    %rbx,%rax
add    $0xffffffffffffffff,%rdx
jne    1390 <extrapshc+0x290>
cmp    $0x3,%rbp
jae    13c0 <extrapshc+0x2c0>
jmp    14e0 <extrapshc+0x3e0>
mov    %rax,%rbx
cmp    $0x3,%rbp
jb     14e0 <extrapshc+0x3e0>
movsd  (%rsi,%rbx,8),%xmm1
movsd  %xmm1,(%r9,%rbx,8)
movsd  0x8(%rsi,%rbx,8),%xmm1
movsd  %xmm1,0x8(%r9,%rbx,8)
movsd  0x10(%rsi,%rbx,8),%xmm1
movsd  %xmm1,0x10(%r9,%rbx,8)
movsd  0x18(%rsi,%rbx,8),%xmm1
movsd  %xmm1,0x18(%r9,%rbx,8)
lea    0x4(%rbx),%rax
mov    %rax,%rbx
cmp    %rax,%r10
jne    13c0 <extrapshc+0x2c0>
jmp    14e0 <extrapshc+0x3e0>
xor    %ebx,%ebx
test   $0x1,%r12b
je     142e <extrapshc+0x32e>
add    %rdi,%rbx
movupd (%rcx,%rbx,8),%xmm2
movupd 0x10(%rcx,%rbx,8),%xmm3
mulpd  %xmm1,%xmm2
mulpd  %xmm1,%xmm3
movupd %xmm2,(%r9,%rbx,8)
movupd %xmm3,0x10(%r9,%rbx,8)
mov    -0x8(%rsp),%rbx
cmp    %rbx,%r15
je     14de <extrapshc+0x3de>
add    %rbx,%rdi
sub    %edi,%eax
mov    %rdi,%rbp
not    %rbp
add    %r10,%rbp
and    $0x3,%rax
je     16c5 <extrapshc+0x5c5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rdi),%rbx
movsd  (%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rdi,8)
mov    %rbx,%rdi
add    $0xffffffffffffffff,%rax
jne    1460 <extrapshc+0x360>
cmp    $0x3,%rbp
jb     14de <extrapshc+0x3de>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rcx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rbx,8)
movsd  0x8(%rcx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r9,%rbx,8)
movsd  0x10(%rcx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r9,%rbx,8)
movsd  0x18(%rcx,%rbx,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  %xmm1,0x18(%r9,%rbx,8)
lea    0x4(%rbx),%rax
mov    %rax,%rbx
cmp    %rax,%r10
jne    1490 <extrapshc+0x390>
mov    %edx,%edi
mov    %edi,(%r8)
test   %r11d,%r11d
jle    16a4 <extrapshc+0x5a4>
mov    %r11d,%r8d
lea    0x1(%r8),%rdx
mov    $0x1,%edi
cmp    $0x4,%r11d
jb     163c <extrapshc+0x53c>
lea    (%rsi,%rdx,8),%rax
add    $0xfffffffffffffff8,%rax
cmp    %r9,%rax
seta   %r11b
lea    (%r9,%rdx,8),%rbp
add    $0xfffffffffffffff8,%rbp
cmp    %rsi,%rbp
seta   %bl
lea    (%rcx,%rdx,8),%rax
add    $0xfffffffffffffff8,%rax
cmp    %r9,%rax
seta   %al
cmp    %rcx,%rbp
seta   %r10b
test   %bl,%r11b
jne    163c <extrapshc+0x53c>
and    %r10b,%al
jne    163c <extrapshc+0x53c>
mov    %r8d,%edi
and    $0xfffffffc,%edi
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rdi),%rax
mov    %rax,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rax,%rax
je     16b1 <extrapshc+0x5b1>
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
mov    $0x6,%ebx
nopl   0x0(%rax,%rax,1)
movupd -0x30(%rsi,%rbx,8),%xmm2
movupd -0x20(%rsi,%rbx,8),%xmm3
movupd -0x30(%rcx,%rbx,8),%xmm4
movupd -0x20(%rcx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x30(%r9,%rbx,8)
movupd %xmm5,-0x20(%r9,%rbx,8)
movupd -0x10(%rsi,%rbx,8),%xmm2
movupd (%rsi,%rbx,8),%xmm3
movupd -0x10(%rcx,%rbx,8),%xmm4
movupd (%rcx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x10(%r9,%rbx,8)
movupd %xmm5,(%r9,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rax
jne    1580 <extrapshc+0x480>
add    $0xfffffffffffffffb,%rbx
test   $0x1,%r10b
je     1633 <extrapshc+0x533>
movupd -0x8(%rsi,%rbx,8),%xmm2
movupd 0x8(%rsi,%rbx,8),%xmm3
movupd -0x8(%rcx,%rbx,8),%xmm4
movupd 0x8(%rcx,%rbx,8),%xmm5
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,-0x8(%r9,%rbx,8)
movupd %xmm5,0x8(%r9,%rbx,8)
cmp    %rdi,%r8
je     16a4 <extrapshc+0x5a4>
or     $0x1,%rdi
mov    %rdi,%rax
not    %rax
test   $0x1,%dl
jne    1662 <extrapshc+0x562>
movsd  -0x8(%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rsi,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r9,%rdi,8)
add    $0x1,%rdi
add    %rdx,%rax
je     16a4 <extrapshc+0x5a4>
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%rsi,%rdi,8),%xmm1
movsd  %xmm1,-0x8(%r9,%rdi,8)
movsd  (%rcx,%rdi,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rdi,8),%xmm1
movsd  %xmm1,(%r9,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    1670 <extrapshc+0x570>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%ebx
test   $0x1,%r10b
jne    15fd <extrapshc+0x4fd>
jmp    1633 <extrapshc+0x533>
mov    %rdi,%rbx
cmp    $0x3,%rbp
jae    1490 <extrapshc+0x390>
jmp    14de <extrapshc+0x3de>

LLVM IR (-O0):
define i32 @extrapshc(double %0, double %1, i32 %2, double* %3, i32 %4, double* %5, i32* %6, double* %7) {
%9 = alloca double
%10 = alloca double
%11 = alloca i32
%12 = alloca double*
%13 = alloca i32
%14 = alloca double*
%15 = alloca i32*
%16 = alloca double*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca double
store double %0, double* %9
store double %1, double* %10
store i32 %2, i32* %11
store double* %3, double** %12
store i32 %4, i32* %13
store double* %5, double** %14
store i32* %6, i32** %15
store double* %7, double** %16
%21 = load double*, double** %16
%22 = getelementptr inbounds double, double* %21, i32 -1
store double* %22, double** %16
%23 = load double*, double** %14
%24 = getelementptr inbounds double, double* %23, i32 -1
store double* %24, double** %14
%25 = load double*, double** %12
%26 = getelementptr inbounds double, double* %25, i32 -1
store double* %26, double** %12
%27 = load double, double* %9
%28 = load double, double* %10
%29 = fsub double %27, %28
store double %29, double* %20
%30 = load i32, i32* %11
%31 = load i32, i32* %13
%32 = icmp eq i32 %30, %31
br i1 %32, label %33, label %40
33: ; preds = %8
%34 = load i32, i32* %11
%35 = load i32, i32* %11
%36 = add nsw i32 %35, 2
%37 = mul nsw i32 %34, %36
store i32 %37, i32* %18
%38 = load i32, i32* %11
%39 = load i32*, i32** %15
store i32 %38, i32* %39
br label %109
40: ; preds = %8
%41 = load i32, i32* %11
%42 = load i32, i32* %13
%43 = icmp sgt i32 %41, %42
br i1 %43, label %44, label %75
44: ; preds = %40
%45 = load i32, i32* %13
%46 = load i32, i32* %13
%47 = add nsw i32 %46, 2
%48 = mul nsw i32 %45, %47
store i32 %48, i32* %18
%49 = load i32, i32* %11
%50 = load i32, i32* %11
%51 = add nsw i32 %50, 2
%52 = mul nsw i32 %49, %51
store i32 %52, i32* %19
%53 = load i32, i32* %18
%54 = add nsw i32 %53, 1
store i32 %54, i32* %17
br label %55
55: ; preds = %69, %44
%56 = load i32, i32* %17
%57 = load i32, i32* %19
%58 = icmp sle i32 %56, %57
br i1 %58, label %59, label %72
59: ; preds = %55
%60 = load double*, double** %12
%61 = load i32, i32* %17
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds double, double* %60, i64 %62
%64 = load double, double* %63
%65 = load double*, double** %16
%66 = load i32, i32* %17
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds double, double* %65, i64 %67
store double %64, double* %68
br label %69
69: ; preds = %59
%70 = load i32, i32* %17
%71 = add nsw i32 %70, 1
store i32 %71, i32* %17
br label %55
72: ; preds = %55
%73 = load i32, i32* %11
%74 = load i32*, i32** %15
store i32 %73, i32* %74
br label %108
75: ; preds = %40
%76 = load i32, i32* %11
%77 = load i32, i32* %11
%78 = add nsw i32 %77, 2
%79 = mul nsw i32 %76, %78
store i32 %79, i32* %18
%80 = load i32, i32* %13
%81 = load i32, i32* %13
%82 = add nsw i32 %81, 2
%83 = mul nsw i32 %80, %82
store i32 %83, i32* %19
%84 = load i32, i32* %18
%85 = add nsw i32 %84, 1
store i32 %85, i32* %17
br label %86
86: ; preds = %102, %75
%87 = load i32, i32* %17
%88 = load i32, i32* %19
%89 = icmp sle i32 %87, %88
br i1 %89, label %90, label %105
90: ; preds = %86
%91 = load double, double* %20
%92 = load double*, double** %14
%93 = load i32, i32* %17
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double, double* %92, i64 %94
%96 = load double, double* %95
%97 = fmul double %91, %96
%98 = load double*, double** %16
%99 = load i32, i32* %17
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds double, double* %98, i64 %100
store double %97, double* %101
br label %102
102: ; preds = %90
%103 = load i32, i32* %17
%104 = add nsw i32 %103, 1
store i32 %104, i32* %17
br label %86
105: ; preds = %86
%106 = load i32, i32* %13
%107 = load i32*, i32** %15
store i32 %106, i32* %107
br label %108
108: ; preds = %105, %72
br label %109
109: ; preds = %108, %33
store i32 1, i32* %17
br label %110
110: ; preds = %131, %109
%111 = load i32, i32* %17
%112 = load i32, i32* %18
%113 = icmp sle i32 %111, %112
br i1 %113, label %114, label %134
114: ; preds = %110
%115 = load double*, double** %12
%116 = load i32, i32* %17
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %115, i64 %117
%119 = load double, double* %118
%120 = load double, double* %20
%121 = load double*, double** %14
%122 = load i32, i32* %17
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds double, double* %121, i64 %123
%125 = load double, double* %124
%126 = call double @llvm.fmuladd.f64(double %120, double %125, double %119)
%127 = load double*, double** %16
%128 = load i32, i32* %17
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
store double %126, double* %130
br label %131
131: ; preds = %114
%132 = load i32, i32* %17
%133 = add nsw i32 %132, 1
store i32 %133, i32* %17
br label %110
134: ; preds = %110
ret i32 0
}

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