#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);
int LinRegress(double *x, double *y, int n, double *a, double *b, double *r) {
  int i;
  double sumx = 0, sumy = 0, sumx2 = 0, sumy2 = 0, sumxy = 0;
  double sxx, syy, sxy;
  *a = 0;
  *b = 0;
  *r = 0;
  if (n < 2)
    return (0);
  for (i = 0; i < n; i++) {
    sumx += x[i];
    sumy += y[i];
    sumx2 += (x[i] * x[i]);
    sumy2 += (y[i] * y[i]);
    sumxy += (x[i] * y[i]);
  }
  sxx = sumx2 - sumx * sumx / n;
  syy = sumy2 - sumy * sumy / n;
  sxy = sumxy - sumx * sumy / n;
  if ((sxx < 0 ? -(sxx) : (sxx)) == 0)
    return (0);
  *b = sxy / sxx;
  *a = sumy / n - (*b) * sumx / n;
  if ((syy < 0 ? -(syy) : (syy)) == 0)
    *r = 1;
  else
    *r = sxy / sqrt(sxx * syy);
  return (1);
}


x86 assembly (clang, -O0):
<LinRegress>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%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)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
mov    -0x38(%rbp),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax)
cmpl   $0x2,-0x1c(%rbp)
jge    1191 <LinRegress+0x81>
movl   $0x0,-0x4(%rbp)
jmp    1422 <LinRegress+0x312>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1264 <LinRegress+0x154>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x68(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1198 <LinRegress+0x88>
movsd  -0x58(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  -0x48(%rbp),%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
mulsd  -0x50(%rbp),%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    12fe <LinRegress+0x1ee>
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
jmp    130b <LinRegress+0x1fb>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1332 <LinRegress+0x222>
jp     1332 <LinRegress+0x222>
movl   $0x0,-0x4(%rbp)
jmp    1422 <LinRegress+0x312>
movsd  -0x80(%rbp),%xmm0
divsd  -0x70(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x50(%rbp),%xmm0
cvtsi2sdl -0x1c(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
movsd  (%rax),%xmm1
mulsd  -0x48(%rbp),%xmm1
cvtsi2sdl -0x1c(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movsd  %xmm0,(%rax)
xorps  %xmm0,%xmm0
ucomisd -0x78(%rbp),%xmm0
jbe    13ab <LinRegress+0x29b>
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
jmp    13b8 <LinRegress+0x2a8>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13e8 <LinRegress+0x2d8>
jp     13e8 <LinRegress+0x2d8>
mov    -0x38(%rbp),%rax
movsd  0xc21(%rip),%xmm0
movsd  %xmm0,(%rax)
jmp    141b <LinRegress+0x30b>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
mulsd  -0x78(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
mov    -0x38(%rbp),%rax
movsd  %xmm0,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LinRegress>:
push   %r14
push   %rbx
sub    $0x18,%rsp
movq   $0x0,(%rcx)
movq   $0x0,(%r8)
movq   $0x0,(%r9)
xor    %eax,%eax
cmp    $0x2,%edx
jl     12f6 <LinRegress+0x1e6>
mov    %r9,%r14
mov    %edx,%r9d
lea    0x0(,%r9,8),%rax
and    $0xfffffffffffffff0,%rax
xorpd  %xmm7,%xmm7
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
xorpd  %xmm1,%xmm1
xorpd  %xmm3,%xmm3
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rbx,1),%xmm0
movsd  0x8(%rdi,%rbx,1),%xmm4
addsd  %xmm0,%xmm2
movsd  (%rsi,%rbx,1),%xmm5
addsd  %xmm5,%xmm3
movapd %xmm0,%xmm6
unpcklpd %xmm5,%xmm0
unpcklpd %xmm5,%xmm5
mulpd  %xmm0,%xmm5
addpd  %xmm7,%xmm5
movsd  0x8(%rsi,%rbx,1),%xmm0
mulsd  %xmm6,%xmm6
addsd  %xmm1,%xmm6
addsd  %xmm4,%xmm2
addsd  %xmm0,%xmm3
movapd %xmm4,%xmm1
mulsd  %xmm4,%xmm1
addsd  %xmm6,%xmm1
unpcklpd %xmm0,%xmm4
unpcklpd %xmm0,%xmm0
mulpd  %xmm4,%xmm0
movapd %xmm0,%xmm7
addpd  %xmm5,%xmm7
add    $0x10,%rbx
cmp    %rbx,%rax
jne    1160 <LinRegress+0x50>
test   $0x1,%r9b
je     11ff <LinRegress+0xef>
movsd  (%rdi,%rbx,1),%xmm0
addsd  %xmm0,%xmm2
movsd  (%rsi,%rbx,1),%xmm4
addsd  %xmm4,%xmm3
movapd %xmm0,%xmm5
mulsd  %xmm0,%xmm5
addsd  %xmm5,%xmm1
unpcklpd %xmm4,%xmm0
unpcklpd %xmm4,%xmm4
mulpd  %xmm0,%xmm4
addpd  %xmm4,%xmm7
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
xorps  %xmm5,%xmm5
cvtsi2sd %edx,%xmm5
divsd  %xmm5,%xmm0
subsd  %xmm0,%xmm1
movapd 0xde2(%rip),%xmm0
xorpd  %xmm1,%xmm0
xorpd  %xmm4,%xmm4
movapd %xmm1,%xmm6
cmpltsd %xmm4,%xmm6
andpd  %xmm6,%xmm0
andnpd %xmm1,%xmm6
orpd   %xmm0,%xmm6
xor    %eax,%eax
ucomisd %xmm4,%xmm6
jne    1249 <LinRegress+0x139>
jnp    12f6 <LinRegress+0x1e6>
movapd %xmm3,%xmm6
mulsd  %xmm3,%xmm6
divsd  %xmm5,%xmm6
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
subsd  %xmm6,%xmm0
movapd %xmm3,%xmm6
mulsd  %xmm2,%xmm6
divsd  %xmm5,%xmm6
subsd  %xmm6,%xmm7
movapd %xmm7,%xmm6
divsd  %xmm1,%xmm6
movsd  %xmm6,(%r8)
divsd  %xmm5,%xmm3
mulsd  %xmm2,%xmm6
divsd  %xmm5,%xmm6
subsd  %xmm6,%xmm3
movsd  %xmm3,(%rcx)
movapd 0xd66(%rip),%xmm2
xorpd  %xmm0,%xmm2
movapd %xmm0,%xmm3
cmpltsd %xmm4,%xmm3
andpd  %xmm3,%xmm2
andnpd %xmm0,%xmm3
orpd   %xmm2,%xmm3
ucomisd %xmm4,%xmm3
jne    12c5 <LinRegress+0x1b5>
jp     12c5 <LinRegress+0x1b5>
movsd  0xd4d(%rip),%xmm7
jmp    12ec <LinRegress+0x1dc>
mulsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12d9 <LinRegress+0x1c9>
sqrtsd %xmm0,%xmm0
jmp    12e8 <LinRegress+0x1d8>
movapd %xmm7,(%rsp)
call   1030 <sqrt@plt>
movapd (%rsp),%xmm7
divsd  %xmm0,%xmm7
movsd  %xmm7,(%r14)
mov    $0x1,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i32 @LinRegress(double* nocapture %0, double* nocapture %1, i32 %2, double* nocapture writeonly %3, double* nocapture writeonly %4, double* nocapture writeonly %5) {
store double 0.000000e+00, double* %3
store double 0.000000e+00, double* %4
store double 0.000000e+00, double* %5
%7 = icmp slt i32 %2, 2
br i1 %7, label %99, label %8
8: ; preds = %6
%9 = zext i32 %2 to i64
%10 = and i64 %9, 1
%11 = and i64 %9, 4294967294
br label %12
12: ; preds = %12, %8
%13 = phi i64 [ 0, %8 ], [ %44, %12 ]
%14 = phi double [ 0.000000e+00, %8 ], [ %34, %12 ]
%15 = phi double [ 0.000000e+00, %8 ], [ %38, %12 ]
%16 = phi double [ 0.000000e+00, %8 ], [ %37, %12 ]
%17 = phi <2 x double> [ zeroinitializer, %8 ], [ %43, %12 ]
%18 = phi i64 [ 0, %8 ], [ %45, %12 ]
%19 = getelementptr inbounds double, double* %0, i64 %13
%20 = load double, double* %19
%21 = fadd double %14, %20
%22 = getelementptr inbounds double, double* %1, i64 %13
%23 = load double, double* %22
%24 = fadd double %16, %23
%25 = tail call double @llvm.fmuladd.f64(double %20, double %20, double %15)
%26 = insertelement <2 x double> poison, double %20, i64 0
%27 = insertelement <2 x double> %26, double %23, i64 1
%28 = insertelement <2 x double> poison, double %23, i64 0
%29 = shufflevector <2 x double> %28, <2 x double> poison, <2 x i32> zeroinitializer
%30 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %27, <2 x double> %29, <2 x double> %17)
%31 = or i64 %13, 1
%32 = getelementptr inbounds double, double* %0, i64 %31
%33 = load double, double* %32
%34 = fadd double %21, %33
%35 = getelementptr inbounds double, double* %1, i64 %31
%36 = load double, double* %35
%37 = fadd double %24, %36
%38 = tail call double @llvm.fmuladd.f64(double %33, double %33, double %25)
%39 = insertelement <2 x double> poison, double %33, i64 0
%40 = insertelement <2 x double> %39, double %36, i64 1
%41 = insertelement <2 x double> poison, double %36, 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> %30)
%44 = add nuw nsw i64 %13, 2
%45 = add i64 %18, 2
%46 = icmp eq i64 %45, %11
br i1 %46, label %47, label %12
47: ; preds = %12
%48 = icmp eq i64 %10, 0
br i1 %48, label %62, label %49
49: ; preds = %47
%50 = getelementptr inbounds double, double* %0, i64 %44
%51 = load double, double* %50
%52 = fadd double %34, %51
%53 = getelementptr inbounds double, double* %1, i64 %44
%54 = load double, double* %53
%55 = fadd double %37, %54
%56 = tail call double @llvm.fmuladd.f64(double %51, double %51, double %38)
%57 = insertelement <2 x double> poison, double %51, i64 0
%58 = insertelement <2 x double> %57, double %54, i64 1
%59 = insertelement <2 x double> poison, double %54, i64 0
%60 = shufflevector <2 x double> %59, <2 x double> poison, <2 x i32> zeroinitializer
%61 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %58, <2 x double> %60, <2 x double> %43)
br label %62
62: ; preds = %47, %49
%63 = phi double [ %34, %47 ], [ %52, %49 ]
%64 = phi double [ %37, %47 ], [ %55, %49 ]
%65 = phi double [ %38, %47 ], [ %56, %49 ]
%66 = phi <2 x double> [ %43, %47 ], [ %61, %49 ]
%67 = fmul double %63, %63
%68 = sitofp i32 %2 to double
%69 = fdiv double %67, %68
%70 = fsub double %65, %69
%71 = fmul double %64, %64
%72 = fdiv double %71, %68
%73 = extractelement <2 x double> %66, i64 1
%74 = fsub double %73, %72
%75 = fmul double %64, %63
%76 = fdiv double %75, %68
%77 = extractelement <2 x double> %66, i64 0
%78 = fsub double %77, %76
%79 = fcmp olt double %70, 0.000000e+00
%80 = fneg double %70
%81 = select i1 %79, double %80, double %70
%82 = fcmp oeq double %81, 0.000000e+00
br i1 %82, label %99, label %83
83: ; preds = %62
%84 = fdiv double %78, %70
store double %84, double* %4
%85 = fdiv double %64, %68
%86 = fmul double %63, %84
%87 = fdiv double %86, %68
%88 = fsub double %85, %87
store double %88, double* %3
%89 = fcmp olt double %74, 0.000000e+00
%90 = fneg double %74
%91 = select i1 %89, double %90, double %74
%92 = fcmp oeq double %91, 0.000000e+00
br i1 %92, label %97, label %93
93: ; preds = %83
%94 = fmul double %74, %70
%95 = tail call double @sqrt(double %94)
%96 = fdiv double %78, %95
br label %97
97: ; preds = %83, %93
%98 = phi double [ %96, %93 ], [ 1.000000e+00, %83 ]
store double %98, double* %5
br label %99
99: ; preds = %62, %6, %97
%100 = phi i32 [ 1, %97 ], [ 0, %6 ], [ 0, %62 ]
ret i32 %100
}