#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 sortdi1(double a[], int n, int jun[]) {
  int i, j, k, l, *p, r, s, w, st1[32], st2[32];
  double x;
  if (n <= 1) {
    fprintf(stderr, "Error : n <= 1  in sortdi1()\n");
    return;
  }
  for (i = 0, p = jun; i < n; i++)
    *p++ = i;
  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 + *(jun + k)) > *(a + *(jun + j))) {
          w = *(jun + k);
          *(jun + k) = *(jun + j);
          *(jun + j) = w;
          if (j <= l + 1)
            break;
          j = k--;
        }
      }
    } else {
      for (;;) {
        i = l;
        j = r;
        x = *(a + *(jun + (int)((l + r) / 2)));
        for (;;) {
          while (x > *(a + *(jun + i)))
            i++;
          while (*(a + *(jun + j)) > x)
            j--;
          if (i > j)
            break;
          w = *(jun + i);
          *(jun + i++) = *(jun + j);
          *(jun + 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):
<sortdi1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
cmpl   $0x1,-0xc(%rbp)
jg     114a <sortdi1+0x3a>
mov    0x2ea9(%rip),%rax
mov    (%rax),%edi
lea    0xec0(%rip),%rsi
call   1030 <fprintf@plt>
jmp    146d <sortdi1+0x35d>
movl   $0x0,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1187 <sortdi1+0x77>
mov    -0x1c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1159 <sortdi1+0x49>
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0xc0(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x140(%rbp)
movslq -0x38(%rbp),%rax
mov    -0xc0(%rbp,%rax,4),%eax
mov    %eax,-0x28(%rbp)
movslq -0x38(%rbp),%rax
mov    -0x140(%rbp,%rax,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x28(%rbp),%eax
cmp    $0xb,%eax
jge    1293 <sortdi1+0x183>
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    128e <sortdi1+0x17e>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x1c(%rbp)
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1289 <sortdi1+0x179>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1276 <sortdi1+0x166>
jmp    1289 <sortdi1+0x179>
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x24(%rbp)
mov    %eax,-0x20(%rbp)
jmp    11fe <sortdi1+0xee>
jmp    11de <sortdi1+0xce>
jmp    1459 <sortdi1+0x349>
jmp    1298 <sortdi1+0x188>
mov    -0x28(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%eax
add    -0x34(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x150(%rbp),%rax
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x148(%rbp)
ff
jmp    12e3 <sortdi1+0x1d3>
movsd  -0x148(%rbp),%xmm0
ff
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1314 <sortdi1+0x204>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12e3 <sortdi1+0x1d3>
jmp    1319 <sortdi1+0x209>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x148(%rbp),%xmm0
ff
jbe    134a <sortdi1+0x23a>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1319 <sortdi1+0x209>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    135b <sortdi1+0x24b>
jmp    13b7 <sortdi1+0x2a7>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0xffffffff,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    13b2 <sortdi1+0x2a2>
jmp    13b7 <sortdi1+0x2a7>
jmp    12de <sortdi1+0x1ce>
mov    -0x20(%rbp),%eax
sub    -0x28(%rbp),%eax
mov    -0x34(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    1407 <sortdi1+0x2f7>
mov    -0x1c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13fc <sortdi1+0x2ec>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x1c(%rbp),%ecx
movslq -0x38(%rbp),%rax
mov    %ecx,-0xc0(%rbp,%rax,4)
mov    -0x34(%rbp),%ecx
movslq -0x38(%rbp),%rax
mov    %ecx,-0x140(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    143e <sortdi1+0x32e>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1438 <sortdi1+0x328>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%ecx
movslq -0x38(%rbp),%rax
mov    %ecx,-0xc0(%rbp,%rax,4)
mov    -0x20(%rbp),%ecx
movslq -0x38(%rbp),%rax
mov    %ecx,-0x140(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     144f <sortdi1+0x33f>
jmp    1454 <sortdi1+0x344>
jmp    1298 <sortdi1+0x188>
jmp    1459 <sortdi1+0x349>
jmp    145e <sortdi1+0x34e>
cmpl   $0x0,-0x38(%rbp)
jge    11a4 <sortdi1+0x94>
jmp    146d <sortdi1+0x35d>
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sortdi1>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x80,%rsp
cmp    $0x2,%esi
jge    1148 <sortdi1+0x38>
mov    0x2eb5(%rip),%rax
mov    (%rax),%edi
lea    0xf5c(%rip),%rsi
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <fprintf@plt>
lea    -0x1(%rsi),%r10d
xor    %ecx,%ecx
mov    %rdx,%rax
cmp    $0x7,%r10d
jb     12c0 <sortdi1+0x1b0>
lea    0x1(%r10),%r8
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rax
jae    1191 <sortdi1+0x81>
movdqa 0xe76(%rip),%xmm0
xor    %eax,%eax
jmp    1268 <sortdi1+0x158>
and    $0xfffffffffffffffc,%r11
movdqa 0xe63(%rip),%xmm0
xor    %eax,%eax
movdqa 0xe68(%rip),%xmm8
movdqa 0xe6f(%rip),%xmm9
movdqa 0xe76(%rip),%xmm10
movdqa 0xe7e(%rip),%xmm4
movdqa 0xe86(%rip),%xmm5
movdqa 0xe8e(%rip),%xmm6
movdqa 0xe96(%rip),%xmm7
movdqa 0xe9e(%rip),%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%rdx,%rax,4)
movdqu %xmm2,0x10(%rdx,%rax,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%rdx,%rax,4)
movdqu %xmm3,0x30(%rdx,%rax,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%rdx,%rax,4)
movdqu %xmm3,0x50(%rdx,%rax,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%rdx,%rax,4)
movdqu %xmm3,0x70(%rdx,%rax,4)
add    $0x20,%rax
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%r11
jne    11f0 <sortdi1+0xe0>
test   %r9,%r9
je     12b0 <sortdi1+0x1a0>
lea    (%rdx,%rax,4),%rax
add    $0x10,%rax
shl    $0x5,%r9
xor    %ebp,%ebp
movdqa 0xd8d(%rip),%xmm1
movdqa 0xd95(%rip),%xmm2
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rax,%rbp,1)
movdqu %xmm3,(%rax,%rbp,1)
paddd  %xmm2,%xmm0
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1290 <sortdi1+0x180>
cmp    %rcx,%r8
je     12cd <sortdi1+0x1bd>
lea    (%rdx,%rcx,4),%rax
nopl   0x0(%rax)
mov    %ecx,(%rax)
add    $0x4,%rax
add    $0x1,%ecx
cmp    %ecx,%esi
jne    12c0 <sortdi1+0x1b0>
movl   $0x0,(%rsp)
mov    %r10d,-0x80(%rsp)
lea    0x4(%rdx),%r14
xor    %r9d,%r9d
xor    %r8d,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffff,%r8d
mov    %r10d,%eax
sub    %r9d,%eax
cmp    $0xb,%eax
jge    1341 <sortdi1+0x231>
cmp    %r9d,%r10d
jle    1470 <sortdi1+0x360>
movslq %r9d,%r11
add    $0x1,%r9d
movslq %r10d,%r10
lea    (%rdx,%r11,4),%r15
mov    %r9d,%ebp
jmp    141c <sortdi1+0x30c>
xchg   %ax,%ax
movslq %r8d,%rbp
add    $0x1,%r8d
mov    %ecx,0x4(%rsp,%rbp,4)
mov    %esi,-0x7c(%rsp,%rbp,4)
mov    %r9d,%r15d
mov    %eax,%r10d
mov    %r15d,%r9d
cmp    %r10d,%r15d
jge    1470 <sortdi1+0x360>
lea    (%r10,%r9,1),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
movslq (%rdx,%rax,4),%rax
movsd  (%rdi,%rax,8),%xmm0
mov    %r10d,%eax
mov    %r9d,%r15d
movslq %r15d,%rcx
lea    (%rdx,%rcx,4),%rcx
nopw   0x0(%rax,%rax,1)
movslq (%rcx),%rbx
add    $0x1,%r15d
add    $0x4,%rcx
ucomisd (%rdi,%rbx,8),%xmm0
ja     1370 <sortdi1+0x260>
lea    -0x1(%r15),%r11d
movslq %eax,%rsi
lea    (%r14,%rsi,4),%rbp
nopl   (%rax)
movslq -0x4(%rbp),%rsi
add    $0xfffffffffffffffc,%rbp
movsd  (%rdi,%rsi,8),%xmm1
add    $0xffffffff,%eax
ucomisd %xmm0,%xmm1
ja     1390 <sortdi1+0x280>
lea    0x1(%rax),%r12d
cmp    %r12d,%r11d
jg     13c0 <sortdi1+0x2b0>
mov    %esi,-0x4(%rcx)
mov    %ebx,0x0(%rbp)
cmp    %r11d,%eax
jg     1360 <sortdi1+0x250>
jmp    13c6 <sortdi1+0x2b6>
nopl   0x0(%rax)
mov    %r12d,%eax
mov    %r11d,%r15d
mov    %eax,%ecx
sub    %r9d,%ecx
mov    %r10d,%esi
sub    %r15d,%esi
cmp    %esi,%ecx
jge    13f0 <sortdi1+0x2e0>
mov    %r15d,%ecx
mov    %r10d,%esi
cmp    %r15d,%r10d
jg     1320 <sortdi1+0x210>
jmp    132f <sortdi1+0x21f>
nopl   0x0(%rax)
mov    %r9d,%ecx
mov    %eax,%esi
cmp    %r9d,%eax
mov    %r15d,%r9d
mov    %r10d,%eax
jg     1320 <sortdi1+0x210>
jmp    1335 <sortdi1+0x225>
nopl   0x0(%rax)
add    $0x1,%ebp
add    $0x4,%r15
cmp    %r10,%r11
je     1470 <sortdi1+0x360>
movslq (%rdx,%r11,4),%rcx
movslq 0x4(%rdx,%r11,4),%rsi
add    $0x1,%r11
movsd  (%rdi,%rcx,8),%xmm0
ucomisd (%rdi,%rsi,8),%xmm0
jbe    1410 <sortdi1+0x300>
mov    %r15,%rax
mov    %ebp,%ebx
nopw   0x0(%rax,%rax,1)
mov    %esi,(%rax)
mov    %ecx,0x4(%rax)
cmp    %ebx,%r9d
jge    1410 <sortdi1+0x300>
movslq -0x4(%rax),%rcx
movslq (%rax),%rsi
add    $0xfffffffffffffffc,%rax
movsd  (%rdi,%rcx,8),%xmm0
add    $0xffffffff,%ebx
ucomisd (%rdi,%rsi,8),%xmm0
ja     1440 <sortdi1+0x330>
jmp    1410 <sortdi1+0x300>
cs nopw 0x0(%rax,%rax,1)
test   %r8d,%r8d
js     1486 <sortdi1+0x376>
mov    %r8d,%eax
mov    (%rsp,%rax,4),%r9d
mov    -0x80(%rsp,%rax,4),%r10d
jmp    12f0 <sortdi1+0x1e0>
add    $0x80,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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