#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*/ free(int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printf(char *);
void SortUnstableDouble(int N, double *A, double *C, int *idx) {
  int l, r;
  int i, j, k;
  int vidx, itemp;
  int stack_idx, *stack;
  double v;
  for (j = 0; j < N; j++)
    idx[j] = j;
  stack = (int *)malloc(50 * sizeof(int));
  stack_idx = 0;
  stack[stack_idx++] = 0;
  stack[stack_idx++] = N - 1;
  while (stack_idx > 0) {
    r = stack[--stack_idx];
    l = stack[--stack_idx];
    if (r - l >= 7) {
      k = (l + r) >> 1;
      {
        itemp = idx[k];
        idx[k] = idx[r];
        idx[r] = itemp;
      };
      if (A[idx[l]] > A[idx[r]]) {
        itemp = idx[l];
        idx[l] = idx[r];
        idx[r] = itemp;
      };
      if (A[idx[l + 1]] > A[idx[r]]) {
        itemp = idx[l + 1];
        idx[l + 1] = idx[r];
        idx[r] = itemp;
      };
      if (A[idx[l]] > A[idx[l + 1]]) {
        itemp = idx[l];
        idx[l] = idx[l + 1];
        idx[l + 1] = itemp;
      };
      i = l + 1;
      j = r;
      vidx = idx[i];
      v = A[vidx];
      while (i <= j) {
        while (A[idx[++i]] < v)
          ;
        while (A[idx[--j]] > v)
          ;
        if (i <= j) {
          itemp = idx[i];
          idx[i] = idx[j];
          idx[j] = itemp;
        };
      }
      idx[l + 1] = idx[j];
      idx[j] = vidx;
      if (stack_idx + 4 > 50)
        printf("Imminent stack overflow!\n");
      if (r - i + 1 >= j - l) {
        stack[stack_idx++] = i;
        stack[stack_idx++] = r;
        stack[stack_idx++] = l;
        stack[stack_idx++] = j - 1;
      } else {
        stack[stack_idx++] = l;
        stack[stack_idx++] = j - 1;
        stack[stack_idx++] = i;
        stack[stack_idx++] = r;
      }
    } else {
      for (j = l + 1; j <= r; j++) {
        vidx = idx[j];
        v = A[vidx];
        for (i = j - 1; i >= l; i--) {
          if (A[idx[i]] <= v)
            break;
          idx[i + 1] = idx[i];
        }
        idx[i + 1] = vidx;
      }
    }
  }
  for (j = 0; j < N; j++)
    C[j] = A[idx[j]];
  free(stack);
}


