void heapsort(long long int a[], long long int n) {
  long long int i, j, k;
  long long int temp;
  for (i = 1; i < n; i++) {
    j = i;
    do {
      k = (j - 1) / 2;
      if (a[k] < a[j]) {
        temp = a[k];
        a[k] = a[j];
        a[j] = temp;
      }
      j = k;
    } while (j != 0);
  }
  for (i = (n - 1); i >= 0; i--) {
    temp = a[0];
    a[0] = a[i];
    a[i] = temp;
    k = 0;
    do {
      j = (2 * k) + 1;
      if ((a[j] < a[j + 1]) && (j < (i - 1))) {
        j++;
      }
      if ((a[k] < a[j]) && (j < i)) {
        temp = a[k];
        a[k] = a[j];
        a[j] = temp;
      }
      k = j;
    } while (k < i);
  }
}


x86 assembly (clang, -O0):
<heapsort>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movq   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    11bf <heapsort+0xbf>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    $0x1,%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jge    1196 <heapsort+0x96>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    112a <heapsort+0x2a>
jmp    11ae <heapsort+0xae>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1114 <heapsort+0x14>
mov    -0x10(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jl     12ec <heapsort+0x1ec>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movq   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x1,%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rdx
cmp    0x8(%rcx,%rdx,8),%rax
jge    125c <heapsort+0x15c>
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    125c <heapsort+0x15c>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jge    12c0 <heapsort+0x1c0>
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    12c0 <heapsort+0x1c0>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jl     120c <heapsort+0x10c>
jmp    12db <heapsort+0x1db>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    11cb <heapsort+0xcb>
pop    %rbp
ret

x86 assembly (clang, -O2):
<heapsort>:
push   %rbx
cmp    $0x2,%rsi
jl     1153 <heapsort+0x53>
mov    $0x1,%r8d
jmp    1119 <heapsort+0x19>
nop
add    $0x1,%r8
cmp    %rsi,%r8
je     1153 <heapsort+0x53>
mov    %r8,%rcx
jmp    1129 <heapsort+0x29>
xchg   %ax,%ax
cmp    $0x2,%rcx
mov    %rdx,%rcx
jbe    1110 <heapsort+0x10>
lea    -0x1(%rcx),%rax
shr    $0x3f,%rax
lea    (%rcx,%rax,1),%rdx
add    $0xffffffffffffffff,%rdx
sar    %rdx
mov    (%rdi,%rdx,8),%r9
mov    (%rdi,%rcx,8),%rax
cmp    %rax,%r9
jge    1120 <heapsort+0x20>
mov    %rax,(%rdi,%rdx,8)
mov    %r9,(%rdi,%rcx,8)
jmp    1120 <heapsort+0x20>
test   %rsi,%rsi
jg     1166 <heapsort+0x66>
pop    %rbx
ret
nopw   0x0(%rax,%rax,1)
cmp    $0x2,%r8
jl     1158 <heapsort+0x58>
mov    %rsi,%r8
add    $0xffffffffffffffff,%rsi
mov    (%rdi),%rax
mov    -0x8(%rdi,%r8,8),%rcx
mov    %rcx,(%rdi)
mov    %rax,-0x8(%rdi,%r8,8)
lea    -0x2(%r8),%r9
mov    (%rdi),%r10
xor    %eax,%eax
jmp    1198 <heapsort+0x98>
nopl   0x0(%rax,%rax,1)
mov    %rdx,%r10
cmp    %rsi,%rax
jge    1160 <heapsort+0x60>
mov    %rax,%rcx
lea    (%rax,%rax,1),%r11
lea    (%rax,%rax,1),%rdx
add    $0x1,%rdx
mov    0x8(%rdi,%r11,8),%rbx
add    %rax,%rax
add    $0x2,%rax
cmp    %r9,%rdx
cmovge %rdx,%rax
cmp    0x10(%rdi,%r11,8),%rbx
jl     11c4 <heapsort+0xc4>
mov    %rdx,%rax
mov    (%rdi,%rax,8),%rdx
cmp    %rdx,%r10
jge    1190 <heapsort+0x90>
cmp    %rsi,%rax
jge    1190 <heapsort+0x90>
mov    %rdx,(%rdi,%rcx,8)
mov    %r10,(%rdi,%rax,8)
cmp    %rsi,%rax
jl     1198 <heapsort+0x98>
jmp    1160 <heapsort+0x60>

LLVM IR (-O0):
define void @heapsort(i64* %0, i64 %1) {
%3 = alloca i64*
%4 = alloca i64
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
store i64* %0, i64** %3
store i64 %1, i64* %4
store i64 1, i64* %5
br label %9
9: ; preds = %50, %2
%10 = load i64, i64* %5
%11 = load i64, i64* %4
%12 = icmp slt i64 %10, %11
br i1 %12, label %13, label %53
13: ; preds = %9
%14 = load i64, i64* %5
store i64 %14, i64* %6
br label %15
15: ; preds = %46, %13
%16 = load i64, i64* %6
%17 = sub nsw i64 %16, 1
%18 = sdiv i64 %17, 2
store i64 %18, i64* %7
%19 = load i64*, i64** %3
%20 = load i64, i64* %7
%21 = getelementptr inbounds i64, i64* %19, i64 %20
%22 = load i64, i64* %21
%23 = load i64*, i64** %3
%24 = load i64, i64* %6
%25 = getelementptr inbounds i64, i64* %23, i64 %24
%26 = load i64, i64* %25
%27 = icmp slt i64 %22, %26
br i1 %27, label %28, label %44
28: ; preds = %15
%29 = load i64*, i64** %3
%30 = load i64, i64* %7
%31 = getelementptr inbounds i64, i64* %29, i64 %30
%32 = load i64, i64* %31
store i64 %32, i64* %8
%33 = load i64*, i64** %3
%34 = load i64, i64* %6
%35 = getelementptr inbounds i64, i64* %33, i64 %34
%36 = load i64, i64* %35
%37 = load i64*, i64** %3
%38 = load i64, i64* %7
%39 = getelementptr inbounds i64, i64* %37, i64 %38
store i64 %36, i64* %39
%40 = load i64, i64* %8
%41 = load i64*, i64** %3
%42 = load i64, i64* %6
%43 = getelementptr inbounds i64, i64* %41, i64 %42
store i64 %40, i64* %43
br label %44
44: ; preds = %28, %15
%45 = load i64, i64* %7
store i64 %45, i64* %6
br label %46
46: ; preds = %44
%47 = load i64, i64* %6
%48 = icmp ne i64 %47, 0
br i1 %48, label %15, label %49
49: ; preds = %46
br label %50
50: ; preds = %49
%51 = load i64, i64* %5
%52 = add nsw i64 %51, 1
store i64 %52, i64* %5
br label %9
53: ; preds = %9
%54 = load i64, i64* %4
%55 = sub nsw i64 %54, 1
store i64 %55, i64* %5
br label %56
56: ; preds = %132, %53
%57 = load i64, i64* %5
%58 = icmp sge i64 %57, 0
br i1 %58, label %59, label %135
59: ; preds = %56
%60 = load i64*, i64** %3
%61 = getelementptr inbounds i64, i64* %60, i64 0
%62 = load i64, i64* %61
store i64 %62, i64* %8
%63 = load i64*, i64** %3
%64 = load i64, i64* %5
%65 = getelementptr inbounds i64, i64* %63, i64 %64
%66 = load i64, i64* %65
%67 = load i64*, i64** %3
%68 = getelementptr inbounds i64, i64* %67, i64 0
store i64 %66, i64* %68
%69 = load i64, i64* %8
%70 = load i64*, i64** %3
%71 = load i64, i64* %5
%72 = getelementptr inbounds i64, i64* %70, i64 %71
store i64 %69, i64* %72
store i64 0, i64* %7
br label %73
73: ; preds = %127, %59
%74 = load i64, i64* %7
%75 = mul nsw i64 2, %74
%76 = add nsw i64 %75, 1
store i64 %76, i64* %6
%77 = load i64*, i64** %3
%78 = load i64, i64* %6
%79 = getelementptr inbounds i64, i64* %77, i64 %78
%80 = load i64, i64* %79
%81 = load i64*, i64** %3
%82 = load i64, i64* %6
%83 = add nsw i64 %82, 1
%84 = getelementptr inbounds i64, i64* %81, i64 %83
%85 = load i64, i64* %84
%86 = icmp slt i64 %80, %85
br i1 %86, label %87, label %95
87: ; preds = %73
%88 = load i64, i64* %6
%89 = load i64, i64* %5
%90 = sub nsw i64 %89, 1
%91 = icmp slt i64 %88, %90
br i1 %91, label %92, label %95
92: ; preds = %87
%93 = load i64, i64* %6
%94 = add nsw i64 %93, 1
store i64 %94, i64* %6
br label %95
95: ; preds = %92, %87, %73
%96 = load i64*, i64** %3
%97 = load i64, i64* %7
%98 = getelementptr inbounds i64, i64* %96, i64 %97
%99 = load i64, i64* %98
%100 = load i64*, i64** %3
%101 = load i64, i64* %6
%102 = getelementptr inbounds i64, i64* %100, i64 %101
%103 = load i64, i64* %102
%104 = icmp slt i64 %99, %103
br i1 %104, label %105, label %125
105: ; preds = %95
%106 = load i64, i64* %6
%107 = load i64, i64* %5
%108 = icmp slt i64 %106, %107
br i1 %108, label %109, label %125
109: ; preds = %105
%110 = load i64*, i64** %3
%111 = load i64, i64* %7
%112 = getelementptr inbounds i64, i64* %110, i64 %111
%113 = load i64, i64* %112
store i64 %113, i64* %8
%114 = load i64*, i64** %3
%115 = load i64, i64* %6
%116 = getelementptr inbounds i64, i64* %114, i64 %115
%117 = load i64, i64* %116
%118 = load i64*, i64** %3
%119 = load i64, i64* %7
%120 = getelementptr inbounds i64, i64* %118, i64 %119
store i64 %117, i64* %120
%121 = load i64, i64* %8
%122 = load i64*, i64** %3
%123 = load i64, i64* %6
%124 = getelementptr inbounds i64, i64* %122, i64 %123
store i64 %121, i64* %124
br label %125
125: ; preds = %109, %105, %95
%126 = load i64, i64* %6
store i64 %126, i64* %7
br label %127
127: ; preds = %125
%128 = load i64, i64* %7
%129 = load i64, i64* %5
%130 = icmp slt i64 %128, %129
br i1 %130, label %73, label %131
131: ; preds = %127
br label %132
132: ; preds = %131
%133 = load i64, i64* %5
%134 = add nsw i64 %133, -1
store i64 %134, i64* %5
br label %56
135: ; preds = %56
ret void
}

LLVM IR (-O2):
define void @heapsort(i64* nocapture %0, i64 %1) {
%3 = icmp sgt i64 %1, 1
br i1 %3, label %4, label %6
4: ; preds = %2, %20
%5 = phi i64 [ %21, %20 ], [ 1, %2 ]
br label %8
6: ; preds = %20, %2
%7 = icmp sgt i64 %1, 0
br i1 %7, label %25, label %56
8: ; preds = %4, %18
%9 = phi i64 [ %11, %18 ], [ %5, %4 ]
%10 = add nsw i64 %9, -1
%11 = sdiv i64 %10, 2
%12 = getelementptr inbounds i64, i64* %0, i64 %11
%13 = load i64, i64* %12
%14 = getelementptr inbounds i64, i64* %0, i64 %9
%15 = load i64, i64* %14
%16 = icmp slt i64 %13, %15
br i1 %16, label %17, label %18
17: ; preds = %8
store i64 %15, i64* %12
store i64 %13, i64* %14
br label %18
18: ; preds = %17, %8
%19 = icmp ult i64 %9, 3
br i1 %19, label %20, label %8
20: ; preds = %18
%21 = add nuw nsw i64 %5, 1
%22 = icmp eq i64 %21, %1
br i1 %22, label %6, label %4
23: ; preds = %54
%24 = icmp sgt i64 %26, 1
br i1 %24, label %25, label %56
25: ; preds = %6, %23
%26 = phi i64 [ %27, %23 ], [ %1, %6 ]
%27 = add nsw i64 %26, -1
%28 = load i64, i64* %0
%29 = getelementptr inbounds i64, i64* %0, i64 %27
%30 = load i64, i64* %29
store i64 %30, i64* %0
store i64 %28, i64* %29
%31 = add nsw i64 %26, -2
%32 = load i64, i64* %0
br label %33
33: ; preds = %54, %25
%34 = phi i64 [ %32, %25 ], [ %55, %54 ]
%35 = phi i64 [ 0, %25 ], [ %46, %54 ]
%36 = shl nsw i64 %35, 1
%37 = or i64 %36, 1
%38 = getelementptr inbounds i64, i64* %0, i64 %37
%39 = load i64, i64* %38
%40 = add i64 %36, 2
%41 = getelementptr inbounds i64, i64* %0, i64 %40
%42 = load i64, i64* %41
%43 = icmp slt i64 %39, %42
%44 = icmp slt i64 %37, %31
%45 = select i1 %43, i1 %44, i1 false
%46 = select i1 %45, i64 %40, i64 %37
%47 = getelementptr inbounds i64, i64* %0, i64 %46
%48 = load i64, i64* %47
%49 = icmp slt i64 %34, %48
%50 = icmp slt i64 %46, %27
%51 = select i1 %49, i1 %50, i1 false
br i1 %51, label %52, label %54
52: ; preds = %33
%53 = getelementptr inbounds i64, i64* %0, i64 %35
store i64 %48, i64* %53
store i64 %34, i64* %47
br label %54
54: ; preds = %52, %33
%55 = phi i64 [ %34, %52 ], [ %48, %33 ]
br i1 %50, label %33, label %23
56: ; preds = %23, %6
ret void
}