#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);
double *shapiro_wilk_exp(double *x, int n) {
  static double y[2];
  double mean, b, s1, xs, sum1 = 0.0, sum2 = 0.0;
  int i;
  for (i = 0; i < n; ++i)
    if (i == 0 || xs > x[i])
      xs = x[i];
  for (i = 0; i < n; ++i) {
    sum1 += x[i];
    sum2 += x[i] * x[i];
  }
  s1 = sum2 - sum1 * sum1 / n;
  mean = sum1 / n;
  b = (mean - xs) * sqrt((double)n / (n - 1.0));
  y[0] = b * b / s1;
  return y;
}


x86 assembly (clang, -O0):
<shapiro_wilk_exp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1189 <shapiro_wilk_exp+0x79>
cmpl   $0x0,-0x44(%rbp)
je     1164 <shapiro_wilk_exp+0x54>
movsd  -0x30(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1176 <shapiro_wilk_exp+0x66>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
jmp    117b <shapiro_wilk_exp+0x6b>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1136 <shapiro_wilk_exp+0x26>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11ed <shapiro_wilk_exp+0xdd>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1190 <shapiro_wilk_exp+0x80>
movsd  -0x40(%rbp),%xmm0
movsd  -0x38(%rbp),%xmm1
mulsd  -0x38(%rbp),%xmm1
cvtsi2sdl -0xc(%rbp),%xmm2
divsd  %xmm2,%xmm1
subsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x38(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x18(%rbp)
movsd  -0x18(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
cvtsi2sdl -0xc(%rbp),%xmm1
movsd  0xdbe(%rip),%xmm2
subsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x50(%rbp),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
mulsd  -0x20(%rbp),%xmm0
divsd  -0x28(%rbp),%xmm0
movsd  %xmm0,0x2dc9(%rip)
lea    0x2dc2(%rip),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<shapiro_wilk_exp>:
sub    $0x18,%rsp
xorpd  %xmm1,%xmm1
test   %esi,%esi
jle    1146 <shapiro_wilk_exp+0x36>
mov    %esi,%r8d
movsd  (%rdi),%xmm2
cmp    $0x1,%esi
je     11da <shapiro_wilk_exp+0xca>
lea    -0x1(%r8),%rcx
lea    -0x2(%r8),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1153 <shapiro_wilk_exp+0x43>
mov    $0x1,%edx
jmp    1195 <shapiro_wilk_exp+0x85>
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
jmp    128a <shapiro_wilk_exp+0x17a>
and    $0xfffffffffffffffc,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movsd  0x8(%rdi,%rdx,8),%xmm0
minsd  %xmm2,%xmm0
movsd  0x10(%rdi,%rdx,8),%xmm2
minsd  %xmm0,%xmm2
movsd  0x18(%rdi,%rdx,8),%xmm0
minsd  %xmm2,%xmm0
movsd  0x20(%rdi,%rdx,8),%xmm2
minsd  %xmm0,%xmm2
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1160 <shapiro_wilk_exp+0x50>
add    $0x1,%rdx
movapd %xmm2,%xmm0
test   %rax,%rax
je     11c6 <shapiro_wilk_exp+0xb6>
lea    (%rdi,%rdx,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rcx,%rdx,8),%xmm0
minsd  %xmm2,%xmm0
add    $0x1,%rdx
movapd %xmm0,%xmm2
cmp    %rdx,%rax
jne    11b0 <shapiro_wilk_exp+0xa0>
movapd %xmm0,%xmm2
xorpd  %xmm4,%xmm4
xorpd  %xmm5,%xmm5
test   %esi,%esi
jle    128a <shapiro_wilk_exp+0x17a>
lea    -0x1(%r8),%rax
mov    %r8d,%ecx
and    $0x3,%ecx
cmp    $0x3,%rax
jae    11f6 <shapiro_wilk_exp+0xe6>
xorpd  %xmm5,%xmm5
xor    %edx,%edx
xorpd  %xmm4,%xmm4
jmp    1260 <shapiro_wilk_exp+0x150>
and    $0xfffffffc,%r8d
xorpd  %xmm5,%xmm5
xor    %edx,%edx
xorpd  %xmm4,%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdi,%rdx,8),%xmm0
movsd  0x8(%rdi,%rdx,8),%xmm3
addsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm0
addsd  %xmm5,%xmm0
addsd  %xmm3,%xmm4
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
movsd  0x10(%rdi,%rdx,8),%xmm0
addsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm0
addsd  %xmm3,%xmm0
movsd  0x18(%rdi,%rdx,8),%xmm5
addsd  %xmm5,%xmm4
mulsd  %xmm5,%xmm5
addsd  %xmm0,%xmm5
add    $0x4,%rdx
cmp    %rdx,%r8
jne    1210 <shapiro_wilk_exp+0x100>
test   %rcx,%rcx
je     128a <shapiro_wilk_exp+0x17a>
lea    (%rdi,%rdx,8),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
addsd  %xmm0,%xmm4
mulsd  %xmm0,%xmm0
addsd  %xmm0,%xmm5
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1270 <shapiro_wilk_exp+0x160>
movapd %xmm4,%xmm3
mulsd  %xmm4,%xmm3
xorps  %xmm0,%xmm0
cvtsi2sd %esi,%xmm0
divsd  %xmm0,%xmm3
subsd  %xmm3,%xmm5
divsd  %xmm0,%xmm4
subsd  %xmm2,%xmm4
movsd  0xd4f(%rip),%xmm2
addsd  %xmm0,%xmm2
divsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jb     12c5 <shapiro_wilk_exp+0x1b5>
sqrtsd %xmm0,%xmm0
jmp    12e2 <shapiro_wilk_exp+0x1d2>
movsd  %xmm4,0x10(%rsp)
movsd  %xmm5,0x8(%rsp)
call   1030 <sqrt@plt>
movsd  0x8(%rsp),%xmm5
movsd  0x10(%rsp),%xmm4
mulsd  %xmm0,%xmm4
mulsd  %xmm4,%xmm4
divsd  %xmm5,%xmm4
movsd  %xmm4,0x2d4a(%rip)
lea    0x2d43(%rip),%rax
add    $0x18,%rsp
ret

LLVM IR (-O0):
@shapiro_wilk_exp.y = internal global [2 x double] zeroinitializer
define double* @shapiro_wilk_exp(double* %0, i32 %1) {
%3 = alloca double*
%4 = alloca i32
%5 = alloca double
%6 = alloca double
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca double
%11 = alloca i32
store double* %0, double** %3
store i32 %1, i32* %4
store double 0.000000e+00, double* %9
store double 0.000000e+00, double* %10
store i32 0, i32* %11
br label %12
12: ; preds = %34, %2
%13 = load i32, i32* %11
%14 = load i32, i32* %4
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %37
16: ; preds = %12
%17 = load i32, i32* %11
%18 = icmp eq i32 %17, 0
br i1 %18, label %27, label %19
19: ; preds = %16
%20 = load double, double* %8
%21 = load double*, double** %3
%22 = load i32, i32* %11
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds double, double* %21, i64 %23
%25 = load double, double* %24
%26 = fcmp ogt double %20, %25
br i1 %26, label %27, label %33
27: ; preds = %19, %16
%28 = load double*, double** %3
%29 = load i32, i32* %11
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds double, double* %28, i64 %30
%32 = load double, double* %31
store double %32, double* %8
br label %33
33: ; preds = %27, %19
br label %34
34: ; preds = %33
%35 = load i32, i32* %11
%36 = add nsw i32 %35, 1
store i32 %36, i32* %11
br label %12
37: ; preds = %12
store i32 0, i32* %11
br label %38
38: ; preds = %62, %37
%39 = load i32, i32* %11
%40 = load i32, i32* %4
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %65
42: ; preds = %38
%43 = load double*, double** %3
%44 = load i32, i32* %11
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds double, double* %43, i64 %45
%47 = load double, double* %46
%48 = load double, double* %9
%49 = fadd double %48, %47
store double %49, double* %9
%50 = load double*, double** %3
%51 = load i32, i32* %11
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds double, double* %50, i64 %52
%54 = load double, double* %53
%55 = load double*, double** %3
%56 = load i32, i32* %11
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds double, double* %55, i64 %57
%59 = load double, double* %58
%60 = load double, double* %10
%61 = call double @llvm.fmuladd.f64(double %54, double %59, double %60)
store double %61, double* %10
br label %62
62: ; preds = %42
%63 = load i32, i32* %11
%64 = add nsw i32 %63, 1
store i32 %64, i32* %11
br label %38
65: ; preds = %38
%66 = load double, double* %10
%67 = load double, double* %9
%68 = load double, double* %9
%69 = fmul double %67, %68
%70 = load i32, i32* %4
%71 = sitofp i32 %70 to double
%72 = fdiv double %69, %71
%73 = fsub double %66, %72
store double %73, double* %7
%74 = load double, double* %9
%75 = load i32, i32* %4
%76 = sitofp i32 %75 to double
%77 = fdiv double %74, %76
store double %77, double* %5
%78 = load double, double* %5
%79 = load double, double* %8
%80 = fsub double %78, %79
%81 = load i32, i32* %4
%82 = sitofp i32 %81 to double
%83 = load i32, i32* %4
%84 = sitofp i32 %83 to double
%85 = fsub double %84, 1.000000e+00
%86 = fdiv double %82, %85
%87 = call double @sqrt(double %86)
%88 = fmul double %80, %87
store double %88, double* %6
%89 = load double, double* %6
%90 = load double, double* %6
%91 = fmul double %89, %90
%92 = load double, double* %7
%93 = fdiv double %91, %92
store double %93, double* getelementptr inbounds ([2 x double], [2 x double]* @shapiro_wilk_exp.y, i64 0, i64 0)
ret double* getelementptr inbounds ([2 x double], [2 x double]* @shapiro_wilk_exp.y, i64 0, i64 0)
}

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