x86 assembly (clang, -O0):
<SortUnstableDouble>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1176 <SortUnstableDouble+0x46>
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    114e <SortUnstableDouble+0x1e>
mov    $0xc8,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x4(%rbp),%edx
sub    $0x1,%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
cmpl   $0x0,-0x40(%rbp)
jle    165e <SortUnstableDouble+0x52e>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x40(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x40(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
sub    -0x24(%rbp),%eax
cmp    $0x7,%eax
jl     1597 <SortUnstableDouble+0x467>
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    12a4 <SortUnstableDouble+0x174>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1315 <SortUnstableDouble+0x1e5>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1386 <SortUnstableDouble+0x256>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     146c <SortUnstableDouble+0x33c>
jmp    13c6 <SortUnstableDouble+0x296>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    13f7 <SortUnstableDouble+0x2c7>
jmp    13c6 <SortUnstableDouble+0x296>
jmp    13fc <SortUnstableDouble+0x2cc>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%edx
add    $0xffffffff,%edx
mov    %edx,-0x30(%rbp)
movslq %edx,%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x50(%rbp),%xmm0
jbe    1429 <SortUnstableDouble+0x2f9>
jmp    13fc <SortUnstableDouble+0x2cc>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1467 <SortUnstableDouble+0x337>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13b5 <SortUnstableDouble+0x285>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x4,%eax
cmp    $0x32,%eax
jle    14b0 <SortUnstableDouble+0x380>
lea    0xb55(%rip),%rdi
call   1040 <printf@plt>
mov    -0x28(%rbp),%eax
sub    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    -0x30(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jl     152f <SortUnstableDouble+0x3ff>
mov    -0x2c(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1592 <SortUnstableDouble+0x462>
mov    -0x24(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x40(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1659 <SortUnstableDouble+0x529>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1654 <SortUnstableDouble+0x524>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jl     1633 <SortUnstableDouble+0x503>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x50(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     160a <SortUnstableDouble+0x4da>
jmp    1633 <SortUnstableDouble+0x503>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    15d5 <SortUnstableDouble+0x4a5>
mov    -0x38(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    15a0 <SortUnstableDouble+0x470>
jmp    1659 <SortUnstableDouble+0x529>
jmp    11bf <SortUnstableDouble+0x8f>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16a1 <SortUnstableDouble+0x571>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x30(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1665 <SortUnstableDouble+0x535>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SortUnstableDouble>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rcx,%r14
mov    %rsi,%r13
mov    %edi,%ebx
mov    %edi,%ebp
test   %edi,%edi
jle    12cd <SortUnstableDouble+0x19d>
cmp    $0x8,%ebx
jae    115c <SortUnstableDouble+0x2c>
xor    %eax,%eax
jmp    12c0 <SortUnstableDouble+0x190>
mov    %ebp,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    118a <SortUnstableDouble+0x5a>
movdqa 0xe7d(%rip),%xmm0
xor    %esi,%esi
jmp    1260 <SortUnstableDouble+0x130>
and    $0xfffffffffffffffc,%rdi
movdqa 0xe6a(%rip),%xmm0
xor    %esi,%esi
movdqa 0xe6f(%rip),%xmm8
movdqa 0xe76(%rip),%xmm9
movdqa 0xe7d(%rip),%xmm10
movdqa 0xe85(%rip),%xmm4
movdqa 0xe8d(%rip),%xmm5
movdqa 0xe95(%rip),%xmm6
movdqa 0xe9d(%rip),%xmm7
movdqa 0xea5(%rip),%xmm1
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm2
paddd  %xmm8,%xmm2
movdqu %xmm0,(%r14,%rsi,4)
movdqu %xmm2,0x10(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm10,%xmm3
movdqu %xmm2,0x20(%r14,%rsi,4)
movdqu %xmm3,0x30(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm4,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm5,%xmm3
movdqu %xmm2,0x40(%r14,%rsi,4)
movdqu %xmm3,0x50(%r14,%rsi,4)
movdqa %xmm0,%xmm2
paddd  %xmm6,%xmm2
movdqa %xmm0,%xmm3
paddd  %xmm7,%xmm3
movdqu %xmm2,0x60(%r14,%rsi,4)
movdqu %xmm3,0x70(%r14,%rsi,4)
add    $0x20,%rsi
paddd  %xmm1,%xmm0
add    $0xfffffffffffffffc,%rdi
jne    11e0 <SortUnstableDouble+0xb0>
test   %rcx,%rcx
je     12b0 <SortUnstableDouble+0x180>
lea    (%r14,%rsi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rcx
xor    %esi,%esi
movdqa 0xd95(%rip),%xmm1
movdqa 0xd9d(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm0,-0x10(%rdi,%rsi,1)
movdqu %xmm3,(%rdi,%rsi,1)
paddd  %xmm2,%xmm0
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1290 <SortUnstableDouble+0x160>
cmp    %rbp,%rax
je     12cd <SortUnstableDouble+0x19d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %eax,(%r14,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    12c0 <SortUnstableDouble+0x190>
mov    %rbp,0x30(%rsp)
mov    %rdx,0x40(%rsp)
mov    $0xc8,%edi
call   1050 <malloc@plt>
movl   $0x0,(%rax)
mov    %rbx,0x38(%rsp)
lea    -0x1(%rbx),%ecx
mov    %rax,0x8(%rsp)
mov    %ecx,0x4(%rax)
lea    0x4(%r14),%r11
mov    $0x2,%r10d
movabs $0xffffffff00000000,%r15
ff ff ff
jmp    133e <SortUnstableDouble+0x20e>
nopl   (%rax)
mov    0x8(%rsp),%rcx
mov    %esi,(%rcx,%rax,4)
add    $0xffffffff,%ebp
mov    0x10(%rsp),%rax
mov    %ebp,(%rcx,%rax,4)
mov    %r12d,(%rcx,%rbx,4)
add    $0x2,%r10d
mov    0x8(%rsp),%rax
mov    %r8d,0x4(%rax,%rbx,4)
test   %r10d,%r10d
jle    15a5 <SortUnstableDouble+0x475>
lea    -0x1(%r10),%edi
mov    0x8(%rsp),%rax
mov    (%rax,%rdi,4),%r8d
movslq %r8d,%rcx
movslq %r10d,%rbp
mov    -0x8(%rax,%rbp,4),%ebx
movslq %ebx,%r9
mov    %ecx,%eax
sub    %r9d,%eax
cmp    $0x6,%eax
jle    13b0 <SortUnstableDouble+0x280>
lea    (%rbx,%r8,1),%eax
sar    %eax
cltq
movslq (%r14,%rax,4),%rdx
mov    (%r14,%rcx,4),%esi
mov    %esi,(%r14,%rax,4)
mov    %edx,(%r14,%rcx,4)
movslq (%r14,%r9,4),%rax
movsd  0x0(%r13,%rax,8),%xmm0
movsd  0x0(%r13,%rdx,8),%xmm1
ucomisd %xmm1,%xmm0
mov    %rbp,0x50(%rsp)
mov    %rdi,0x10(%rsp)
jbe    1430 <SortUnstableDouble+0x300>
mov    %edx,(%r14,%r9,4)
mov    %eax,(%r14,%rcx,4)
mov    %eax,%edx
jmp    1434 <SortUnstableDouble+0x304>
nop
add    $0xfffffffe,%r10d
cmp    %ebx,%r8d
jle    1335 <SortUnstableDouble+0x205>
add    $0xffffffff,%ebx
lea    0x1(%r9),%rdx
mov    %r9,%rsi
jmp    13e5 <SortUnstableDouble+0x2b5>
nopl   0x0(%rax)
movslq %edi,%rax
mov    %r8d,0x4(%r14,%rax,4)
add    $0x1,%rdx
cmp    %rcx,%rsi
je     1335 <SortUnstableDouble+0x205>
mov    %rsi,%rdi
add    $0x1,%rsi
movslq 0x4(%r14,%rdi,4),%r8
cmp    %r9,%rdi
jl     13d0 <SortUnstableDouble+0x2a0>
movsd  0x0(%r13,%r8,8),%xmm0
mov    %rdx,%rax
movslq -0x4(%r14,%rax,4),%rbp
ucomisd 0x0(%r13,%rbp,8),%xmm0
jae    13d0 <SortUnstableDouble+0x2a0>
mov    %ebp,(%r14,%rax,4)
add    $0xffffffff,%edi
add    $0xffffffffffffffff,%rax
cmp    %r9,%rax
jg     1400 <SortUnstableDouble+0x2d0>
mov    %ebx,%edi
jmp    13d0 <SortUnstableDouble+0x2a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movapd %xmm1,%xmm0
movslq 0x4(%r14,%r9,4),%rsi
movsd  0x0(%r13,%rsi,8),%xmm1
ucomisd %xmm0,%xmm1
mov    %rbx,0x28(%rsp)
jbe    1460 <SortUnstableDouble+0x330>
mov    %edx,0x4(%r14,%r9,4)
mov    %esi,(%r14,%rcx,4)
movslq 0x4(%r14,%r9,4),%rsi
movsd  0x0(%r13,%rsi,8),%xmm1
mov    %r9,%r12
add    $0x1,%r12
movslq (%r14,%r9,4),%rax
movsd  0x0(%r13,%rax,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1490 <SortUnstableDouble+0x360>
mov    %esi,(%r14,%r9,4)
mov    %eax,0x4(%r14,%r9,4)
mov    %eax,%esi
jmp    1494 <SortUnstableDouble+0x364>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm1,%xmm0
cmp    0x28(%rsp),%r8d
mov    %r10,0x20(%rsp)
mov    %r8,0x18(%rsp)
jle    1510 <SortUnstableDouble+0x3e0>
mov    %rsi,0x48(%rsp)
mov    %r8d,%ebp
nopl   (%rax)
movslq %r12d,%rax
lea    (%r11,%rax,4),%rsi
nopw   0x0(%rax,%rax,1)
movslq (%rsi),%rdi
add    $0x1,%r12d
add    $0x4,%rsi
ucomisd 0x0(%r13,%rdi,8),%xmm0
ja     14c0 <SortUnstableDouble+0x390>
movslq %ebp,%rcx
lea    (%r14,%rcx,4),%rdx
shl    $0x20,%rcx
nop
add    %r15,%rcx
movslq -0x4(%rdx),%rax
add    $0xfffffffffffffffc,%rdx
movsd  0x0(%r13,%rax,8),%xmm1
add    $0xffffffff,%ebp
ucomisd %xmm0,%xmm1
ja     14e0 <SortUnstableDouble+0x3b0>
lea    -0x1(%r12),%ebx
cmp    %ebp,%ebx
jge    1520 <SortUnstableDouble+0x3f0>
mov    %eax,-0x4(%rsi)
mov    %edi,(%rdx)
jmp    14b0 <SortUnstableDouble+0x380>
nopl   0x0(%rax,%rax,1)
mov    %r8d,%ebp
jmp    1533 <SortUnstableDouble+0x403>
cs nopw 0x0(%rax,%rax,1)
nop
sar    $0x20,%rcx
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%r8
mov    0x48(%rsp),%rsi
mov    (%r14,%rcx,4),%eax
mov    %eax,0x4(%r14,%r9,4)
mov    %esi,(%r14,%rcx,4)
cmp    $0x31,%r10d
jl     1562 <SortUnstableDouble+0x432>
lea    0xb43(%rip),%rdi
mov    %r11,%rbx
call   1040 <puts@plt>
mov    0x18(%rsp),%r8
mov    %rbx,%r11
mov    0x20(%rsp),%r10
mov    0x50(%rsp),%rbx
lea    -0x2(%rbx),%rax
mov    %r8d,%ecx
sub    %r12d,%ecx
add    $0x1,%ecx
mov    %ebp,%edx
mov    0x28(%rsp),%rsi
sub    %esi,%edx
cmp    %edx,%ecx
jl     1310 <SortUnstableDouble+0x1e0>
mov    0x8(%rsp),%rcx
mov    %r12d,(%rcx,%rax,4)
mov    0x10(%rsp),%rax
mov    %r8d,(%rcx,%rax,4)
mov    %esi,(%rcx,%rbx,4)
add    $0xffffffff,%ebp
mov    %ebp,%r8d
jmp    1327 <SortUnstableDouble+0x1f7>
cmpl   $0x0,0x38(%rsp)
mov    0x40(%rsp),%rsi
jle    1659 <SortUnstableDouble+0x529>
mov    0x30(%rsp),%rdi
lea    -0x1(%rdi),%rcx
mov    %edi,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    15cd <SortUnstableDouble+0x49d>
xor    %ecx,%ecx
jmp    162f <SortUnstableDouble+0x4ff>
and    $0xfffffffc,%edi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%r14,%rcx,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,(%rsi,%rcx,8)
movslq 0x4(%r14,%rcx,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rsi,%rcx,8)
movslq 0x8(%r14,%rcx,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rsi,%rcx,8)
movslq 0xc(%r14,%rcx,4),%rdx
movsd  0x0(%r13,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rsi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rdi
jne    15e0 <SortUnstableDouble+0x4b0>
test   %rax,%rax
je     1659 <SortUnstableDouble+0x529>
lea    (%rsi,%rcx,8),%rdx
lea    (%r14,%rcx,4),%rcx
xor    %esi,%esi
xchg   %ax,%ax
movslq (%rcx,%rsi,4),%rdi
movsd  0x0(%r13,%rdi,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1640 <SortUnstableDouble+0x510>
mov    0x8(%rsp),%rdi
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
@.str = [26 x i8] c"Imminent stack overflow!\0A\00"
define void @SortUnstableDouble(i32 %0, double* %1, double* %2, i32* %3) {
%5 = alloca i32
%6 = alloca double*
%7 = alloca double*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32*
%18 = alloca double
store i32 %0, i32* %5
store double* %1, double** %6
store double* %2, double** %7
store i32* %3, i32** %8
store i32 0, i32* %12
br label %19
19: ; preds = %29, %4
%20 = load i32, i32* %12
%21 = load i32, i32* %5
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %32
23: ; preds = %19
%24 = load i32, i32* %12
%25 = load i32*, i32** %8
%26 = load i32, i32* %12
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i32, i32* %25, i64 %27
store i32 %24, i32* %28
br label %29
29: ; preds = %23
%30 = load i32, i32* %12
%31 = add nsw i32 %30, 1
store i32 %31, i32* %12
br label %19
32: ; preds = %19
%33 = call i64 @malloc(i32 200)
%34 = inttoptr i64 %33 to i32*
store i32* %34, i32** %17
store i32 0, i32* %16
%35 = load i32*, i32** %17
%36 = load i32, i32* %16
%37 = add nsw i32 %36, 1
store i32 %37, i32* %16
%38 = sext i32 %36 to i64
%39 = getelementptr inbounds i32, i32* %35, i64 %38
store i32 0, i32* %39
%40 = load i32, i32* %5
%41 = sub nsw i32 %40, 1
%42 = load i32*, i32** %17
%43 = load i32, i32* %16
%44 = add nsw i32 %43, 1
store i32 %44, i32* %16
%45 = sext i32 %43 to i64
%46 = getelementptr inbounds i32, i32* %42, i64 %45
store i32 %41, i32* %46
br label %47
47: ; preds = %434, %32
%48 = load i32, i32* %16
%49 = icmp sgt i32 %48, 0
br i1 %49, label %50, label %435
50: ; preds = %47
%51 = load i32*, i32** %17
%52 = load i32, i32* %16
%53 = add nsw i32 %52, -1
store i32 %53, i32* %16
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %51, i64 %54
%56 = load i32, i32* %55
store i32 %56, i32* %10
%57 = load i32*, i32** %17
%58 = load i32, i32* %16
%59 = add nsw i32 %58, -1
store i32 %59, i32* %16
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %57, i64 %60
%62 = load i32, i32* %61
store i32 %62, i32* %9
%63 = load i32, i32* %10
%64 = load i32, i32* %9
%65 = sub nsw i32 %63, %64
%66 = icmp sge i32 %65, 7
br i1 %66, label %67, label %372
67: ; preds = %50
%68 = load i32, i32* %9
%69 = load i32, i32* %10
%70 = add nsw i32 %68, %69
%71 = ashr i32 %70, 1
store i32 %71, i32* %13
%72 = load i32*, i32** %8
%73 = load i32, i32* %13
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i32, i32* %72, i64 %74
%76 = load i32, i32* %75
store i32 %76, i32* %15
%77 = load i32*, i32** %8
%78 = load i32, i32* %10
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
%81 = load i32, i32* %80
%82 = load i32*, i32** %8
%83 = load i32, i32* %13
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds i32, i32* %82, i64 %84
store i32 %81, i32* %85
%86 = load i32, i32* %15
%87 = load i32*, i32** %8
%88 = load i32, i32* %10
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i32, i32* %87, i64 %89
store i32 %86, i32* %90
%91 = load double*, double** %6
%92 = load i32*, i32** %8
%93 = load i32, i32* %9
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %92, i64 %94
%96 = load i32, i32* %95
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds double, double* %91, i64 %97
%99 = load double, double* %98
%100 = load double*, double** %6
%101 = load i32*, i32** %8
%102 = load i32, i32* %10
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i32, i32* %101, i64 %103
%105 = load i32, i32* %104
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %100, i64 %106
%108 = load double, double* %107
%109 = fcmp ogt double %99, %108
br i1 %109, label %110, label %130
110: ; preds = %67
%111 = load i32*, i32** %8
%112 = load i32, i32* %9
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %111, i64 %113
%115 = load i32, i32* %114
store i32 %115, i32* %15
%116 = load i32*, i32** %8
%117 = load i32, i32* %10
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32, i32* %116, i64 %118
%120 = load i32, i32* %119
%121 = load i32*, i32** %8
%122 = load i32, i32* %9
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i32, i32* %121, i64 %123
store i32 %120, i32* %124
%125 = load i32, i32* %15
%126 = load i32*, i32** %8
%127 = load i32, i32* %10
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %126, i64 %128
store i32 %125, i32* %129
br label %130
130: ; preds = %110, %67
%131 = load double*, double** %6
%132 = load i32*, i32** %8
%133 = load i32, i32* %9
%134 = add nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %132, i64 %135
%137 = load i32, i32* %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %131, i64 %138
%140 = load double, double* %139
%141 = load double*, double** %6
%142 = load i32*, i32** %8
%143 = load i32, i32* %10
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds i32, i32* %142, i64 %144
%146 = load i32, i32* %145
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %141, i64 %147
%149 = load double, double* %148
%150 = fcmp ogt double %140, %149
br i1 %150, label %151, label %173
151: ; preds = %130
%152 = load i32*, i32** %8
%153 = load i32, i32* %9
%154 = add nsw i32 %153, 1
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %152, i64 %155
%157 = load i32, i32* %156
store i32 %157, i32* %15
%158 = load i32*, i32** %8
%159 = load i32, i32* %10
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %158, i64 %160
%162 = load i32, i32* %161
%163 = load i32*, i32** %8
%164 = load i32, i32* %9
%165 = add nsw i32 %164, 1
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds i32, i32* %163, i64 %166
store i32 %162, i32* %167
%168 = load i32, i32* %15
%169 = load i32*, i32** %8
%170 = load i32, i32* %10
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i32, i32* %169, i64 %171
store i32 %168, i32* %172
br label %173
173: ; preds = %151, %130
%174 = load double*, double** %6
%175 = load i32*, i32** %8
%176 = load i32, i32* %9
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i32, i32* %175, i64 %177
%179 = load i32, i32* %178
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %174, i64 %180
%182 = load double, double* %181
%183 = load double*, double** %6
%184 = load i32*, i32** %8
%185 = load i32, i32* %9
%186 = add nsw i32 %185, 1
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i32, i32* %184, i64 %187
%189 = load i32, i32* %188
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds double, double* %183, i64 %190
%192 = load double, double* %191
%193 = fcmp ogt double %182, %192
br i1 %193, label %194, label %216
194: ; preds = %173
%195 = load i32*, i32** %8
%196 = load i32, i32* %9
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %195, i64 %197
%199 = load i32, i32* %198
store i32 %199, i32* %15
%200 = load i32*, i32** %8
%201 = load i32, i32* %9
%202 = add nsw i32 %201, 1
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds i32, i32* %200, i64 %203
%205 = load i32, i32* %204
%206 = load i32*, i32** %8
%207 = load i32, i32* %9
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i32, i32* %206, i64 %208
store i32 %205, i32* %209
%210 = load i32, i32* %15
%211 = load i32*, i32** %8
%212 = load i32, i32* %9
%213 = add nsw i32 %212, 1
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds i32, i32* %211, i64 %214
store i32 %210, i32* %215
br label %216
216: ; preds = %194, %173
%217 = load i32, i32* %9
%218 = add nsw i32 %217, 1
store i32 %218, i32* %11
%219 = load i32, i32* %10
store i32 %219, i32* %12
%220 = load i32*, i32** %8
%221 = load i32, i32* %11
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i32, i32* %220, i64 %222
%224 = load i32, i32* %223
store i32 %224, i32* %14
%225 = load double*, double** %6
%226 = load i32, i32* %14
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %225, i64 %227
%229 = load double, double* %228
store double %229, double* %18
br label %230
230: ; preds = %288, %216
%231 = load i32, i32* %11
%232 = load i32, i32* %12
%233 = icmp sle i32 %231, %232
br i1 %233, label %234, label %289
234: ; preds = %230
br label %235
235: ; preds = %248, %234
%236 = load double*, double** %6
%237 = load i32*, i32** %8
%238 = load i32, i32* %11
%239 = add nsw i32 %238, 1
store i32 %239, i32* %11
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i32, i32* %237, i64 %240
%242 = load i32, i32* %241
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds double, double* %236, i64 %243
%245 = load double, double* %244
%246 = load double, double* %18
%247 = fcmp olt double %245, %246
br i1 %247, label %248, label %249
248: ; preds = %235
br label %235
249: ; preds = %235
br label %250
250: ; preds = %263, %249
%251 = load double*, double** %6
%252 = load i32*, i32** %8
%253 = load i32, i32* %12
%254 = add nsw i32 %253, -1
store i32 %254, i32* %12
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds i32, i32* %252, i64 %255
%257 = load i32, i32* %256
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds double, double* %251, i64 %258
%260 = load double, double* %259
%261 = load double, double* %18
%262 = fcmp ogt double %260, %261
br i1 %262, label %263, label %264
263: ; preds = %250
br label %250
264: ; preds = %250
%265 = load i32, i32* %11
%266 = load i32, i32* %12
%267 = icmp sle i32 %265, %266
br i1 %267, label %268, label %288
268: ; preds = %264
%269 = load i32*, i32** %8
%270 = load i32, i32* %11
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i32, i32* %269, i64 %271
%273 = load i32, i32* %272
store i32 %273, i32* %15
%274 = load i32*, i32** %8
%275 = load i32, i32* %12
%276 = sext i32 %275 to i64
%277 = getelementptr inbounds i32, i32* %274, i64 %276
%278 = load i32, i32* %277
%279 = load i32*, i32** %8
%280 = load i32, i32* %11
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i32, i32* %279, i64 %281
store i32 %278, i32* %282
%283 = load i32, i32* %15
%284 = load i32*, i32** %8
%285 = load i32, i32* %12
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i32, i32* %284, i64 %286
store i32 %283, i32* %287
br label %288
288: ; preds = %268, %264
br label %230
289: ; preds = %230
%290 = load i32*, i32** %8
%291 = load i32, i32* %12
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i32, i32* %290, i64 %292
%294 = load i32, i32* %293
%295 = load i32*, i32** %8
%296 = load i32, i32* %9
%297 = add nsw i32 %296, 1
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i32, i32* %295, i64 %298
store i32 %294, i32* %299
%300 = load i32, i32* %14
%301 = load i32*, i32** %8
%302 = load i32, i32* %12
%303 = sext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %301, i64 %303
store i32 %300, i32* %304
%305 = load i32, i32* %16
%306 = add nsw i32 %305, 4
%307 = icmp sgt i32 %306, 50
br i1 %307, label %308, label %310
308: ; preds = %289
%309 = call i32 @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0))
br label %310
310: ; preds = %308, %289
%311 = load i32, i32* %10
%312 = load i32, i32* %11
%313 = sub nsw i32 %311, %312
%314 = add nsw i32 %313, 1
%315 = load i32, i32* %12
%316 = load i32, i32* %9
%317 = sub nsw i32 %315, %316
%318 = icmp sge i32 %314, %317
br i1 %318, label %319, label %345
319: ; preds = %310
%320 = load i32, i32* %11
%321 = load i32*, i32** %17
%322 = load i32, i32* %16
%323 = add nsw i32 %322, 1
store i32 %323, i32* %16
%324 = sext i32 %322 to i64
%325 = getelementptr inbounds i32, i32* %321, i64 %324
store i32 %320, i32* %325
%326 = load i32, i32* %10
%327 = load i32*, i32** %17
%328 = load i32, i32* %16
%329 = add nsw i32 %328, 1
store i32 %329, i32* %16
%330 = sext i32 %328 to i64
%331 = getelementptr inbounds i32, i32* %327, i64 %330
store i32 %326, i32* %331
%332 = load i32, i32* %9
%333 = load i32*, i32** %17
%334 = load i32, i32* %16
%335 = add nsw i32 %334, 1
store i32 %335, i32* %16
%336 = sext i32 %334 to i64
%337 = getelementptr inbounds i32, i32* %333, i64 %336
store i32 %332, i32* %337
%338 = load i32, i32* %12
%339 = sub nsw i32 %338, 1
%340 = load i32*, i32** %17
%341 = load i32, i32* %16
%342 = add nsw i32 %341, 1
store i32 %342, i32* %16
%343 = sext i32 %341 to i64
%344 = getelementptr inbounds i32, i32* %340, i64 %343
store i32 %339, i32* %344
br label %371
345: ; preds = %310
%346 = load i32, i32* %9
%347 = load i32*, i32** %17
%348 = load i32, i32* %16
%349 = add nsw i32 %348, 1
store i32 %349, i32* %16
%350 = sext i32 %348 to i64
%351 = getelementptr inbounds i32, i32* %347, i64 %350
store i32 %346, i32* %351
%352 = load i32, i32* %12
%353 = sub nsw i32 %352, 1
%354 = load i32*, i32** %17
%355 = load i32, i32* %16
%356 = add nsw i32 %355, 1
store i32 %356, i32* %16
%357 = sext i32 %355 to i64
%358 = getelementptr inbounds i32, i32* %354, i64 %357
store i32 %353, i32* %358
%359 = load i32, i32* %11
%360 = load i32*, i32** %17
%361 = load i32, i32* %16
%362 = add nsw i32 %361, 1
store i32 %362, i32* %16
%363 = sext i32 %361 to i64
%364 = getelementptr inbounds i32, i32* %360, i64 %363
store i32 %359, i32* %364
%365 = load i32, i32* %10
%366 = load i32*, i32** %17
%367 = load i32, i32* %16
%368 = add nsw i32 %367, 1
store i32 %368, i32* %16
%369 = sext i32 %367 to i64
%370 = getelementptr inbounds i32, i32* %366, i64 %369
store i32 %365, i32* %370
br label %371
371: ; preds = %345, %319
br label %434
372: ; preds = %50
%373 = load i32, i32* %9
%374 = add nsw i32 %373, 1
store i32 %374, i32* %12
br label %375
375: ; preds = %430, %372
%376 = load i32, i32* %12
%377 = load i32, i32* %10
%378 = icmp sle i32 %376, %377
br i1 %378, label %379, label %433
379: ; preds = %375
%380 = load i32*, i32** %8
%381 = load i32, i32* %12
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds i32, i32* %380, i64 %382
%384 = load i32, i32* %383
store i32 %384, i32* %14
%385 = load double*, double** %6
%386 = load i32, i32* %14
%387 = sext i32 %386 to i64
%388 = getelementptr inbounds double, double* %385, i64 %387
%389 = load double, double* %388
store double %389, double* %18
%390 = load i32, i32* %12
%391 = sub nsw i32 %390, 1
store i32 %391, i32* %11
br label %392
392: ; preds = %420, %379
%393 = load i32, i32* %11
%394 = load i32, i32* %9
%395 = icmp sge i32 %393, %394
br i1 %395, label %396, label %423
396: ; preds = %392
%397 = load double*, double** %6
%398 = load i32*, i32** %8
%399 = load i32, i32* %11
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i32, i32* %398, i64 %400
%402 = load i32, i32* %401
%403 = sext i32 %402 to i64
%404 = getelementptr inbounds double, double* %397, i64 %403
%405 = load double, double* %404
%406 = load double, double* %18
%407 = fcmp ole double %405, %406
br i1 %407, label %408, label %409
408: ; preds = %396
br label %423
409: ; preds = %396
%410 = load i32*, i32** %8
%411 = load i32, i32* %11
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i32, i32* %410, i64 %412
%414 = load i32, i32* %413
%415 = load i32*, i32** %8
%416 = load i32, i32* %11
%417 = add nsw i32 %416, 1
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds i32, i32* %415, i64 %418
store i32 %414, i32* %419
br label %420
420: ; preds = %409
%421 = load i32, i32* %11
%422 = add nsw i32 %421, -1
store i32 %422, i32* %11
br label %392
423: ; preds = %408, %392
%424 = load i32, i32* %14
%425 = load i32*, i32** %8
%426 = load i32, i32* %11
%427 = add nsw i32 %426, 1
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds i32, i32* %425, i64 %428
store i32 %424, i32* %429
br label %430
430: ; preds = %423
%431 = load i32, i32* %12
%432 = add nsw i32 %431, 1
store i32 %432, i32* %12
br label %375
433: ; preds = %375
br label %434
434: ; preds = %433, %371
br label %47
435: ; preds = %47
store i32 0, i32* %12
br label %436
436: ; preds = %454, %435
%437 = load i32, i32* %12
%438 = load i32, i32* %5
%439 = icmp slt i32 %437, %438
br i1 %439, label %440, label %457
440: ; preds = %436
%441 = load double*, double** %6
%442 = load i32*, i32** %8
%443 = load i32, i32* %12
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds i32, i32* %442, i64 %444
%446 = load i32, i32* %445
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %441, i64 %447
%449 = load double, double* %448
%450 = load double*, double** %7
%451 = load i32, i32* %12
%452 = sext i32 %451 to i64
%453 = getelementptr inbounds double, double* %450, i64 %452
store double %449, double* %453
br label %454
454: ; preds = %440
%455 = load i32, i32* %12
%456 = add nsw i32 %455, 1
store i32 %456, i32* %12
br label %436
457: ; preds = %436
%458 = load i32*, i32** %17
%459 = call i32 @free(i32* %458)
ret void
}

LLVM IR (-O2):
@str = [25 x i8] c"Imminent stack overflow!\00"
define void @SortUnstableDouble(i32 %0, double* nocapture %1, double* nocapture writeonly %2, i32* nocapture %3) {
%5 = icmp sgt i32 %0, 0
br i1 %5, label %6, label %79
6: ; preds = %4
%7 = zext i32 %0 to i64
%8 = icmp ult i32 %0, 8
br i1 %8, label %71, label %9
9: ; preds = %6
%10 = and i64 %7, 4294967288
%11 = add nsw i64 %10, -8
%12 = lshr exact i64 %11, 3
%13 = add nuw nsw i64 %12, 1
%14 = and i64 %13, 3
%15 = icmp ult i64 %11, 24
br i1 %15, label %52, label %16
16: ; preds = %9
%17 = and i64 %13, 4611686018427387900
br label %18
18: ; preds = %18, %16
%19 = phi i64 [ 0, %16 ], [ %48, %18 ]
%20 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %16 ], [ %49, %18 ]
%21 = phi i64 [ 0, %16 ], [ %50, %18 ]
%22 = add <4 x i32> %20, <i32 4, i32 4, i32 4, i32 4>
%23 = getelementptr inbounds i32, i32* %3, i64 %19
%24 = bitcast i32* %23 to <4 x i32>*
store <4 x i32> %20, <4 x i32>* %24
%25 = getelementptr inbounds i32, i32* %23, i64 4
%26 = bitcast i32* %25 to <4 x i32>*
store <4 x i32> %22, <4 x i32>* %26
%27 = or i64 %19, 8
%28 = add <4 x i32> %20, <i32 8, i32 8, i32 8, i32 8>
%29 = add <4 x i32> %20, <i32 12, i32 12, i32 12, i32 12>
%30 = getelementptr inbounds i32, i32* %3, i64 %27
%31 = bitcast i32* %30 to <4 x i32>*
store <4 x i32> %28, <4 x i32>* %31
%32 = getelementptr inbounds 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 %19, 16
%35 = add <4 x i32> %20, <i32 16, i32 16, i32 16, i32 16>
%36 = add <4 x i32> %20, <i32 20, i32 20, i32 20, i32 20>
%37 = getelementptr inbounds i32, i32* %3, i64 %34
%38 = bitcast i32* %37 to <4 x i32>*
store <4 x i32> %35, <4 x i32>* %38
%39 = getelementptr inbounds 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 %19, 24
%42 = add <4 x i32> %20, <i32 24, i32 24, i32 24, i32 24>
%43 = add <4 x i32> %20, <i32 28, i32 28, i32 28, i32 28>
%44 = getelementptr inbounds i32, i32* %3, i64 %41
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %42, <4 x i32>* %45
%46 = getelementptr inbounds i32, i32* %44, i64 4
%47 = bitcast i32* %46 to <4 x i32>*
store <4 x i32> %43, <4 x i32>* %47
%48 = add nuw i64 %19, 32
%49 = add <4 x i32> %20, <i32 32, i32 32, i32 32, i32 32>
%50 = add i64 %21, 4
%51 = icmp eq i64 %50, %17
br i1 %51, label %52, label %18
52: ; preds = %18, %9
%53 = phi i64 [ 0, %9 ], [ %48, %18 ]
%54 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %9 ], [ %49, %18 ]
%55 = icmp eq i64 %14, 0
br i1 %55, label %69, label %56
56: ; preds = %52, %56
%57 = phi i64 [ %65, %56 ], [ %53, %52 ]
%58 = phi <4 x i32> [ %66, %56 ], [ %54, %52 ]
%59 = phi i64 [ %67, %56 ], [ 0, %52 ]
%60 = add <4 x i32> %58, <i32 4, i32 4, i32 4, i32 4>
%61 = getelementptr inbounds i32, i32* %3, i64 %57
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> %58, <4 x i32>* %62
%63 = getelementptr inbounds i32, i32* %61, i64 4
%64 = bitcast i32* %63 to <4 x i32>*
store <4 x i32> %60, <4 x i32>* %64
%65 = add nuw i64 %57, 8
%66 = add <4 x i32> %58, <i32 8, i32 8, i32 8, i32 8>
%67 = add i64 %59, 1
%68 = icmp eq i64 %67, %14
br i1 %68, label %69, label %56
69: ; preds = %56, %52
%70 = icmp eq i64 %10, %7
br i1 %70, label %79, label %71
71: ; preds = %6, %69
%72 = phi i64 [ 0, %6 ], [ %10, %69 ]
br label %73
73: ; preds = %71, %73
%74 = phi i64 [ %77, %73 ], [ %72, %71 ]
%75 = getelementptr inbounds i32, i32* %3, i64 %74
%76 = trunc i64 %74 to i32
store i32 %76, i32* %75
%77 = add nuw nsw i64 %74, 1
%78 = icmp eq i64 %77, %7
br i1 %78, label %79, label %73
79: ; preds = %73, %69, %4
%80 = tail call i64 @malloc(i32 200)
%81 = inttoptr i64 %80 to i32*
store i32 0, i32* %81
%82 = add nsw i32 %0, -1
%83 = getelementptr inbounds i32, i32* %81, i64 1
store i32 %82, i32* %83
br label %92
84: ; preds = %255
br i1 %5, label %85, label %306
85: ; preds = %84
%86 = zext i32 %0 to i64
%87 = add nsw i64 %86, -1
%88 = and i64 %86, 3
%89 = icmp ult i64 %87, 3
br i1 %89, label %291, label %90
90: ; preds = %85
%91 = and i64 %86, 4294967292
br label %258
92: ; preds = %255, %79
%93 = phi i32 [ 2, %79 ], [ %256, %255 ]
%94 = add nsw i32 %93, -1
%95 = zext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %81, i64 %95
%97 = load i32, i32* %96
%98 = add nsw i32 %93, -2
%99 = sext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %81, i64 %99
%101 = load i32, i32* %100
%102 = sub nsw i32 %97, %101
%103 = icmp sgt i32 %102, 6
br i1 %103, label %110, label %104
104: ; preds = %92
%105 = icmp sgt i32 %97, %101
br i1 %105, label %106, label %255
106: ; preds = %104
%107 = sext i32 %101 to i64
%108 = add i32 %101, -1
%109 = sext i32 %97 to i64
br label %218
110: ; preds = %92
%111 = add nsw i32 %101, %97
%112 = ashr i32 %111, 1
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %3, i64 %113
%115 = load i32, i32* %114
%116 = sext i32 %97 to i64
%117 = getelementptr inbounds i32, i32* %3, i64 %116
%118 = load i32, i32* %117
store i32 %118, i32* %114
store i32 %115, i32* %117
%119 = sext i32 %101 to i64
%120 = getelementptr inbounds i32, i32* %3, i64 %119
%121 = load i32, i32* %120
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %1, i64 %122
%124 = load double, double* %123
%125 = sext i32 %115 to i64
%126 = getelementptr inbounds double, double* %1, i64 %125
%127 = load double, double* %126
%128 = fcmp ogt double %124, %127
br i1 %128, label %129, label %130
129: ; preds = %110
store i32 %115, i32* %120
store i32 %121, i32* %117
br label %130
130: ; preds = %129, %110
%131 = phi double [ %124, %129 ], [ %127, %110 ]
%132 = phi i32 [ %121, %129 ], [ %115, %110 ]
%133 = add nsw i32 %101, 1
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds i32, i32* %3, i64 %134
%136 = load i32, i32* %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %1, i64 %137
%139 = load double, double* %138
%140 = fcmp ogt double %139, %131
br i1 %140, label %141, label %146
141: ; preds = %130
store i32 %132, i32* %135
store i32 %136, i32* %117
%142 = load i32, i32* %135
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %1, i64 %143
%145 = load double, double* %144
br label %146
146: ; preds = %141, %130
%147 = phi double [ %145, %141 ], [ %139, %130 ]
%148 = phi i32 [ %142, %141 ], [ %136, %130 ]
%149 = load i32, i32* %120
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds double, double* %1, i64 %150
%152 = load double, double* %151
%153 = fcmp ogt double %152, %147
br i1 %153, label %154, label %155
154: ; preds = %146
store i32 %148, i32* %120
store i32 %149, i32* %135
br label %155
155: ; preds = %154, %146
%156 = phi double [ %152, %154 ], [ %147, %146 ]
%157 = phi i32 [ %149, %154 ], [ %148, %146 ]
%158 = icmp sgt i32 %97, %101
br i1 %158, label %159, label %196
159: ; preds = %155, %189
%160 = phi i32 [ %174, %189 ], [ %133, %155 ]
%161 = phi i32 [ %187, %189 ], [ %97, %155 ]
%162 = sext i32 %160 to i64
br label %163
163: ; preds = %159, %163
%164 = phi i64 [ %162, %159 ], [ %165, %163 ]
%165 = add nsw i64 %164, 1
%166 = getelementptr inbounds i32, i32* %3, i64 %165
%167 = load i32, i32* %166
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds double, double* %1, i64 %168
%170 = load double, double* %169
%171 = fcmp olt double %170, %156
br i1 %171, label %163, label %172
172: ; preds = %163
%173 = getelementptr inbounds i32, i32* %3, i64 %165
%174 = trunc i64 %165 to i32
%175 = sext i32 %161 to i64
br label %176
176: ; preds = %172, %176
%177 = phi i64 [ %175, %172 ], [ %178, %176 ]
%178 = add i64 %177, -1
%179 = getelementptr inbounds i32, i32* %3, i64 %178
%180 = load i32, i32* %179
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds double, double* %1, i64 %181
%183 = load double, double* %182
%184 = fcmp ogt double %183, %156
br i1 %184, label %176, label %185
185: ; preds = %176
%186 = trunc i64 %164 to i32
%187 = trunc i64 %178 to i32
%188 = icmp slt i32 %186, %187
br i1 %188, label %189, label %191
189: ; preds = %185
%190 = getelementptr inbounds i32, i32* %3, i64 %178
store i32 %180, i32* %173
store i32 %167, i32* %190
br label %159
191: ; preds = %185
%192 = trunc i64 %165 to i32
%193 = trunc i64 %178 to i32
%194 = shl i64 %178, 32
%195 = ashr exact i64 %194, 32
br label %196
196: ; preds = %191, %155
%197 = phi i64 [ %195, %191 ], [ %116, %155 ]
%198 = phi i32 [ %193, %191 ], [ %97, %155 ]
%199 = phi i32 [ %192, %191 ], [ %133, %155 ]
%200 = getelementptr inbounds i32, i32* %3, i64 %197
%201 = load i32, i32* %200
store i32 %201, i32* %135
store i32 %157, i32* %200
%202 = icmp sgt i32 %93, 48
br i1 %202, label %203, label %205
203: ; preds = %196
%204 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([25 x i8], [25 x i8]* @str, i64 0, i64 0))
br label %205
205: ; preds = %203, %196
%206 = add i32 %97, 1
%207 = sub i32 %206, %199
%208 = sub nsw i32 %198, %101
%209 = icmp slt i32 %207, %208
br i1 %209, label %214, label %210
210: ; preds = %205
store i32 %199, i32* %100
store i32 %97, i32* %96
%211 = sext i32 %93 to i64
%212 = getelementptr inbounds i32, i32* %81, i64 %211
store i32 %101, i32* %212
%213 = add nsw i32 %198, -1
br label %249
214: ; preds = %205
store i32 %101, i32* %100
%215 = add nsw i32 %198, -1
store i32 %215, i32* %96
%216 = sext i32 %93 to i64
%217 = getelementptr inbounds i32, i32* %81, i64 %216
store i32 %199, i32* %217
br label %249
218: ; preds = %106, %243
%219 = phi i64 [ %107, %106 ], [ %220, %243 ]
%220 = add nsw i64 %219, 1
%221 = getelementptr inbounds i32, i32* %3, i64 %220
%222 = load i32, i32* %221
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds double, double* %1, i64 %223
%225 = load double, double* %224
%226 = icmp slt i64 %219, %107
%227 = trunc i64 %219 to i32
br i1 %226, label %243, label %228
228: ; preds = %218, %236
%229 = phi i64 [ %239, %236 ], [ %219, %218 ]
%230 = getelementptr inbounds i32, i32* %3, i64 %229
%231 = load i32, i32* %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %1, i64 %232
%234 = load double, double* %233
%235 = fcmp ugt double %234, %225
br i1 %235, label %236, label %241
236: ; preds = %228
%237 = add nsw i64 %229, 1
%238 = getelementptr inbounds i32, i32* %3, i64 %237
store i32 %231, i32* %238
%239 = add nsw i64 %229, -1
%240 = icmp sgt i64 %229, %107
br i1 %240, label %228, label %243
241: ; preds = %228
%242 = trunc i64 %229 to i32
br label %243
243: ; preds = %236, %241, %218
%244 = phi i32 [ %227, %218 ], [ %242, %241 ], [ %108, %236 ]
%245 = add nsw i32 %244, 1
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i32, i32* %3, i64 %246
store i32 %222, i32* %247
%248 = icmp eq i64 %220, %109
br i1 %248, label %255, label %218
249: ; preds = %214, %210
%250 = phi i32 [ %213, %210 ], [ %97, %214 ]
%251 = add nsw i32 %93, 1
%252 = add nsw i32 %93, 2
%253 = sext i32 %251 to i64
%254 = getelementptr inbounds i32, i32* %81, i64 %253
store i32 %250, i32* %254
br label %255
255: ; preds = %243, %249, %104
%256 = phi i32 [ %98, %104 ], [ %252, %249 ], [ %98, %243 ]
%257 = icmp sgt i32 %256, 0
br i1 %257, label %92, label %84
258: ; preds = %258, %90
%259 = phi i64 [ 0, %90 ], [ %288, %258 ]
%260 = phi i64 [ 0, %90 ], [ %289, %258 ]
%261 = getelementptr inbounds i32, i32* %3, i64 %259
%262 = load i32, i32* %261
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds double, double* %1, i64 %263
%265 = load double, double* %264
%266 = getelementptr inbounds double, double* %2, i64 %259
store double %265, double* %266
%267 = or i64 %259, 1
%268 = getelementptr inbounds i32, i32* %3, i64 %267
%269 = load i32, i32* %268
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds double, double* %1, i64 %270
%272 = load double, double* %271
%273 = getelementptr inbounds double, double* %2, i64 %267
store double %272, double* %273
%274 = or i64 %259, 2
%275 = getelementptr inbounds i32, i32* %3, i64 %274
%276 = load i32, i32* %275
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds double, double* %1, i64 %277
%279 = load double, double* %278
%280 = getelementptr inbounds double, double* %2, i64 %274
store double %279, double* %280
%281 = or i64 %259, 3
%282 = getelementptr inbounds i32, i32* %3, i64 %281
%283 = load i32, i32* %282
%284 = sext i32 %283 to i64
%285 = getelementptr inbounds double, double* %1, i64 %284
%286 = load double, double* %285
%287 = getelementptr inbounds double, double* %2, i64 %281
store double %286, double* %287
%288 = add nuw nsw i64 %259, 4
%289 = add i64 %260, 4
%290 = icmp eq i64 %289, %91
br i1 %290, label %291, label %258
291: ; preds = %258, %85
%292 = phi i64 [ 0, %85 ], [ %288, %258 ]
%293 = icmp eq i64 %88, 0
br i1 %293, label %306, label %294
294: ; preds = %291, %294
%295 = phi i64 [ %303, %294 ], [ %292, %291 ]
%296 = phi i64 [ %304, %294 ], [ 0, %291 ]
%297 = getelementptr inbounds i32, i32* %3, i64 %295
%298 = load i32, i32* %297
%299 = sext i32 %298 to i64
%300 = getelementptr inbounds double, double* %1, i64 %299
%301 = load double, double* %300
%302 = getelementptr inbounds double, double* %2, i64 %295
store double %301, double* %302
%303 = add nuw nsw i64 %295, 1
%304 = add i64 %296, 1
%305 = icmp eq i64 %304, %88
br i1 %305, label %306, label %294
306: ; preds = %291, %294, %84
%307 = tail call i32 @free(i32* %81)
ret void
}