void order_float(float unord_arr[], float ord_arr[], int start, int num_elems) {
  int i, j, k;
  double temp;
  for (i = start, k = 0; i < start + num_elems; i++, k++)
    ord_arr[k] = unord_arr[i];
  for (i = 1; i < num_elems; i++) {
    for (j = i - 1; j >= 0; j--)
      if (ord_arr[j + 1] < ord_arr[j]) {
        temp = ord_arr[j];
        ord_arr[j] = ord_arr[j + 1];
        ord_arr[j + 1] = temp;
      } else
        break;
  }
}


x86 assembly (clang, -O0):
<order_float>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    1161 <order_float+0x61>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111f <order_float+0x1f>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    122f <order_float+0x12f>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     121c <order_float+0x11c>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
ucomiss %xmm1,%xmm0
jbe    1204 <order_float+0x104>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movsd  -0x30(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1209 <order_float+0x109>
jmp    121c <order_float+0x11c>
jmp    120e <order_float+0x10e>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    117d <order_float+0x7d>
jmp    1221 <order_float+0x121>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1168 <order_float+0x68>
pop    %rbp
ret

x86 assembly (clang, -O2):
<order_float>:
push   %r14
push   %rbx
test   %ecx,%ecx
jle    11d0 <order_float+0xd0>
lea    (%rcx,%rdx,1),%ebx
movslq %edx,%rax
movslq %ebx,%r11
lea    0x1(%rax),%rdx
cmp    %r11,%rdx
mov    %r11,%r8
cmovg  %rdx,%r8
sub    %rax,%r8
cmp    $0x8,%r8
jb     1153 <order_float+0x53>
cmp    %r11,%rdx
cmovle %r11,%rdx
lea    (%rdi,%rdx,4),%rbx
cmp    %rsi,%rbx
jbe    11d4 <order_float+0xd4>
sub    %rax,%rdx
lea    (%rsi,%rdx,4),%rdx
lea    (%rdi,%rax,4),%rbx
cmp    %rdx,%rbx
jae    11d4 <order_float+0xd4>
xor    %r9d,%r9d
lea    (%rsi,%r9,4),%rdx
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%rdx)
add    $0x1,%rax
add    $0x4,%rdx
cmp    %r11,%rax
jl     1160 <order_float+0x60>
cmp    $0x2,%ecx
jl     11d0 <order_float+0xd0>
mov    %ecx,%eax
mov    $0x1,%ecx
xor    %edx,%edx
jmp    119d <order_float+0x9d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%rdx
cmp    %rax,%rcx
je     11d0 <order_float+0xd0>
mov    %rdx,%rdi
movss  0x4(%rsi,%rdi,4),%xmm0
mov    %edi,%ebx
movss  (%rsi,%rbx,4),%xmm1
ucomiss %xmm0,%xmm1
jbe    1190 <order_float+0x90>
movss  %xmm0,(%rsi,%rbx,4)
movss  %xmm1,0x4(%rsi,%rdi,4)
lea    -0x1(%rdi),%rbx
add    $0x1,%rdi
cmp    $0x1,%rdi
mov    %rbx,%rdi
jg     11a0 <order_float+0xa0>
jmp    1190 <order_float+0x90>
pop    %rbx
pop    %r14
ret
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rdx
mov    %rdx,%r14
shr    $0x3,%r14
add    $0x1,%r14
mov    %r14d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rdx
jae    11fb <order_float+0xfb>
xor    %ebx,%ebx
jmp    1268 <order_float+0x168>
and    $0xfffffffffffffffc,%r14
lea    (%rdi,%rax,4),%rdx
add    $0x70,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x70(%rdx,%rbx,4),%xmm0
movups -0x60(%rdx,%rbx,4),%xmm1
movups %xmm0,(%rsi,%rbx,4)
movups %xmm1,0x10(%rsi,%rbx,4)
movups -0x50(%rdx,%rbx,4),%xmm0
movups -0x40(%rdx,%rbx,4),%xmm1
movups %xmm0,0x20(%rsi,%rbx,4)
movups %xmm1,0x30(%rsi,%rbx,4)
movups -0x30(%rdx,%rbx,4),%xmm0
movups -0x20(%rdx,%rbx,4),%xmm1
movups %xmm0,0x40(%rsi,%rbx,4)
movups %xmm1,0x50(%rsi,%rbx,4)
movups -0x10(%rdx,%rbx,4),%xmm0
movups (%rdx,%rbx,4),%xmm1
movups %xmm0,0x60(%rsi,%rbx,4)
movups %xmm1,0x70(%rsi,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r14
jne    1210 <order_float+0x110>
test   %r10,%r10
je     12ad <order_float+0x1ad>
lea    (%rsi,%rbx,4),%r14
add    $0x10,%r14
add    %rax,%rbx
lea    (%rdi,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rbx,%rdx,1),%xmm0
movups (%rbx,%rdx,1),%xmm1
movups %xmm0,-0x10(%r14,%rdx,1)
movups %xmm1,(%r14,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    1290 <order_float+0x190>
cmp    %r9,%r8
je     1176 <order_float+0x76>
add    %r9,%rax
jmp    1156 <order_float+0x56>

LLVM IR (-O0):
define void @order_float(float* %0, float* %1, i32 %2, i32 %3) {
%5 = alloca float*
%6 = alloca float*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double
store float* %0, float** %5
store float* %1, float** %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%13 = load i32, i32* %7
store i32 %13, i32* %9
store i32 0, i32* %11
br label %14
14: ; preds = %30, %4
%15 = load i32, i32* %9
%16 = load i32, i32* %7
%17 = load i32, i32* %8
%18 = add nsw i32 %16, %17
%19 = icmp slt i32 %15, %18
br i1 %19, label %20, label %35
20: ; preds = %14
%21 = load float*, float** %5
%22 = load i32, i32* %9
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %21, i64 %23
%25 = load float, float* %24
%26 = load float*, float** %6
%27 = load i32, i32* %11
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds float, float* %26, i64 %28
store float %25, float* %29
br label %30
30: ; preds = %20
%31 = load i32, i32* %9
%32 = add nsw i32 %31, 1
store i32 %32, i32* %9
%33 = load i32, i32* %11
%34 = add nsw i32 %33, 1
store i32 %34, i32* %11
br label %14
35: ; preds = %14
store i32 1, i32* %9
br label %36
36: ; preds = %89, %35
%37 = load i32, i32* %9
%38 = load i32, i32* %8
%39 = icmp slt i32 %37, %38
br i1 %39, label %40, label %92
40: ; preds = %36
%41 = load i32, i32* %9
%42 = sub nsw i32 %41, 1
store i32 %42, i32* %10
br label %43
43: ; preds = %85, %40
%44 = load i32, i32* %10
%45 = icmp sge i32 %44, 0
br i1 %45, label %46, label %88
46: ; preds = %43
%47 = load float*, float** %6
%48 = load i32, i32* %10
%49 = add nsw i32 %48, 1
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds float, float* %47, i64 %50
%52 = load float, float* %51
%53 = load float*, float** %6
%54 = load i32, i32* %10
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %53, i64 %55
%57 = load float, float* %56
%58 = fcmp olt float %52, %57
br i1 %58, label %59, label %83
59: ; preds = %46
%60 = load float*, float** %6
%61 = load i32, i32* %10
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds float, float* %60, i64 %62
%64 = load float, float* %63
%65 = fpext float %64 to double
store double %65, double* %12
%66 = load float*, float** %6
%67 = load i32, i32* %10
%68 = add nsw i32 %67, 1
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %66, i64 %69
%71 = load float, float* %70
%72 = load float*, float** %6
%73 = load i32, i32* %10
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %72, i64 %74
store float %71, float* %75
%76 = load double, double* %12
%77 = fptrunc double %76 to float
%78 = load float*, float** %6
%79 = load i32, i32* %10
%80 = add nsw i32 %79, 1
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %78, i64 %81
store float %77, float* %82
br label %84
83: ; preds = %46
br label %88
84: ; preds = %59
br label %85
85: ; preds = %84
%86 = load i32, i32* %10
%87 = add nsw i32 %86, -1
store i32 %87, i32* %10
br label %43
88: ; preds = %83, %43
br label %89
89: ; preds = %88
%90 = load i32, i32* %9
%91 = add nsw i32 %90, 1
store i32 %91, i32* %9
br label %36
92: ; preds = %36
ret void
}

LLVM IR (-O2):
define void @order_float(float* nocapture %0, float* nocapture %1, i32 %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %141
6: ; preds = %4
%7 = add nsw i32 %3, %2
%8 = sext i32 %2 to i64
%9 = sext i32 %7 to i64
%10 = add nsw i64 %8, 1
%11 = call i64 @llvm.smax.i64(i64 %10, i64 %9)
%12 = sub i64 %11, %8
%13 = icmp ult i64 %12, 8
br i1 %13, label %109, label %14
14: ; preds = %6
%15 = add nsw i64 %8, 1
%16 = call i64 @llvm.smax.i64(i64 %15, i64 %9)
%17 = sub i64 %16, %8
%18 = getelementptr float, float* %1, i64 %17
%19 = getelementptr float, float* %0, i64 %8
%20 = getelementptr float, float* %0, i64 %16
%21 = icmp ugt float* %20, %1
%22 = icmp ult float* %19, %18
%23 = and i1 %21, %22
br i1 %23, label %109, label %24
24: ; preds = %14
%25 = and i64 %12, -8
%26 = add i64 %25, %8
%27 = add i64 %25, -8
%28 = lshr exact i64 %27, 3
%29 = add nuw nsw i64 %28, 1
%30 = and i64 %29, 3
%31 = icmp ult i64 %27, 24
br i1 %31, label %87, label %32
32: ; preds = %24
%33 = and i64 %29, 4611686018427387900
br label %34
34: ; preds = %34, %32
%35 = phi i64 [ 0, %32 ], [ %84, %34 ]
%36 = phi i64 [ 0, %32 ], [ %85, %34 ]
%37 = add i64 %35, %8
%38 = getelementptr inbounds float, float* %0, i64 %37
%39 = bitcast float* %38 to <4 x float>*
%40 = load <4 x float>, <4 x float>* %39
%41 = getelementptr inbounds float, float* %38, i64 4
%42 = bitcast float* %41 to <4 x float>*
%43 = load <4 x float>, <4 x float>* %42
%44 = getelementptr inbounds float, float* %1, i64 %35
%45 = bitcast float* %44 to <4 x float>*
store <4 x float> %40, <4 x float>* %45
%46 = getelementptr inbounds float, float* %44, i64 4
%47 = bitcast float* %46 to <4 x float>*
store <4 x float> %43, <4 x float>* %47
%48 = or i64 %35, 8
%49 = add i64 %48, %8
%50 = getelementptr inbounds float, float* %0, i64 %49
%51 = bitcast float* %50 to <4 x float>*
%52 = load <4 x float>, <4 x float>* %51
%53 = getelementptr inbounds float, float* %50, i64 4
%54 = bitcast float* %53 to <4 x float>*
%55 = load <4 x float>, <4 x float>* %54
%56 = getelementptr inbounds float, float* %1, i64 %48
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %52, <4 x float>* %57
%58 = getelementptr inbounds float, float* %56, i64 4
%59 = bitcast float* %58 to <4 x float>*
store <4 x float> %55, <4 x float>* %59
%60 = or i64 %35, 16
%61 = add i64 %60, %8
%62 = getelementptr inbounds float, float* %0, i64 %61
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = getelementptr inbounds float, float* %62, i64 4
%66 = bitcast float* %65 to <4 x float>*
%67 = load <4 x float>, <4 x float>* %66
%68 = getelementptr inbounds float, float* %1, i64 %60
%69 = bitcast float* %68 to <4 x float>*
store <4 x float> %64, <4 x float>* %69
%70 = getelementptr inbounds float, float* %68, i64 4
%71 = bitcast float* %70 to <4 x float>*
store <4 x float> %67, <4 x float>* %71
%72 = or i64 %35, 24
%73 = add i64 %72, %8
%74 = getelementptr inbounds float, float* %0, i64 %73
%75 = bitcast float* %74 to <4 x float>*
%76 = load <4 x float>, <4 x float>* %75
%77 = getelementptr inbounds float, float* %74, i64 4
%78 = bitcast float* %77 to <4 x float>*
%79 = load <4 x float>, <4 x float>* %78
%80 = getelementptr inbounds float, float* %1, i64 %72
%81 = bitcast float* %80 to <4 x float>*
store <4 x float> %76, <4 x float>* %81
%82 = getelementptr inbounds float, float* %80, i64 4
%83 = bitcast float* %82 to <4 x float>*
store <4 x float> %79, <4 x float>* %83
%84 = add nuw i64 %35, 32
%85 = add i64 %36, 4
%86 = icmp eq i64 %85, %33
br i1 %86, label %87, label %34
87: ; preds = %34, %24
%88 = phi i64 [ 0, %24 ], [ %84, %34 ]
%89 = icmp eq i64 %30, 0
br i1 %89, label %107, label %90
90: ; preds = %87, %90
%91 = phi i64 [ %104, %90 ], [ %88, %87 ]
%92 = phi i64 [ %105, %90 ], [ 0, %87 ]
%93 = add i64 %91, %8
%94 = getelementptr inbounds float, float* %0, i64 %93
%95 = bitcast float* %94 to <4 x float>*
%96 = load <4 x float>, <4 x float>* %95
%97 = getelementptr inbounds float, float* %94, i64 4
%98 = bitcast float* %97 to <4 x float>*
%99 = load <4 x float>, <4 x float>* %98
%100 = getelementptr inbounds float, float* %1, i64 %91
%101 = bitcast float* %100 to <4 x float>*
store <4 x float> %96, <4 x float>* %101
%102 = getelementptr inbounds float, float* %100, i64 4
%103 = bitcast float* %102 to <4 x float>*
store <4 x float> %99, <4 x float>* %103
%104 = add nuw i64 %91, 8
%105 = add i64 %92, 1
%106 = icmp eq i64 %105, %30
br i1 %106, label %107, label %90
107: ; preds = %90, %87
%108 = icmp eq i64 %12, %25
br i1 %108, label %112, label %109
109: ; preds = %14, %6, %107
%110 = phi i64 [ 0, %14 ], [ 0, %6 ], [ %25, %107 ]
%111 = phi i64 [ %8, %14 ], [ %8, %6 ], [ %26, %107 ]
br label %116
112: ; preds = %116, %107
%113 = icmp sgt i32 %3, 1
br i1 %113, label %114, label %141
114: ; preds = %112
%115 = zext i32 %3 to i64
br label %125
116: ; preds = %109, %116
%117 = phi i64 [ %123, %116 ], [ %110, %109 ]
%118 = phi i64 [ %122, %116 ], [ %111, %109 ]
%119 = getelementptr inbounds float, float* %0, i64 %118
%120 = load float, float* %119
%121 = getelementptr inbounds float, float* %1, i64 %117
store float %120, float* %121
%122 = add nsw i64 %118, 1
%123 = add nuw nsw i64 %117, 1
%124 = icmp slt i64 %122, %9
br i1 %124, label %116, label %112
125: ; preds = %114, %138
%126 = phi i64 [ 1, %114 ], [ %139, %138 ]
br label %127
127: ; preds = %125, %136
%128 = phi i64 [ %126, %125 ], [ %129, %136 ]
%129 = add nsw i64 %128, -1
%130 = getelementptr inbounds float, float* %1, i64 %128
%131 = load float, float* %130
%132 = and i64 %129, 4294967295
%133 = getelementptr inbounds float, float* %1, i64 %132
%134 = load float, float* %133
%135 = fcmp olt float %131, %134
br i1 %135, label %136, label %138
136: ; preds = %127
store float %131, float* %133
store float %134, float* %130
%137 = icmp sgt i64 %128, 1
br i1 %137, label %127, label %138
138: ; preds = %136, %127
%139 = add nuw nsw i64 %126, 1
%140 = icmp eq i64 %139, %115
br i1 %140, label %141, label %125
141: ; preds = %138, %4, %112
ret void
}