#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
void sorti1(int a[], int n) {
  int i, j, k, l, r, s, x, w, st1[32], st2[32];
  if (n <= 1) {
    fprintf(stderr, "Error : n <= 1  in sorti1()\n");
    return;
  }
  s = 0;
  st1[0] = 0;
  st2[0] = n - 1;
  do {
    l = st1[s];
    r = st2[s];
    s--;
    if (r - l < 11) {
      i = l;
      while (i < r) {
        k = i++;
        j = i;
        while (*(a + k) > *(a + j)) {
          w = *(a + k);
          *(a + k) = *(a + j);
          *(a + j) = w;
          if (j <= l + 1)
            break;
          j = k--;
        }
      }
    } else {
      for (;;) {
        i = l;
        j = r;
        x = *(a + (int)((l + r) / 2));
        for (;;) {
          while (x > *(a + i))
            i++;
          while (*(a + j) > x)
            j--;
          if (i > j)
            break;
          w = *(a + i);
          *(a + i++) = *(a + j);
          *(a + j--) = w;
          if (i > j)
            break;
        }
        if (j - l < r - i) {
          if (i < r) {
            s++;
            st1[s] = i;
            st2[s] = r;
          }
          r = j;
        } else {
          if (l < j) {
            s++;
            st1[s] = l;
            st2[s] = j;
          }
          l = i;
        }
        if (l >= r)
          break;
      }
    }
  } while (s >= 0);
  return;
}


