void index_bubble_sort_single(unsigned long n, float *arr,
                              unsigned long *indx) {
  unsigned long indxt;
  int i, len, isSorted = 0;
  for (i = 0; i < n; i++)
    indx[i] = i;
  for (len = n - 1; len > 0; len--) {
    isSorted = 1;
    for (i = 0; i < len; i++) {
      if (arr[indx[i]] > arr[indx[i + 1]]) {
        isSorted = 0;
        indxt = indx[i];
        indx[i] = indx[i + 1];
        indx[i + 1] = indxt;
      }
    }
    if (isSorted == 1)
      break;
  }
}


x86 assembly (clang, -O0):
<index_bubble_sort_single>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
movslq -0x24(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    114a <index_bubble_sort_single+0x4a>
movslq -0x24(%rbp),%rdx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111e <index_bubble_sort_single+0x1e>
mov    -0x8(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jle    122b <index_bubble_sort_single+0x12b>
movl   $0x1,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1209 <index_bubble_sort_single+0x109>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
ucomiss (%rax,%rcx,4),%xmm0
jbe    11f6 <index_bubble_sort_single+0xf6>
movl   $0x0,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%rdx
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    11fb <index_bubble_sort_single+0xfb>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    116d <index_bubble_sort_single+0x6d>
cmpl   $0x1,-0x2c(%rbp)
jne    1218 <index_bubble_sort_single+0x118>
jmp    122b <index_bubble_sort_single+0x12b>
jmp    121d <index_bubble_sort_single+0x11d>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    1155 <index_bubble_sort_single+0x55>
pop    %rbp
ret

x86 assembly (clang, -O2):
<index_bubble_sort_single>:
push   %rbp
push   %r15
push   %r14
push   %rbx
test   %rdi,%rdi
je     127d <index_bubble_sort_single+0x17d>
cmp    $0x4,%rdi
jae    111c <index_bubble_sort_single+0x1c>
xor    %eax,%eax
jmp    1270 <index_bubble_sort_single+0x170>
mov    %rdi,%rax
and    $0xfffffffffffffffc,%rax
lea    -0x4(%rax),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9d,%r8d
and    $0x3,%r8d
cmp    $0xc,%rcx
jae    114e <index_bubble_sort_single+0x4e>
movdqa 0xeb9(%rip),%xmm0
xor    %ecx,%ecx
jmp    1218 <index_bubble_sort_single+0x118>
and    $0xfffffffffffffffc,%r9
movdqa 0xea6(%rip),%xmm0
xor    %ecx,%ecx
movdqa 0xeab(%rip),%xmm8
movdqa 0xeb2(%rip),%xmm9
movdqa 0xeb9(%rip),%xmm10
movdqa 0xec1(%rip),%xmm4
movdqa 0xec9(%rip),%xmm5
movdqa 0xed1(%rip),%xmm6
movdqa 0xed9(%rip),%xmm7
movdqa 0xee1(%rip),%xmm1
nop
movdqa %xmm0,%xmm2
paddq  %xmm8,%xmm2
movdqu %xmm0,(%rdx,%rcx,8)
movdqu %xmm2,0x10(%rdx,%rcx,8)
movdqa %xmm0,%xmm2
paddq  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm10,%xmm3
movdqu %xmm2,0x20(%rdx,%rcx,8)
movdqu %xmm3,0x30(%rdx,%rcx,8)
movdqa %xmm0,%xmm2
paddq  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm5,%xmm3
movdqu %xmm2,0x40(%rdx,%rcx,8)
movdqu %xmm3,0x50(%rdx,%rcx,8)
movdqa %xmm0,%xmm2
paddq  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddq  %xmm7,%xmm3
movdqu %xmm2,0x60(%rdx,%rcx,8)
movdqu %xmm3,0x70(%rdx,%rcx,8)
add    $0x10,%rcx
paddq  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r9
jne    11a0 <index_bubble_sort_single+0xa0>
test   %r8,%r8
je     1260 <index_bubble_sort_single+0x160>
lea    (%rdx,%rcx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%r8
xor    %ebp,%ebp
movdqa 0xddd(%rip),%xmm1
movdqa 0xde5(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddq  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rcx,%rbp,1)
movdqu %xmm3,(%rcx,%rbp,1)
paddq  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%r8
jne    1240 <index_bubble_sort_single+0x140>
cmp    %rdi,%rax
je     127d <index_bubble_sort_single+0x17d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rax,(%rdx,%rax,8)
add    $0x1,%rax
cmp    %rax,%rdi
jne    1270 <index_bubble_sort_single+0x170>
lea    -0x1(%rdi),%r8d
xor    %r9d,%r9d
mov    %edi,%r10d
jmp    12a2 <index_bubble_sort_single+0x1a2>
nopl   0x0(%rax)
add    $0x1,%r9d
add    $0xffffffffffffffff,%r8
cmp    $0x1,%r14d
je     136c <index_bubble_sort_single+0x26c>
add    $0xffffffff,%r10d
test   %r10d,%r10d
jle    136c <index_bubble_sort_single+0x26c>
mov    %r9d,%r11d
not    %r11d
add    %edi,%r11d
mov    (%rdx),%rbx
cmp    $0x1,%r11d
jne    12f0 <index_bubble_sort_single+0x1f0>
mov    $0x1,%r14d
xor    %ebp,%ebp
test   $0x1,%r11b
je     1290 <index_bubble_sort_single+0x190>
movss  (%rsi,%rbx,4),%xmm0
mov    0x8(%rdx,%rbp,8),%rax
ucomiss (%rsi,%rax,4),%xmm0
jbe    1290 <index_bubble_sort_single+0x190>
mov    %rax,(%rdx,%rbp,8)
mov    %rbx,0x8(%rdx,%rbp,8)
xor    %r14d,%r14d
jmp    1290 <index_bubble_sort_single+0x190>
nopl   (%rax)
mov    %r8d,%r15d
and    $0xfffffffe,%r15d
mov    $0x1,%r14d
xor    %eax,%eax
jmp    1325 <index_bubble_sort_single+0x225>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rcx,0x8(%rdx,%rax,8)
mov    %rbx,0x10(%rdx,%rax,8)
xor    %r14d,%r14d
mov    %rbp,%rax
cmp    %rbp,%r15
je     12c9 <index_bubble_sort_single+0x1c9>
movss  (%rsi,%rbx,4),%xmm0
mov    0x8(%rdx,%rax,8),%rcx
ucomiss (%rsi,%rcx,4),%xmm0
jbe    1350 <index_bubble_sort_single+0x250>
mov    %rcx,(%rdx,%rax,8)
mov    %rbx,0x8(%rdx,%rax,8)
xor    %r14d,%r14d
jmp    1353 <index_bubble_sort_single+0x253>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rcx,%rbx
movss  (%rsi,%rbx,4),%xmm0
lea    0x2(%rax),%rbp
mov    0x10(%rdx,%rax,8),%rcx
ucomiss (%rsi,%rcx,4),%xmm0
ja     1310 <index_bubble_sort_single+0x210>
mov    %rcx,%rbx
jmp    131d <index_bubble_sort_single+0x21d>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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