void hpsel(unsigned long m, unsigned long n, float arr[], float heap[]) {
  void sort(unsigned long n, float arr[]);
  void nrerror(char error_text[]);
  unsigned long i, j, k;
  float swap;
  if (m > n / 2 || m < 1)
    nrerror("probable misuse of hpsel");
  for (i = 1; i <= m; i++)
    heap[i] = arr[i];
  sort(m, heap);
  for (i = m + 1; i <= n; i++) {
    if (arr[i] > heap[1]) {
      heap[1] = arr[i];
      for (j = 1;;) {
        k = j << 1;
        if (k > m)
          break;
        if (k != m && heap[k] > heap[k + 1])
          k++;
        if (heap[j] <= heap[k])
          break;
        swap = heap[k];
        heap[k] = heap[j];
        heap[j] = swap;
        j = k;
      }
    }
  }
}


x86 assembly (clang, -O0):
<hpsel>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shr    $0x1,%rcx
cmp    %rcx,%rax
ja     1158 <hpsel+0x38>
cmpq   $0x1,-0x8(%rbp)
jae    1164 <hpsel+0x44>
lea    0xea1(%rip),%rdi
call   1030 <nrerror@plt>
movq   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x8(%rbp),%rax
ja     11a5 <hpsel+0x85>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    116c <hpsel+0x4c>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
call   1040 <sort@plt>
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x10(%rbp),%rax
ja     12ec <hpsel+0x1cc>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
ucomiss 0x4(%rax),%xmm0
jbe    12d6 <hpsel+0x1b6>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jbe    1224 <hpsel+0x104>
jmp    12d1 <hpsel+0x1b1>
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
je     125e <hpsel+0x13e>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
ucomiss 0x4(%rax,%rcx,4),%xmm0
jbe    125e <hpsel+0x13e>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jb     1286 <hpsel+0x166>
jmp    12d1 <hpsel+0x1b1>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x3c(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1205 <hpsel+0xe5>
jmp    12d6 <hpsel+0x1b6>
jmp    12db <hpsel+0x1bb>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    11be <hpsel+0x9e>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hpsel>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rcx,%rbx
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%r12
mov    %rsi,%rax
shr    %rax
lea    -0x1(%rdi),%rcx
cmp    %rax,%rcx
jb     1159 <hpsel+0x39>
lea    0xeb5(%rip),%rdi
call   1030 <nrerror@plt>
test   %r12,%r12
je     12f7 <hpsel+0x1d7>
mov    $0x1,%eax
cmp    $0x8,%r12
jb     1267 <hpsel+0x147>
lea    0x4(%rbx),%rcx
lea    (%r14,%r12,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rcx
jae    118e <hpsel+0x6e>
lea    (%rbx,%r12,4),%rcx
add    $0x4,%rcx
lea    0x4(%r14),%rdx
cmp    %rcx,%rdx
jb     1267 <hpsel+0x147>
mov    %r12,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rdx
jae    11b3 <hpsel+0x93>
xor    %edx,%edx
jmp    1222 <hpsel+0x102>
and    $0xfffffffffffffffc,%rsi
xor    %edx,%edx
nopl   0x0(%rax)
movups 0x4(%r14,%rdx,4),%xmm0
movups 0x14(%r14,%rdx,4),%xmm1
movups %xmm0,0x4(%rbx,%rdx,4)
movups %xmm1,0x14(%rbx,%rdx,4)
movups 0x24(%r14,%rdx,4),%xmm0
movups 0x34(%r14,%rdx,4),%xmm1
movups %xmm0,0x24(%rbx,%rdx,4)
movups %xmm1,0x34(%rbx,%rdx,4)
movups 0x44(%r14,%rdx,4),%xmm0
movups 0x54(%r14,%rdx,4),%xmm1
movups %xmm0,0x44(%rbx,%rdx,4)
movups %xmm1,0x54(%rbx,%rdx,4)
movups 0x64(%r14,%rdx,4),%xmm0
movups 0x74(%r14,%rdx,4),%xmm1
movups %xmm0,0x64(%rbx,%rdx,4)
movups %xmm1,0x74(%rbx,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    11c0 <hpsel+0xa0>
test   %rcx,%rcx
je     125a <hpsel+0x13a>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rdx,4),%rsi
or     $0x4,%rsi
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movups %xmm0,(%rbx,%rsi,1)
movups %xmm1,0x10(%rbx,%rsi,1)
add    $0x8,%rdx
add    $0xffffffffffffffff,%rcx
jne    1230 <hpsel+0x110>
cmp    %r12,%rax
je     12f7 <hpsel+0x1d7>
or     $0x1,%rax
mov    %r12d,%edx
sub    %eax,%edx
add    $0x1,%edx
mov    %r12,%rcx
sub    %rax,%rcx
and    $0x3,%rdx
je     1295 <hpsel+0x175>
nopl   0x0(%rax,%rax,1)
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1280 <hpsel+0x160>
cmp    $0x3,%rcx
jb     12f7 <hpsel+0x1d7>
mov    %r12,%rcx
sub    %rax,%rcx
lea    (%rbx,%rax,4),%rdx
add    $0xc,%rdx
lea    (%r14,%rax,4),%rax
add    $0xc,%rax
mov    $0xffffffffffffffff,%rsi
nopl   0x0(%rax,%rax,1)
movss  -0x8(%rax,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rdx,%rsi,4)
movss  -0x4(%rax,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rdx,%rsi,4)
movss  (%rax,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  0x4(%rax,%rsi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    12c0 <hpsel+0x1a0>
lea    0x1(%r12),%r13
mov    %r12,%rdi
mov    %rbx,%rsi
call   1040 <sort@plt>
jmp    1314 <hpsel+0x1f4>
nopl   0x0(%rax)
add    $0x1,%r13
cmp    %r15,%r13
ja     1387 <hpsel+0x267>
movss  (%r14,%r13,4),%xmm0
ucomiss 0x4(%rbx),%xmm0
jbe    1310 <hpsel+0x1f0>
movss  %xmm0,0x4(%rbx)
cmp    $0x2,%r12
jb     1310 <hpsel+0x1f0>
mov    $0x1,%eax
mov    $0x2,%ecx
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdx
cmp    %r12,%rcx
je     1360 <hpsel+0x240>
movss  (%rbx,%rcx,4),%xmm0
mov    %rcx,%rsi
or     $0x1,%rsi
ucomiss (%rbx,%rsi,4),%xmm0
mov    %rcx,%rdx
jbe    1360 <hpsel+0x240>
mov    %rsi,%rdx
movss  (%rbx,%rax,4),%xmm0
movss  (%rbx,%rdx,4),%xmm1
ucomiss %xmm0,%xmm1
jae    1310 <hpsel+0x1f0>
movss  %xmm0,(%rbx,%rdx,4)
movss  %xmm1,(%rbx,%rax,4)
lea    (%rdx,%rdx,1),%rcx
mov    %rdx,%rax
cmp    %r12,%rcx
jbe    1340 <hpsel+0x220>
jmp    1310 <hpsel+0x1f0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [25 x i8] c"probable misuse of hpsel\00"
define void @hpsel(i64 %0, i64 %1, float* %2, float* %3) {
%5 = alloca i64
%6 = alloca i64
%7 = alloca float*
%8 = alloca float*
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca float
store i64 %0, i64* %5
store i64 %1, i64* %6
store float* %2, float** %7
store float* %3, float** %8
%13 = load i64, i64* %5
%14 = load i64, i64* %6
%15 = udiv i64 %14, 2
%16 = icmp ugt i64 %13, %15
br i1 %16, label %20, label %17
17: ; preds = %4
%18 = load i64, i64* %5
%19 = icmp ult i64 %18, 1
br i1 %19, label %20, label %21
20: ; preds = %17, %4
br label %21
21: ; preds = %20, %17
store i64 1, i64* %9
br label %22
22: ; preds = %34, %21
%23 = load i64, i64* %9
%24 = load i64, i64* %5
%25 = icmp ule i64 %23, %24
br i1 %25, label %26, label %37
26: ; preds = %22
%27 = load float*, float** %7
%28 = load i64, i64* %9
%29 = getelementptr inbounds float, float* %27, i64 %28
%30 = load float, float* %29
%31 = load float*, float** %8
%32 = load i64, i64* %9
%33 = getelementptr inbounds float, float* %31, i64 %32
store float %30, float* %33
br label %34
34: ; preds = %26
%35 = load i64, i64* %9
%36 = add i64 %35, 1
store i64 %36, i64* %9
br label %22
37: ; preds = %22
%38 = load i64, i64* %5
%39 = load float*, float** %8
%40 = load i64, i64* %5
%41 = add i64 %40, 1
store i64 %41, i64* %9
br label %42
42: ; preds = %117, %37
%43 = load i64, i64* %9
%44 = load i64, i64* %6
%45 = icmp ule i64 %43, %44
br i1 %45, label %46, label %120
46: ; preds = %42
%47 = load float*, float** %7
%48 = load i64, i64* %9
%49 = getelementptr inbounds float, float* %47, i64 %48
%50 = load float, float* %49
%51 = load float*, float** %8
%52 = getelementptr inbounds float, float* %51, i64 1
%53 = load float, float* %52
%54 = fcmp ogt float %50, %53
br i1 %54, label %55, label %116
55: ; preds = %46
%56 = load float*, float** %7
%57 = load i64, i64* %9
%58 = getelementptr inbounds float, float* %56, i64 %57
%59 = load float, float* %58
%60 = load float*, float** %8
%61 = getelementptr inbounds float, float* %60, i64 1
store float %59, float* %61
store i64 1, i64* %10
br label %62
62: ; preds = %98, %55
%63 = load i64, i64* %10
%64 = shl i64 %63, 1
store i64 %64, i64* %11
%65 = load i64, i64* %11
%66 = load i64, i64* %5
%67 = icmp ugt i64 %65, %66
br i1 %67, label %68, label %69
68: ; preds = %62
br label %115
69: ; preds = %62
%70 = load i64, i64* %11
%71 = load i64, i64* %5
%72 = icmp ne i64 %70, %71
br i1 %72, label %73, label %87
73: ; preds = %69
%74 = load float*, float** %8
%75 = load i64, i64* %11
%76 = getelementptr inbounds float, float* %74, i64 %75
%77 = load float, float* %76
%78 = load float*, float** %8
%79 = load i64, i64* %11
%80 = add i64 %79, 1
%81 = getelementptr inbounds float, float* %78, i64 %80
%82 = load float, float* %81
%83 = fcmp ogt float %77, %82
br i1 %83, label %84, label %87
84: ; preds = %73
%85 = load i64, i64* %11
%86 = add i64 %85, 1
store i64 %86, i64* %11
br label %87
87: ; preds = %84, %73, %69
%88 = load float*, float** %8
%89 = load i64, i64* %10
%90 = getelementptr inbounds float, float* %88, i64 %89
%91 = load float, float* %90
%92 = load float*, float** %8
%93 = load i64, i64* %11
%94 = getelementptr inbounds float, float* %92, i64 %93
%95 = load float, float* %94
%96 = fcmp ole float %91, %95
br i1 %96, label %97, label %98
97: ; preds = %87
br label %115
98: ; preds = %87
%99 = load float*, float** %8
%100 = load i64, i64* %11
%101 = getelementptr inbounds float, float* %99, i64 %100
%102 = load float, float* %101
store float %102, float* %12
%103 = load float*, float** %8
%104 = load i64, i64* %10
%105 = getelementptr inbounds float, float* %103, i64 %104
%106 = load float, float* %105
%107 = load float*, float** %8
%108 = load i64, i64* %11
%109 = getelementptr inbounds float, float* %107, i64 %108
store float %106, float* %109
%110 = load float, float* %12
%111 = load float*, float** %8
%112 = load i64, i64* %10
%113 = getelementptr inbounds float, float* %111, i64 %112
store float %110, float* %113
%114 = load i64, i64* %11
store i64 %114, i64* %10
br label %62
115: ; preds = %97, %68
br label %116
116: ; preds = %115, %46
br label %117
117: ; preds = %116
%118 = load i64, i64* %9
%119 = add i64 %118, 1
store i64 %119, i64* %9
br label %42
120: ; preds = %42
ret void
}

LLVM IR (-O2):
@.str = [25 x i8] c"probable misuse of hpsel\00"
define void @hpsel(i64 %0, i64 %1, float* nocapture %2, float* %3) {
%5 = lshr i64 %1, 1
%6 = add i64 %0, -1
%7 = icmp ult i64 %6, %5
br i1 %7, label %10, label %8
8: ; preds = %4
tail call void @nrerror(i8* getelementptr inbounds ([25 x i8], [25 x i8]* @.str, i64 0, i64 0))
%9 = icmp eq i64 %0, 0
br i1 %9, label %141, label %10
10: ; preds = %4, %8
%11 = icmp ult i64 %0, 8
br i1 %11, label %103, label %12
12: ; preds = %10
%13 = getelementptr float, float* %3, i64 1
%14 = add i64 %0, 1
%15 = getelementptr float, float* %3, i64 %14
%16 = getelementptr float, float* %2, i64 1
%17 = getelementptr float, float* %2, i64 %14
%18 = icmp ult float* %13, %17
%19 = icmp ult float* %16, %15
%20 = and i1 %18, %19
br i1 %20, label %103, label %21
21: ; preds = %12
%22 = and i64 %0, -8
%23 = or i64 %22, 1
%24 = add i64 %22, -8
%25 = lshr exact i64 %24, 3
%26 = add nuw nsw i64 %25, 1
%27 = and i64 %26, 3
%28 = icmp ult i64 %24, 24
br i1 %28, label %81, label %29
29: ; preds = %21
%30 = and i64 %26, 4611686018427387900
br label %31
31: ; preds = %31, %29
%32 = phi i64 [ 0, %29 ], [ %78, %31 ]
%33 = phi i64 [ 0, %29 ], [ %79, %31 ]
%34 = or i64 %32, 1
%35 = getelementptr inbounds float, float* %2, i64 %34
%36 = bitcast float* %35 to <4 x float>*
%37 = load <4 x float>, <4 x float>* %36
%38 = getelementptr inbounds float, float* %35, i64 4
%39 = bitcast float* %38 to <4 x float>*
%40 = load <4 x float>, <4 x float>* %39
%41 = getelementptr inbounds float, float* %3, i64 %34
%42 = bitcast float* %41 to <4 x float>*
store <4 x float> %37, <4 x float>* %42
%43 = getelementptr inbounds float, float* %41, i64 4
%44 = bitcast float* %43 to <4 x float>*
store <4 x float> %40, <4 x float>* %44
%45 = or i64 %32, 9
%46 = getelementptr inbounds float, float* %2, i64 %45
%47 = bitcast float* %46 to <4 x float>*
%48 = load <4 x float>, <4 x float>* %47
%49 = getelementptr inbounds float, float* %46, i64 4
%50 = bitcast float* %49 to <4 x float>*
%51 = load <4 x float>, <4 x float>* %50
%52 = getelementptr inbounds float, float* %3, i64 %45
%53 = bitcast float* %52 to <4 x float>*
store <4 x float> %48, <4 x float>* %53
%54 = getelementptr inbounds float, float* %52, i64 4
%55 = bitcast float* %54 to <4 x float>*
store <4 x float> %51, <4 x float>* %55
%56 = or i64 %32, 17
%57 = getelementptr inbounds float, float* %2, i64 %56
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = getelementptr inbounds float, float* %57, i64 4
%61 = bitcast float* %60 to <4 x float>*
%62 = load <4 x float>, <4 x float>* %61
%63 = getelementptr inbounds float, float* %3, i64 %56
%64 = bitcast float* %63 to <4 x float>*
store <4 x float> %59, <4 x float>* %64
%65 = getelementptr inbounds float, float* %63, i64 4
%66 = bitcast float* %65 to <4 x float>*
store <4 x float> %62, <4 x float>* %66
%67 = or i64 %32, 25
%68 = getelementptr inbounds float, float* %2, i64 %67
%69 = bitcast float* %68 to <4 x float>*
%70 = load <4 x float>, <4 x float>* %69
%71 = getelementptr inbounds float, float* %68, i64 4
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = getelementptr inbounds float, float* %3, i64 %67
%75 = bitcast float* %74 to <4 x float>*
store <4 x float> %70, <4 x float>* %75
%76 = getelementptr inbounds float, float* %74, i64 4
%77 = bitcast float* %76 to <4 x float>*
store <4 x float> %73, <4 x float>* %77
%78 = add nuw i64 %32, 32
%79 = add i64 %33, 4
%80 = icmp eq i64 %79, %30
br i1 %80, label %81, label %31
81: ; preds = %31, %21
%82 = phi i64 [ 0, %21 ], [ %78, %31 ]
%83 = icmp eq i64 %27, 0
br i1 %83, label %101, label %84
84: ; preds = %81, %84
%85 = phi i64 [ %98, %84 ], [ %82, %81 ]
%86 = phi i64 [ %99, %84 ], [ 0, %81 ]
%87 = or i64 %85, 1
%88 = getelementptr inbounds float, float* %2, i64 %87
%89 = bitcast float* %88 to <4 x float>*
%90 = load <4 x float>, <4 x float>* %89
%91 = getelementptr inbounds float, float* %88, i64 4
%92 = bitcast float* %91 to <4 x float>*
%93 = load <4 x float>, <4 x float>* %92
%94 = getelementptr inbounds float, float* %3, i64 %87
%95 = bitcast float* %94 to <4 x float>*
store <4 x float> %90, <4 x float>* %95
%96 = getelementptr inbounds float, float* %94, i64 4
%97 = bitcast float* %96 to <4 x float>*
store <4 x float> %93, <4 x float>* %97
%98 = add nuw i64 %85, 8
%99 = add i64 %86, 1
%100 = icmp eq i64 %99, %27
br i1 %100, label %101, label %84
101: ; preds = %84, %81
%102 = icmp eq i64 %22, %0
br i1 %102, label %141, label %103
103: ; preds = %12, %10, %101
%104 = phi i64 [ 1, %12 ], [ 1, %10 ], [ %23, %101 ]
%105 = add i64 %0, 1
%106 = sub i64 %105, %104
%107 = sub i64 %0, %104
%108 = and i64 %106, 3
%109 = icmp eq i64 %108, 0
br i1 %109, label %119, label %110
110: ; preds = %103, %110
%111 = phi i64 [ %116, %110 ], [ %104, %103 ]
%112 = phi i64 [ %117, %110 ], [ 0, %103 ]
%113 = getelementptr inbounds float, float* %2, i64 %111
%114 = load float, float* %113
%115 = getelementptr inbounds float, float* %3, i64 %111
store float %114, float* %115
%116 = add nuw i64 %111, 1
%117 = add i64 %112, 1
%118 = icmp eq i64 %117, %108
br i1 %118, label %119, label %110
119: ; preds = %110, %103
%120 = phi i64 [ %104, %103 ], [ %116, %110 ]
%121 = icmp ult i64 %107, 3
br i1 %121, label %141, label %122
122: ; preds = %119, %122
%123 = phi i64 [ %139, %122 ], [ %120, %119 ]
%124 = getelementptr inbounds float, float* %2, i64 %123
%125 = load float, float* %124
%126 = getelementptr inbounds float, float* %3, i64 %123
store float %125, float* %126
%127 = add nuw i64 %123, 1
%128 = getelementptr inbounds float, float* %2, i64 %127
%129 = load float, float* %128
%130 = getelementptr inbounds float, float* %3, i64 %127
store float %129, float* %130
%131 = add nuw i64 %123, 2
%132 = getelementptr inbounds float, float* %2, i64 %131
%133 = load float, float* %132
%134 = getelementptr inbounds float, float* %3, i64 %131
store float %133, float* %134
%135 = add nuw i64 %123, 3
%136 = getelementptr inbounds float, float* %2, i64 %135
%137 = load float, float* %136
%138 = getelementptr inbounds float, float* %3, i64 %135
store float %137, float* %138
%139 = add nuw i64 %123, 4
%140 = icmp eq i64 %135, %0
br i1 %140, label %141, label %122
141: ; preds = %119, %122, %101, %8
%142 = add i64 %0, 1
tail call void @sort(i64 %0, float* %3)
%143 = icmp ugt i64 %142, %1
br i1 %143, label %179, label %144
144: ; preds = %141
%145 = getelementptr inbounds float, float* %3, i64 1
%146 = icmp ult i64 %0, 2
br label %147
147: ; preds = %144, %176
%148 = phi i64 [ %142, %144 ], [ %177, %176 ]
%149 = getelementptr inbounds float, float* %2, i64 %148
%150 = load float, float* %149
%151 = load float, float* %145
%152 = fcmp ogt float %150, %151
br i1 %152, label %153, label %176
153: ; preds = %147
store float %150, float* %145
br i1 %146, label %176, label %154
154: ; preds = %153, %173
%155 = phi i64 [ %174, %173 ], [ 2, %153 ]
%156 = phi i64 [ %167, %173 ], [ 1, %153 ]
%157 = icmp eq i64 %155, %0
br i1 %157, label %166, label %158
158: ; preds = %154
%159 = getelementptr inbounds float, float* %3, i64 %155
%160 = load float, float* %159
%161 = or i64 %155, 1
%162 = getelementptr inbounds float, float* %3, i64 %161
%163 = load float, float* %162
%164 = fcmp ogt float %160, %163
br i1 %164, label %165, label %166
165: ; preds = %158
br label %166
166: ; preds = %165, %158, %154
%167 = phi i64 [ %161, %165 ], [ %155, %158 ], [ %0, %154 ]
%168 = getelementptr inbounds float, float* %3, i64 %156
%169 = load float, float* %168
%170 = getelementptr inbounds float, float* %3, i64 %167
%171 = load float, float* %170
%172 = fcmp ugt float %169, %171
br i1 %172, label %173, label %176
173: ; preds = %166
store float %169, float* %170
store float %171, float* %168
%174 = shl i64 %167, 1
%175 = icmp ugt i64 %174, %0
br i1 %175, label %176, label %154
176: ; preds = %173, %166, %153, %147
%177 = add i64 %148, 1
%178 = icmp ugt i64 %177, %1
br i1 %178, label %179, label %147
179: ; preds = %176, %141
ret void
}