void order_int(int unord_arr[], int ord_arr[], int num_elems) {
  int i, j;
  int temp;
  for (i = 0; i < num_elems; i++)
    ord_arr[i] = 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_int>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1146 <order_int+0x46>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1116 <order_int+0x16>
movl   $0x1,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11f9 <order_int+0xf9>
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     11e6 <order_int+0xe6>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11ce <order_int+0xce>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11d3 <order_int+0xd3>
jmp    11e6 <order_int+0xe6>
jmp    11d8 <order_int+0xd8>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1162 <order_int+0x62>
jmp    11eb <order_int+0xeb>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    114d <order_int+0x4d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<order_int>:
push   %rbx
test   %edx,%edx
jle    12ae <order_int+0x1ae>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     1123 <order_int+0x23>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    118c <order_int+0x8c>
lea    (%rsi,%r9,4),%rax
cmp    %rdi,%rax
jbe    118c <order_int+0x8c>
xor    %ecx,%ecx
mov    %rcx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     1150 <order_int+0x50>
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rcx,4),%ebx
mov    %ebx,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1140 <order_int+0x40>
cmp    $0x3,%r8
jb     1268 <order_int+0x168>
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rcx,4),%eax
mov    %eax,(%rsi,%rcx,4)
mov    0x4(%rdi,%rcx,4),%eax
mov    %eax,0x4(%rsi,%rcx,4)
mov    0x8(%rdi,%rcx,4),%eax
mov    %eax,0x8(%rsi,%rcx,4)
mov    0xc(%rdi,%rcx,4),%eax
mov    %eax,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1160 <order_int+0x60>
jmp    1268 <order_int+0x168>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r8d
and    $0x3,%r8d
cmp    $0x18,%rax
jae    11b2 <order_int+0xb2>
xor    %eax,%eax
jmp    1218 <order_int+0x118>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rax,4),%xmm0
movups 0x10(%rdi,%rax,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
movups 0x20(%rdi,%rax,4),%xmm0
movups 0x30(%rdi,%rax,4),%xmm1
movups %xmm0,0x20(%rsi,%rax,4)
movups %xmm1,0x30(%rsi,%rax,4)
movups 0x40(%rdi,%rax,4),%xmm0
movups 0x50(%rdi,%rax,4),%xmm1
movups %xmm0,0x40(%rsi,%rax,4)
movups %xmm1,0x50(%rsi,%rax,4)
movups 0x60(%rdi,%rax,4),%xmm0
movups 0x70(%rdi,%rax,4),%xmm1
movups %xmm0,0x60(%rsi,%rax,4)
movups %xmm1,0x70(%rsi,%rax,4)
add    $0x20,%rax
add    $0xfffffffffffffffc,%r10
jne    11c0 <order_int+0xc0>
test   %r8,%r8
je     125f <order_int+0x15f>
lea    (%rsi,%rax,4),%r10
add    $0x10,%r10
lea    (%rdi,%rax,4),%r11
add    $0x10,%r11
shl    $0x5,%r8
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rax,1),%xmm0
movups (%r11,%rax,1),%xmm1
movups %xmm0,-0x10(%r10,%rax,1)
movups %xmm1,(%r10,%rax,1)
add    $0x20,%rax
cmp    %rax,%r8
jne    1240 <order_int+0x140>
cmp    %r9,%rcx
jne    1125 <order_int+0x25>
cmp    $0x2,%edx
jl     12ae <order_int+0x1ae>
lea    -0x1(%rdx),%r8d
mov    $0x1,%r10d
cmp    $0x2,%edx
jne    12b0 <order_int+0x1b0>
test   $0x1,%r8b
je     12ae <order_int+0x1ae>
mov    %r10d,%eax
lea    (%rsi,%rax,4),%rcx
mov    (%rsi,%rax,4),%edx
add    $0x1,%r10d
lea    -0x2(%r10),%eax
mov    (%rsi,%rax,4),%edi
cmp    %edi,%edx
jge    12ae <order_int+0x1ae>
mov    %edx,(%rsi,%rax,4)
mov    %edi,(%rcx)
add    $0xffffffff,%r10d
add    $0xfffffffffffffffc,%rcx
cmp    $0x1,%r10d
jg     1290 <order_int+0x190>
pop    %rbx
ret
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
mov    $0x1,%r10d
xor    %eax,%eax
jmp    12dd <order_int+0x1dd>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%r10d
add    $0x2,%rax
cmp    %r9d,%eax
je     127c <order_int+0x17c>
mov    %r10d,%r11d
mov    (%rsi,%r11,4),%edx
mov    %rax,%rdi
nopw   0x0(%rax,%rax,1)
mov    %edi,%ecx
mov    (%rsi,%rcx,4),%ebx
cmp    %ebx,%edx
jge    130c <order_int+0x20c>
mov    %edx,(%rsi,%rcx,4)
mov    %ebx,0x4(%rsi,%rdi,4)
add    $0xffffffffffffffff,%rdi
lea    0x2(%rdi),%ecx
cmp    $0x1,%ecx
jg     12f0 <order_int+0x1f0>
mov    0x4(%rsi,%r11,4),%ecx
mov    %rax,%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%rdx),%edi
mov    (%rsi,%rdi,4),%ebx
cmp    %ebx,%ecx
jge    12d0 <order_int+0x1d0>
mov    %ecx,(%rsi,%rdi,4)
mov    %ebx,0x8(%rsi,%rdx,4)
add    $0xffffffffffffffff,%rdx
lea    0x3(%rdx),%edi
cmp    $0x1,%edi
jg     1320 <order_int+0x220>
jmp    12d0 <order_int+0x1d0>

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

