#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*/ printf(char *, ...);
int /*<<< orphan*/ quickSort(double *, int /*<<< orphan*/, int);
int /*<<< orphan*/ scanf(char *, ...);
int main(void) {
  int n;
  scanf("%d", &n);
  int i;
  double w[5000], s[5000], a[5000];
  for (i = 0; i < n; i++) {
    scanf("%lf%lf", &w[i], &s[i]);
  }
  double low = 0.454545, high = 1.666667;
  double mid;
  while (high - low > 1e-7) {
    int flag = 0;
    mid = (low + high) / 2.0;
    for (i = 0; i < n; i++) {
      a[i] = s[i] - mid * w[i];
    }
    quickSort(a, 0, n - 1);
    for (i = 0; i < n / 2; i++) {
      if (a[i] + a[n - 1 - i] < 20 * mid) {
        flag = 1;
        printf("hi");
        break;
      }
    }
    if (flag == 1) {
      high = mid;
    } else
      low = mid;
  }
  printf("%lf", mid);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d4f0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xedf(%rip),%rdi
lea    -0x8(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11a7 <main+0x77>
movslq -0xc(%rbp),%rax
lea    -0x9c50(%rbp),%rsi
shl    $0x3,%rax
add    %rax,%rsi
movslq -0xc(%rbp),%rax
lea    -0x13890(%rbp),%rdx
shl    $0x3,%rax
add    %rax,%rdx
lea    0xe99(%rip),%rdi
mov    $0x0,%al
call   1040 <scanf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    115b <main+0x2b>
movsd  0xe59(%rip),%xmm0
movsd  %xmm0,-0x1d4d8(%rbp)
ff
movsd  0xe41(%rip),%xmm0
movsd  %xmm0,-0x1d4e0(%rbp)
ff
movsd  -0x1d4e0(%rbp),%xmm0
ff
subsd  -0x1d4d8(%rbp),%xmm0
ff
movsd  0xe31(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1367 <main+0x237>
movl   $0x0,-0x1d4ec(%rbp)
movsd  -0x1d4d8(%rbp),%xmm0
ff
addsd  -0x1d4e0(%rbp),%xmm0
ff
movsd  0xe0d(%rip),%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x1d4e8(%rbp)
ff
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1286 <main+0x156>
movslq -0xc(%rbp),%rax
movsd  -0x13890(%rbp,%rax,8),%xmm1
fe ff
movsd  -0x1d4e8(%rbp),%xmm0
ff
movslq -0xc(%rbp),%rax
movsd  -0x9c50(%rbp,%rax,8),%xmm2
ff ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movslq -0xc(%rbp),%rax
movsd  %xmm0,-0x1d4d0(%rbp,%rax,8)
fe ff
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    121e <main+0xee>
lea    -0x1d4d0(%rbp),%rdi
mov    -0x8(%rbp),%edx
sub    $0x1,%edx
xor    %esi,%esi
call   1050 <quickSort@plt>
movl   $0x0,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x1d4f0(%rbp)
mov    -0x8(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1d4f0(%rbp),%eax
cmp    %ecx,%eax
jge    1330 <main+0x200>
movslq -0xc(%rbp),%rax
movsd  -0x1d4d0(%rbp,%rax,8),%xmm1
fe ff
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
sub    -0xc(%rbp),%eax
cltq
addsd  -0x1d4d0(%rbp,%rax,8),%xmm1
fe ff
movsd  0xd32(%rip),%xmm0
mulsd  -0x1d4e8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    131d <main+0x1ed>
movl   $0x1,-0x1d4ec(%rbp)
lea    0xd21(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    1330 <main+0x200>
jmp    1322 <main+0x1f2>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12a1 <main+0x171>
cmpl   $0x1,-0x1d4ec(%rbp)
jne    1352 <main+0x222>
movsd  -0x1d4e8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d4e0(%rbp)
ff
jmp    1362 <main+0x232>
movsd  -0x1d4e8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d4d8(%rbp)
ff
jmp    11c7 <main+0x97>
movsd  -0x1d4e8(%rbp),%xmm0
ff
lea    0xcb8(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1d4f0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x1d4f8,%rsp
lea    0xefb(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
mov    0x4(%rsp),%edx
test   %edx,%edx
jle    11a6 <main+0x76>
lea    0x9c70(%rsp),%r14
lea    0x138b0(%rsp),%r12
lea    0xed3(%rip),%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r15,%rdi
mov    %r12,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1040 <scanf@plt>
add    $0x1,%rbx
movslq 0x4(%rsp),%rdx
add    $0x8,%r14
add    $0x8,%r12
cmp    %rdx,%rbx
jl     1180 <main+0x50>
movsd  0xe52(%rip),%xmm1
movsd  0xe52(%rip),%xmm4
lea    0x30(%rsp),%r15
lea    0xe88(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm1,0x28(%rsp)
movapd %xmm1,%xmm5
addsd  %xmm4,%xmm5
mulsd  0xe2a(%rip),%xmm5
test   %edx,%edx
jle    1325 <main+0x1f5>
movapd %xmm5,%xmm0
xorpd  0xe36(%rip),%xmm0
mov    %edx,%eax
cmp    $0x4,%edx
jae    1210 <main+0xe0>
xor    %ecx,%ecx
jmp    1300 <main+0x1d0>
nopl   0x0(%rax,%rax,1)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
lea    -0x4(%rcx),%rsi
mov    %rsi,%rbx
shr    $0x2,%rbx
add    $0x1,%rbx
test   %rsi,%rsi
je     13f5 <main+0x2c5>
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
xchg   %ax,%ax
movapd 0x138b0(%rsp,%rsi,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  0x9c70(%rsp,%rsi,8),%xmm2
movapd 0x138c0(%rsp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  0x9c80(%rsp,%rsi,8),%xmm3
movapd %xmm2,0x30(%rsp,%rsi,8)
movapd %xmm3,0x40(%rsp,%rsi,8)
movapd 0x138d0(%rsp,%rsi,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  0x9c90(%rsp,%rsi,8),%xmm2
movapd 0x138e0(%rsp,%rsi,8),%xmm3
mulpd  %xmm1,%xmm3
addpd  0x9ca0(%rsp,%rsi,8),%xmm3
movapd %xmm2,0x50(%rsp,%rsi,8)
movapd %xmm3,0x60(%rsp,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1240 <main+0x110>
test   $0x1,%bl
je     12f3 <main+0x1c3>
movapd 0x138b0(%rsp,%rsi,8),%xmm2
mulpd  %xmm1,%xmm2
addpd  0x9c70(%rsp,%rsi,8),%xmm2
mulpd  0x138c0(%rsp,%rsi,8),%xmm1
addpd  0x9c80(%rsp,%rsi,8),%xmm1
movapd %xmm2,0x30(%rsp,%rsi,8)
movapd %xmm1,0x40(%rsp,%rsi,8)
cmp    %rax,%rcx
je     1325 <main+0x1f5>
nopl   0x0(%rax,%rax,1)
movsd  0x138b0(%rsp,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  0x9c70(%rsp,%rcx,8),%xmm1
movsd  %xmm1,0x30(%rsp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1300 <main+0x1d0>
movapd %xmm5,0x10(%rsp)
movsd  %xmm4,0x8(%rsp)
add    $0xffffffff,%edx
mov    %r15,%rdi
xor    %esi,%esi
call   1050 <quickSort@plt>
mov    0x4(%rsp),%eax
cmp    $0x2,%eax
jl     13a0 <main+0x270>
mov    %eax,%ecx
shr    %rax
movapd 0x10(%rsp),%xmm0
movapd %xmm0,%xmm2
mulsd  0xcba(%rip),%xmm2
add    $0xffffffff,%ecx
xor    %edx,%edx
movsd  0x8(%rsp),%xmm4
nopl   0x0(%rax)
movsd  0x30(%rsp,%rdx,8),%xmm1
movslq %ecx,%rsi
addsd  0x30(%rsp,%rsi,8),%xmm1
ucomisd %xmm1,%xmm2
ja     13c0 <main+0x290>
add    $0x1,%rdx
add    $0xffffffff,%ecx
cmp    %rdx,%rax
jne    1370 <main+0x240>
movapd %xmm0,%xmm1
jmp    13da <main+0x2aa>
nopw   0x0(%rax,%rax,1)
movapd 0x10(%rsp),%xmm0
movapd %xmm0,%xmm1
movsd  0x8(%rsp),%xmm4
jmp    13da <main+0x2aa>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,%rdi
xor    %eax,%eax
call   1030 <printf@plt>
movapd 0x10(%rsp),%xmm0
movapd %xmm0,%xmm4
movsd  0x28(%rsp),%xmm1
movapd %xmm4,%xmm2
subsd  %xmm1,%xmm2
ucomisd 0xc36(%rip),%xmm2
jbe    1405 <main+0x2d5>
mov    0x4(%rsp),%edx
jmp    11d0 <main+0xa0>
xor    %esi,%esi
test   $0x1,%bl
jne    12bf <main+0x18f>
jmp    12f3 <main+0x1c3>
lea    0xc3a(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1d4f8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%d\00"
@.str.1 = [7 x i8] c"%lf%lf\00"
@.str.2 = [3 x i8] c"hi\00"
@.str.3 = [4 x i8] c"%lf\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca [5000 x double]
%5 = alloca [5000 x double]
%6 = alloca [5000 x double]
%7 = alloca double
%8 = alloca double
%9 = alloca double
%10 = alloca i32
store i32 0, i32* %1
%11 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %2)
store i32 0, i32* %3
br label %12
12: ; preds = %24, %0
%13 = load i32, i32* %3
%14 = load i32, i32* %2
%15 = icmp slt i32 %13, %14
br i1 %15, label %16, label %27
16: ; preds = %12
%17 = load i32, i32* %3
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds [5000 x double], [5000 x double]* %4, i64 0, i64 %18
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds [5000 x double], [5000 x double]* %5, i64 0, i64 %21
%23 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double* %19, double* %22)
br label %24
24: ; preds = %16
%25 = load i32, i32* %3
%26 = add nsw i32 %25, 1
store i32 %26, i32* %3
br label %12
27: ; preds = %12
store double 4.545450e-01, double* %7
store double 0x3FFAAAAB042528AE, double* %8
br label %28
28: ; preds = %99, %27
%29 = load double, double* %8
%30 = load double, double* %7
%31 = fsub double %29, %30
%32 = fcmp ogt double %31, 0x3E7AD7F29ABCAF48
br i1 %32, label %33, label %100
33: ; preds = %28
store i32 0, i32* %10
%34 = load double, double* %7
%35 = load double, double* %8
%36 = fadd double %34, %35
%37 = fdiv double %36, 2.000000e+00
store double %37, double* %9
store i32 0, i32* %3
br label %38
38: ; preds = %57, %33
%39 = load i32, i32* %3
%40 = load i32, i32* %2
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %60
42: ; preds = %38
%43 = load i32, i32* %3
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [5000 x double], [5000 x double]* %5, i64 0, i64 %44
%46 = load double, double* %45
%47 = load double, double* %9
%48 = load i32, i32* %3
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds [5000 x double], [5000 x double]* %4, i64 0, i64 %49
%51 = load double, double* %50
%52 = fneg double %47
%53 = call double @llvm.fmuladd.f64(double %52, double %51, double %46)
%54 = load i32, i32* %3
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds [5000 x double], [5000 x double]* %6, i64 0, i64 %55
store double %53, double* %56
br label %57
57: ; preds = %42
%58 = load i32, i32* %3
%59 = add nsw i32 %58, 1
store i32 %59, i32* %3
br label %38
60: ; preds = %38
%61 = getelementptr inbounds [5000 x double], [5000 x double]* %6, i64 0, i64 0
%62 = load i32, i32* %2
%63 = sub nsw i32 %62, 1
%64 = call i32 @quickSort(double* %61, i32 0, i32 %63)
store i32 0, i32* %3
br label %65
65: ; preds = %89, %60
%66 = load i32, i32* %3
%67 = load i32, i32* %2
%68 = sdiv i32 %67, 2
%69 = icmp slt i32 %66, %68
br i1 %69, label %70, label %92
70: ; preds = %65
%71 = load i32, i32* %3
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds [5000 x double], [5000 x double]* %6, i64 0, i64 %72
%74 = load double, double* %73
%75 = load i32, i32* %2
%76 = sub nsw i32 %75, 1
%77 = load i32, i32* %3
%78 = sub nsw i32 %76, %77
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds [5000 x double], [5000 x double]* %6, i64 0, i64 %79
%81 = load double, double* %80
%82 = fadd double %74, %81
%83 = load double, double* %9
%84 = fmul double 2.000000e+01, %83
%85 = fcmp olt double %82, %84
br i1 %85, label %86, label %88
86: ; preds = %70
store i32 1, i32* %10
%87 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0))
br label %92
88: ; preds = %70
br label %89
89: ; preds = %88
%90 = load i32, i32* %3
%91 = add nsw i32 %90, 1
store i32 %91, i32* %3
br label %65
92: ; preds = %86, %65
%93 = load i32, i32* %10
%94 = icmp eq i32 %93, 1
br i1 %94, label %95, label %97
95: ; preds = %92
%96 = load double, double* %9
store double %96, double* %8
br label %99
97: ; preds = %92
%98 = load double, double* %9
store double %98, double* %7
br label %99
99: ; preds = %97, %95
br label %28
100: ; preds = %28
%101 = load double, double* %9
%102 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.3, i64 0, i64 0), double %101)
ret i32 0
}

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