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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int spline(const double *px, const double *py, size_t n, double *py2,
           double *pu) {
  double qn = 0.0;
  double un = 0.0;
  double p;
  double sig;
  py2[0] = 0.0;
  pu[0] = 0.0;
  for (size_t i = 1; i < n - 1; i++) {
    sig = (px[i] - px[i - 1]) / (px[i + 1] - px[i - 1]);
    p = sig * py2[i - 1] + 2.0;
    py2[i] = (sig - 1.0) / p;
    pu[i] = (py[i + 1] - py[i]) / (px[i + 1] - px[i]) -
            (py[i] - py[i - 1]) / (px[i] - px[i - 1]);
    pu[i] = (6.0 * pu[i] / (px[i + 1] - px[i - 1]) - sig * pu[i - 1]) / p;
  }
  py2[n - 1] = (un - qn * pu[n - 2]) / (qn * py2[n - 2] + 1.0);
  for (size_t k = n - 1; k-- > 0;)
    py2[k] = py2[k] * py2[k + 1] + pu[k];
  return 0;
}


x86 assembly (clang, -O0):
<spline>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
movq   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jae    130a <spline+0x20a>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xe4d(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  0xe27(%rip),%xmm1
subsd  %xmm1,%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
divsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0xd7e(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
subsd  (%rax,%rcx,8),%xmm0
divsd  %xmm0,%xmm1
movsd  -0x48(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
sub    $0x1,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
divsd  -0x40(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1146 <spline+0x46>
movsd  -0x38(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x30(%rbp),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x2,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
movsd  0xc9a(%rip),%xmm2
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x58(%rbp)
cmp    $0x0,%rax
jbe    13e6 <spline+0x2e6>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  0x8(%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    138b <spline+0x28b>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<spline>:
movq   $0x0,(%rcx)
movq   $0x0,(%r8)
lea    -0x1(%rdx),%r9
cmp    $0x2,%r9
jb     12f9 <spline+0x1f9>
lea    (%r8,%r9,8),%rax
cmp    %rcx,%rax
jbe    1214 <spline+0x114>
lea    (%rcx,%r9,8),%rax
cmp    %r8,%rax
jbe    1214 <spline+0x114>
lea    -0x2(%rdx),%r10
xor    %eax,%eax
movsd  0xebb(%rip),%xmm8
movsd  0xebb(%rip),%xmm1
movsd  0xebb(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rax,8),%xmm4
movsd  0x8(%rdi,%rax,8),%xmm3
subsd  %xmm4,%xmm3
movsd  0x10(%rdi,%rax,8),%xmm5
subsd  %xmm4,%xmm5
divsd  %xmm5,%xmm3
movsd  (%rcx,%rax,8),%xmm4
mulsd  %xmm3,%xmm4
addsd  %xmm8,%xmm4
movapd %xmm3,%xmm5
addsd  %xmm1,%xmm5
divsd  %xmm4,%xmm5
movsd  %xmm5,0x8(%rcx,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm5
movsd  0x10(%rsi,%rax,8),%xmm6
subsd  %xmm5,%xmm6
movsd  0x8(%rdi,%rax,8),%xmm7
movsd  0x10(%rdi,%rax,8),%xmm0
subsd  %xmm7,%xmm0
subsd  (%rsi,%rax,8),%xmm5
subsd  (%rdi,%rax,8),%xmm7
divsd  %xmm0,%xmm6
divsd  %xmm7,%xmm5
subsd  %xmm5,%xmm6
movsd  %xmm6,0x8(%r8,%rax,8)
mulsd  %xmm2,%xmm6
movsd  0x10(%rdi,%rax,8),%xmm0
subsd  (%rdi,%rax,8),%xmm0
divsd  %xmm0,%xmm6
mulsd  (%r8,%rax,8),%xmm3
subsd  %xmm3,%xmm6
divsd  %xmm4,%xmm6
movsd  %xmm6,0x8(%r8,%rax,8)
add    $0x1,%rax
cmp    %rax,%r10
jne    1160 <spline+0x60>
jmp    12f9 <spline+0x1f9>
movsd  (%rcx),%xmm0
movsd  (%r8),%xmm4
lea    -0x2(%rdx),%r10
xor    %eax,%eax
movsd  0xdd4(%rip),%xmm8
movsd  0xdd3(%rip),%xmm9
movsd  0xdd3(%rip),%xmm3
nopl   (%rax)
movupd 0x8(%rdi,%rax,8),%xmm5
movsd  (%rdi,%rax,8),%xmm6
unpcklpd %xmm6,%xmm6
subpd  %xmm6,%xmm5
movapd %xmm5,%xmm6
unpckhpd %xmm5,%xmm6
divsd  %xmm6,%xmm5
mulsd  %xmm5,%xmm0
addsd  %xmm8,%xmm0
movapd %xmm5,%xmm6
addsd  %xmm9,%xmm6
divsd  %xmm0,%xmm6
movsd  %xmm6,0x8(%rcx,%rax,8)
movupd 0x8(%rsi,%rax,8),%xmm7
mulsd  %xmm4,%xmm5
movapd %xmm7,%xmm4
shufpd $0x1,%xmm7,%xmm4
movupd 0x8(%rdi,%rax,8),%xmm2
movapd %xmm2,%xmm1
shufpd $0x1,%xmm2,%xmm1
movhpd (%rsi,%rax,8),%xmm7
movhpd (%rdi,%rax,8),%xmm2
subpd  %xmm7,%xmm4
subpd  %xmm2,%xmm1
divpd  %xmm1,%xmm4
movapd %xmm4,%xmm1
unpckhpd %xmm4,%xmm1
subsd  %xmm1,%xmm4
movsd  %xmm4,0x8(%r8,%rax,8)
mulsd  %xmm3,%xmm4
movsd  0x10(%rdi,%rax,8),%xmm1
subsd  (%rdi,%rax,8),%xmm1
divsd  %xmm1,%xmm4
subsd  %xmm5,%xmm4
divsd  %xmm0,%xmm4
movsd  %xmm4,0x8(%r8,%rax,8)
add    $0x1,%rax
movapd %xmm6,%xmm0
cmp    %rax,%r10
jne    1240 <spline+0x140>
movsd  -0x10(%r8,%rdx,8),%xmm1
mulsd  0xd10(%rip),%xmm1
xorpd  %xmm2,%xmm2
addsd  %xmm2,%xmm1
movsd  -0x10(%rcx,%rdx,8),%xmm0
mulsd  %xmm0,%xmm2
addsd  0xcfe(%rip),%xmm2
divsd  %xmm2,%xmm1
movsd  %xmm1,-0x8(%rcx,%rdx,8)
test   %r9,%r9
je     13ad <spline+0x2ad>
mov    %rdx,%rax
mulsd  %xmm1,%xmm0
addsd  -0x10(%r8,%rdx,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rdx,8)
add    $0xfffffffffffffffe,%rax
je     13ad <spline+0x2ad>
lea    -0x3(%rdx),%rax
test   $0x1,%dl
jne    1362 <spline+0x262>
mov    %rax,%rdx
test   %rax,%rax
jne    1380 <spline+0x280>
jmp    13ad <spline+0x2ad>
mulsd  -0x18(%rcx,%rdx,8),%xmm0
addsd  -0x18(%r8,%rdx,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rdx,8)
add    $0xfffffffffffffffc,%rdx
test   %rax,%rax
je     13ad <spline+0x2ad>
xchg   %ax,%ax
mulsd  (%rcx,%rdx,8),%xmm0
addsd  (%r8,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
mulsd  -0x8(%rcx,%rdx,8),%xmm0
addsd  -0x8(%r8,%rdx,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
add    $0xfffffffffffffffe,%rdx
cmp    $0xffffffffffffffff,%rdx
jne    1380 <spline+0x280>
xor    %eax,%eax
ret

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

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