void sort_index_vector_selection_min(float *key, long nl, long nh, int *index) {
  int i, j, pos, tmp;
  float x, min;
  for (i = nl; i <= nh; i++) {
    index[i] = i;
  }
  for (i = nl; i < nh; i++) {
    min = key[i];
    pos = i;
    for (j = i + 1; j <= nh; j++) {
      x = key[j];
      if (x < min) {
        min = x;
        pos = j;
      }
    }
    key[pos] = key[i];
    key[i] = min;
    tmp = index[i];
    index[i] = index[pos];
    index[pos] = tmp;
  }
}


x86 assembly (clang, -O0):
<sort_index_vector_selection_min>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %eax,-0x24(%rbp)
movslq -0x24(%rbp),%rax
cmp    -0x18(%rbp),%rax
jg     1145 <sort_index_vector_selection_min+0x45>
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111b <sort_index_vector_selection_min+0x1b>
mov    -0x10(%rbp),%rax
mov    %eax,-0x24(%rbp)
movslq -0x24(%rbp),%rax
cmp    -0x18(%rbp),%rax
jge    123d <sort_index_vector_selection_min+0x13d>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
movslq -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jg     11d1 <sort_index_vector_selection_min+0xd1>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm1
movss  -0x38(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    11be <sort_index_vector_selection_min+0xbe>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    11c3 <sort_index_vector_selection_min+0xc3>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    117b <sort_index_vector_selection_min+0x7b>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x38(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    114c <sort_index_vector_selection_min+0x4c>
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort_index_vector_selection_min>:
push   %r15
push   %r14
push   %rbx
movslq %esi,%r15
cmp    %rdx,%r15
jg     12ad <sort_index_vector_selection_min+0x1ad>
lea    0x1(%rdx),%rax
lea    0x1(%r15),%r9
cmp    %r9,%rax
cmovg  %rax,%r9
sub    %r15,%r9
mov    %r15,%r8
cmp    $0x8,%r9
jb     12a0 <sort_index_vector_selection_min+0x1a0>
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
movd   %esi,%xmm0
pshufd $0x0,%xmm0,%xmm0
paddd  0xeb8(%rip),%xmm0
lea    -0x8(%r8),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rax
jae    116b <sort_index_vector_selection_min+0x6b>
xor    %ebx,%ebx
jmp    1240 <sort_index_vector_selection_min+0x140>
and    $0xfffffffffffffffc,%r11
lea    (%rcx,%r15,4),%r14
add    $0x70,%r14
xor    %ebx,%ebx
movdqa 0xe8e(%rip),%xmm8
movdqa 0xe95(%rip),%xmm9
movdqa 0xe9c(%rip),%xmm10
movdqa 0xea4(%rip),%xmm4
movdqa 0xeac(%rip),%xmm5
movdqa 0xeb4(%rip),%xmm6
movdqa 0xebc(%rip),%xmm7
movdqa 0xec4(%rip),%xmm1
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,-0x70(%r14,%rbx,4)
movdqu %xmm2,-0x60(%r14,%rbx,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,-0x50(%r14,%rbx,4)
movdqu %xmm3,-0x40(%r14,%rbx,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,-0x30(%r14,%rbx,4)
movdqu %xmm3,-0x20(%r14,%rbx,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,-0x10(%r14,%rbx,4)
movdqu %xmm3,(%r14,%rbx,4)
add    $0x20,%rbx
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r11
jne    11c0 <sort_index_vector_selection_min+0xc0>
test   %r10,%r10
je     1290 <sort_index_vector_selection_min+0x190>
add    %r15,%rbx
lea    (%rcx,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %eax,%eax
movdqa 0xdb2(%rip),%xmm1
movdqa 0xdba(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rbx,%rax,1)
movdqu %xmm3,(%rbx,%rax,1)
paddd  %xmm2,%xmm0
add    $0x20,%rax
cmp    %rax,%r10
jne    1270 <sort_index_vector_selection_min+0x170>
cmp    %r8,%r9
je     12ad <sort_index_vector_selection_min+0x1ad>
add    %r15,%r8
nopl   0x0(%rax,%rax,1)
mov    %r8d,(%rcx,%r8,4)
add    $0x1,%r8
cmp    %rdx,%r8
jle    12a0 <sort_index_vector_selection_min+0x1a0>
cmp    %rdx,%r15
jge    132d <sort_index_vector_selection_min+0x22d>
add    $0x1,%esi
movslq %esi,%rax
jmp    12ef <sort_index_vector_selection_min+0x1ef>
nopw   0x0(%rax,%rax,1)
mov    %r15d,%ebx
movaps %xmm0,%xmm1
movslq %ebx,%rsi
movss  %xmm0,(%rdi,%rsi,4)
movss  %xmm1,(%rdi,%r15,4)
mov    (%rcx,%r15,4),%r9d
mov    (%rcx,%rsi,4),%ebx
mov    %ebx,(%rcx,%r15,4)
mov    %r9d,(%rcx,%rsi,4)
add    $0x1,%rax
mov    %r8,%r15
cmp    %rdx,%r8
jge    132d <sort_index_vector_selection_min+0x22d>
movss  (%rdi,%r15,4),%xmm0
lea    0x1(%r15),%r8
cmp    %rdx,%r15
jge    12c0 <sort_index_vector_selection_min+0x1c0>
mov    %rax,%rsi
movaps %xmm0,%xmm2
mov    %r15d,%ebx
nopw   0x0(%rax,%rax,1)
movss  (%rdi,%rsi,4),%xmm1
ucomiss %xmm1,%xmm2
cmova  %esi,%ebx
minss  %xmm2,%xmm1
add    $0x1,%rsi
movaps %xmm1,%xmm2
cmp    %rdx,%rsi
jle    1310 <sort_index_vector_selection_min+0x210>
jmp    12c6 <sort_index_vector_selection_min+0x1c6>
pop    %rbx
pop    %r14
pop    %r15
ret

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

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