#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*/ free_lvector(unsigned long *, int, int);
unsigned long *lvector(int, int);
int /*<<< orphan*/ nrerror(char *);
void sort(unsigned long n, float arr[]) {
  unsigned long i, ir = n, j, k, l = 1, *istack;
  int jstack = 0;
  float a, temp;
  istack = lvector(1, 50);
  for (;;) {
    if (ir - l < 7) {
      for (j = l + 1; j <= ir; j++) {
        a = arr[j];
        for (i = j - 1; i >= l; i--) {
          if (arr[i] <= a)
            break;
          arr[i + 1] = arr[i];
        }
        arr[i + 1] = a;
      }
      if (jstack == 0)
        break;
      ir = istack[jstack--];
      l = istack[jstack--];
    } else {
      k = (l + ir) >> 1;
      temp = (arr[k]);
      (arr[k]) = (arr[l + 1]);
      (arr[l + 1]) = temp;
      if (arr[l] > arr[ir]) {
        temp = (arr[l]);
        (arr[l]) = (arr[ir]);
        (arr[ir]) = temp;
      }
      if (arr[l + 1] > arr[ir]) {
        temp = (arr[l + 1]);
        (arr[l + 1]) = (arr[ir]);
        (arr[ir]) = temp;
      }
      if (arr[l] > arr[l + 1]) {
        temp = (arr[l]);
        (arr[l]) = (arr[l + 1]);
        (arr[l + 1]) = temp;
      }
      i = l + 1;
      j = ir;
      a = arr[l + 1];
      for (;;) {
        do
          i++;
        while (arr[i] < a);
        do
          j--;
        while (arr[j] > a);
        if (j < i)
          break;
        temp = (arr[i]);
        (arr[i]) = (arr[j]);
        (arr[j]) = temp;
        ;
      }
      arr[l + 1] = arr[j];
      arr[j] = a;
      jstack += 2;
      if (jstack > 50)
        nrerror("NSTACK too small in sort.");
      if (ir - i + 1 >= j - l) {
        istack[jstack] = ir;
        istack[jstack - 1] = i;
        ir = j - 1;
      } else {
        istack[jstack] = j - 1;
        istack[jstack - 1] = l;
        l = i;
      }
    }
  }
  free_lvector(istack, 1, 50);
}


