#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 sqrt(double);
void polinomial(double *x, double *y, int n, double *a1, double *a0,
                double *syx, double *r2) {
  double sumx = 0, sumxy = 0, st = 0, sumy = 0, sumx2 = 0, sr = 0, ym, xm;
  int i;
  for (i = 0; i < n; i++) {
    sumx = sumx + x[i];
    sumy = sumy + y[i];
    sumxy = sumxy + (x[i] * y[i]);
    sumx2 = sumx2 + (x[i] * y[i]);
  }
  xm = sumx / n;
  ym = sumy / n;
  *a1 = (n * sumxy - sumx * sumy) / (n * sumx2 - sumx * sumx);
  *a0 = ym - *a1 * xm;
  for (i = 0; i < n; i++) {
    st = st + ((y[i] - ym) * (y[i] - ym));
    sr = sr + ((y[i] - (*a1 * x[i]) - *a0) * (y[i] - (*a1 * x[i]) - *a0));
  }
  *syx = sqrt(sr * (n - 2));
  *r2 = (st - sr) / st;
}


x86 assembly (clang, -O0):
<polinomial>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    120d <polinomial+0xfd>
movsd  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x50(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
movsd  -0x40(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
movsd  -0x58(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    116d <polinomial+0x5d>
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x50(%rbp),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x38(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm3
movsd  -0x38(%rbp),%xmm2
mulsd  -0x38(%rbp),%xmm2
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x68(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movsd  -0x70(%rbp),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13d9 <polinomial+0x2c9>
movsd  -0x48(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
subsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm3,%xmm0
addsd  %xmm2,%xmm0
mov    -0x28(%rbp),%rax
subsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x74(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm4
movq   %xmm2,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm2
mulsd  %xmm4,%xmm2
addsd  %xmm3,%xmm2
mov    -0x28(%rbp),%rax
subsd  (%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    12e5 <polinomial+0x1d5>
movsd  -0x60(%rbp),%xmm0
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
cvtsi2sd %eax,%xmm1
mulsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x48(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
mov    0x10(%rbp),%rax
movsd  %xmm0,(%rax)
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<polinomial>:
push   %r14
push   %rbx
sub    $0x28,%rsp
mov    %r9,%r14
xorpd  %xmm7,%xmm7
mov    %edx,%r9d
test   %edx,%edx
jle    1147 <polinomial+0x37>
cmp    $0x1,%edx
jne    1158 <polinomial+0x48>
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
xorpd  %xmm2,%xmm2
test   $0x1,%r9b
jne    11d1 <polinomial+0xc1>
jmp    11ef <polinomial+0xdf>
xorpd  %xmm2,%xmm2
xorpd  %xmm0,%xmm0
xorpd  %xmm3,%xmm3
jmp    11ef <polinomial+0xdf>
mov    %r9d,%eax
and    $0xfffffffe,%eax
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
xorpd  %xmm2,%xmm2
nopl   0x0(%rax)
movsd  (%rdi,%rbx,8),%xmm4
movsd  0x8(%rdi,%rbx,8),%xmm5
addsd  %xmm4,%xmm0
movsd  (%rsi,%rbx,8),%xmm6
movsd  0x8(%rsi,%rbx,8),%xmm3
addsd  %xmm6,%xmm2
mulsd  %xmm6,%xmm4
unpcklpd %xmm4,%xmm4
addpd  %xmm1,%xmm4
addsd  %xmm5,%xmm0
addsd  %xmm3,%xmm2
movapd %xmm5,%xmm1
mulsd  %xmm3,%xmm1
unpcklpd %xmm1,%xmm1
addpd  %xmm4,%xmm1
add    $0x2,%rbx
cmp    %rbx,%rax
jne    1170 <polinomial+0x60>
unpcklpd %xmm5,%xmm5
unpcklpd %xmm3,%xmm3
mulpd  %xmm5,%xmm3
addpd  %xmm4,%xmm3
test   $0x1,%r9b
je     11ef <polinomial+0xdf>
movsd  (%rdi,%rbx,8),%xmm3
addsd  %xmm3,%xmm0
movsd  (%rsi,%rbx,8),%xmm4
addsd  %xmm4,%xmm2
mulsd  %xmm4,%xmm3
unpcklpd %xmm3,%xmm3
addpd  %xmm1,%xmm3
xorps  %xmm4,%xmm4
cvtsi2sd %edx,%xmm4
movapd %xmm0,%xmm5
divsd  %xmm4,%xmm5
movapd %xmm2,%xmm1
divsd  %xmm4,%xmm1
mulsd  %xmm0,%xmm2
movapd %xmm3,%xmm6
unpckhpd %xmm3,%xmm6
mulsd  %xmm4,%xmm6
subsd  %xmm2,%xmm6
mulsd  %xmm0,%xmm0
mulsd  %xmm3,%xmm4
subsd  %xmm0,%xmm4
divsd  %xmm4,%xmm6
movsd  %xmm6,(%rcx)
mulsd  %xmm5,%xmm6
movapd %xmm1,%xmm2
subsd  %xmm6,%xmm2
movsd  %xmm2,(%r8)
test   %edx,%edx
jle    12fb <polinomial+0x1eb>
movsd  (%rcx),%xmm0
xorpd  0xdad(%rip),%xmm0
unpcklpd %xmm2,%xmm1
cmp    $0x1,%edx
jne    126d <polinomial+0x15d>
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
test   $0x1,%r9b
jne    12dd <polinomial+0x1cd>
jmp    12fb <polinomial+0x1eb>
mov    %r9d,%eax
and    $0xfffffffe,%eax
xorpd  %xmm2,%xmm2
xor    %ecx,%ecx
nopl   0x0(%rax)
movsd  (%rdi,%rcx,8),%xmm4
mulsd  %xmm0,%xmm4
movsd  (%rsi,%rcx,8),%xmm3
movsd  0x8(%rsi,%rcx,8),%xmm7
addsd  %xmm3,%xmm4
unpcklpd %xmm4,%xmm3
subpd  %xmm1,%xmm3
mulpd  %xmm3,%xmm3
addpd  %xmm2,%xmm3
movsd  0x8(%rdi,%rcx,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm7,%xmm2
unpcklpd %xmm2,%xmm7
subpd  %xmm1,%xmm7
mulpd  %xmm7,%xmm7
movapd %xmm7,%xmm2
addpd  %xmm3,%xmm2
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1280 <polinomial+0x170>
addpd  %xmm3,%xmm7
test   $0x1,%r9b
je     12fb <polinomial+0x1eb>
movsd  (%rsi,%rcx,8),%xmm7
mulsd  (%rdi,%rcx,8),%xmm0
addsd  %xmm7,%xmm0
unpcklpd %xmm0,%xmm7
subpd  %xmm1,%xmm7
mulpd  %xmm7,%xmm7
addpd  %xmm2,%xmm7
mov    0x40(%rsp),%rbx
add    $0xfffffffe,%edx
xorps  %xmm1,%xmm1
cvtsi2sd %edx,%xmm1
movapd %xmm7,%xmm2
unpckhpd %xmm7,%xmm2
movapd %xmm2,%xmm0
mulsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     132a <polinomial+0x21a>
sqrtsd %xmm0,%xmm0
jmp    1345 <polinomial+0x235>
movapd %xmm7,0x10(%rsp)
movapd %xmm2,(%rsp)
call   1030 <sqrt@plt>
movapd (%rsp),%xmm2
movapd 0x10(%rsp),%xmm7
movsd  %xmm0,(%r14)
movapd %xmm7,%xmm0
subsd  %xmm2,%xmm0
divsd  %xmm7,%xmm0
movsd  %xmm0,(%rbx)
add    $0x28,%rsp
pop    %rbx
pop    %r14
ret

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

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