LLVM IR (-O2):
define void @order_int(i32* nocapture %0, i32* nocapture %1, i32 %2) {
%4 = icmp sgt i32 %2, 0
br i1 %4, label %5, label %193
5: ; preds = %3
%6 = zext i32 %2 to i64
%7 = icmp ult i32 %2, 8
br i1 %7, label %93, label %8
8: ; preds = %5
%9 = getelementptr i32, i32* %1, i64 %6
%10 = getelementptr i32, i32* %0, i64 %6
%11 = icmp ugt i32* %10, %1
%12 = icmp ugt i32* %9, %0
%13 = and i1 %11, %12
br i1 %13, label %93, label %14
14: ; preds = %8
%15 = and i64 %6, 4294967288
%16 = add nsw i64 %15, -8
%17 = lshr exact i64 %16, 3
%18 = add nuw nsw i64 %17, 1
%19 = and i64 %18, 3
%20 = icmp ult i64 %16, 24
br i1 %20, label %72, label %21
21: ; preds = %14
%22 = and i64 %18, 4611686018427387900
br label %23
23: ; preds = %23, %21
%24 = phi i64 [ 0, %21 ], [ %69, %23 ]
%25 = phi i64 [ 0, %21 ], [ %70, %23 ]
%26 = getelementptr inbounds i32, i32* %0, i64 %24
%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 = getelementptr inbounds i32, i32* %1, i64 %24
%33 = bitcast i32* %32 to <4 x i32>*
store <4 x i32> %28, <4 x i32>* %33
%34 = getelementptr inbounds i32, i32* %32, i64 4
%35 = bitcast i32* %34 to <4 x i32>*
store <4 x i32> %31, <4 x i32>* %35
%36 = or i64 %24, 8
%37 = getelementptr inbounds i32, i32* %0, 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 = getelementptr inbounds i32, i32* %1, i64 %36
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> %39, <4 x i32>* %44
%45 = getelementptr inbounds i32, i32* %43, i64 4
%46 = bitcast i32* %45 to <4 x i32>*
store <4 x i32> %42, <4 x i32>* %46
%47 = or i64 %24, 16
%48 = getelementptr inbounds i32, i32* %0, i64 %47
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = getelementptr inbounds i32, i32* %48, i64 4
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = getelementptr inbounds i32, i32* %1, i64 %47
%55 = bitcast i32* %54 to <4 x i32>*
store <4 x i32> %50, <4 x i32>* %55
%56 = getelementptr inbounds i32, i32* %54, i64 4
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> %53, <4 x i32>* %57
%58 = or i64 %24, 24
%59 = getelementptr inbounds i32, i32* %0, i64 %58
%60 = bitcast i32* %59 to <4 x i32>*
%61 = load <4 x i32>, <4 x i32>* %60
%62 = getelementptr inbounds i32, i32* %59, i64 4
%63 = bitcast i32* %62 to <4 x i32>*
%64 = load <4 x i32>, <4 x i32>* %63
%65 = getelementptr inbounds i32, i32* %1, i64 %58
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> %61, <4 x i32>* %66
%67 = getelementptr inbounds i32, i32* %65, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %68
%69 = add nuw i64 %24, 32
%70 = add i64 %25, 4
%71 = icmp eq i64 %70, %22
br i1 %71, label %72, label %23
72: ; preds = %23, %14
%73 = phi i64 [ 0, %14 ], [ %69, %23 ]
%74 = icmp eq i64 %19, 0
br i1 %74, label %91, label %75
75: ; preds = %72, %75
%76 = phi i64 [ %88, %75 ], [ %73, %72 ]
%77 = phi i64 [ %89, %75 ], [ 0, %72 ]
%78 = getelementptr inbounds i32, i32* %0, i64 %76
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = getelementptr inbounds i32, i32* %78, i64 4
%82 = bitcast i32* %81 to <4 x i32>*
%83 = load <4 x i32>, <4 x i32>* %82
%84 = getelementptr inbounds i32, i32* %1, i64 %76
%85 = bitcast i32* %84 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %85
%86 = getelementptr inbounds i32, i32* %84, i64 4
%87 = bitcast i32* %86 to <4 x i32>*
store <4 x i32> %83, <4 x i32>* %87
%88 = add nuw i64 %76, 8
%89 = add i64 %77, 1
%90 = icmp eq i64 %89, %19
br i1 %90, label %91, label %75
91: ; preds = %75, %72
%92 = icmp eq i64 %15, %6
br i1 %92, label %111, label %93
93: ; preds = %8, %5, %91
%94 = phi i64 [ 0, %8 ], [ 0, %5 ], [ %15, %91 ]
%95 = xor i64 %94, -1
%96 = add nsw i64 %95, %6
%97 = and i64 %6, 3
%98 = icmp eq i64 %97, 0
br i1 %98, label %108, label %99
99: ; preds = %93, %99
%100 = phi i64 [ %105, %99 ], [ %94, %93 ]
%101 = phi i64 [ %106, %99 ], [ 0, %93 ]
%102 = getelementptr inbounds i32, i32* %0, i64 %100
%103 = load i32, i32* %102
%104 = getelementptr inbounds i32, i32* %1, i64 %100
store i32 %103, i32* %104
%105 = add nuw nsw i64 %100, 1
%106 = add i64 %101, 1
%107 = icmp eq i64 %106, %97
br i1 %107, label %108, label %99
108: ; preds = %99, %93
%109 = phi i64 [ %94, %93 ], [ %105, %99 ]
%110 = icmp ult i64 %96, 3
br i1 %110, label %111, label %119
111: ; preds = %108, %119, %91
%112 = icmp sgt i32 %2, 1
br i1 %112, label %113, label %193
113: ; preds = %111
%114 = add i32 %2, -1
%115 = and i32 %114, 1
%116 = icmp eq i32 %2, 2
br i1 %116, label %175, label %117
117: ; preds = %113
%118 = and i32 %114, -2
br label %138
119: ; preds = %108, %119
%120 = phi i64 [ %136, %119 ], [ %109, %108 ]
%121 = getelementptr inbounds i32, i32* %0, i64 %120
%122 = load i32, i32* %121
%123 = getelementptr inbounds i32, i32* %1, i64 %120
store i32 %122, i32* %123
%124 = add nuw nsw i64 %120, 1
%125 = getelementptr inbounds i32, i32* %0, i64 %124
%126 = load i32, i32* %125
%127 = getelementptr inbounds i32, i32* %1, i64 %124
store i32 %126, i32* %127
%128 = add nuw nsw i64 %120, 2
%129 = getelementptr inbounds i32, i32* %0, i64 %128
%130 = load i32, i32* %129
%131 = getelementptr inbounds i32, i32* %1, i64 %128
store i32 %130, i32* %131
%132 = add nuw nsw i64 %120, 3
%133 = getelementptr inbounds i32, i32* %0, i64 %132
%134 = load i32, i32* %133
%135 = getelementptr inbounds i32, i32* %1, i64 %132
store i32 %134, i32* %135
%136 = add nuw nsw i64 %120, 4
%137 = icmp eq i64 %136, %6
br i1 %137, label %111, label %119
138: ; preds = %171, %117
%139 = phi i32 [ 1, %117 ], [ %172, %171 ]
%140 = phi i32 [ 0, %117 ], [ %173, %171 ]
%141 = zext i32 %139 to i64
%142 = getelementptr inbounds i32, i32* %1, i64 %141
%143 = load i32, i32* %142
br label %144
144: ; preds = %138, %151
%145 = phi i32 [ %139, %138 ], [ %146, %151 ]
%146 = add nsw i32 %145, -1
%147 = zext i32 %146 to i64
%148 = getelementptr inbounds i32, i32* %1, i64 %147
%149 = load i32, i32* %148
%150 = icmp slt i32 %143, %149
br i1 %150, label %151, label %155
151: ; preds = %144
%152 = zext i32 %145 to i64
%153 = getelementptr inbounds i32, i32* %1, i64 %152
store i32 %143, i32* %148
store i32 %149, i32* %153
%154 = icmp sgt i32 %145, 1
br i1 %154, label %144, label %155
155: ; preds = %151, %144
%156 = add nuw nsw i32 %139, 1
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %1, i64 %157
%159 = load i32, i32* %158
br label %160
160: ; preds = %167, %155
%161 = phi i32 [ %156, %155 ], [ %162, %167 ]
%162 = add nsw i32 %161, -1
%163 = zext i32 %162 to i64
%164 = getelementptr inbounds i32, i32* %1, i64 %163
%165 = load i32, i32* %164
%166 = icmp slt i32 %159, %165
br i1 %166, label %167, label %171
167: ; preds = %160
%168 = zext i32 %161 to i64
%169 = getelementptr inbounds i32, i32* %1, i64 %168
store i32 %159, i32* %164
store i32 %165, i32* %169
%170 = icmp sgt i32 %161, 1
br i1 %170, label %160, label %171
171: ; preds = %167, %160
%172 = add nuw nsw i32 %139, 2
%173 = add i32 %140, 2
%174 = icmp eq i32 %173, %118
br i1 %174, label %175, label %138
175: ; preds = %171, %113
%176 = phi i32 [ 1, %113 ], [ %172, %171 ]
%177 = icmp eq i32 %115, 0
br i1 %177, label %193, label %178
178: ; preds = %175
%179 = zext i32 %176 to i64
%180 = getelementptr inbounds i32, i32* %1, i64 %179
%181 = load i32, i32* %180
br label %182
182: ; preds = %189, %178
%183 = phi i32 [ %176, %178 ], [ %184, %189 ]
%184 = add nsw i32 %183, -1
%185 = zext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %1, i64 %185
%187 = load i32, i32* %186
%188 = icmp slt i32 %181, %187
br i1 %188, label %189, label %193
189: ; preds = %182
%190 = zext i32 %183 to i64
%191 = getelementptr inbounds i32, i32* %1, i64 %190
store i32 %181, i32* %186
store i32 %187, i32* %191
%192 = icmp sgt i32 %183, 1
br i1 %192, label %182, label %193
193: ; preds = %175, %189, %182, %3, %111
ret void
}