#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 sortd1(double a[], int n) {
  int i, j, k, l, r, s, st1[32], st2[32];
  double x, w;
  if (n <= 1) {
    fprintf(stderr, "Error : n <= 1  in sortd1()\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):
<sortd1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jg     1146 <sortd1+0x36>
mov    0x2ead(%rip),%rax
mov    (%rax),%edi
lea    0xec4(%rip),%rsi
call   1030 <fprintf@plt>
jmp    1428 <sortd1+0x318>
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    1254 <sortd1+0x144>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    124f <sortd1+0x13f>
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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    124a <sortd1+0x13a>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1237 <sortd1+0x127>
jmp    124a <sortd1+0x13a>
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x18(%rbp)
mov    %eax,-0x14(%rbp)
jmp    11bd <sortd1+0xad>
jmp    119d <sortd1+0x8d>
jmp    1414 <sortd1+0x304>
jmp    1259 <sortd1+0x149>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x10(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x148(%rbp),%rax
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
jmp    129c <sortd1+0x18c>
movsd  -0x138(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    12c5 <sortd1+0x1b5>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    129c <sortd1+0x18c>
jmp    12ca <sortd1+0x1ba>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x138(%rbp),%xmm0
ff
jbe    12f3 <sortd1+0x1e3>
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    12ca <sortd1+0x1ba>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    1304 <sortd1+0x1f4>
jmp    1372 <sortd1+0x262>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x10(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x140(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0xffffffff,%edx
mov    %edx,-0x14(%rbp)
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    136d <sortd1+0x25d>
jmp    1372 <sortd1+0x262>
jmp    1297 <sortd1+0x187>
mov    -0x14(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    13c2 <sortd1+0x2b2>
mov    -0x10(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    13b7 <sortd1+0x2a7>
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    13f9 <sortd1+0x2e9>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13f3 <sortd1+0x2e3>
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     140a <sortd1+0x2fa>
jmp    140f <sortd1+0x2ff>
jmp    1259 <sortd1+0x149>
jmp    1414 <sortd1+0x304>
jmp    1419 <sortd1+0x309>
cmpl   $0x0,-0x24(%rbp)
jge    1163 <sortd1+0x53>
jmp    1428 <sortd1+0x318>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sortd1>:
push   %rbp
push   %rbx
sub    $0x88,%rsp
cmp    $0x1,%esi
jg     113c <sortd1+0x2c>
mov    0x2ebb(%rip),%rax
mov    (%rax),%edi
lea    0xed2(%rip),%rsi
add    $0x88,%rsp
pop    %rbx
pop    %rbp
jmp    1030 <fprintf@plt>
movl   $0x0,(%rsp)
add    $0xffffffff,%esi
mov    %esi,-0x80(%rsp)
lea    0x8(%rdi),%r11
xor    %r9d,%r9d
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0xffffffff,%r8d
mov    %esi,%eax
sub    %r9d,%eax
cmp    $0xb,%eax
jge    11af <sortd1+0x9f>
cmp    %r9d,%esi
jle    12e0 <sortd1+0x1d0>
movslq %r9d,%rcx
add    $0x1,%r9d
movslq %esi,%r10
lea    (%rdi,%rcx,8),%rdx
mov    %r9d,%esi
jmp    128c <sortd1+0x17c>
nopl   (%rax)
movslq %r8d,%rdx
add    $0x1,%r8d
mov    %eax,0x4(%rsp,%rdx,4)
mov    %ebx,-0x7c(%rsp,%rdx,4)
mov    %r9d,%edx
mov    %ecx,%esi
mov    %edx,%r9d
cmp    %esi,%edx
jge    12e0 <sortd1+0x1d0>
lea    (%rsi,%r9,1),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
movsd  (%rdi,%rax,8),%xmm0
mov    %esi,%ecx
mov    %r9d,%edx
nopl   0x0(%rax)
movslq %edx,%rax
lea    (%rdi,%rax,8),%rax
nopw   0x0(%rax,%rax,1)
movsd  (%rax),%xmm1
add    $0x1,%edx
add    $0x8,%rax
ucomisd %xmm1,%xmm0
ja     11e0 <sortd1+0xd0>
lea    -0x1(%rdx),%r10d
movslq %ecx,%rbx
lea    (%r11,%rbx,8),%rbx
nopl   0x0(%rax)
movsd  -0x8(%rbx),%xmm2
add    $0xfffffffffffffff8,%rbx
add    $0xffffffff,%ecx
ucomisd %xmm0,%xmm2
ja     1200 <sortd1+0xf0>
lea    0x1(%rcx),%ebp
cmp    %ebp,%r10d
jg     1230 <sortd1+0x120>
movsd  %xmm2,-0x8(%rax)
movsd  %xmm1,(%rbx)
cmp    %r10d,%ecx
jg     11d0 <sortd1+0xc0>
jmp    1235 <sortd1+0x125>
nopw   0x0(%rax,%rax,1)
mov    %ebp,%ecx
mov    %r10d,%edx
mov    %ecx,%eax
sub    %r9d,%eax
mov    %esi,%ebp
sub    %edx,%ebp
cmp    %ebp,%eax
jge    1260 <sortd1+0x150>
mov    %edx,%eax
mov    %esi,%ebx
cmp    %edx,%esi
jg     1190 <sortd1+0x80>
jmp    119f <sortd1+0x8f>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r9d,%eax
mov    %ecx,%ebx
cmp    %r9d,%ecx
mov    %edx,%r9d
mov    %esi,%ecx
jg     1190 <sortd1+0x80>
jmp    11a4 <sortd1+0x94>
nopl   0x0(%rax,%rax,1)
add    $0x1,%esi
add    $0x8,%rdx
cmp    %r10,%rcx
je     12e0 <sortd1+0x1d0>
movsd  (%rdi,%rcx,8),%xmm0
movsd  0x8(%rdi,%rcx,8),%xmm1
add    $0x1,%rcx
ucomisd %xmm1,%xmm0
mov    %rdx,%rbx
mov    %esi,%eax
jbe    1280 <sortd1+0x170>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm1,(%rbx)
movsd  %xmm0,0x8(%rbx)
cmp    %eax,%r9d
jge    1280 <sortd1+0x170>
movsd  -0x8(%rbx),%xmm0
movsd  (%rbx),%xmm1
add    $0xfffffffffffffff8,%rbx
add    $0xffffffff,%eax
ucomisd %xmm1,%xmm0
ja     12b0 <sortd1+0x1a0>
jmp    1280 <sortd1+0x170>
cs nopw 0x0(%rax,%rax,1)
test   %r8d,%r8d
js     12f5 <sortd1+0x1e5>
mov    %r8d,%eax
mov    (%rsp,%rax,4),%r9d
mov    -0x80(%rsp,%rax,4),%esi
jmp    1160 <sortd1+0x50>
add    $0x88,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@stderr = global i32 0
@.str = [29 x i8] c"Error : n <= 1 in sortd1()\0A\00"
define void @sortd1(double* %0, i32 %1) {
%3 = alloca double*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca [32 x i32]
%12 = alloca [32 x i32]
%13 = alloca double
%14 = alloca double
store double* %0, double** %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]* %11, 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]* %12, 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]* %11, 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]* %12, 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 double*, double** %3
%52 = load i32, i32* %7
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double, double* %51, i64 %53
%55 = load double, double* %54
%56 = load double*, double** %3
%57 = load i32, i32* %6
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %56, i64 %58
%60 = load double, double* %59
%61 = fcmp ogt double %55, %60
br i1 %61, label %62, label %90
62: ; preds = %50
%63 = load double*, double** %3
%64 = load i32, i32* %7
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds double, double* %63, i64 %65
%67 = load double, double* %66
store double %67, double* %14
%68 = load double*, double** %3
%69 = load i32, i32* %6
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds double, double* %68, i64 %70
%72 = load double, double* %71
%73 = load double*, double** %3
%74 = load i32, i32* %7
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds double, double* %73, i64 %75
store double %72, double* %76
%77 = load double, double* %14
%78 = load double*, double** %3
%79 = load i32, i32* %6
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds double, double* %78, i64 %80
store double %77, double* %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 double*, double** %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 double, double* %96, i64 %101
%103 = load double, double* %102
store double %103, double* %13
br label %104
104: ; preds = %159, %93
br label %105
105: ; preds = %113, %104
%106 = load double, double* %13
%107 = load double*, double** %3
%108 = load i32, i32* %5
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds double, double* %107, i64 %109
%111 = load double, double* %110
%112 = fcmp ogt double %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 double*, double** %3
%119 = load i32, i32* %6
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds double, double* %118, i64 %120
%122 = load double, double* %121
%123 = load double, double* %13
%124 = fcmp ogt double %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 double*, double** %3
%135 = load i32, i32* %5
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds double, double* %134, i64 %136
%138 = load double, double* %137
store double %138, double* %14
%139 = load double*, double** %3
%140 = load i32, i32* %6
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds double, double* %139, i64 %141
%143 = load double, double* %142
%144 = load double*, double** %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 double, double* %144, i64 %147
store double %143, double* %148
%149 = load double, double* %14
%150 = load double*, double** %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 double, double* %150, i64 %153
store double %149, double* %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]* %11, 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]* %12, 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]* %11, 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]* %12, 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 sortd1()\0A\00"
define void @sortd1(double* 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 double, double* %0, i64 %29
%32 = load double, double* %31
%33 = getelementptr inbounds double, double* %0, i64 %30
%34 = load double, double* %33
%35 = fcmp ogt double %32, %34
br i1 %35, label %42, label %52
36: ; preds = %42
%37 = getelementptr inbounds double, double* %0, i64 %51
%38 = load double, double* %37
%39 = getelementptr inbounds double, double* %0, i64 %43
%40 = load double, double* %39
%41 = fcmp ogt double %38, %40
br i1 %41, label %42, label %52
42: ; preds = %28, %36
%43 = phi i64 [ %51, %36 ], [ %29, %28 ]
%44 = phi double [ %40, %36 ], [ %34, %28 ]
%45 = phi double* [ %39, %36 ], [ %33, %28 ]
%46 = phi double [ %38, %36 ], [ %32, %28 ]
%47 = phi double* [ %37, %36 ], [ %31, %28 ]
%48 = phi i64 [ %43, %36 ], [ %30, %28 ]
%49 = trunc i64 %48 to i32
store double %44, double* %47
store double %46, double* %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 double, double* %0, i64 %60
%62 = load double, double* %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 double, double* %0, i64 %68
%70 = load double, double* %69
%71 = fcmp ogt double %62, %70
%72 = add i64 %68, 1
br i1 %71, label %67, label %73
73: ; preds = %67
%74 = getelementptr inbounds double, double* %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 double, double* %0, i64 %78
%80 = load double, double* %79
%81 = fcmp ogt double %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 double, double* %0, i64 %78
%88 = add nsw i32 %75, 1
store double %80, double* %74
%89 = add nsw i32 %84, -1
store double %70, double* %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
}