x86 assembly (clang, -O0):
<sorti1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jg     1146 <sorti1+0x36>
mov    0x2ead(%rip),%rax
mov    (%rax),%edi
lea    0xec4(%rip),%rsi
call   1030 <fprintf@plt>
jmp    13eb <sorti1+0x2db>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0xb0(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x130(%rbp)
movslq -0x24(%rbp),%rax
mov    -0xb0(%rbp,%rax,4),%eax
mov    %eax,-0x1c(%rbp)
movslq -0x24(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
sub    -0x1c(%rbp),%eax
cmp    $0xb,%eax
jge    123e <sorti1+0x12e>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1239 <sorti1+0x129>
mov    -0x10(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x10(%rbp)
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1234 <sorti1+0x124>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1221 <sorti1+0x111>
jmp    1234 <sorti1+0x124>
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
mov    %eax,-0x14(%rbp)
jmp    11bd <sorti1+0xad>
jmp    119d <sorti1+0x8d>
jmp    13d7 <sorti1+0x2c7>
jmp    1243 <sorti1+0x133>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x138(%rbp),%rax
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
jmp    127f <sorti1+0x16f>
mov    -0x28(%rbp),%eax
mov    -0x8(%rbp),%rcx
movslq -0x10(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    12a1 <sorti1+0x191>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    127f <sorti1+0x16f>
jmp    12a6 <sorti1+0x196>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x28(%rbp),%eax
jle    12c8 <sorti1+0x1b8>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    12a6 <sorti1+0x196>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    12d9 <sorti1+0x1c9>
jmp    1335 <sorti1+0x225>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x10(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
mov    %esi,-0x14(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1330 <sorti1+0x220>
jmp    1335 <sorti1+0x225>
jmp    127a <sorti1+0x16a>
mov    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1385 <sorti1+0x275>
mov    -0x10(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    137a <sorti1+0x26a>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,4)
mov    -0x20(%rbp),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    13bc <sorti1+0x2ac>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13b6 <sorti1+0x2a6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0xb0(%rbp,%rax,4)
mov    -0x14(%rbp),%ecx
movslq -0x24(%rbp),%rax
mov    %ecx,-0x130(%rbp,%rax,4)
mov    -0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jl     13cd <sorti1+0x2bd>
jmp    13d2 <sorti1+0x2c2>
jmp    1243 <sorti1+0x133>
jmp    13d7 <sorti1+0x2c7>
jmp    13dc <sorti1+0x2cc>
cmpl   $0x0,-0x24(%rbp)
jge    1163 <sorti1+0x53>
jmp    13eb <sorti1+0x2db>
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sorti1>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x80,%rsp
cmp    $0x1,%esi
jg     1148 <sorti1+0x38>
mov    0x2eb5(%rip),%rax
mov    (%rax),%edi
lea    0xecc(%rip),%rsi
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <fprintf@plt>
movl   $0x0,(%rsp)
add    $0xffffffff,%esi
mov    %esi,-0x80(%rsp)
lea    0x4(%rdi),%r10
xor    %r9d,%r9d
xor    %r8d,%r8d
add    $0xffffffff,%r8d
mov    %esi,%eax
sub    %r9d,%eax
cmp    $0xb,%eax
jge    11b0 <sorti1+0xa0>
cmp    %r9d,%esi
jle    12d0 <sorti1+0x1c0>
movslq %r9d,%r14
add    $0x1,%r9d
movslq %esi,%r11
lea    (%rdi,%r14,4),%rax
mov    %r9d,%ebp
jmp    128c <sorti1+0x17c>
nopl   (%rax)
movslq %r8d,%rsi
add    $0x1,%r8d
mov    %eax,0x4(%rsp,%rsi,4)
mov    %edx,-0x7c(%rsp,%rsi,4)
mov    %r9d,%r15d
mov    %ecx,%esi
mov    %r15d,%r9d
cmp    %esi,%r15d
jge    12d0 <sorti1+0x1c0>
lea    (%rsi,%r9,1),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
mov    (%rdi,%rax,4),%r11d
mov    %esi,%ecx
mov    %r9d,%r15d
nopl   0x0(%rax)
movslq %r15d,%rax
lea    (%rdi,%rax,4),%rax
nopw   0x0(%rax,%rax,1)
mov    (%rax),%ebx
add    $0x1,%r15d
add    $0x4,%rax
cmp    %ebx,%r11d
jg     11e0 <sorti1+0xd0>
lea    -0x1(%r15),%r14d
movslq %ecx,%rdx
lea    (%r10,%rdx,4),%rbp
nopw   0x0(%rax,%rax,1)
mov    -0x4(%rbp),%edx
add    $0xfffffffffffffffc,%rbp
add    $0xffffffff,%ecx
cmp    %r11d,%edx
jg     1200 <sorti1+0xf0>
lea    0x1(%rcx),%r12d
cmp    %r12d,%r14d
jg     1230 <sorti1+0x120>
mov    %edx,-0x4(%rax)
mov    %ebx,0x0(%rbp)
cmp    %r14d,%ecx
jg     11d0 <sorti1+0xc0>
jmp    1236 <sorti1+0x126>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12d,%ecx
mov    %r14d,%r15d
mov    %ecx,%eax
sub    %r9d,%eax
mov    %esi,%edx
sub    %r15d,%edx
cmp    %edx,%eax
jge    1260 <sorti1+0x150>
mov    %r15d,%eax
mov    %esi,%edx
cmp    %r15d,%esi
jg     1190 <sorti1+0x80>
jmp    119f <sorti1+0x8f>
nopw   0x0(%rax,%rax,1)
mov    %r9d,%eax
mov    %ecx,%edx
cmp    %r9d,%ecx
mov    %r15d,%r9d
mov    %esi,%ecx
jg     1190 <sorti1+0x80>
jmp    11a4 <sorti1+0x94>
nopl   0x0(%rax,%rax,1)
add    $0x1,%ebp
add    $0x4,%rax
cmp    %r11,%r14
je     12d0 <sorti1+0x1c0>
mov    (%rdi,%r14,4),%ebx
mov    0x4(%rdi,%r14,4),%edx
add    $0x1,%r14
mov    %rax,%rcx
mov    %ebp,%esi
cmp    %edx,%ebx
jle    1280 <sorti1+0x170>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edx,(%rcx)
mov    %ebx,0x4(%rcx)
cmp    %esi,%r9d
jge    1280 <sorti1+0x170>
mov    -0x4(%rcx),%ebx
mov    (%rcx),%edx
add    $0xfffffffffffffffc,%rcx
add    $0xffffffff,%esi
cmp    %edx,%ebx
jg     12b0 <sorti1+0x1a0>
jmp    1280 <sorti1+0x170>
nopl   0x0(%rax)
test   %r8d,%r8d
js     12e5 <sorti1+0x1d5>
mov    %r8d,%eax
mov    (%rsp,%rax,4),%r9d
mov    -0x80(%rsp,%rax,4),%esi
jmp    1160 <sorti1+0x50>
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [29 x i8] c"Error : n <= 1 in sorti1()\0A\00"
define void @sorti1(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca [32 x i32]
%14 = alloca [32 x i32]
store i32* %0, i32** %3
store i32 %1, i32* %4
%15 = load i32, i32* %4
%16 = icmp sle i32 %15, 1
br i1 %16, label %17, label %20
17: ; preds = %2
%18 = load i32, i32* @stderr
%19 = call i32 @fprintf(i32 %18, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0))
br label %214
20: ; preds = %2
store i32 0, i32* %10
%21 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 0
store i32 0, i32* %21
%22 = load i32, i32* %4
%23 = sub nsw i32 %22, 1
%24 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 0
store i32 %23, i32* %24
br label %25
25: ; preds = %210, %20
%26 = load i32, i32* %10
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %27
%29 = load i32, i32* %28
store i32 %29, i32* %8
%30 = load i32, i32* %10
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %31
%33 = load i32, i32* %32
store i32 %33, i32* %9
%34 = load i32, i32* %10
%35 = add nsw i32 %34, -1
store i32 %35, i32* %10
%36 = load i32, i32* %9
%37 = load i32, i32* %8
%38 = sub nsw i32 %36, %37
%39 = icmp slt i32 %38, 11
br i1 %39, label %40, label %92
40: ; preds = %25
%41 = load i32, i32* %8
store i32 %41, i32* %5
br label %42
42: ; preds = %90, %40
%43 = load i32, i32* %5
%44 = load i32, i32* %9
%45 = icmp slt i32 %43, %44
br i1 %45, label %46, label %91
46: ; preds = %42
%47 = load i32, i32* %5
%48 = add nsw i32 %47, 1
store i32 %48, i32* %5
store i32 %47, i32* %7
%49 = load i32, i32* %5
store i32 %49, i32* %6
br label %50
50: ; preds = %87, %46
%51 = load i32*, i32** %3
%52 = load i32, i32* %7
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32, i32* %51, i64 %53
%55 = load i32, i32* %54
%56 = load i32*, i32** %3
%57 = load i32, i32* %6
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %56, i64 %58
%60 = load i32, i32* %59
%61 = icmp sgt i32 %55, %60
br i1 %61, label %62, label %90
62: ; preds = %50
%63 = load i32*, i32** %3
%64 = load i32, i32* %7
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i32, i32* %63, i64 %65
%67 = load i32, i32* %66
store i32 %67, i32* %12
%68 = load i32*, i32** %3
%69 = load i32, i32* %6
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i32, i32* %68, i64 %70
%72 = load i32, i32* %71
%73 = load i32*, i32** %3
%74 = load i32, i32* %7
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i32, i32* %73, i64 %75
store i32 %72, i32* %76
%77 = load i32, i32* %12
%78 = load i32*, i32** %3
%79 = load i32, i32* %6
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %78, i64 %80
store i32 %77, i32* %81
%82 = load i32, i32* %6
%83 = load i32, i32* %8
%84 = add nsw i32 %83, 1
%85 = icmp sle i32 %82, %84
br i1 %85, label %86, label %87
86: ; preds = %62
br label %90
87: ; preds = %62
%88 = load i32, i32* %7
%89 = add nsw i32 %88, -1
store i32 %89, i32* %7
store i32 %88, i32* %6
br label %50
90: ; preds = %86, %50
br label %42
91: ; preds = %42
br label %209
92: ; preds = %25
br label %93
93: ; preds = %207, %92
%94 = load i32, i32* %8
store i32 %94, i32* %5
%95 = load i32, i32* %9
store i32 %95, i32* %6
%96 = load i32*, i32** %3
%97 = load i32, i32* %8
%98 = load i32, i32* %9
%99 = add nsw i32 %97, %98
%100 = sdiv i32 %99, 2
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %96, i64 %101
%103 = load i32, i32* %102
store i32 %103, i32* %11
br label %104
104: ; preds = %159, %93
br label %105
105: ; preds = %113, %104
%106 = load i32, i32* %11
%107 = load i32*, i32** %3
%108 = load i32, i32* %5
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %107, i64 %109
%111 = load i32, i32* %110
%112 = icmp sgt i32 %106, %111
br i1 %112, label %113, label %116
113: ; preds = %105
%114 = load i32, i32* %5
%115 = add nsw i32 %114, 1
store i32 %115, i32* %5
br label %105
116: ; preds = %105
br label %117
117: ; preds = %125, %116
%118 = load i32*, i32** %3
%119 = load i32, i32* %6
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32, i32* %118, i64 %120
%122 = load i32, i32* %121
%123 = load i32, i32* %11
%124 = icmp sgt i32 %122, %123
br i1 %124, label %125, label %128
125: ; preds = %117
%126 = load i32, i32* %6
%127 = add nsw i32 %126, -1
store i32 %127, i32* %6
br label %117
128: ; preds = %117
%129 = load i32, i32* %5
%130 = load i32, i32* %6
%131 = icmp sgt i32 %129, %130
br i1 %131, label %132, label %133
132: ; preds = %128
br label %160
133: ; preds = %128
%134 = load i32*, i32** %3
%135 = load i32, i32* %5
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %134, i64 %136
%138 = load i32, i32* %137
store i32 %138, i32* %12
%139 = load i32*, i32** %3
%140 = load i32, i32* %6
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %139, i64 %141
%143 = load i32, i32* %142
%144 = load i32*, i32** %3
%145 = load i32, i32* %5
%146 = add nsw i32 %145, 1
store i32 %146, i32* %5
%147 = sext i32 %145 to i64
%148 = getelementptr inbounds i32, i32* %144, i64 %147
store i32 %143, i32* %148
%149 = load i32, i32* %12
%150 = load i32*, i32** %3
%151 = load i32, i32* %6
%152 = add nsw i32 %151, -1
store i32 %152, i32* %6
%153 = sext i32 %151 to i64
%154 = getelementptr inbounds i32, i32* %150, i64 %153
store i32 %149, i32* %154
%155 = load i32, i32* %5
%156 = load i32, i32* %6
%157 = icmp sgt i32 %155, %156
br i1 %157, label %158, label %159
158: ; preds = %133
br label %160
159: ; preds = %133
br label %104
160: ; preds = %158, %132
%161 = load i32, i32* %6
%162 = load i32, i32* %8
%163 = sub nsw i32 %161, %162
%164 = load i32, i32* %9
%165 = load i32, i32* %5
%166 = sub nsw i32 %164, %165
%167 = icmp slt i32 %163, %166
br i1 %167, label %168, label %185
168: ; preds = %160
%169 = load i32, i32* %5
%170 = load i32, i32* %9
%171 = icmp slt i32 %169, %170
br i1 %171, label %172, label %183
172: ; preds = %168
%173 = load i32, i32* %10
%174 = add nsw i32 %173, 1
store i32 %174, i32* %10
%175 = load i32, i32* %5
%176 = load i32, i32* %10
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %177
store i32 %175, i32* %178
%179 = load i32, i32* %9
%180 = load i32, i32* %10
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %181
store i32 %179, i32* %182
br label %183
183: ; preds = %172, %168
%184 = load i32, i32* %6
store i32 %184, i32* %9
br label %202
185: ; preds = %160
%186 = load i32, i32* %8
%187 = load i32, i32* %6
%188 = icmp slt i32 %186, %187
br i1 %188, label %189, label %200
189: ; preds = %185
%190 = load i32, i32* %10
%191 = add nsw i32 %190, 1
store i32 %191, i32* %10
%192 = load i32, i32* %8
%193 = load i32, i32* %10
%194 = sext i32 %193 to i64
%195 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 %194
store i32 %192, i32* %195
%196 = load i32, i32* %6
%197 = load i32, i32* %10
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 %198
store i32 %196, i32* %199
br label %200
200: ; preds = %189, %185
%201 = load i32, i32* %5
store i32 %201, i32* %8
br label %202
202: ; preds = %200, %183
%203 = load i32, i32* %8
%204 = load i32, i32* %9
%205 = icmp sge i32 %203, %204
br i1 %205, label %206, label %207
206: ; preds = %202
br label %208
207: ; preds = %202
br label %93
208: ; preds = %206
br label %209
209: ; preds = %208, %91
br label %210
210: ; preds = %209
%211 = load i32, i32* %10
%212 = icmp sge i32 %211, 0
br i1 %212, label %25, label %213
213: ; preds = %210
br label %214
214: ; preds = %213, %17
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [29 x i8] c"Error : n <= 1 in sorti1()\0A\00"
define void @sorti1(i32* nocapture %0, i32 %1) {
%3 = alloca [32 x i32]
%4 = alloca [32 x i32]
%5 = bitcast [32 x i32]* %3 to i8*
%6 = bitcast [32 x i32]* %4 to i8*
%7 = icmp slt i32 %1, 2
br i1 %7, label %8, label %11
8: ; preds = %2
%9 = load i32, i32* @stderr
%10 = tail call i32 @fprintf(i32 %9, i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0))
br label %127
11: ; preds = %2
%12 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 0
store i32 0, i32* %12
%13 = add nsw i32 %1, -1
%14 = getelementptr inbounds [32 x i32], [32 x i32]* %4, i64 0, i64 0
store i32 %13, i32* %14
br label %15
15: ; preds = %121, %11
%16 = phi i32 [ %13, %11 ], [ %126, %121 ]
%17 = phi i32 [ 0, %11 ], [ %124, %121 ]
%18 = phi i32 [ 0, %11 ], [ %119, %121 ]
%19 = add nsw i32 %18, -1
%20 = sub nsw i32 %16, %17
%21 = icmp slt i32 %20, 11
br i1 %21, label %22, label %54
22: ; preds = %15
%23 = icmp sgt i32 %16, %17
br i1 %23, label %24, label %118
24: ; preds = %22
%25 = add nsw i32 %17, 1
%26 = sext i32 %17 to i64
%27 = sext i32 %16 to i64
br label %28
28: ; preds = %24, %52
%29 = phi i64 [ %26, %24 ], [ %30, %52 ]
%30 = add nsw i64 %29, 1
%31 = getelementptr inbounds i32, i32* %0, i64 %29
%32 = load i32, i32* %31
%33 = getelementptr inbounds i32, i32* %0, i64 %30
%34 = load i32, i32* %33
%35 = icmp sgt i32 %32, %34
br i1 %35, label %42, label %52
36: ; preds = %42
%37 = getelementptr inbounds i32, i32* %0, i64 %51
%38 = load i32, i32* %37
%39 = getelementptr inbounds i32, i32* %0, i64 %43
%40 = load i32, i32* %39
%41 = icmp sgt i32 %38, %40
br i1 %41, label %42, label %52
42: ; preds = %28, %36
%43 = phi i64 [ %51, %36 ], [ %29, %28 ]
%44 = phi i32 [ %40, %36 ], [ %34, %28 ]
%45 = phi i32* [ %39, %36 ], [ %33, %28 ]
%46 = phi i32 [ %38, %36 ], [ %32, %28 ]
%47 = phi i32* [ %37, %36 ], [ %31, %28 ]
%48 = phi i64 [ %43, %36 ], [ %30, %28 ]
%49 = trunc i64 %48 to i32
store i32 %44, i32* %47
store i32 %46, i32* %45
%50 = icmp slt i32 %25, %49
%51 = add nsw i64 %43, -1
br i1 %50, label %36, label %52
52: ; preds = %36, %42, %28
%53 = icmp eq i64 %30, %27
br i1 %53, label %118, label %28
54: ; preds = %15, %113
%55 = phi i32 [ %114, %113 ], [ %17, %15 ]
%56 = phi i32 [ %115, %113 ], [ %16, %15 ]
%57 = phi i32 [ %116, %113 ], [ %19, %15 ]
%58 = add nsw i32 %56, %55
%59 = sdiv i32 %58, 2
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %0, i64 %60
%62 = load i32, i32* %61
br label %63
63: ; preds = %86, %54
%64 = phi i32 [ %56, %54 ], [ %89, %86 ]
%65 = phi i32 [ %55, %54 ], [ %88, %86 ]
%66 = sext i32 %65 to i64
br label %67
67: ; preds = %67, %63
%68 = phi i64 [ %72, %67 ], [ %66, %63 ]
%69 = getelementptr inbounds i32, i32* %0, i64 %68
%70 = load i32, i32* %69
%71 = icmp sgt i32 %62, %70
%72 = add i64 %68, 1
br i1 %71, label %67, label %73
73: ; preds = %67
%74 = getelementptr inbounds i32, i32* %0, i64 %68
%75 = trunc i64 %68 to i32
%76 = sext i32 %64 to i64
br label %77
77: ; preds = %77, %73
%78 = phi i64 [ %82, %77 ], [ %76, %73 ]
%79 = getelementptr inbounds i32, i32* %0, i64 %78
%80 = load i32, i32* %79
%81 = icmp sgt i32 %80, %62
%82 = add i64 %78, -1
br i1 %81, label %77, label %83
83: ; preds = %77
%84 = trunc i64 %78 to i32
%85 = icmp sgt i32 %75, %84
br i1 %85, label %91, label %86
86: ; preds = %83
%87 = getelementptr inbounds i32, i32* %0, i64 %78
%88 = add nsw i32 %75, 1
store i32 %80, i32* %74
%89 = add nsw i32 %84, -1
store i32 %70, i32* %87
%90 = icmp sgt i32 %89, %75
br i1 %90, label %63, label %94
91: ; preds = %83
%92 = trunc i64 %68 to i32
%93 = trunc i64 %78 to i32
br label %94
94: ; preds = %86, %91
%95 = phi i32 [ %93, %91 ], [ %89, %86 ]
%96 = phi i32 [ %92, %91 ], [ %88, %86 ]
%97 = sub nsw i32 %95, %55
%98 = sub nsw i32 %56, %96
%99 = icmp slt i32 %97, %98
br i1 %99, label %100, label %102
100: ; preds = %94
%101 = icmp sgt i32 %56, %96
br i1 %101, label %104, label %113
102: ; preds = %94
%103 = icmp sgt i32 %95, %55
br i1 %103, label %104, label %113
104: ; preds = %102, %100
%105 = phi i32 [ %96, %100 ], [ %55, %102 ]
%106 = phi i32 [ %56, %100 ], [ %95, %102 ]
%107 = phi i32 [ %55, %100 ], [ %96, %102 ]
%108 = phi i32 [ %95, %100 ], [ %56, %102 ]
%109 = add nsw i32 %57, 1
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %110
store i32 %105, i32* %111
%112 = getelementptr inbounds [32 x i32], [32 x i32]* %4, i64 0, i64 %110
store i32 %106, i32* %112
br label %113
113: ; preds = %104, %102, %100
%114 = phi i32 [ %55, %100 ], [ %96, %102 ], [ %107, %104 ]
%115 = phi i32 [ %95, %100 ], [ %56, %102 ], [ %108, %104 ]
%116 = phi i32 [ %57, %100 ], [ %57, %102 ], [ %109, %104 ]
%117 = icmp slt i32 %114, %115
br i1 %117, label %54, label %118
118: ; preds = %113, %52, %22
%119 = phi i32 [ %19, %22 ], [ %19, %52 ], [ %116, %113 ]
%120 = icmp sgt i32 %119, -1
br i1 %120, label %121, label %127
121: ; preds = %118
%122 = zext i32 %119 to i64
%123 = getelementptr inbounds [32 x i32], [32 x i32]* %3, i64 0, i64 %122
%124 = load i32, i32* %123
%125 = getelementptr inbounds [32 x i32], [32 x i32]* %4, i64 0, i64 %122
%126 = load i32, i32* %125
br label %15
127: ; preds = %118, %8
ret void
}