x86 assembly (clang, -O0):
<sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
movq   $0x1,-0x38(%rbp)
movl   $0x0,-0x44(%rbp)
mov    $0x1,%edi
mov    $0x32,%esi
call   1050 <lvector@plt>
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x38(%rbp),%rax
cmp    $0x7,%rax
jae    127a <sort+0x14a>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
ja     1232 <sort+0x102>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x28(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x38(%rbp),%rax
jb     120e <sort+0xde>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jb     11e2 <sort+0xb2>
jmp    120e <sort+0xde>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    11b4 <sort+0x84>
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1188 <sort+0x58>
cmpl   $0x0,-0x44(%rbp)
jne    1241 <sort+0x111>
jmp    1592 <sort+0x462>
mov    -0x40(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x20(%rbp)
mov    -0x40(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
jmp    158d <sort+0x45d>
mov    -0x38(%rbp),%rax
add    -0x20(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1327 <sort+0x1f7>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    1387 <sort+0x257>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
ucomiss 0x4(%rax,%rcx,4),%xmm0
jbe    13e7 <sort+0x2b7>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,-0x48(%rbp)
jmp    1413 <sort+0x2e3>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
ja     1413 <sort+0x2e3>
jmp    143f <sort+0x30f>
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss -0x48(%rbp),%xmm0
ja     143f <sort+0x30f>
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1475 <sort+0x345>
jmp    14b8 <sort+0x388>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x4c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    140e <sort+0x2de>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,0x4(%rax,%rcx,4)
movss  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x44(%rbp)
cmpl   $0x32,-0x44(%rbp)
jle    1504 <sort+0x3d4>
lea    0xb01(%rip),%rdi
call   1030 <nrerror@plt>
mov    -0x20(%rbp),%rax
sub    -0x18(%rbp),%rax
add    $0x1,%rax
mov    -0x28(%rbp),%rcx
sub    -0x38(%rbp),%rcx
cmp    %rcx,%rax
jb     1557 <sort+0x427>
mov    -0x20(%rbp),%rdx
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1588 <sort+0x458>
mov    -0x28(%rbp),%rdx
sub    $0x1,%rdx
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%rax
mov    -0x44(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    158d <sort+0x45d>
jmp    116a <sort+0x3a>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x32,%edx
call   1040 <free_lvector@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rsi,%rbx
mov    %rdi,%r14
mov    $0x1,%edi
mov    $0x32,%esi
call   1050 <lvector@plt>
mov    %rax,%rdi
xor    %ebp,%ebp
mov    $0x1,%r12d
mov    %rax,0x8(%rsp)
jmp    1180 <sort+0x50>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r14,(%rdi,%rcx,8)
mov    %r13,0x8(%rdi,%rax,8)
add    $0xffffffffffffffff,%r15
mov    %r15,%r14
mov    %ebp,%r8d
mov    %r14,0x10(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r14,%rax
sub    %r12,%rax
cmp    $0x6,%rax
jbe    12f0 <sort+0x1c0>
lea    (%r12,%r14,1),%rax
and    $0xfffffffffffffffe,%rax
movss  (%rbx,%rax,2),%xmm1
movss  0x4(%rbx,%r12,4),%xmm0
movss  %xmm0,(%rbx,%rax,2)
movss  %xmm1,0x4(%rbx,%r12,4)
movss  (%rbx,%r12,4),%xmm0
movss  (%rbx,%r14,4),%xmm2
ucomiss %xmm2,%xmm0
jbe    11f0 <sort+0xc0>
movss  %xmm2,(%rbx,%r12,4)
movss  %xmm0,(%rbx,%r14,4)
movss  0x4(%rbx,%r12,4),%xmm1
ucomiss %xmm0,%xmm1
ja     11f8 <sort+0xc8>
jmp    120c <sort+0xdc>
nopl   0x0(%rax,%rax,1)
movaps %xmm2,%xmm0
ucomiss %xmm0,%xmm1
jbe    120c <sort+0xdc>
movss  %xmm0,0x4(%rbx,%r12,4)
movss  %xmm1,(%rbx,%r14,4)
movss  0x4(%rbx,%r12,4),%xmm1
movss  (%rbx,%r12,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1230 <sort+0x100>
movss  %xmm1,(%rbx,%r12,4)
movss  %xmm0,0x4(%rbx,%r12,4)
jmp    1233 <sort+0x103>
cs nopw 0x0(%rax,%rax,1)
movaps %xmm1,%xmm0
lea    0x1(%r12),%r13
mov    %r14,%r15
nopl   0x0(%rax,%rax,1)
movss  0x4(%rbx,%r13,4),%xmm1
add    $0x1,%r13
ucomiss %xmm1,%xmm0
ja     1240 <sort+0x110>
movss  -0x4(%rbx,%r15,4),%xmm2
add    $0xffffffffffffffff,%r15
ucomiss %xmm0,%xmm2
ja     1250 <sort+0x120>
cmp    %r13,%r15
jb     1280 <sort+0x150>
movss  %xmm2,(%rbx,%r13,4)
movss  %xmm1,(%rbx,%r15,4)
jmp    1240 <sort+0x110>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm2,0x4(%rbx,%r12,4)
movss  %xmm0,(%rbx,%r15,4)
lea    0x2(%r8),%ebp
cmp    $0x31,%r8d
jl     12b3 <sort+0x183>
lea    0xd62(%rip),%rdi
mov    %r8,%r14
call   1030 <nrerror@plt>
mov    %r14,%r8
mov    0x8(%rsp),%rdi
mov    0x10(%rsp),%r14
mov    %r14,%rdx
sub    %r13,%rdx
add    $0x1,%rdx
mov    %r15,%rsi
sub    %r12,%rsi
movslq %ebp,%rcx
movslq %r8d,%rax
cmp    %rsi,%rdx
jae    1170 <sort+0x40>
add    $0xffffffffffffffff,%r15
mov    %r15,(%rdi,%rcx,8)
mov    %r12,0x8(%rdi,%rax,8)
mov    %r13,%r12
mov    %ebp,%r8d
jmp    1190 <sort+0x60>
nopw   0x0(%rax,%rax,1)
lea    0x1(%r12),%rdx
cmp    %r14,%rdx
jbe    1320 <sort+0x1f0>
test   %r8d,%r8d
je     136b <sort+0x23b>
movslq %r8d,%rax
mov    -0x8(%rdi,%rax,8),%r12
mov    (%rdi,%rax,8),%r14
add    $0xfffffffe,%r8d
mov    %r8d,%ebp
jmp    1180 <sort+0x50>
nopw   0x0(%rax,%rax,1)
mov    %r12,%rax
jmp    133f <sort+0x20f>
cs nopw 0x0(%rax,%rax,1)
nop
movss  %xmm0,0x4(%rbx,%rcx,4)
lea    0x1(%rax),%rdx
cmp    %r14,%rdx
ja     12fa <sort+0x1ca>
mov    %rax,%rcx
mov    %rdx,%rax
movss  (%rbx,%rdx,4),%xmm0
cmp    %r12,%rcx
jb     1330 <sort+0x200>
nop
movss  (%rbx,%rcx,4),%xmm1
ucomiss %xmm1,%xmm0
jae    1330 <sort+0x200>
movss  %xmm1,0x4(%rbx,%rcx,4)
add    $0xffffffffffffffff,%rcx
cmp    %r12,%rcx
jae    1350 <sort+0x220>
jmp    1330 <sort+0x200>
mov    $0x1,%esi
mov    $0x32,%edx
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_lvector@plt>

LLVM IR (-O0):
@.str = [26 x i8] c"NSTACK too small in sort.\00"
define void @sort(i64 %0, float* %1) {
%3 = alloca i64
%4 = alloca float*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64*
%11 = alloca i32
%12 = alloca float
%13 = alloca float
store i64 %0, i64* %3
store float* %1, float** %4
%14 = load i64, i64* %3
store i64 %14, i64* %6
store i64 1, i64* %9
store i32 0, i32* %11
%15 = call i64* @lvector(i32 1, i32 50)
store i64* %15, i64** %10
br label %16
16: ; preds = %299, %2
%17 = load i64, i64* %6
%18 = load i64, i64* %9
%19 = sub i64 %17, %18
%20 = icmp ult i64 %19, 7
br i1 %20, label %21, label %85
21: ; preds = %16
%22 = load i64, i64* %9
%23 = add i64 %22, 1
store i64 %23, i64* %7
br label %24
24: ; preds = %65, %21
%25 = load i64, i64* %7
%26 = load i64, i64* %6
%27 = icmp ule i64 %25, %26
br i1 %27, label %28, label %68
28: ; preds = %24
%29 = load float*, float** %4
%30 = load i64, i64* %7
%31 = getelementptr inbounds float, float* %29, i64 %30
%32 = load float, float* %31
store float %32, float* %12
%33 = load i64, i64* %7
%34 = sub i64 %33, 1
store i64 %34, i64* %5
br label %35
35: ; preds = %56, %28
%36 = load i64, i64* %5
%37 = load i64, i64* %9
%38 = icmp uge i64 %36, %37
br i1 %38, label %39, label %59
39: ; preds = %35
%40 = load float*, float** %4
%41 = load i64, i64* %5
%42 = getelementptr inbounds float, float* %40, i64 %41
%43 = load float, float* %42
%44 = load float, float* %12
%45 = fcmp ole float %43, %44
br i1 %45, label %46, label %47
46: ; preds = %39
br label %59
47: ; preds = %39
%48 = load float*, float** %4
%49 = load i64, i64* %5
%50 = getelementptr inbounds float, float* %48, i64 %49
%51 = load float, float* %50
%52 = load float*, float** %4
%53 = load i64, i64* %5
%54 = add i64 %53, 1
%55 = getelementptr inbounds float, float* %52, i64 %54
store float %51, float* %55
br label %56
56: ; preds = %47
%57 = load i64, i64* %5
%58 = add i64 %57, -1
store i64 %58, i64* %5
br label %35
59: ; preds = %46, %35
%60 = load float, float* %12
%61 = load float*, float** %4
%62 = load i64, i64* %5
%63 = add i64 %62, 1
%64 = getelementptr inbounds float, float* %61, i64 %63
store float %60, float* %64
br label %65
65: ; preds = %59
%66 = load i64, i64* %7
%67 = add i64 %66, 1
store i64 %67, i64* %7
br label %24
68: ; preds = %24
%69 = load i32, i32* %11
%70 = icmp eq i32 %69, 0
br i1 %70, label %71, label %72
71: ; preds = %68
br label %300
72: ; preds = %68
%73 = load i64*, i64** %10
%74 = load i32, i32* %11
%75 = add nsw i32 %74, -1
store i32 %75, i32* %11
%76 = sext i32 %74 to i64
%77 = getelementptr inbounds i64, i64* %73, i64 %76
%78 = load i64, i64* %77
store i64 %78, i64* %6
%79 = load i64*, i64** %10
%80 = load i32, i32* %11
%81 = add nsw i32 %80, -1
store i32 %81, i32* %11
%82 = sext i32 %80 to i64
%83 = getelementptr inbounds i64, i64* %79, i64 %82
%84 = load i64, i64* %83
store i64 %84, i64* %9
br label %299
85: ; preds = %16
%86 = load i64, i64* %9
%87 = load i64, i64* %6
%88 = add i64 %86, %87
%89 = lshr i64 %88, 1
store i64 %89, i64* %8
%90 = load float*, float** %4
%91 = load i64, i64* %8
%92 = getelementptr inbounds float, float* %90, i64 %91
%93 = load float, float* %92
store float %93, float* %13
%94 = load float*, float** %4
%95 = load i64, i64* %9
%96 = add i64 %95, 1
%97 = getelementptr inbounds float, float* %94, i64 %96
%98 = load float, float* %97
%99 = load float*, float** %4
%100 = load i64, i64* %8
%101 = getelementptr inbounds float, float* %99, i64 %100
store float %98, float* %101
%102 = load float, float* %13
%103 = load float*, float** %4
%104 = load i64, i64* %9
%105 = add i64 %104, 1
%106 = getelementptr inbounds float, float* %103, i64 %105
store float %102, float* %106
%107 = load float*, float** %4
%108 = load i64, i64* %9
%109 = getelementptr inbounds float, float* %107, i64 %108
%110 = load float, float* %109
%111 = load float*, float** %4
%112 = load i64, i64* %6
%113 = getelementptr inbounds float, float* %111, i64 %112
%114 = load float, float* %113
%115 = fcmp ogt float %110, %114
br i1 %115, label %116, label %132
116: ; preds = %85
%117 = load float*, float** %4
%118 = load i64, i64* %9
%119 = getelementptr inbounds float, float* %117, i64 %118
%120 = load float, float* %119
store float %120, float* %13
%121 = load float*, float** %4
%122 = load i64, i64* %6
%123 = getelementptr inbounds float, float* %121, i64 %122
%124 = load float, float* %123
%125 = load float*, float** %4
%126 = load i64, i64* %9
%127 = getelementptr inbounds float, float* %125, i64 %126
store float %124, float* %127
%128 = load float, float* %13
%129 = load float*, float** %4
%130 = load i64, i64* %6
%131 = getelementptr inbounds float, float* %129, i64 %130
store float %128, float* %131
br label %132
132: ; preds = %116, %85
%133 = load float*, float** %4
%134 = load i64, i64* %9
%135 = add i64 %134, 1
%136 = getelementptr inbounds float, float* %133, i64 %135
%137 = load float, float* %136
%138 = load float*, float** %4
%139 = load i64, i64* %6
%140 = getelementptr inbounds float, float* %138, i64 %139
%141 = load float, float* %140
%142 = fcmp ogt float %137, %141
br i1 %142, label %143, label %161
143: ; preds = %132
%144 = load float*, float** %4
%145 = load i64, i64* %9
%146 = add i64 %145, 1
%147 = getelementptr inbounds float, float* %144, i64 %146
%148 = load float, float* %147
store float %148, float* %13
%149 = load float*, float** %4
%150 = load i64, i64* %6
%151 = getelementptr inbounds float, float* %149, i64 %150
%152 = load float, float* %151
%153 = load float*, float** %4
%154 = load i64, i64* %9
%155 = add i64 %154, 1
%156 = getelementptr inbounds float, float* %153, i64 %155
store float %152, float* %156
%157 = load float, float* %13
%158 = load float*, float** %4
%159 = load i64, i64* %6
%160 = getelementptr inbounds float, float* %158, i64 %159
store float %157, float* %160
br label %161
161: ; preds = %143, %132
%162 = load float*, float** %4
%163 = load i64, i64* %9
%164 = getelementptr inbounds float, float* %162, i64 %163
%165 = load float, float* %164
%166 = load float*, float** %4
%167 = load i64, i64* %9
%168 = add i64 %167, 1
%169 = getelementptr inbounds float, float* %166, i64 %168
%170 = load float, float* %169
%171 = fcmp ogt float %165, %170
br i1 %171, label %172, label %190
172: ; preds = %161
%173 = load float*, float** %4
%174 = load i64, i64* %9
%175 = getelementptr inbounds float, float* %173, i64 %174
%176 = load float, float* %175
store float %176, float* %13
%177 = load float*, float** %4
%178 = load i64, i64* %9
%179 = add i64 %178, 1
%180 = getelementptr inbounds float, float* %177, i64 %179
%181 = load float, float* %180
%182 = load float*, float** %4
%183 = load i64, i64* %9
%184 = getelementptr inbounds float, float* %182, i64 %183
store float %181, float* %184
%185 = load float, float* %13
%186 = load float*, float** %4
%187 = load i64, i64* %9
%188 = add i64 %187, 1
%189 = getelementptr inbounds float, float* %186, i64 %188
store float %185, float* %189
br label %190
190: ; preds = %172, %161
%191 = load i64, i64* %9
%192 = add i64 %191, 1
store i64 %192, i64* %5
%193 = load i64, i64* %6
store i64 %193, i64* %7
%194 = load float*, float** %4
%195 = load i64, i64* %9
%196 = add i64 %195, 1
%197 = getelementptr inbounds float, float* %194, i64 %196
%198 = load float, float* %197
store float %198, float* %12
br label %199
199: ; preds = %226, %190
br label %200
200: ; preds = %203, %199
%201 = load i64, i64* %5
%202 = add i64 %201, 1
store i64 %202, i64* %5
br label %203
203: ; preds = %200
%204 = load float*, float** %4
%205 = load i64, i64* %5
%206 = getelementptr inbounds float, float* %204, i64 %205
%207 = load float, float* %206
%208 = load float, float* %12
%209 = fcmp olt float %207, %208
br i1 %209, label %200, label %210
210: ; preds = %203
br label %211
211: ; preds = %214, %210
%212 = load i64, i64* %7
%213 = add i64 %212, -1
store i64 %213, i64* %7
br label %214
214: ; preds = %211
%215 = load float*, float** %4
%216 = load i64, i64* %7
%217 = getelementptr inbounds float, float* %215, i64 %216
%218 = load float, float* %217
%219 = load float, float* %12
%220 = fcmp ogt float %218, %219
br i1 %220, label %211, label %221
221: ; preds = %214
%222 = load i64, i64* %7
%223 = load i64, i64* %5
%224 = icmp ult i64 %222, %223
br i1 %224, label %225, label %226
225: ; preds = %221
br label %242
226: ; preds = %221
%227 = load float*, float** %4
%228 = load i64, i64* %5
%229 = getelementptr inbounds float, float* %227, i64 %228
%230 = load float, float* %229
store float %230, float* %13
%231 = load float*, float** %4
%232 = load i64, i64* %7
%233 = getelementptr inbounds float, float* %231, i64 %232
%234 = load float, float* %233
%235 = load float*, float** %4
%236 = load i64, i64* %5
%237 = getelementptr inbounds float, float* %235, i64 %236
store float %234, float* %237
%238 = load float, float* %13
%239 = load float*, float** %4
%240 = load i64, i64* %7
%241 = getelementptr inbounds float, float* %239, i64 %240
store float %238, float* %241
br label %199
242: ; preds = %225
%243 = load float*, float** %4
%244 = load i64, i64* %7
%245 = getelementptr inbounds float, float* %243, i64 %244
%246 = load float, float* %245
%247 = load float*, float** %4
%248 = load i64, i64* %9
%249 = add i64 %248, 1
%250 = getelementptr inbounds float, float* %247, i64 %249
store float %246, float* %250
%251 = load float, float* %12
%252 = load float*, float** %4
%253 = load i64, i64* %7
%254 = getelementptr inbounds float, float* %252, i64 %253
store float %251, float* %254
%255 = load i32, i32* %11
%256 = add nsw i32 %255, 2
store i32 %256, i32* %11
%257 = load i32, i32* %11
%258 = icmp sgt i32 %257, 50
br i1 %258, label %259, label %261
259: ; preds = %242
%260 = call i32 @nrerror(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
br label %261
261: ; preds = %259, %242
%262 = load i64, i64* %6
%263 = load i64, i64* %5
%264 = sub i64 %262, %263
%265 = add i64 %264, 1
%266 = load i64, i64* %7
%267 = load i64, i64* %9
%268 = sub i64 %266, %267
%269 = icmp uge i64 %265, %268
br i1 %269, label %270, label %284
270: ; preds = %261
%271 = load i64, i64* %6
%272 = load i64*, i64** %10
%273 = load i32, i32* %11
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds i64, i64* %272, i64 %274
store i64 %271, i64* %275
%276 = load i64, i64* %5
%277 = load i64*, i64** %10
%278 = load i32, i32* %11
%279 = sub nsw i32 %278, 1
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds i64, i64* %277, i64 %280
store i64 %276, i64* %281
%282 = load i64, i64* %7
%283 = sub i64 %282, 1
store i64 %283, i64* %6
br label %298
284: ; preds = %261
%285 = load i64, i64* %7
%286 = sub i64 %285, 1
%287 = load i64*, i64** %10
%288 = load i32, i32* %11
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds i64, i64* %287, i64 %289
store i64 %286, i64* %290
%291 = load i64, i64* %9
%292 = load i64*, i64** %10
%293 = load i32, i32* %11
%294 = sub nsw i32 %293, 1
%295 = sext i32 %294 to i64
%296 = getelementptr inbounds i64, i64* %292, i64 %295
store i64 %291, i64* %296
%297 = load i64, i64* %5
store i64 %297, i64* %9
br label %298
298: ; preds = %284, %270
br label %299
299: ; preds = %298, %72
br label %16
300: ; preds = %71
%301 = load i64*, i64** %10
%302 = call i32 @free_lvector(i64* %301, i32 1, i32 50)
ret void
}

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