#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 /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, int, ...);
double pow(double, int);
double sqrt(double);
int /*<<< orphan*/ stderr;
void calcular_varianza_desvio_estandar(double *medidas, int sum, int cant,
                                       int mi) {
  double varianza = 0;
  double desv_estandar = 0;
  double media = (double)sum / cant;
  int cant_en_desviacion = 0;
  int i;
  for (i = 0; i < mi; i++)
    varianza = varianza + pow((medidas[i] - media), 2);
  varianza = varianza / mi;
  desv_estandar = sqrt(varianza);
  for (i = 0; i < mi; i++)
    if (((media - desv_estandar) <= medidas[i]) &&
        (medidas[i] <= (media + desv_estandar)))
      cant_en_desviacion++;
  fprintf(stderr, "\n\tNro de Mediciones = %i \tMedia = %f\n", mi, media);
  fprintf(stderr, "\tVarianza : %f\n", varianza);
  fprintf(stderr, "\tDesviacion estandar : %f\n", sqrt(varianza));
  fprintf(stderr, "\tMedidas dentro de la desviacion estandar : %i (%i%%)\n\n",
          cant_en_desviacion, cant_en_desviacion * 100 / mi);
}


x86 assembly (clang, -O0):
<calcular_varianza_desvio_estandar>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x20(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x28(%rbp)
cvtsi2sdl -0xc(%rbp),%xmm0
cvtsi2sdl -0x10(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11c7 <calcular_varianza_desvio_estandar+0x97>
movsd  -0x20(%rbp),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x30(%rbp),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
movaps %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1176 <calcular_varianza_desvio_estandar+0x46>
movsd  -0x20(%rbp),%xmm0
cvtsi2sdl -0x14(%rbp),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x20(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1050 <sqrt@plt>
movsd  %xmm0,-0x28(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    125a <calcular_varianza_desvio_estandar+0x12a>
movsd  -0x30(%rbp),%xmm1
subsd  -0x28(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     1247 <calcular_varianza_desvio_estandar+0x117>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x30(%rbp),%xmm0
addsd  -0x28(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1247 <calcular_varianza_desvio_estandar+0x117>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    124c <calcular_varianza_desvio_estandar+0x11c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11f0 <calcular_varianza_desvio_estandar+0xc0>
mov    0x2d7f(%rip),%rax
mov    (%rax),%edi
mov    -0x14(%rbp),%edx
movsd  -0x30(%rbp),%xmm0
lea    0xd8e(%rip),%rsi
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    0x2d60(%rip),%rax
mov    (%rax),%edi
cvttsd2si -0x20(%rbp),%edx
lea    0xd98(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d44(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x48(%rbp)
movsd  -0x20(%rbp),%xmm0
call   1050 <sqrt@plt>
mov    -0x48(%rbp),%edi
cvttsd2si %xmm0,%edx
lea    0xd7d(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
mov    0x2d19(%rip),%rax
mov    (%rax),%edi
mov    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
imul   $0x64,-0x34(%rbp),%eax
cltd
idivl  -0x14(%rbp)
mov    -0x44(%rbp),%edx
mov    %eax,%ecx
lea    0xd6e(%rip),%rsi
mov    $0x0,%al
call   1030 <fprintf@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calcular_varianza_desvio_estandar>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%r12d
cvtsi2sd %esi,%xmm1
cvtsi2sd %edx,%xmm0
divsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%rsp)
test   %ecx,%ecx
jle    1184 <calcular_varianza_desvio_estandar+0x54>
mov    %rdi,%r14
mov    %r12d,0x14(%rsp)
mov    %r12d,%r15d
lea    -0x1(%r15),%rax
mov    %r15d,%r12d
and    $0x3,%r12d
cmp    $0x3,%rax
jae    11b0 <calcular_varianza_desvio_estandar+0x80>
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
movsd  0x8(%rsp),%xmm2
jmp    1268 <calcular_varianza_desvio_estandar+0x138>
cvtsi2sd %r12d,%xmm2
xorpd  %xmm1,%xmm1
xorpd  %xmm0,%xmm0
divsd  %xmm2,%xmm0
xor    %ebp,%ebp
ucomisd %xmm1,%xmm0
movsd  %xmm0,(%rsp)
jae    14b5 <calcular_varianza_desvio_estandar+0x385>
call   1050 <sqrt@plt>
jmp    14b5 <calcular_varianza_desvio_estandar+0x385>
mov    %r15d,%r13d
and    $0xfffffffc,%r13d
xorpd  %xmm1,%xmm1
xor    %ebp,%ebp
movsd  0x8(%rsp),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm1,(%rsp)
movsd  (%r14,%rbp,8),%xmm0
subsd  %xmm2,%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x8(%r14,%rbp,8),%xmm0
subsd  0x8(%rsp),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x10(%r14,%rbp,8),%xmm0
subsd  0x8(%rsp),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movsd  0x18(%r14,%rbp,8),%xmm0
subsd  0x8(%rsp),%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
movsd  0x8(%rsp),%xmm2
movapd %xmm0,%xmm1
addsd  (%rsp),%xmm1
add    $0x4,%rbp
cmp    %rbp,%r13
jne    11d0 <calcular_varianza_desvio_estandar+0xa0>
test   %r12,%r12
je     12b1 <calcular_varianza_desvio_estandar+0x181>
lea    (%r14,%rbp,8),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  %xmm1,(%rsp)
movsd  0x0(%rbp,%rbx,8),%xmm0
subsd  %xmm2,%xmm0
mov    $0x2,%edi
call   1040 <pow@plt>
movsd  0x8(%rsp),%xmm2
movsd  (%rsp),%xmm1
addsd  %xmm0,%xmm1
add    $0x1,%rbx
cmp    %rbx,%r12
jne    1280 <calcular_varianza_desvio_estandar+0x150>
mov    0x14(%rsp),%r12d
xorps  %xmm0,%xmm0
cvtsi2sd %r12d,%xmm0
divsd  %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm0,%xmm1
movsd  %xmm1,(%rsp)
jb     12e4 <calcular_varianza_desvio_estandar+0x1b4>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
test   %r12d,%r12d
jg     12f2 <calcular_varianza_desvio_estandar+0x1c2>
xor    %ebp,%ebp
jmp    14b5 <calcular_varianza_desvio_estandar+0x385>
movapd %xmm1,%xmm0
call   1050 <sqrt@plt>
test   %r12d,%r12d
jle    12dd <calcular_varianza_desvio_estandar+0x1ad>
movsd  0x8(%rsp),%xmm1
movapd %xmm1,%xmm8
subsd  %xmm0,%xmm8
addsd  %xmm1,%xmm0
cmp    $0x4,%r12d
jae    1315 <calcular_varianza_desvio_estandar+0x1e5>
xor    %eax,%eax
xor    %ebp,%ebp
jmp    1490 <calcular_varianza_desvio_estandar+0x360>
mov    %r15d,%eax
and    $0xfffffffc,%eax
movapd %xmm8,%xmm9
unpcklpd %xmm8,%xmm9
movapd %xmm0,%xmm10
unpcklpd %xmm0,%xmm10
lea    -0x4(%rax),%rdx
mov    %rdx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     1547 <calcular_varianza_desvio_estandar+0x417>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm11,%xmm11
xor    %edx,%edx
pxor   %xmm5,%xmm5
nopl   0x0(%rax)
movupd (%r14,%rdx,8),%xmm1
movupd 0x10(%r14,%rdx,8),%xmm2
movupd 0x20(%r14,%rdx,8),%xmm7
movupd 0x30(%r14,%rdx,8),%xmm6
movapd %xmm9,%xmm3
cmplepd %xmm1,%xmm3
movapd %xmm9,%xmm4
cmplepd %xmm2,%xmm4
cmplepd %xmm10,%xmm1
andpd  %xmm3,%xmm1
cmplepd %xmm10,%xmm2
andpd  %xmm4,%xmm2
psrlq  $0x3f,%xmm1
psrlq  $0x3f,%xmm2
pshufd $0xe8,%xmm1,%xmm1
paddd  %xmm11,%xmm1
pshufd $0xe8,%xmm2,%xmm2
paddd  %xmm5,%xmm2
movapd %xmm9,%xmm3
cmplepd %xmm7,%xmm3
movapd %xmm9,%xmm4
cmplepd %xmm6,%xmm4
cmplepd %xmm10,%xmm7
andpd  %xmm3,%xmm7
cmplepd %xmm10,%xmm6
andpd  %xmm4,%xmm6
psrlq  $0x3f,%xmm7
psrlq  $0x3f,%xmm6
pshufd $0xe8,%xmm7,%xmm11
paddd  %xmm1,%xmm11
pshufd $0xe8,%xmm6,%xmm5
paddd  %xmm2,%xmm5
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rsi
jne    1360 <calcular_varianza_desvio_estandar+0x230>
test   $0x1,%cl
je     1468 <calcular_varianza_desvio_estandar+0x338>
movupd (%r14,%rdx,8),%xmm1
movupd 0x10(%r14,%rdx,8),%xmm2
movapd %xmm9,%xmm3
cmplepd %xmm1,%xmm3
cmplepd %xmm2,%xmm9
cmplepd %xmm10,%xmm1
andpd  %xmm3,%xmm1
cmplepd %xmm10,%xmm2
andpd  %xmm9,%xmm2
psrlq  $0x3f,%xmm1
psrlq  $0x3f,%xmm2
pshufd $0xe8,%xmm1,%xmm1
paddd  %xmm1,%xmm11
pshufd $0xe8,%xmm2,%xmm1
paddd  %xmm1,%xmm5
paddd  %xmm5,%xmm11
pshufd $0x55,%xmm11,%xmm1
paddd  %xmm11,%xmm1
movd   %xmm1,%ebp
cmp    %r15,%rax
je     14b5 <calcular_varianza_desvio_estandar+0x385>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm8,%xmm1
setae  %cl
ucomisd %xmm1,%xmm0
setae  %dl
and    %cl,%dl
movzbl %dl,%ecx
add    %ecx,%ebp
add    $0x1,%rax
cmp    %rax,%r15
jne    1490 <calcular_varianza_desvio_estandar+0x360>
movsd  0x8(%rsp),%xmm0
mov    0x2b1e(%rip),%r15
mov    (%r15),%edi
lea    0xb34(%rip),%rsi
mov    %r12d,%edx
mov    $0x1,%al
call   1030 <fprintf@plt>
mov    (%r15),%edi
cvttsd2si (%rsp),%edx
lea    0xb41(%rip),%rsi
xor    %eax,%eax
call   1030 <fprintf@plt>
movsd  (%rsp),%xmm0
mov    (%r15),%ebx
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1504 <calcular_varianza_desvio_estandar+0x3d4>
sqrtsd %xmm0,%xmm0
jmp    1509 <calcular_varianza_desvio_estandar+0x3d9>
call   1050 <sqrt@plt>
cvttsd2si %xmm0,%edx
lea    0xb22(%rip),%rsi
mov    %ebx,%edi
xor    %eax,%eax
call   1030 <fprintf@plt>
mov    (%r15),%edi
imul   $0x64,%ebp,%eax
cltd
idiv   %r12d
lea    0xb23(%rip),%rsi
mov    %ebp,%edx
mov    %eax,%ecx
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <fprintf@plt>
pxor   %xmm11,%xmm11
xor    %edx,%edx
pxor   %xmm5,%xmm5
test   $0x1,%cl
jne    1419 <calcular_varianza_desvio_estandar+0x2e9>
jmp    1468 <calcular_varianza_desvio_estandar+0x338>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [38 x i8] c"\0A\09Nro de Mediciones = %i \09Media = %f\0A\00"
@.str.1 = [16 x i8] c"\09Varianza : %f\0A\00"
@.str.2 = [27 x i8] c"\09Desviacion estandar : %f\0A\00"
@.str.3 = [56 x i8] c"\09Medidas dentro de la desviacion estandar : %i (%i%%)\0A\0A\00"
define void @calcular_varianza_desvio_estandar(double* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca double*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca double
%10 = alloca double
%11 = alloca double
%12 = alloca i32
%13 = alloca i32
store double* %0, double** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
store double 0.000000e+00, double* %9
store double 0.000000e+00, double* %10
%14 = load i32, i32* %6
%15 = sitofp i32 %14 to double
%16 = load i32, i32* %7
%17 = sitofp i32 %16 to double
%18 = fdiv double %15, %17
store double %18, double* %11
store i32 0, i32* %12
store i32 0, i32* %13
br label %19
19: ; preds = %34, %4
%20 = load i32, i32* %13
%21 = load i32, i32* %8
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %37
23: ; preds = %19
%24 = load double, double* %9
%25 = load double*, double** %5
%26 = load i32, i32* %13
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds double, double* %25, i64 %27
%29 = load double, double* %28
%30 = load double, double* %11
%31 = fsub double %29, %30
%32 = call double @pow(double %31, i32 2)
%33 = fadd double %24, %32
store double %33, double* %9
br label %34
34: ; preds = %23
%35 = load i32, i32* %13
%36 = add nsw i32 %35, 1
store i32 %36, i32* %13
br label %19
37: ; preds = %19
%38 = load double, double* %9
%39 = load i32, i32* %8
%40 = sitofp i32 %39 to double
%41 = fdiv double %38, %40
store double %41, double* %9
%42 = load double, double* %9
%43 = call double @sqrt(double %42)
store double %43, double* %10
store i32 0, i32* %13
br label %44
44: ; preds = %72, %37
%45 = load i32, i32* %13
%46 = load i32, i32* %8
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %75
48: ; preds = %44
%49 = load double, double* %11
%50 = load double, double* %10
%51 = fsub double %49, %50
%52 = load double*, double** %5
%53 = load i32, i32* %13
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds double, double* %52, i64 %54
%56 = load double, double* %55
%57 = fcmp ole double %51, %56
br i1 %57, label %58, label %71
58: ; preds = %48
%59 = load double*, double** %5
%60 = load i32, i32* %13
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %59, i64 %61
%63 = load double, double* %62
%64 = load double, double* %11
%65 = load double, double* %10
%66 = fadd double %64, %65
%67 = fcmp ole double %63, %66
br i1 %67, label %68, label %71
68: ; preds = %58
%69 = load i32, i32* %12
%70 = add nsw i32 %69, 1
store i32 %70, i32* %12
br label %71
71: ; preds = %68, %58, %48
br label %72
72: ; preds = %71
%73 = load i32, i32* %13
%74 = add nsw i32 %73, 1
store i32 %74, i32* %13
br label %44
75: ; preds = %44
%76 = load i32, i32* @stderr
%77 = load i32, i32* %8
%78 = load double, double* %11
%79 = call i32 (i32, i8*, i32, ...) @fprintf(i32 %76, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0), i32 %77, double %78)
%80 = load i32, i32* @stderr
%81 = load double, double* %9
%82 = fptosi double %81 to i32
%83 = call i32 (i32, i8*, i32, ...) @fprintf(i32 %80, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i32 %82)
%84 = load i32, i32* @stderr
%85 = load double, double* %9
%86 = call double @sqrt(double %85)
%87 = fptosi double %86 to i32
%88 = call i32 (i32, i8*, i32, ...) @fprintf(i32 %84, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), i32 %87)
%89 = load i32, i32* @stderr
%90 = load i32, i32* %12
%91 = load i32, i32* %12
%92 = mul nsw i32 %91, 100
%93 = load i32, i32* %8
%94 = sdiv i32 %92, %93
%95 = call i32 (i32, i8*, i32, ...) @fprintf(i32 %89, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.3, i64 0, i64 0), i32 %90, i32 %94)
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [38 x i8] c"\0A\09Nro de Mediciones = %i \09Media = %f\0A\00"
@.str.1 = [16 x i8] c"\09Varianza : %f\0A\00"
@.str.2 = [27 x i8] c"\09Desviacion estandar : %f\0A\00"
@.str.3 = [56 x i8] c"\09Medidas dentro de la desviacion estandar : %i (%i%%)\0A\0A\00"
define void @calcular_varianza_desvio_estandar(double* nocapture %0, i32 %1, i32 %2, i32 %3) {
%5 = sitofp i32 %1 to double
%6 = sitofp i32 %2 to double
%7 = fdiv double %5, %6
%8 = icmp sgt i32 %3, 0
br i1 %8, label %13, label %9
9: ; preds = %4
%10 = sitofp i32 %3 to double
%11 = fdiv double 0.000000e+00, %10
%12 = tail call double @sqrt(double %11)
br label %180
13: ; preds = %4
%14 = zext i32 %3 to i64
%15 = add nsw i64 %14, -1
%16 = and i64 %14, 3
%17 = icmp ult i64 %15, 3
br i1 %17, label %50, label %18
18: ; preds = %13
%19 = and i64 %14, 4294967292
br label %20
20: ; preds = %20, %18
%21 = phi i64 [ 0, %18 ], [ %47, %20 ]
%22 = phi double [ 0.000000e+00, %18 ], [ %46, %20 ]
%23 = phi i64 [ 0, %18 ], [ %48, %20 ]
%24 = getelementptr inbounds double, double* %0, i64 %21
%25 = load double, double* %24
%26 = fsub double %25, %7
%27 = tail call double @pow(double %26, i32 2)
%28 = fadd double %22, %27
%29 = or i64 %21, 1
%30 = getelementptr inbounds double, double* %0, i64 %29
%31 = load double, double* %30
%32 = fsub double %31, %7
%33 = tail call double @pow(double %32, i32 2)
%34 = fadd double %28, %33
%35 = or i64 %21, 2
%36 = getelementptr inbounds double, double* %0, i64 %35
%37 = load double, double* %36
%38 = fsub double %37, %7
%39 = tail call double @pow(double %38, i32 2)
%40 = fadd double %34, %39
%41 = or i64 %21, 3
%42 = getelementptr inbounds double, double* %0, i64 %41
%43 = load double, double* %42
%44 = fsub double %43, %7
%45 = tail call double @pow(double %44, i32 2)
%46 = fadd double %40, %45
%47 = add nuw nsw i64 %21, 4
%48 = add i64 %23, 4
%49 = icmp eq i64 %48, %19
br i1 %49, label %50, label %20
50: ; preds = %20, %13
%51 = phi double [ undef, %13 ], [ %46, %20 ]
%52 = phi i64 [ 0, %13 ], [ %47, %20 ]
%53 = phi double [ 0.000000e+00, %13 ], [ %46, %20 ]
%54 = icmp eq i64 %16, 0
br i1 %54, label %67, label %55
55: ; preds = %50, %55
%56 = phi i64 [ %64, %55 ], [ %52, %50 ]
%57 = phi double [ %63, %55 ], [ %53, %50 ]
%58 = phi i64 [ %65, %55 ], [ 0, %50 ]
%59 = getelementptr inbounds double, double* %0, i64 %56
%60 = load double, double* %59
%61 = fsub double %60, %7
%62 = tail call double @pow(double %61, i32 2)
%63 = fadd double %57, %62
%64 = add nuw nsw i64 %56, 1
%65 = add i64 %58, 1
%66 = icmp eq i64 %65, %16
br i1 %66, label %67, label %55
67: ; preds = %55, %50
%68 = phi double [ %51, %50 ], [ %63, %55 ]
%69 = sitofp i32 %3 to double
%70 = fdiv double %68, %69
%71 = tail call double @sqrt(double %70)
br i1 %8, label %72, label %180
72: ; preds = %67
%73 = fsub double %7, %71
%74 = fadd double %7, %71
%75 = zext i32 %3 to i64
%76 = icmp ult i32 %3, 4
br i1 %76, label %165, label %77
77: ; preds = %72
%78 = and i64 %14, 4294967292
%79 = insertelement <2 x double> poison, double %73, i64 0
%80 = shufflevector <2 x double> %79, <2 x double> poison, <2 x i32> zeroinitializer
%81 = insertelement <2 x double> poison, double %73, i64 0
%82 = shufflevector <2 x double> %81, <2 x double> poison, <2 x i32> zeroinitializer
%83 = insertelement <2 x double> poison, double %74, i64 0
%84 = shufflevector <2 x double> %83, <2 x double> poison, <2 x i32> zeroinitializer
%85 = insertelement <2 x double> poison, double %74, i64 0
%86 = shufflevector <2 x double> %85, <2 x double> poison, <2 x i32> zeroinitializer
%87 = add nsw i64 %78, -4
%88 = lshr exact i64 %87, 2
%89 = add nuw nsw i64 %88, 1
%90 = and i64 %89, 1
%91 = icmp eq i64 %87, 0
br i1 %91, label %135, label %92
92: ; preds = %77
%93 = and i64 %89, 9223372036854775806
br label %94
94: ; preds = %94, %92
%95 = phi i64 [ 0, %92 ], [ %132, %94 ]
%96 = phi <2 x i32> [ zeroinitializer, %92 ], [ %130, %94 ]
%97 = phi <2 x i32> [ zeroinitializer, %92 ], [ %131, %94 ]
%98 = phi i64 [ 0, %92 ], [ %133, %94 ]
%99 = getelementptr inbounds double, double* %0, i64 %95
%100 = bitcast double* %99 to <2 x double>*
%101 = load <2 x double>, <2 x double>* %100
%102 = getelementptr inbounds double, double* %99, i64 2
%103 = bitcast double* %102 to <2 x double>*
%104 = load <2 x double>, <2 x double>* %103
%105 = fcmp ole <2 x double> %80, %101
%106 = fcmp ole <2 x double> %82, %104
%107 = fcmp ole <2 x double> %101, %84
%108 = fcmp ole <2 x double> %104, %86
%109 = and <2 x i1> %105, %107
%110 = and <2 x i1> %106, %108
%111 = zext <2 x i1> %109 to <2 x i32>
%112 = zext <2 x i1> %110 to <2 x i32>
%113 = add <2 x i32> %96, %111
%114 = add <2 x i32> %97, %112
%115 = or i64 %95, 4
%116 = getelementptr inbounds double, double* %0, i64 %115
%117 = bitcast double* %116 to <2 x double>*
%118 = load <2 x double>, <2 x double>* %117
%119 = getelementptr inbounds double, double* %116, i64 2
%120 = bitcast double* %119 to <2 x double>*
%121 = load <2 x double>, <2 x double>* %120
%122 = fcmp ole <2 x double> %80, %118
%123 = fcmp ole <2 x double> %82, %121
%124 = fcmp ole <2 x double> %118, %84
%125 = fcmp ole <2 x double> %121, %86
%126 = and <2 x i1> %122, %124
%127 = and <2 x i1> %123, %125
%128 = zext <2 x i1> %126 to <2 x i32>
%129 = zext <2 x i1> %127 to <2 x i32>
%130 = add <2 x i32> %113, %128
%131 = add <2 x i32> %114, %129
%132 = add nuw i64 %95, 8
%133 = add i64 %98, 2
%134 = icmp eq i64 %133, %93
br i1 %134, label %135, label %94
135: ; preds = %94, %77
%136 = phi <2 x i32> [ undef, %77 ], [ %130, %94 ]
%137 = phi <2 x i32> [ undef, %77 ], [ %131, %94 ]
%138 = phi i64 [ 0, %77 ], [ %132, %94 ]
%139 = phi <2 x i32> [ zeroinitializer, %77 ], [ %130, %94 ]
%140 = phi <2 x i32> [ zeroinitializer, %77 ], [ %131, %94 ]
%141 = icmp eq i64 %90, 0
br i1 %141, label %159, label %142
142: ; preds = %135
%143 = getelementptr inbounds double, double* %0, i64 %138
%144 = bitcast double* %143 to <2 x double>*
%145 = load <2 x double>, <2 x double>* %144
%146 = getelementptr inbounds double, double* %143, i64 2
%147 = bitcast double* %146 to <2 x double>*
%148 = load <2 x double>, <2 x double>* %147
%149 = fcmp ole <2 x double> %80, %145
%150 = fcmp ole <2 x double> %82, %148
%151 = fcmp ole <2 x double> %145, %84
%152 = fcmp ole <2 x double> %148, %86
%153 = and <2 x i1> %149, %151
%154 = and <2 x i1> %150, %152
%155 = zext <2 x i1> %153 to <2 x i32>
%156 = zext <2 x i1> %154 to <2 x i32>
%157 = add <2 x i32> %139, %155
%158 = add <2 x i32> %140, %156
br label %159
159: ; preds = %135, %142
%160 = phi <2 x i32> [ %136, %135 ], [ %157, %142 ]
%161 = phi <2 x i32> [ %137, %135 ], [ %158, %142 ]
%162 = add <2 x i32> %161, %160
%163 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %162)
%164 = icmp eq i64 %78, %14
br i1 %164, label %180, label %165
165: ; preds = %72, %159
%166 = phi i64 [ 0, %72 ], [ %78, %159 ]
%167 = phi i32 [ 0, %72 ], [ %163, %159 ]
br label %168
168: ; preds = %165, %168
%169 = phi i64 [ %178, %168 ], [ %166, %165 ]
%170 = phi i32 [ %177, %168 ], [ %167, %165 ]
%171 = getelementptr inbounds double, double* %0, i64 %169
%172 = load double, double* %171
%173 = fcmp ole double %73, %172
%174 = fcmp ole double %172, %74
%175 = and i1 %173, %174
%176 = zext i1 %175 to i32
%177 = add nuw nsw i32 %170, %176
%178 = add nuw nsw i64 %169, 1
%179 = icmp eq i64 %178, %75
br i1 %179, label %180, label %168
180: ; preds = %168, %159, %9, %67
%181 = phi double [ %70, %67 ], [ %11, %9 ], [ %70, %159 ], [ %70, %168 ]
%182 = phi i32 [ 0, %67 ], [ 0, %9 ], [ %163, %159 ], [ %177, %168 ]
%183 = load i32, i32* @stderr
%184 = tail call i32 (i32, i8*, i32, ...) @fprintf(i32 %183, i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str, i64 0, i64 0), i32 %3, double %7)
%185 = load i32, i32* @stderr
%186 = fptosi double %181 to i32
%187 = tail call i32 (i32, i8*, i32, ...) @fprintf(i32 %185, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i32 %186)
%188 = load i32, i32* @stderr
%189 = tail call double @sqrt(double %181)
%190 = fptosi double %189 to i32
%191 = tail call i32 (i32, i8*, i32, ...) @fprintf(i32 %188, i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.2, i64 0, i64 0), i32 %190)
%192 = load i32, i32* @stderr
%193 = mul nsw i32 %182, 100
%194 = sdiv i32 %193, %3
%195 = tail call i32 (i32, i8*, i32, ...) @fprintf(i32 %192, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str.3, i64 0, i64 0), i32 %182, i32 %194)
ret void
}