void order_dbl(double unord_arr[], double 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_dbl>:
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_dbl+0x61>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
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_dbl+0x1f>
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1228 <order_dbl+0x128>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     1215 <order_dbl+0x115>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    11fd <order_dbl+0xfd>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x30(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1202 <order_dbl+0x102>
jmp    1215 <order_dbl+0x115>
jmp    1207 <order_dbl+0x107>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    117d <order_dbl+0x7d>
jmp    121a <order_dbl+0x11a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1168 <order_dbl+0x68>
pop    %rbp
ret

x86 assembly (clang, -O2):
<order_dbl>:
push   %r14
push   %rbx
test   %ecx,%ecx
jle    11d1 <order_dbl+0xd1>
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    $0x4,%r8
jb     1153 <order_dbl+0x53>
cmp    %r11,%rdx
cmovle %r11,%rdx
lea    (%rdi,%rdx,8),%rbx
cmp    %rsi,%rbx
jbe    11d5 <order_dbl+0xd5>
sub    %rax,%rdx
lea    (%rsi,%rdx,8),%rdx
lea    (%rdi,%rax,8),%rbx
cmp    %rdx,%rbx
jae    11d5 <order_dbl+0xd5>
xor    %r9d,%r9d
lea    (%rsi,%r9,8),%rdx
nopw   0x0(%rax,%rax,1)
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rdx)
add    $0x1,%rax
add    $0x8,%rdx
cmp    %r11,%rax
jl     1160 <order_dbl+0x60>
cmp    $0x2,%ecx
jl     11d1 <order_dbl+0xd1>
mov    %ecx,%eax
mov    $0x1,%ecx
xor    %edx,%edx
jmp    119d <order_dbl+0x9d>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%rdx
cmp    %rax,%rcx
je     11d1 <order_dbl+0xd1>
mov    %rdx,%rdi
movsd  0x8(%rsi,%rdi,8),%xmm0
mov    %edi,%ebx
movsd  (%rsi,%rbx,8),%xmm1
ucomisd %xmm0,%xmm1
jbe    1190 <order_dbl+0x90>
movsd  %xmm0,(%rsi,%rbx,8)
movsd  %xmm1,0x8(%rsi,%rdi,8)
lea    -0x1(%rdi),%rbx
add    $0x1,%rdi
cmp    $0x1,%rdi
mov    %rbx,%rdi
jg     11a0 <order_dbl+0xa0>
jmp    1190 <order_dbl+0x90>
pop    %rbx
pop    %r14
ret
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rdx
mov    %rdx,%r14
shr    $0x2,%r14
add    $0x1,%r14
mov    %r14d,%r10d
and    $0x3,%r10d
cmp    $0xc,%rdx
jae    11fc <order_dbl+0xfc>
xor    %ebx,%ebx
jmp    126c <order_dbl+0x16c>
and    $0xfffffffffffffffc,%r14
lea    (%rdi,%rax,8),%rdx
add    $0x70,%rdx
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x70(%rdx,%rbx,8),%xmm0
movups -0x60(%rdx,%rbx,8),%xmm1
movups %xmm0,(%rsi,%rbx,8)
movups %xmm1,0x10(%rsi,%rbx,8)
movups -0x50(%rdx,%rbx,8),%xmm0
movups -0x40(%rdx,%rbx,8),%xmm1
movups %xmm0,0x20(%rsi,%rbx,8)
movups %xmm1,0x30(%rsi,%rbx,8)
movups -0x30(%rdx,%rbx,8),%xmm0
movups -0x20(%rdx,%rbx,8),%xmm1
movups %xmm0,0x40(%rsi,%rbx,8)
movups %xmm1,0x50(%rsi,%rbx,8)
movupd -0x10(%rdx,%rbx,8),%xmm0
movupd (%rdx,%rbx,8),%xmm1
movupd %xmm0,0x60(%rsi,%rbx,8)
movupd %xmm1,0x70(%rsi,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%r14
jne    1210 <order_dbl+0x110>
test   %r10,%r10
je     12b1 <order_dbl+0x1b1>
lea    (%rsi,%rbx,8),%r14
add    $0x10,%r14
add    %rax,%rbx
lea    (%rdi,%rbx,8),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movupd -0x10(%rbx,%rdx,1),%xmm0
movupd (%rbx,%rdx,1),%xmm1
movupd %xmm0,-0x10(%r14,%rdx,1)
movupd %xmm1,(%r14,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r10
jne    1290 <order_dbl+0x190>
cmp    %r9,%r8
je     1176 <order_dbl+0x76>
add    %r9,%rax
jmp    1156 <order_dbl+0x56>

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

LLVM IR (-O2):
define void @order_dbl(double* nocapture %0, double* 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, 4
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 double, double* %1, i64 %17
%19 = getelementptr double, double* %0, i64 %8
%20 = getelementptr double, double* %0, i64 %16
%21 = icmp ugt double* %20, %1
%22 = icmp ult double* %19, %18
%23 = and i1 %21, %22
br i1 %23, label %109, label %24
24: ; preds = %14
%25 = and i64 %12, -4
%26 = add i64 %25, %8
%27 = add i64 %25, -4
%28 = lshr exact i64 %27, 2
%29 = add nuw nsw i64 %28, 1
%30 = and i64 %29, 3
%31 = icmp ult i64 %27, 12
br i1 %31, label %87, label %32
32: ; preds = %24
%33 = and i64 %29, 9223372036854775804
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 double, double* %0, i64 %37
%39 = bitcast double* %38 to <2 x double>*
%40 = load <2 x double>, <2 x double>* %39
%41 = getelementptr inbounds double, double* %38, i64 2
%42 = bitcast double* %41 to <2 x double>*
%43 = load <2 x double>, <2 x double>* %42
%44 = getelementptr inbounds double, double* %1, i64 %35
%45 = bitcast double* %44 to <2 x double>*
store <2 x double> %40, <2 x double>* %45
%46 = getelementptr inbounds double, double* %44, i64 2
%47 = bitcast double* %46 to <2 x double>*
store <2 x double> %43, <2 x double>* %47
%48 = or i64 %35, 4
%49 = add i64 %48, %8
%50 = getelementptr inbounds double, double* %0, i64 %49
%51 = bitcast double* %50 to <2 x double>*
%52 = load <2 x double>, <2 x double>* %51
%53 = getelementptr inbounds double, double* %50, i64 2
%54 = bitcast double* %53 to <2 x double>*
%55 = load <2 x double>, <2 x double>* %54
%56 = getelementptr inbounds double, double* %1, i64 %48
%57 = bitcast double* %56 to <2 x double>*
store <2 x double> %52, <2 x double>* %57
%58 = getelementptr inbounds double, double* %56, i64 2
%59 = bitcast double* %58 to <2 x double>*
store <2 x double> %55, <2 x double>* %59
%60 = or i64 %35, 8
%61 = add i64 %60, %8
%62 = getelementptr inbounds double, double* %0, i64 %61
%63 = bitcast double* %62 to <2 x double>*
%64 = load <2 x double>, <2 x double>* %63
%65 = getelementptr inbounds double, double* %62, i64 2
%66 = bitcast double* %65 to <2 x double>*
%67 = load <2 x double>, <2 x double>* %66
%68 = getelementptr inbounds double, double* %1, i64 %60
%69 = bitcast double* %68 to <2 x double>*
store <2 x double> %64, <2 x double>* %69
%70 = getelementptr inbounds double, double* %68, i64 2
%71 = bitcast double* %70 to <2 x double>*
store <2 x double> %67, <2 x double>* %71
%72 = or i64 %35, 12
%73 = add i64 %72, %8
%74 = getelementptr inbounds double, double* %0, i64 %73
%75 = bitcast double* %74 to <2 x double>*
%76 = load <2 x double>, <2 x double>* %75
%77 = getelementptr inbounds double, double* %74, i64 2
%78 = bitcast double* %77 to <2 x double>*
%79 = load <2 x double>, <2 x double>* %78
%80 = getelementptr inbounds double, double* %1, i64 %72
%81 = bitcast double* %80 to <2 x double>*
store <2 x double> %76, <2 x double>* %81
%82 = getelementptr inbounds double, double* %80, i64 2
%83 = bitcast double* %82 to <2 x double>*
store <2 x double> %79, <2 x double>* %83
%84 = add nuw i64 %35, 16
%85 = add nuw 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 double, double* %0, i64 %93
%95 = bitcast double* %94 to <2 x double>*
%96 = load <2 x double>, <2 x double>* %95
%97 = getelementptr inbounds double, double* %94, i64 2
%98 = bitcast double* %97 to <2 x double>*
%99 = load <2 x double>, <2 x double>* %98
%100 = getelementptr inbounds double, double* %1, i64 %91
%101 = bitcast double* %100 to <2 x double>*
store <2 x double> %96, <2 x double>* %101
%102 = getelementptr inbounds double, double* %100, i64 2
%103 = bitcast double* %102 to <2 x double>*
store <2 x double> %99, <2 x double>* %103
%104 = add nuw i64 %91, 4
%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 double, double* %0, i64 %118
%120 = load double, double* %119
%121 = getelementptr inbounds double, double* %1, i64 %117
store double %120, double* %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 double, double* %1, i64 %128
%131 = load double, double* %130
%132 = and i64 %129, 4294967295
%133 = getelementptr inbounds double, double* %1, i64 %132
%134 = load double, double* %133
%135 = fcmp olt double %131, %134
br i1 %135, label %136, label %138
136: ; preds = %127
store double %131, double* %133
store double %134, double* %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
}