void convertToOutputHigh(int *out_step, int *out_level, float *out_pressure,
                         int input_line_count, int *in_level, int *in_step,
                         float *in_pressure) {
  int max_level = 0;
  for (int i = 0; i < input_line_count; i++) {
    if (in_level[i] > max_level)
      max_level = in_level[i];
  }
  for (int j = 0; j <= max_level; j++) {
    for (int i = 0; i < input_line_count; i++) {
      if (in_level[i] == j) {
        out_step[in_step[i] - 1] = in_step[i];
        out_level[in_step[i] - 1] = in_level[i];
        out_pressure[in_step[i] - 1] = in_pressure[i];
      }
    }
  }
}


x86 assembly (clang, -O0):
<convertToOutputHigh>:
push   %rbp
mov    %rsp,%rbp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    116e <convertToOutputHigh+0x6e>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x34(%rbp),%eax
jle    115b <convertToOutputHigh+0x5b>
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
jmp    1160 <convertToOutputHigh+0x60>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    112d <convertToOutputHigh+0x2d>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jg     123b <convertToOutputHigh+0x13b>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1228 <convertToOutputHigh+0x128>
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x3c(%rbp),%eax
jne    1215 <convertToOutputHigh+0x115>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x40(%rbp),%rsi
mov    (%rcx,%rsi,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x40(%rbp),%rsi
mov    (%rcx,%rsi,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x40(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    121a <convertToOutputHigh+0x11a>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1188 <convertToOutputHigh+0x88>
jmp    122d <convertToOutputHigh+0x12d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1175 <convertToOutputHigh+0x75>
pop    %rbp
ret

x86 assembly (clang, -O2):
<convertToOutputHigh>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
xor    %r12d,%r12d
mov    %ecx,%r10d
mov    $0x0,%r14d
test   %ecx,%ecx
jle    1289 <convertToOutputHigh+0x189>
cmp    $0x8,%ecx
jae    112c <convertToOutputHigh+0x2c>
xor    %r11d,%r11d
xor    %r14d,%r14d
jmp    1270 <convertToOutputHigh+0x170>
mov    %r10d,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%rbx
mov    %rbx,%r14
shr    $0x3,%r14
add    $0x1,%r14
test   %rbx,%rbx
je     12ee <convertToOutputHigh+0x1ee>
mov    %r14,%r15
and    $0xfffffffffffffffe,%r15
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu (%r8,%rbx,4),%xmm2
movdqu 0x10(%r8,%rbx,4),%xmm3
movdqu 0x20(%r8,%rbx,4),%xmm4
movdqu 0x30(%r8,%rbx,4),%xmm5
movdqa %xmm2,%xmm6
pcmpgtd %xmm0,%xmm6
pand   %xmm6,%xmm2
pandn  %xmm0,%xmm6
por    %xmm2,%xmm6
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
pcmpgtd %xmm6,%xmm0
pand   %xmm0,%xmm4
pandn  %xmm6,%xmm0
por    %xmm4,%xmm0
movdqa %xmm5,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm5
pandn  %xmm2,%xmm1
por    %xmm5,%xmm1
add    $0x10,%rbx
add    $0xfffffffffffffffe,%r15
jne    1160 <convertToOutputHigh+0x60>
test   $0x1,%r14b
je     1218 <convertToOutputHigh+0x118>
movdqu (%r8,%rbx,4),%xmm2
movdqu 0x10(%r8,%rbx,4),%xmm3
movdqa %xmm2,%xmm4
pcmpgtd %xmm0,%xmm4
pand   %xmm4,%xmm2
pandn  %xmm0,%xmm4
por    %xmm2,%xmm4
movdqa %xmm3,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm4,%xmm0
movdqa %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%r14d
cmp    %r10,%r11
je     1284 <convertToOutputHigh+0x184>
nopl   0x0(%rax,%rax,1)
mov    (%r8,%r11,4),%ebx
cmp    %r14d,%ebx
cmovg  %ebx,%r14d
add    $0x1,%r11
cmp    %r11,%r10
jne    1270 <convertToOutputHigh+0x170>
test   %r14d,%r14d
js     12e5 <convertToOutputHigh+0x1e5>
mov    0x30(%rsp),%r11
jmp    129d <convertToOutputHigh+0x19d>
lea    0x1(%r12),%ebp
cmp    %r14d,%r12d
mov    %ebp,%r12d
je     12e5 <convertToOutputHigh+0x1e5>
test   %ecx,%ecx
jle    1290 <convertToOutputHigh+0x190>
xor    %ebp,%ebp
jmp    12b9 <convertToOutputHigh+0x1b9>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    %rbp,%r10
je     1290 <convertToOutputHigh+0x190>
cmp    %r12d,(%r8,%rbp,4)
jne    12b0 <convertToOutputHigh+0x1b0>
movslq (%r9,%rbp,4),%rbx
mov    %ebx,-0x4(%rdi,%rbx,4)
mov    (%r8,%rbp,4),%ebx
movslq (%r9,%rbp,4),%rax
mov    %ebx,-0x4(%rsi,%rax,4)
movd   (%r11,%rbp,4),%xmm0
movslq (%r9,%rbp,4),%rax
movd   %xmm0,-0x4(%rdx,%rax,4)
jmp    12b0 <convertToOutputHigh+0x1b0>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm0,%xmm0
xor    %ebx,%ebx
pxor   %xmm1,%xmm1
test   $0x1,%r14b
jne    11db <convertToOutputHigh+0xdb>
jmp    1218 <convertToOutputHigh+0x118>

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

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