#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*/ cdoAbort(char *);
void sort_add_orig(long num_links, long num_wts, int *restrict add1,
                   int *restrict add2, double *restrict weights) {
  int add1_tmp, add2_tmp;
  long lvl, final_lvl;
  long chk_lvl1, chk_lvl2, max_lvl;
  long i, n;
  double wgttmp[4];
  if (num_links <= 1)
    return;
  for (lvl = num_links / 2 - 1; lvl >= 0; lvl--) {
    final_lvl = lvl;
    add1_tmp = add1[lvl];
    add2_tmp = add2[lvl];
    for (n = 0; n < num_wts; n++)
      wgttmp[n] = weights[num_wts * lvl + n];
    for (i = 0; i < num_links; i++) {
      chk_lvl1 = 2 * final_lvl + 1;
      chk_lvl2 = 2 * final_lvl + 2;
      if (chk_lvl1 == num_links - 1)
        chk_lvl2 = chk_lvl1;
      if ((add1[chk_lvl1] > add1[chk_lvl2]) ||
          ((add1[chk_lvl1] == add1[chk_lvl2]) &&
           (add2[chk_lvl1] > add2[chk_lvl2])))
        max_lvl = chk_lvl1;
      else
        max_lvl = chk_lvl2;
      if ((add1_tmp > add1[max_lvl]) ||
          ((add1_tmp == add1[max_lvl]) && (add2_tmp > add2[max_lvl]))) {
        add1[final_lvl] = add1_tmp;
        add2[final_lvl] = add2_tmp;
        for (n = 0; n < num_wts; n++)
          weights[num_wts * final_lvl + n] = wgttmp[n];
        break;
      } else {
        add1[final_lvl] = add1[max_lvl];
        add2[final_lvl] = add2[max_lvl];
        for (n = 0; n < num_wts; n++)
          weights[num_wts * final_lvl + n] = weights[num_wts * max_lvl + n];
        final_lvl = max_lvl;
        if (2 * final_lvl + 1 >= num_links) {
          add1[final_lvl] = add1_tmp;
          add2[final_lvl] = add2_tmp;
          for (n = 0; n < num_wts; n++)
            weights[num_wts * final_lvl + n] = wgttmp[n];
          break;
        }
      }
    }
    if (i == num_links)
      cdoAbort("Internal problem, link 1 not found!");
  }
  for (lvl = num_links - 1; lvl >= 2; lvl--) {
    add1_tmp = add1[lvl];
    add1[lvl] = add1[0];
    add2_tmp = add2[lvl];
    add2[lvl] = add2[0];
    for (n = 0; n < num_wts; n++)
      wgttmp[n] = weights[num_wts * lvl + n];
    for (n = 0; n < num_wts; n++)
      weights[num_wts * lvl + n] = weights[n];
    final_lvl = 0;
    for (i = 0; i < num_links; i++) {
      chk_lvl1 = 2 * final_lvl + 1;
      chk_lvl2 = 2 * final_lvl + 2;
      if (chk_lvl2 >= lvl)
        chk_lvl2 = chk_lvl1;
      if ((add1[chk_lvl1] > add1[chk_lvl2]) ||
          ((add1[chk_lvl1] == add1[chk_lvl2]) &&
           (add2[chk_lvl1] > add2[chk_lvl2])))
        max_lvl = chk_lvl1;
      else
        max_lvl = chk_lvl2;
      if ((add1_tmp > add1[max_lvl]) ||
          ((add1_tmp == add1[max_lvl]) && (add2_tmp > add2[max_lvl]))) {
        add1[final_lvl] = add1_tmp;
        add2[final_lvl] = add2_tmp;
        for (n = 0; n < num_wts; n++)
          weights[num_wts * final_lvl + n] = wgttmp[n];
        break;
      } else {
        add1[final_lvl] = add1[max_lvl];
        add2[final_lvl] = add2[max_lvl];
        for (n = 0; n < num_wts; n++)
          weights[num_wts * final_lvl + n] = weights[num_wts * max_lvl + n];
        final_lvl = max_lvl;
        if (2 * final_lvl + 1 >= lvl) {
          add1[final_lvl] = add1_tmp;
          add2[final_lvl] = add2_tmp;
          for (n = 0; n < num_wts; n++)
            weights[num_wts * final_lvl + n] = wgttmp[n];
          break;
        }
      }
    }
    if (i == num_links)
      cdoAbort("Internal problem, link 2 not found!");
  }
  add1_tmp = add1[1];
  add1[1] = add1[0];
  add1[0] = add1_tmp;
  add2_tmp = add2[1];
  add2[1] = add2[0];
  add2[0] = add2_tmp;
  for (n = 0; n < num_wts; n++)
    wgttmp[n] = weights[num_wts + n];
  for (n = 0; n < num_wts; n++)
    weights[num_wts + n] = weights[n];
  for (n = 0; n < num_wts; n++)
    weights[n] = wgttmp[n];
}


x86 assembly (clang, -O0):
<sort_add_orig>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
cmpq   $0x1,-0x8(%rbp)
jg     113f <sort_add_orig+0x2f>
jmp    192f <sort_add_orig+0x81f>
mov    -0x8(%rbp),%rax
mov    $0x2,%ecx
cqto
idiv   %rcx
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jl     1484 <sort_add_orig+0x374>
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    11ce <sort_add_orig+0xbe>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x38(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    118c <sort_add_orig+0x7c>
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    1454 <sort_add_orig+0x344>
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x8(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jne    1221 <sort_add_orig+0x111>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x50(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1275 <sort_add_orig+0x165>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x50(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1282 <sort_add_orig+0x172>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
mov    -0x50(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1282 <sort_add_orig+0x172>
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    128a <sort_add_orig+0x17a>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     12c6 <sort_add_orig+0x1b6>
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1331 <sort_add_orig+0x221>
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1331 <sort_add_orig+0x221>
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    132c <sort_add_orig+0x21c>
mov    -0x68(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    12ea <sort_add_orig+0x1da>
jmp    1454 <sort_add_orig+0x344>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    13b0 <sort_add_orig+0x2a0>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x58(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1365 <sort_add_orig+0x255>
mov    -0x58(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    $0x1,%rax
cmp    -0x8(%rbp),%rax
jl     1439 <sort_add_orig+0x329>
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1434 <sort_add_orig+0x324>
mov    -0x68(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    13f2 <sort_add_orig+0x2e2>
jmp    1454 <sort_add_orig+0x344>
jmp    143e <sort_add_orig+0x32e>
jmp    1443 <sort_add_orig+0x333>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    11d6 <sort_add_orig+0xc6>
mov    -0x60(%rbp),%rax
cmp    -0x8(%rbp),%rax
jne    146e <sort_add_orig+0x35e>
lea    0xb97(%rip),%rdi
call   1030 <cdoAbort@plt>
jmp    1473 <sort_add_orig+0x363>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    1155 <sort_add_orig+0x45>
mov    -0x8(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x2,-0x38(%rbp)
jl     1824 <sort_add_orig+0x714>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%edx
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edx
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1523 <sort_add_orig+0x413>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x38(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    14e1 <sort_add_orig+0x3d1>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    156d <sort_add_orig+0x45d>
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x38(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    152b <sort_add_orig+0x41b>
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x8(%rbp),%rax
jge    17f4 <sort_add_orig+0x6e4>
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x38(%rbp),%rax
jl     15c1 <sort_add_orig+0x4b1>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x50(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1615 <sort_add_orig+0x505>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x50(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1622 <sort_add_orig+0x512>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
mov    -0x50(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1622 <sort_add_orig+0x512>
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    162a <sort_add_orig+0x51a>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1666 <sort_add_orig+0x556>
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
mov    -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    16d1 <sort_add_orig+0x5c1>
mov    -0x30(%rbp),%eax
mov    -0x20(%rbp),%rcx
mov    -0x58(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    16d1 <sort_add_orig+0x5c1>
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    16cc <sort_add_orig+0x5bc>
mov    -0x68(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    168a <sort_add_orig+0x57a>
jmp    17f4 <sort_add_orig+0x6e4>
mov    -0x18(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    1750 <sort_add_orig+0x640>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x58(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1705 <sort_add_orig+0x5f5>
mov    -0x58(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
shl    $0x1,%rax
add    $0x1,%rax
cmp    -0x38(%rbp),%rax
jl     17d9 <sort_add_orig+0x6c9>
mov    -0x2c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    17d4 <sort_add_orig+0x6c4>
mov    -0x68(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
imul   -0x40(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    1792 <sort_add_orig+0x682>
jmp    17f4 <sort_add_orig+0x6e4>
jmp    17de <sort_add_orig+0x6ce>
jmp    17e3 <sort_add_orig+0x6d3>
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    157d <sort_add_orig+0x46d>
mov    -0x60(%rbp),%rax
cmp    -0x8(%rbp),%rax
jne    180e <sort_add_orig+0x6fe>
lea    0x81b(%rip),%rdi
call   1030 <cdoAbort@plt>
jmp    1813 <sort_add_orig+0x703>
mov    -0x38(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
jmp    1490 <sort_add_orig+0x380>
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x30(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    18a9 <sort_add_orig+0x799>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movsd  %xmm0,-0x90(%rbp,%rax,8)
ff ff
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    186c <sort_add_orig+0x75c>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    18ee <sort_add_orig+0x7de>
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    18b1 <sort_add_orig+0x7a1>
movq   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%rax
cmp    -0x10(%rbp),%rax
jge    192f <sort_add_orig+0x81f>
mov    -0x68(%rbp),%rax
movsd  -0x90(%rbp,%rax,8),%xmm0
ff ff
mov    -0x28(%rbp),%rax
mov    -0x68(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x68(%rbp)
jmp    18f6 <sort_add_orig+0x7e6>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort_add_orig>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xf8,%rsp
cmp    $0x2,%rdi
jl     1c6f <sort_add_orig+0xb4f>
mov    %r8,%r14
mov    %rcx,%r10
mov    %rdx,%r11
mov    %rsi,%r12
movabs $0x7ffffffffffffffc,%rdx
ff ff 7f
mov    %rdi,%rsi
shr    %rsi
lea    -0x1(%rdi),%rax
mov    %rax,0x60(%rsp)
lea    0x0(,%r12,8),%rax
mov    %rax,0x18(%rsp)
lea    -0x4(%r12),%rcx
mov    %rcx,0x50(%rsp)
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r12,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
add    $0x2,%rdx
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
and    %rcx,%rdx
mov    %rdx,0x68(%rsp)
mov    %r12d,%r15d
and    $0x3,%r15d
lea    0x30(%r8),%rax
mov    %rax,0x80(%rsp)
lea    0x18(%r8),%rax
mov    %rax,0x88(%rsp)
xor    %ebp,%ebp
mov    %rsi,0x38(%rsp)
mov    %rsi,%rbx
mov    %r10,0x30(%rsp)
mov    %rdi,0x28(%rsp)
mov    %r11,0x20(%rsp)
mov    %r15,0x10(%rsp)
jmp    1215 <sort_add_orig+0xf5>
xchg   %ax,%ax
lea    0xe19(%rip),%rdi
call   1040 <cdoAbort@plt>
mov    0x20(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%r10
mov    0x58(%rsp),%rbp
add    $0x1,%rbp
cmpq   $0x1,0x78(%rsp)
mov    0x70(%rsp),%rbx
jle    1525 <sort_add_orig+0x405>
mov    -0x4(%r11,%rbx,4),%eax
mov    %eax,0xc(%rsp)
mov    -0x4(%r10,%rbx,4),%eax
mov    %eax,0x8(%rsp)
test   %r12,%r12
jle    1260 <sort_add_orig+0x140>
mov    %rbp,%rax
not    %rax
add    0x38(%rsp),%rax
imul   %r12,%rax
lea    (%r14,%rax,8),%rsi
lea    0x90(%rsp),%rdi
mov    0x18(%rsp),%rdx
call   1030 <memcpy@plt>
mov    0x20(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%r10
mov    %rbp,0x58(%rsp)
mov    %rbx,0x78(%rsp)
lea    -0x1(%rbx),%rsi
xor    %r13d,%r13d
mov    %rsi,0x70(%rsp)
jmp    12a1 <sort_add_orig+0x181>
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rax,1),%rcx
add    $0x1,%rcx
cmp    %rdi,%rcx
jge    14bf <sort_add_orig+0x39f>
add    $0x1,%r13
mov    %rax,%rsi
cmp    %rdi,%r13
je     11e0 <sort_add_orig+0xc0>
lea    (%rsi,%rsi,1),%rax
add    $0x1,%rax
lea    (%rsi,%rsi,1),%rdx
add    $0x2,%rdx
cmp    0x60(%rsp),%rax
cmove  %rax,%rdx
lea    (%rsi,%rsi,1),%rcx
mov    0x4(%r11,%rcx,4),%ecx
mov    (%r11,%rdx,4),%ebp
cmp    %ebp,%ecx
jg     12e1 <sort_add_orig+0x1c1>
jne    12dc <sort_add_orig+0x1bc>
mov    (%r10,%rax,4),%ebx
cmp    (%r10,%rdx,4),%ebx
mov    0x10(%rsp),%r15
jg     12e1 <sort_add_orig+0x1c1>
mov    %ebp,%ecx
mov    %rdx,%rax
cmp    %ecx,0xc(%rsp)
jg     14a0 <sort_add_orig+0x380>
mov    (%r10,%rax,4),%edx
jne    12fb <sort_add_orig+0x1db>
cmp    %edx,0x8(%rsp)
jg     14a0 <sort_add_orig+0x380>
mov    %ecx,(%r11,%rsi,4)
mov    %edx,(%r10,%rsi,4)
test   %r12,%r12
jle    13f0 <sort_add_orig+0x2d0>
mov    %rax,%r8
imul   %r12,%r8
mov    %rsi,%r9
imul   %r12,%r9
cmp    $0x4,%r12
jb     1358 <sort_add_orig+0x238>
lea    (%r14,%r9,8),%rcx
lea    0x8(,%rax,8),%rdx
imul   %r12,%rdx
add    %r14,%rdx
cmp    %rcx,%rdx
jbe    1406 <sort_add_orig+0x2e6>
lea    0x8(,%rsi,8),%rcx
imul   %r12,%rcx
add    %r14,%rcx
lea    (%r14,%r8,8),%rdx
cmp    %rdx,%rcx
jbe    1406 <sort_add_orig+0x2e6>
xor    %esi,%esi
mov    %rsi,%rbp
not    %rbp
add    %r12,%rbp
test   %r15,%r15
je     1384 <sort_add_orig+0x264>
lea    (%r14,%r9,8),%rcx
lea    (%r14,%r8,8),%rdx
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%r15
jne    1370 <sort_add_orig+0x250>
cmp    $0x3,%rbp
mov    0x10(%rsp),%r15
jb     1280 <sort_add_orig+0x160>
mov    0x88(%rsp),%rdx
lea    (%rdx,%r9,8),%rcx
lea    (%rdx,%r8,8),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  -0x18(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rsi,8)
movsd  -0x10(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rsi,8)
movsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r12
jne    13b0 <sort_add_orig+0x290>
jmp    1280 <sort_add_orig+0x160>
nopl   0x0(%rax)
lea    (%rax,%rax,1),%rcx
add    $0x1,%rcx
cmp    %rdi,%rcx
jl     1291 <sort_add_orig+0x171>
jmp    1507 <sort_add_orig+0x3e7>
cmpq   $0x4,0x50(%rsp)
jae    1412 <sort_add_orig+0x2f2>
xor    %esi,%esi
jmp    1461 <sort_add_orig+0x341>
mov    0x80(%rsp),%rcx
lea    (%rcx,%r8,8),%rbp
lea    (%rcx,%r9,8),%rcx
mov    0x68(%rsp),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x30(%rbp,%rsi,8),%xmm0
movups -0x20(%rbp,%rsi,8),%xmm1
movups %xmm0,-0x30(%rcx,%rsi,8)
movups %xmm1,-0x20(%rcx,%rsi,8)
movups -0x10(%rbp,%rsi,8),%xmm0
movups 0x0(%rbp,%rsi,8),%xmm1
movups %xmm0,-0x10(%rcx,%rsi,8)
movups %xmm1,(%rcx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdx
jne    1430 <sort_add_orig+0x310>
testb  $0x1,0x48(%rsp)
je     1485 <sort_add_orig+0x365>
lea    (%rsi,%r8,1),%rcx
movups (%r14,%rcx,8),%xmm0
movups 0x10(%r14,%rcx,8),%xmm1
add    %r9,%rsi
movups %xmm0,(%r14,%rsi,8)
movups %xmm1,0x10(%r14,%rsi,8)
mov    0x40(%rsp),%rcx
mov    %rcx,%rsi
cmp    %r12,%rcx
je     1280 <sort_add_orig+0x160>
jmp    135a <sort_add_orig+0x23a>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%eax
mov    %eax,(%r11,%rsi,4)
mov    0x8(%rsp),%eax
mov    %eax,(%r10,%rsi,4)
test   %r12,%r12
jle    14f9 <sort_add_orig+0x3d9>
imul   %r12,%rsi
lea    (%r14,%rsi,8),%rdi
jmp    14d8 <sort_add_orig+0x3b8>
mov    0xc(%rsp),%ecx
mov    %ecx,(%r11,%rax,4)
mov    0x8(%rsp),%ecx
mov    %ecx,(%r10,%rax,4)
test   %r12,%r12
jle    14f9 <sort_add_orig+0x3d9>
lea    (%r14,%r8,8),%rdi
lea    0x90(%rsp),%rsi
mov    0x18(%rsp),%rdx
call   1030 <memcpy@plt>
mov    0x20(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%r10
cmp    %rdi,%r13
je     11e0 <sort_add_orig+0xc0>
jmp    11fb <sort_add_orig+0xdb>
mov    0xc(%rsp),%ecx
mov    %ecx,(%r11,%rax,4)
mov    0x8(%rsp),%ecx
mov    %ecx,(%r10,%rax,4)
cmp    %rdi,%r13
je     11e0 <sort_add_orig+0xc0>
jmp    11fb <sort_add_orig+0xdb>
cmp    $0x3,%rdi
jl     1b2a <sort_add_orig+0xa0a>
lea    -0x2(%rdi),%rax
mov    %rax,0x68(%rsp)
mov    0x60(%rsp),%rdx
imul   %r12,%rdx
mov    %r12,%rax
imul   %rdi,%rax
mov    %rax,0xd0(%rsp)
lea    (%r14,%r12,8),%rax
mov    %rax,0xd8(%rsp)
mov    %r12,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x40(%rsp)
mov    0x48(%rsp),%rbp
mov    %ebp,%esi
and    $0x3,%esi
mov    %rbp,%rax
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%rax
mov    %rax,0xb0(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
mov    %rax,0x58(%rsp)
lea    0x2(%rcx),%rax
and    %rbp,%rax
mov    %rax,0xe0(%rsp)
lea    0x70(%r14),%rax
mov    %rax,0xc0(%rsp)
lea    0x0(,%rdx,8),%rbx
lea    0x10(%r14),%rax
mov    %rax,0xb8(%rsp)
mov    %rsi,0xc8(%rsp)
mov    %rsi,%r13
shl    $0x5,%r13
lea    (%r14,%rdx,8),%r15
mov    0x18(%rsp),%rax
neg    %rax
mov    %rax,0xe8(%rsp)
xor    %ebp,%ebp
mov    %rdx,0x60(%rsp)
mov    %rdx,0x38(%rsp)
mov    %rdi,%r9
mov    %r13,0xf0(%rsp)
jmp    1653 <sort_add_orig+0x533>
lea    0xa1d(%rip),%rdi
call   1040 <cdoAbort@plt>
mov    0x10(%rsp),%r9
mov    0x20(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%r10
mov    0x70(%rsp),%rbp
add    $0x1,%rbp
mov    0x78(%rsp),%rbx
sub    0x18(%rsp),%rbx
sub    %r12,0x38(%rsp)
add    0xe8(%rsp),%r15
cmp    0x68(%rsp),%rbp
mov    0xf0(%rsp),%r13
je     1b2a <sort_add_orig+0xa0a>
mov    -0x4(%r11,%r9,4),%eax
mov    %eax,0xc(%rsp)
mov    (%r11),%eax
mov    %eax,-0x4(%r11,%r9,4)
mov    -0x4(%r10,%r9,4),%eax
mov    %eax,0x8(%rsp)
mov    (%r10),%eax
mov    %eax,-0x4(%r10,%r9,4)
test   %r12,%r12
jle    1860 <sort_add_orig+0x740>
mov    %r9,0x10(%rsp)
mov    %rbp,%rax
not    %rax
add    %rdi,%rax
imul   %r12,%rax
lea    (%r14,%rax,8),%rsi
lea    0x90(%rsp),%rdi
mov    0x18(%rsp),%rdx
call   1030 <memcpy@plt>
cmp    $0x4,%r12
jb     16e5 <sort_add_orig+0x5c5>
mov    %rbp,%rax
imul   %r12,%rax
mov    0x60(%rsp),%rcx
sub    %rax,%rcx
lea    (%r14,%rcx,8),%rcx
cmp    0xd8(%rsp),%rcx
jae    1774 <sort_add_orig+0x654>
mov    0xd0(%rsp),%rcx
sub    %rax,%rcx
lea    (%r14,%rcx,8),%rax
cmp    %r14,%rax
jbe    1774 <sort_add_orig+0x654>
xor    %eax,%eax
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%r11
mov    0x10(%rsp),%r9
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
mov    0x58(%rsp),%rdx
test   %rdx,%rdx
je     1726 <sort_add_orig+0x606>
xchg   %ax,%ax
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1710 <sort_add_orig+0x5f0>
cmp    $0x3,%rcx
jb     1860 <sort_add_orig+0x740>
movsd  (%r14,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rax,8)
movsd  0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x8(%r15,%rax,8)
movsd  0x10(%r14,%rax,8),%xmm0
movsd  %xmm0,0x10(%r15,%rax,8)
movsd  0x18(%r14,%rax,8),%xmm0
movsd  %xmm0,0x18(%r15,%rax,8)
add    $0x4,%rax
cmp    %rax,%r12
jne    1730 <sort_add_orig+0x610>
jmp    1860 <sort_add_orig+0x740>
cmpq   $0xc,0x50(%rsp)
mov    0x30(%rsp),%r10
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%r11
mov    0xc0(%rsp),%rsi
mov    0x10(%rsp),%r9
jae    179c <sort_add_orig+0x67c>
xor    %eax,%eax
jmp    1808 <sort_add_orig+0x6e8>
lea    (%rsi,%rbx,1),%rcx
mov    0xb0(%rsp),%rdx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups -0x70(%rsi,%rax,8),%xmm0
movups -0x60(%rsi,%rax,8),%xmm1
movups %xmm0,-0x70(%rcx,%rax,8)
movups %xmm1,-0x60(%rcx,%rax,8)
movups -0x50(%rsi,%rax,8),%xmm0
movups -0x40(%rsi,%rax,8),%xmm1
movups %xmm0,-0x50(%rcx,%rax,8)
movups %xmm1,-0x40(%rcx,%rax,8)
movups -0x30(%rsi,%rax,8),%xmm0
movups -0x20(%rsi,%rax,8),%xmm1
movups %xmm0,-0x30(%rcx,%rax,8)
movups %xmm1,-0x20(%rcx,%rax,8)
movups -0x10(%rsi,%rax,8),%xmm0
movups (%rsi,%rax,8),%xmm1
movups %xmm0,-0x10(%rcx,%rax,8)
movups %xmm1,(%rcx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rdx
jne    17b0 <sort_add_orig+0x690>
cmpq   $0x0,0xc8(%rsp)
je     184b <sort_add_orig+0x72b>
mov    0x38(%rsp),%rcx
add    %rax,%rcx
mov    0xb8(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopl   (%rax)
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r13
jne    1830 <sort_add_orig+0x710>
mov    0x40(%rsp),%rcx
mov    %rcx,%rax
cmp    %r12,%rcx
jne    16fb <sort_add_orig+0x5db>
nopl   0x0(%rax)
mov    %rbp,0x70(%rsp)
mov    %rbx,0x78(%rsp)
add    $0xffffffffffffffff,%r9
xor    %r13d,%r13d
xor    %esi,%esi
mov    %r9,0x10(%rsp)
jmp    18a6 <sort_add_orig+0x786>
nopw   0x0(%rax,%rax,1)
lea    (%rax,%rax,1),%rcx
add    $0x1,%rcx
mov    0x10(%rsp),%r9
cmp    %r9,%rcx
jge    1abf <sort_add_orig+0x99f>
add    $0x1,%r13
mov    %rax,%rsi
cmp    %rdi,%r13
je     1600 <sort_add_orig+0x4e0>
lea    (%rsi,%rsi,1),%rax
add    $0x1,%rax
lea    (%rsi,%rsi,1),%rdx
add    $0x2,%rdx
cmp    %r9,%rdx
cmovge %rax,%rdx
lea    (%rsi,%rsi,1),%rcx
mov    0x4(%r11,%rcx,4),%ecx
mov    (%r11,%rdx,4),%ebp
cmp    %ebp,%ecx
jg     18df <sort_add_orig+0x7bf>
jne    18da <sort_add_orig+0x7ba>
mov    (%r10,%rax,4),%ebx
cmp    (%r10,%rdx,4),%ebx
jg     18df <sort_add_orig+0x7bf>
mov    %ebp,%ecx
mov    %rdx,%rax
cmp    %ecx,0xc(%rsp)
jg     1aa0 <sort_add_orig+0x980>
mov    (%r10,%rax,4),%edx
jne    18f9 <sort_add_orig+0x7d9>
cmp    %edx,0x8(%rsp)
jg     1aa0 <sort_add_orig+0x980>
mov    %ecx,(%r11,%rsi,4)
mov    %edx,(%r10,%rsi,4)
test   %r12,%r12
jle    19f0 <sort_add_orig+0x8d0>
mov    %rax,%r8
imul   %r12,%r8
mov    %rsi,%r9
imul   %r12,%r9
cmp    $0x4,%r12
jb     1956 <sort_add_orig+0x836>
lea    (%r14,%r9,8),%rcx
lea    0x8(,%rax,8),%rdx
imul   %r12,%rdx
add    %r14,%rdx
cmp    %rcx,%rdx
jbe    1a06 <sort_add_orig+0x8e6>
lea    0x8(,%rsi,8),%rcx
imul   %r12,%rcx
add    %r14,%rcx
lea    (%r14,%r8,8),%rdx
cmp    %rdx,%rcx
jbe    1a06 <sort_add_orig+0x8e6>
xor    %esi,%esi
mov    %rsi,%rbp
not    %rbp
add    %r12,%rbp
test   $0x3,%r12b
je     1994 <sort_add_orig+0x874>
lea    (%r14,%r9,8),%rcx
lea    (%r14,%r8,8),%rdx
mov    0x58(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
jne    1980 <sort_add_orig+0x860>
cmp    $0x3,%rbp
jb     1880 <sort_add_orig+0x760>
mov    0x88(%rsp),%rdx
lea    (%rdx,%r9,8),%rcx
lea    (%rdx,%r8,8),%rdx
xchg   %ax,%ax
movsd  -0x18(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x18(%rcx,%rsi,8)
movsd  -0x10(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x10(%rcx,%rsi,8)
movsd  -0x8(%rdx,%rsi,8),%xmm0
movsd  %xmm0,-0x8(%rcx,%rsi,8)
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r12
jne    19b0 <sort_add_orig+0x890>
jmp    1880 <sort_add_orig+0x760>
nopl   0x0(%rax)
lea    (%rax,%rax,1),%rcx
add    $0x1,%rcx
cmp    %r9,%rcx
jl     1896 <sort_add_orig+0x776>
jmp    1b0c <sort_add_orig+0x9ec>
cmpq   $0x4,0x50(%rsp)
jae    1a12 <sort_add_orig+0x8f2>
xor    %esi,%esi
jmp    1a61 <sort_add_orig+0x941>
mov    0x80(%rsp),%rcx
lea    (%rcx,%r8,8),%rbp
lea    (%rcx,%r9,8),%rcx
mov    0xe0(%rsp),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
movups -0x30(%rbp,%rsi,8),%xmm0
movups -0x20(%rbp,%rsi,8),%xmm1
movups %xmm0,-0x30(%rcx,%rsi,8)
movups %xmm1,-0x20(%rcx,%rsi,8)
movups -0x10(%rbp,%rsi,8),%xmm0
movups 0x0(%rbp,%rsi,8),%xmm1
movups %xmm0,-0x10(%rcx,%rsi,8)
movups %xmm1,(%rcx,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdx
jne    1a30 <sort_add_orig+0x910>
testb  $0x1,0x48(%rsp)
je     1a85 <sort_add_orig+0x965>
lea    (%rsi,%r8,1),%rcx
movups (%r14,%rcx,8),%xmm0
movups 0x10(%r14,%rcx,8),%xmm1
add    %r9,%rsi
movups %xmm0,(%r14,%rsi,8)
movups %xmm1,0x10(%r14,%rsi,8)
mov    0x40(%rsp),%rcx
mov    %rcx,%rsi
cmp    %r12,%rcx
je     1880 <sort_add_orig+0x760>
jmp    1958 <sort_add_orig+0x838>
nopl   0x0(%rax,%rax,1)
mov    0xc(%rsp),%eax
mov    %eax,(%r11,%rsi,4)
mov    0x8(%rsp),%eax
mov    %eax,(%r10,%rsi,4)
test   %r12,%r12
jle    1afe <sort_add_orig+0x9de>
imul   %r12,%rsi
lea    (%r14,%rsi,8),%rdi
jmp    1ad8 <sort_add_orig+0x9b8>
mov    0xc(%rsp),%ecx
mov    %ecx,(%r11,%rax,4)
mov    0x8(%rsp),%ecx
mov    %ecx,(%r10,%rax,4)
test   %r12,%r12
jle    1afe <sort_add_orig+0x9de>
lea    (%r14,%r8,8),%rdi
lea    0x90(%rsp),%rsi
mov    0x18(%rsp),%rdx
call   1030 <memcpy@plt>
mov    0x10(%rsp),%r9
mov    0x20(%rsp),%r11
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%r10
cmp    %rdi,%r13
je     1600 <sort_add_orig+0x4e0>
jmp    1620 <sort_add_orig+0x500>
mov    0xc(%rsp),%ecx
mov    %ecx,(%r11,%rax,4)
mov    0x8(%rsp),%ecx
mov    %ecx,(%r10,%rax,4)
cmp    %rdi,%r13
je     1600 <sort_add_orig+0x4e0>
jmp    1620 <sort_add_orig+0x500>
rolq   $0x20,(%r11)
rolq   $0x20,(%r10)
test   %r12,%r12
jle    1c6f <sort_add_orig+0xb4f>
lea    (%r14,%r12,8),%rbp
lea    0x90(%rsp),%rdi
mov    %rbp,%rsi
mov    0x18(%rsp),%rdx
call   1030 <memcpy@plt>
cmp    $0x4,%r12
jae    1b61 <sort_add_orig+0xa41>
xor    %ecx,%ecx
jmp    1c40 <sort_add_orig+0xb20>
mov    0x48(%rsp),%rdi
mov    %edi,%eax
and    $0x3,%eax
cmpq   $0xc,0x50(%rsp)
jae    1b7a <sort_add_orig+0xa5a>
xor    %edx,%edx
jmp    1bf8 <sort_add_orig+0xad8>
movabs $0x7ffffffffffffffc,%rcx
ff ff 7f
and    %rcx,%rdi
lea    0x70(%r14),%rcx
lea    (%r14,%r12,8),%rsi
add    $0x70,%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%rcx,%rdx,8),%xmm0
movups -0x60(%rcx,%rdx,8),%xmm1
movups %xmm0,-0x70(%rsi,%rdx,8)
movups %xmm1,-0x60(%rsi,%rdx,8)
movups -0x50(%rcx,%rdx,8),%xmm0
movups -0x40(%rcx,%rdx,8),%xmm1
movups %xmm0,-0x50(%rsi,%rdx,8)
movups %xmm1,-0x40(%rsi,%rdx,8)
movups -0x30(%rcx,%rdx,8),%xmm0
movups -0x20(%rcx,%rdx,8),%xmm1
movups %xmm0,-0x30(%rsi,%rdx,8)
movups %xmm1,-0x20(%rsi,%rdx,8)
movups -0x10(%rcx,%rdx,8),%xmm0
movups (%rcx,%rdx,8),%xmm1
movups %xmm0,-0x10(%rsi,%rdx,8)
movups %xmm1,(%rsi,%rdx,8)
add    $0x10,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1ba0 <sort_add_orig+0xa80>
mov    %r12,%rcx
and    $0xfffffffffffffffc,%rcx
test   %rax,%rax
je     1c3b <sort_add_orig+0xb1b>
lea    (%rdx,%r12,1),%rsi
lea    (%r14,%rsi,8),%rsi
add    $0x10,%rsi
lea    (%r14,%rdx,8),%rdx
add    $0x10,%rdx
shl    $0x5,%rax
xor    %edi,%edi
xchg   %ax,%ax
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rax
jne    1c20 <sort_add_orig+0xb00>
cmp    %r12,%rcx
je     1c55 <sort_add_orig+0xb35>
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%r12
jne    1c40 <sort_add_orig+0xb20>
test   %r12,%r12
jle    1c6f <sort_add_orig+0xb4f>
lea    0x90(%rsp),%rsi
mov    %r14,%rdi
mov    0x18(%rsp),%rdx
call   1030 <memcpy@plt>
add    $0xf8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [36 x i8] c"Internal problem, link 1 not found!\00"
@.str.1 = [36 x i8] c"Internal problem, link 2 not found!\00"
define void @sort_add_orig(i64 %0, i64 %1, i32* noalias %2, i32* noalias %3, double* noalias %4) {
%6 = alloca i64
%7 = alloca i64
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca double*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i64
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i64
%18 = alloca i64
%19 = alloca i64
%20 = alloca [4 x double]
store i64 %0, i64* %6
store i64 %1, i64* %7
store i32* %2, i32** %8
store i32* %3, i32** %9
store double* %4, double** %10
%21 = load i64, i64* %6
%22 = icmp sle i64 %21, 1
br i1 %22, label %23, label %24
23: ; preds = %5
br label %573
24: ; preds = %5
%25 = load i64, i64* %6
%26 = sdiv i64 %25, 2
%27 = sub nsw i64 %26, 1
store i64 %27, i64* %13
br label %28
28: ; preds = %245, %24
%29 = load i64, i64* %13
%30 = icmp sge i64 %29, 0
br i1 %30, label %31, label %248
31: ; preds = %28
%32 = load i64, i64* %13
store i64 %32, i64* %14
%33 = load i32*, i32** %8
%34 = load i64, i64* %13
%35 = getelementptr inbounds i32, i32* %33, i64 %34
%36 = load i32, i32* %35
store i32 %36, i32* %11
%37 = load i32*, i32** %9
%38 = load i64, i64* %13
%39 = getelementptr inbounds i32, i32* %37, i64 %38
%40 = load i32, i32* %39
store i32 %40, i32* %12
store i64 0, i64* %19
br label %41
41: ; preds = %56, %31
%42 = load i64, i64* %19
%43 = load i64, i64* %7
%44 = icmp slt i64 %42, %43
br i1 %44, label %45, label %59
45: ; preds = %41
%46 = load double*, double** %10
%47 = load i64, i64* %7
%48 = load i64, i64* %13
%49 = mul nsw i64 %47, %48
%50 = load i64, i64* %19
%51 = add nsw i64 %49, %50
%52 = getelementptr inbounds double, double* %46, i64 %51
%53 = load double, double* %52
%54 = load i64, i64* %19
%55 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 %54
store double %53, double* %55
br label %56
56: ; preds = %45
%57 = load i64, i64* %19
%58 = add nsw i64 %57, 1
store i64 %58, i64* %19
br label %41
59: ; preds = %41
store i64 0, i64* %18
br label %60
60: ; preds = %235, %59
%61 = load i64, i64* %18
%62 = load i64, i64* %6
%63 = icmp slt i64 %61, %62
br i1 %63, label %64, label %238
64: ; preds = %60
%65 = load i64, i64* %14
%66 = mul nsw i64 2, %65
%67 = add nsw i64 %66, 1
store i64 %67, i64* %15
%68 = load i64, i64* %14
%69 = mul nsw i64 2, %68
%70 = add nsw i64 %69, 2
store i64 %70, i64* %16
%71 = load i64, i64* %15
%72 = load i64, i64* %6
%73 = sub nsw i64 %72, 1
%74 = icmp eq i64 %71, %73
br i1 %74, label %75, label %77
75: ; preds = %64
%76 = load i64, i64* %15
store i64 %76, i64* %16
br label %77
77: ; preds = %75, %64
%78 = load i32*, i32** %8
%79 = load i64, i64* %15
%80 = getelementptr inbounds i32, i32* %78, i64 %79
%81 = load i32, i32* %80
%82 = load i32*, i32** %8
%83 = load i64, i64* %16
%84 = getelementptr inbounds i32, i32* %82, i64 %83
%85 = load i32, i32* %84
%86 = icmp sgt i32 %81, %85
br i1 %86, label %107, label %87
87: ; preds = %77
%88 = load i32*, i32** %8
%89 = load i64, i64* %15
%90 = getelementptr inbounds i32, i32* %88, i64 %89
%91 = load i32, i32* %90
%92 = load i32*, i32** %8
%93 = load i64, i64* %16
%94 = getelementptr inbounds i32, i32* %92, i64 %93
%95 = load i32, i32* %94
%96 = icmp eq i32 %91, %95
br i1 %96, label %97, label %109
97: ; preds = %87
%98 = load i32*, i32** %9
%99 = load i64, i64* %15
%100 = getelementptr inbounds i32, i32* %98, i64 %99
%101 = load i32, i32* %100
%102 = load i32*, i32** %9
%103 = load i64, i64* %16
%104 = getelementptr inbounds i32, i32* %102, i64 %103
%105 = load i32, i32* %104
%106 = icmp sgt i32 %101, %105
br i1 %106, label %107, label %109
107: ; preds = %97, %77
%108 = load i64, i64* %15
store i64 %108, i64* %17
br label %111
109: ; preds = %97, %87
%110 = load i64, i64* %16
store i64 %110, i64* %17
br label %111
111: ; preds = %109, %107
%112 = load i32, i32* %11
%113 = load i32*, i32** %8
%114 = load i64, i64* %17
%115 = getelementptr inbounds i32, i32* %113, i64 %114
%116 = load i32, i32* %115
%117 = icmp sgt i32 %112, %116
br i1 %117, label %132, label %118
118: ; preds = %111
%119 = load i32, i32* %11
%120 = load i32*, i32** %8
%121 = load i64, i64* %17
%122 = getelementptr inbounds i32, i32* %120, i64 %121
%123 = load i32, i32* %122
%124 = icmp eq i32 %119, %123
br i1 %124, label %125, label %160
125: ; preds = %118
%126 = load i32, i32* %12
%127 = load i32*, i32** %9
%128 = load i64, i64* %17
%129 = getelementptr inbounds i32, i32* %127, i64 %128
%130 = load i32, i32* %129
%131 = icmp sgt i32 %126, %130
br i1 %131, label %132, label %160
132: ; preds = %125, %111
%133 = load i32, i32* %11
%134 = load i32*, i32** %8
%135 = load i64, i64* %14
%136 = getelementptr inbounds i32, i32* %134, i64 %135
store i32 %133, i32* %136
%137 = load i32, i32* %12
%138 = load i32*, i32** %9
%139 = load i64, i64* %14
%140 = getelementptr inbounds i32, i32* %138, i64 %139
store i32 %137, i32* %140
store i64 0, i64* %19
br label %141
141: ; preds = %156, %132
%142 = load i64, i64* %19
%143 = load i64, i64* %7
%144 = icmp slt i64 %142, %143
br i1 %144, label %145, label %159
145: ; preds = %141
%146 = load i64, i64* %19
%147 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 %146
%148 = load double, double* %147
%149 = load double*, double** %10
%150 = load i64, i64* %7
%151 = load i64, i64* %14
%152 = mul nsw i64 %150, %151
%153 = load i64, i64* %19
%154 = add nsw i64 %152, %153
%155 = getelementptr inbounds double, double* %149, i64 %154
store double %148, double* %155
br label %156
156: ; preds = %145
%157 = load i64, i64* %19
%158 = add nsw i64 %157, 1
store i64 %158, i64* %19
br label %141
159: ; preds = %141
br label %238
160: ; preds = %125, %118
%161 = load i32*, i32** %8
%162 = load i64, i64* %17
%163 = getelementptr inbounds i32, i32* %161, i64 %162
%164 = load i32, i32* %163
%165 = load i32*, i32** %8
%166 = load i64, i64* %14
%167 = getelementptr inbounds i32, i32* %165, i64 %166
store i32 %164, i32* %167
%168 = load i32*, i32** %9
%169 = load i64, i64* %17
%170 = getelementptr inbounds i32, i32* %168, i64 %169
%171 = load i32, i32* %170
%172 = load i32*, i32** %9
%173 = load i64, i64* %14
%174 = getelementptr inbounds i32, i32* %172, i64 %173
store i32 %171, i32* %174
store i64 0, i64* %19
br label %175
175: ; preds = %195, %160
%176 = load i64, i64* %19
%177 = load i64, i64* %7
%178 = icmp slt i64 %176, %177
br i1 %178, label %179, label %198
179: ; preds = %175
%180 = load double*, double** %10
%181 = load i64, i64* %7
%182 = load i64, i64* %17
%183 = mul nsw i64 %181, %182
%184 = load i64, i64* %19
%185 = add nsw i64 %183, %184
%186 = getelementptr inbounds double, double* %180, i64 %185
%187 = load double, double* %186
%188 = load double*, double** %10
%189 = load i64, i64* %7
%190 = load i64, i64* %14
%191 = mul nsw i64 %189, %190
%192 = load i64, i64* %19
%193 = add nsw i64 %191, %192
%194 = getelementptr inbounds double, double* %188, i64 %193
store double %187, double* %194
br label %195
195: ; preds = %179
%196 = load i64, i64* %19
%197 = add nsw i64 %196, 1
store i64 %197, i64* %19
br label %175
198: ; preds = %175
%199 = load i64, i64* %17
store i64 %199, i64* %14
%200 = load i64, i64* %14
%201 = mul nsw i64 2, %200
%202 = add nsw i64 %201, 1
%203 = load i64, i64* %6
%204 = icmp sge i64 %202, %203
br i1 %204, label %205, label %233
205: ; preds = %198
%206 = load i32, i32* %11
%207 = load i32*, i32** %8
%208 = load i64, i64* %14
%209 = getelementptr inbounds i32, i32* %207, i64 %208
store i32 %206, i32* %209
%210 = load i32, i32* %12
%211 = load i32*, i32** %9
%212 = load i64, i64* %14
%213 = getelementptr inbounds i32, i32* %211, i64 %212
store i32 %210, i32* %213
store i64 0, i64* %19
br label %214
214: ; preds = %229, %205
%215 = load i64, i64* %19
%216 = load i64, i64* %7
%217 = icmp slt i64 %215, %216
br i1 %217, label %218, label %232
218: ; preds = %214
%219 = load i64, i64* %19
%220 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 %219
%221 = load double, double* %220
%222 = load double*, double** %10
%223 = load i64, i64* %7
%224 = load i64, i64* %14
%225 = mul nsw i64 %223, %224
%226 = load i64, i64* %19
%227 = add nsw i64 %225, %226
%228 = getelementptr inbounds double, double* %222, i64 %227
store double %221, double* %228
br label %229
229: ; preds = %218
%230 = load i64, i64* %19
%231 = add nsw i64 %230, 1
store i64 %231, i64* %19
br label %214
232: ; preds = %214
br label %238
233: ; preds = %198
br label %234
234: ; preds = %233
br label %235
235: ; preds = %234
%236 = load i64, i64* %18
%237 = add nsw i64 %236, 1
store i64 %237, i64* %18
br label %60
238: ; preds = %232, %159, %60
%239 = load i64, i64* %18
%240 = load i64, i64* %6
%241 = icmp eq i64 %239, %240
br i1 %241, label %242, label %244
242: ; preds = %238
%243 = call i32 @cdoAbort(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
br label %244
244: ; preds = %242, %238
br label %245
245: ; preds = %244
%246 = load i64, i64* %13
%247 = add nsw i64 %246, -1
store i64 %247, i64* %13
br label %28
248: ; preds = %28
%249 = load i64, i64* %6
%250 = sub nsw i64 %249, 1
store i64 %250, i64* %13
br label %251
251: ; preds = %498, %248
%252 = load i64, i64* %13
%253 = icmp sge i64 %252, 2
br i1 %253, label %254, label %501
254: ; preds = %251
%255 = load i32*, i32** %8
%256 = load i64, i64* %13
%257 = getelementptr inbounds i32, i32* %255, i64 %256
%258 = load i32, i32* %257
store i32 %258, i32* %11
%259 = load i32*, i32** %8
%260 = getelementptr inbounds i32, i32* %259, i64 0
%261 = load i32, i32* %260
%262 = load i32*, i32** %8
%263 = load i64, i64* %13
%264 = getelementptr inbounds i32, i32* %262, i64 %263
store i32 %261, i32* %264
%265 = load i32*, i32** %9
%266 = load i64, i64* %13
%267 = getelementptr inbounds i32, i32* %265, i64 %266
%268 = load i32, i32* %267
store i32 %268, i32* %12
%269 = load i32*, i32** %9
%270 = getelementptr inbounds i32, i32* %269, i64 0
%271 = load i32, i32* %270
%272 = load i32*, i32** %9
%273 = load i64, i64* %13
%274 = getelementptr inbounds i32, i32* %272, i64 %273
store i32 %271, i32* %274
store i64 0, i64* %19
br label %275
275: ; preds = %290, %254
%276 = load i64, i64* %19
%277 = load i64, i64* %7
%278 = icmp slt i64 %276, %277
br i1 %278, label %279, label %293
279: ; preds = %275
%280 = load double*, double** %10
%281 = load i64, i64* %7
%282 = load i64, i64* %13
%283 = mul nsw i64 %281, %282
%284 = load i64, i64* %19
%285 = add nsw i64 %283, %284
%286 = getelementptr inbounds double, double* %280, i64 %285
%287 = load double, double* %286
%288 = load i64, i64* %19
%289 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 %288
store double %287, double* %289
br label %290
290: ; preds = %279
%291 = load i64, i64* %19
%292 = add nsw i64 %291, 1
store i64 %292, i64* %19
br label %275
293: ; preds = %275
store i64 0, i64* %19
br label %294
294: ; preds = %310, %293
%295 = load i64, i64* %19
%296 = load i64, i64* %7
%297 = icmp slt i64 %295, %296
br i1 %297, label %298, label %313
298: ; preds = %294
%299 = load double*, double** %10
%300 = load i64, i64* %19
%301 = getelementptr inbounds double, double* %299, i64 %300
%302 = load double, double* %301
%303 = load double*, double** %10
%304 = load i64, i64* %7
%305 = load i64, i64* %13
%306 = mul nsw i64 %304, %305
%307 = load i64, i64* %19
%308 = add nsw i64 %306, %307
%309 = getelementptr inbounds double, double* %303, i64 %308
store double %302, double* %309
br label %310
310: ; preds = %298
%311 = load i64, i64* %19
%312 = add nsw i64 %311, 1
store i64 %312, i64* %19
br label %294
313: ; preds = %294
store i64 0, i64* %14
store i64 0, i64* %18
br label %314
314: ; preds = %488, %313
%315 = load i64, i64* %18
%316 = load i64, i64* %6
%317 = icmp slt i64 %315, %316
br i1 %317, label %318, label %491
318: ; preds = %314
%319 = load i64, i64* %14
%320 = mul nsw i64 2, %319
%321 = add nsw i64 %320, 1
store i64 %321, i64* %15
%322 = load i64, i64* %14
%323 = mul nsw i64 2, %322
%324 = add nsw i64 %323, 2
store i64 %324, i64* %16
%325 = load i64, i64* %16
%326 = load i64, i64* %13
%327 = icmp sge i64 %325, %326
br i1 %327, label %328, label %330
328: ; preds = %318
%329 = load i64, i64* %15
store i64 %329, i64* %16
br label %330
330: ; preds = %328, %318
%331 = load i32*, i32** %8
%332 = load i64, i64* %15
%333 = getelementptr inbounds i32, i32* %331, i64 %332
%334 = load i32, i32* %333
%335 = load i32*, i32** %8
%336 = load i64, i64* %16
%337 = getelementptr inbounds i32, i32* %335, i64 %336
%338 = load i32, i32* %337
%339 = icmp sgt i32 %334, %338
br i1 %339, label %360, label %340
340: ; preds = %330
%341 = load i32*, i32** %8
%342 = load i64, i64* %15
%343 = getelementptr inbounds i32, i32* %341, i64 %342
%344 = load i32, i32* %343
%345 = load i32*, i32** %8
%346 = load i64, i64* %16
%347 = getelementptr inbounds i32, i32* %345, i64 %346
%348 = load i32, i32* %347
%349 = icmp eq i32 %344, %348
br i1 %349, label %350, label %362
350: ; preds = %340
%351 = load i32*, i32** %9
%352 = load i64, i64* %15
%353 = getelementptr inbounds i32, i32* %351, i64 %352
%354 = load i32, i32* %353
%355 = load i32*, i32** %9
%356 = load i64, i64* %16
%357 = getelementptr inbounds i32, i32* %355, i64 %356
%358 = load i32, i32* %357
%359 = icmp sgt i32 %354, %358
br i1 %359, label %360, label %362
360: ; preds = %350, %330
%361 = load i64, i64* %15
store i64 %361, i64* %17
br label %364
362: ; preds = %350, %340
%363 = load i64, i64* %16
store i64 %363, i64* %17
br label %364
364: ; preds = %362, %360
%365 = load i32, i32* %11
%366 = load i32*, i32** %8
%367 = load i64, i64* %17
%368 = getelementptr inbounds i32, i32* %366, i64 %367
%369 = load i32, i32* %368
%370 = icmp sgt i32 %365, %369
br i1 %370, label %385, label %371
371: ; preds = %364
%372 = load i32, i32* %11
%373 = load i32*, i32** %8
%374 = load i64, i64* %17
%375 = getelementptr inbounds i32, i32* %373, i64 %374
%376 = load i32, i32* %375
%377 = icmp eq i32 %372, %376
br i1 %377, label %378, label %413
378: ; preds = %371
%379 = load i32, i32* %12
%380 = load i32*, i32** %9
%381 = load i64, i64* %17
%382 = getelementptr inbounds i32, i32* %380, i64 %381
%383 = load i32, i32* %382
%384 = icmp sgt i32 %379, %383
br i1 %384, label %385, label %413
385: ; preds = %378, %364
%386 = load i32, i32* %11
%387 = load i32*, i32** %8
%388 = load i64, i64* %14
%389 = getelementptr inbounds i32, i32* %387, i64 %388
store i32 %386, i32* %389
%390 = load i32, i32* %12
%391 = load i32*, i32** %9
%392 = load i64, i64* %14
%393 = getelementptr inbounds i32, i32* %391, i64 %392
store i32 %390, i32* %393
store i64 0, i64* %19
br label %394
394: ; preds = %409, %385
%395 = load i64, i64* %19
%396 = load i64, i64* %7
%397 = icmp slt i64 %395, %396
br i1 %397, label %398, label %412
398: ; preds = %394
%399 = load i64, i64* %19
%400 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 %399
%401 = load double, double* %400
%402 = load double*, double** %10
%403 = load i64, i64* %7
%404 = load i64, i64* %14
%405 = mul nsw i64 %403, %404
%406 = load i64, i64* %19
%407 = add nsw i64 %405, %406
%408 = getelementptr inbounds double, double* %402, i64 %407
store double %401, double* %408
br label %409
409: ; preds = %398
%410 = load i64, i64* %19
%411 = add nsw i64 %410, 1
store i64 %411, i64* %19
br label %394
412: ; preds = %394
br label %491
413: ; preds = %378, %371
%414 = load i32*, i32** %8
%415 = load i64, i64* %17
%416 = getelementptr inbounds i32, i32* %414, i64 %415
%417 = load i32, i32* %416
%418 = load i32*, i32** %8
%419 = load i64, i64* %14
%420 = getelementptr inbounds i32, i32* %418, i64 %419
store i32 %417, i32* %420
%421 = load i32*, i32** %9
%422 = load i64, i64* %17
%423 = getelementptr inbounds i32, i32* %421, i64 %422
%424 = load i32, i32* %423
%425 = load i32*, i32** %9
%426 = load i64, i64* %14
%427 = getelementptr inbounds i32, i32* %425, i64 %426
store i32 %424, i32* %427
store i64 0, i64* %19
br label %428
428: ; preds = %448, %413
%429 = load i64, i64* %19
%430 = load i64, i64* %7
%431 = icmp slt i64 %429, %430
br i1 %431, label %432, label %451
432: ; preds = %428
%433 = load double*, double** %10
%434 = load i64, i64* %7
%435 = load i64, i64* %17
%436 = mul nsw i64 %434, %435
%437 = load i64, i64* %19
%438 = add nsw i64 %436, %437
%439 = getelementptr inbounds double, double* %433, i64 %438
%440 = load double, double* %439
%441 = load double*, double** %10
%442 = load i64, i64* %7
%443 = load i64, i64* %14
%444 = mul nsw i64 %442, %443
%445 = load i64, i64* %19
%446 = add nsw i64 %444, %445
%447 = getelementptr inbounds double, double* %441, i64 %446
store double %440, double* %447
br label %448
448: ; preds = %432
%449 = load i64, i64* %19
%450 = add nsw i64 %449, 1
store i64 %450, i64* %19
br label %428
451: ; preds = %428
%452 = load i64, i64* %17
store i64 %452, i64* %14
%453 = load i64, i64* %14
%454 = mul nsw i64 2, %453
%455 = add nsw i64 %454, 1
%456 = load i64, i64* %13
%457 = icmp sge i64 %455, %456
br i1 %457, label %458, label %486
458: ; preds = %451
%459 = load i32, i32* %11
%460 = load i32*, i32** %8
%461 = load i64, i64* %14
%462 = getelementptr inbounds i32, i32* %460, i64 %461
store i32 %459, i32* %462
%463 = load i32, i32* %12
%464 = load i32*, i32** %9
%465 = load i64, i64* %14
%466 = getelementptr inbounds i32, i32* %464, i64 %465
store i32 %463, i32* %466
store i64 0, i64* %19
br label %467
467: ; preds = %482, %458
%468 = load i64, i64* %19
%469 = load i64, i64* %7
%470 = icmp slt i64 %468, %469
br i1 %470, label %471, label %485
471: ; preds = %467
%472 = load i64, i64* %19
%473 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 %472
%474 = load double, double* %473
%475 = load double*, double** %10
%476 = load i64, i64* %7
%477 = load i64, i64* %14
%478 = mul nsw i64 %476, %477
%479 = load i64, i64* %19
%480 = add nsw i64 %478, %479
%481 = getelementptr inbounds double, double* %475, i64 %480
store double %474, double* %481
br label %482
482: ; preds = %471
%483 = load i64, i64* %19
%484 = add nsw i64 %483, 1
store i64 %484, i64* %19
br label %467
485: ; preds = %467
br label %491
486: ; preds = %451
br label %487
487: ; preds = %486
br label %488
488: ; preds = %487
%489 = load i64, i64* %18
%490 = add nsw i64 %489, 1
store i64 %490, i64* %18
br label %314
491: ; preds = %485, %412, %314
%492 = load i64, i64* %18
%493 = load i64, i64* %6
%494 = icmp eq i64 %492, %493
br i1 %494, label %495, label %497
495: ; preds = %491
%496 = call i32 @cdoAbort(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
br label %497
497: ; preds = %495, %491
br label %498
498: ; preds = %497
%499 = load i64, i64* %13
%500 = add nsw i64 %499, -1
store i64 %500, i64* %13
br label %251
501: ; preds = %251
%502 = load i32*, i32** %8
%503 = getelementptr inbounds i32, i32* %502, i64 1
%504 = load i32, i32* %503
store i32 %504, i32* %11
%505 = load i32*, i32** %8
%506 = getelementptr inbounds i32, i32* %505, i64 0
%507 = load i32, i32* %506
%508 = load i32*, i32** %8
%509 = getelementptr inbounds i32, i32* %508, i64 1
store i32 %507, i32* %509
%510 = load i32, i32* %11
%511 = load i32*, i32** %8
%512 = getelementptr inbounds i32, i32* %511, i64 0
store i32 %510, i32* %512
%513 = load i32*, i32** %9
%514 = getelementptr inbounds i32, i32* %513, i64 1
%515 = load i32, i32* %514
store i32 %515, i32* %12
%516 = load i32*, i32** %9
%517 = getelementptr inbounds i32, i32* %516, i64 0
%518 = load i32, i32* %517
%519 = load i32*, i32** %9
%520 = getelementptr inbounds i32, i32* %519, i64 1
store i32 %518, i32* %520
%521 = load i32, i32* %12
%522 = load i32*, i32** %9
%523 = getelementptr inbounds i32, i32* %522, i64 0
store i32 %521, i32* %523
store i64 0, i64* %19
br label %524
524: ; preds = %537, %501
%525 = load i64, i64* %19
%526 = load i64, i64* %7
%527 = icmp slt i64 %525, %526
br i1 %527, label %528, label %540
528: ; preds = %524
%529 = load double*, double** %10
%530 = load i64, i64* %7
%531 = load i64, i64* %19
%532 = add nsw i64 %530, %531
%533 = getelementptr inbounds double, double* %529, i64 %532
%534 = load double, double* %533
%535 = load i64, i64* %19
%536 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 %535
store double %534, double* %536
br label %537
537: ; preds = %528
%538 = load i64, i64* %19
%539 = add nsw i64 %538, 1
store i64 %539, i64* %19
br label %524
540: ; preds = %524
store i64 0, i64* %19
br label %541
541: ; preds = %555, %540
%542 = load i64, i64* %19
%543 = load i64, i64* %7
%544 = icmp slt i64 %542, %543
br i1 %544, label %545, label %558
545: ; preds = %541
%546 = load double*, double** %10
%547 = load i64, i64* %19
%548 = getelementptr inbounds double, double* %546, i64 %547
%549 = load double, double* %548
%550 = load double*, double** %10
%551 = load i64, i64* %7
%552 = load i64, i64* %19
%553 = add nsw i64 %551, %552
%554 = getelementptr inbounds double, double* %550, i64 %553
store double %549, double* %554
br label %555
555: ; preds = %545
%556 = load i64, i64* %19
%557 = add nsw i64 %556, 1
store i64 %557, i64* %19
br label %541
558: ; preds = %541
store i64 0, i64* %19
br label %559
559: ; preds = %570, %558
%560 = load i64, i64* %19
%561 = load i64, i64* %7
%562 = icmp slt i64 %560, %561
br i1 %562, label %563, label %573
563: ; preds = %559
%564 = load i64, i64* %19
%565 = getelementptr inbounds [4 x double], [4 x double]* %20, i64 0, i64 %564
%566 = load double, double* %565
%567 = load double*, double** %10
%568 = load i64, i64* %19
%569 = getelementptr inbounds double, double* %567, i64 %568
store double %566, double* %569
br label %570
570: ; preds = %563
%571 = load i64, i64* %19
%572 = add nsw i64 %571, 1
store i64 %572, i64* %19
br label %559
573: ; preds = %23, %559
ret void
}

LLVM IR (-O2):
@.str = [36 x i8] c"Internal problem, link 1 not found!\00"
@.str.1 = [36 x i8] c"Internal problem, link 2 not found!\00"
define void @sort_add_orig(i64 %0, i64 %1, i32* noalias nocapture %2, i32* noalias nocapture %3, double* noalias nocapture %4) {
%6 = bitcast double* %4 to i8*
%7 = alloca [4 x double]
%8 = bitcast [4 x double]* %7 to i8*
%9 = icmp slt i64 %0, 2
br i1 %9, label %682, label %10
10: ; preds = %5
%11 = lshr i64 %0, 1
%12 = icmp sgt i64 %1, 0
%13 = add nsw i64 %0, -1
%14 = shl nuw i64 %1, 3
%15 = add i64 %1, -4
%16 = lshr i64 %15, 2
%17 = add nuw nsw i64 %16, 1
%18 = icmp ult i64 %1, 4
%19 = and i64 %1, -4
%20 = and i64 %17, 1
%21 = icmp ult i64 %15, 4
%22 = and i64 %17, 9223372036854775806
%23 = icmp eq i64 %20, 0
%24 = icmp eq i64 %19, %1
%25 = and i64 %1, 3
%26 = icmp eq i64 %25, 0
br label %55
27: ; preds = %249
%28 = icmp sgt i64 %0, 2
br i1 %28, label %29, label %575
29: ; preds = %27
%30 = icmp sgt i64 %1, 0
%31 = shl nuw i64 %1, 3
%32 = add nsw i64 %0, -2
%33 = add i64 %0, -1
%34 = mul i64 %33, %1
%35 = mul i64 %1, %0
%36 = getelementptr double, double* %4, i64 %1
%37 = icmp ult i64 %1, 4
%38 = and i64 %1, -4
%39 = and i64 %17, 3
%40 = icmp ult i64 %15, 12
%41 = and i64 %17, 9223372036854775804
%42 = icmp eq i64 %39, 0
%43 = icmp eq i64 %38, %1
%44 = and i64 %1, 3
%45 = icmp eq i64 %44, 0
%46 = icmp ult i64 %1, 4
%47 = and i64 %1, -4
%48 = and i64 %17, 1
%49 = icmp ult i64 %15, 4
%50 = and i64 %17, 9223372036854775806
%51 = icmp eq i64 %48, 0
%52 = icmp eq i64 %47, %1
%53 = and i64 %1, 3
%54 = icmp eq i64 %53, 0
br label %252
55: ; preds = %10, %249
%56 = phi i64 [ 0, %10 ], [ %251, %249 ]
%57 = phi i64 [ %11, %10 ], [ %58, %249 ]
%58 = add nsw i64 %57, -1
%59 = getelementptr inbounds i32, i32* %2, i64 %58
%60 = load i32, i32* %59
%61 = getelementptr inbounds i32, i32* %3, i64 %58
%62 = load i32, i32* %61
br i1 %12, label %63, label %69
63: ; preds = %55
%64 = xor i64 %56, -1
%65 = add nsw i64 %11, %64
%66 = mul i64 %65, %1
%67 = getelementptr double, double* %4, i64 %66
%68 = bitcast double* %67 to i8*
br label %69
69: ; preds = %55, %63
br label %70
70: ; preds = %69, %242
%71 = phi i64 [ %243, %242 ], [ 0, %69 ]
%72 = phi i64 [ %94, %242 ], [ %58, %69 ]
%73 = shl nsw i64 %72, 1
%74 = or i64 %73, 1
%75 = add nsw i64 %73, 2
%76 = icmp eq i64 %74, %13
%77 = select i1 %76, i64 %74, i64 %75
%78 = getelementptr inbounds i32, i32* %2, i64 %74
%79 = load i32, i32* %78
%80 = getelementptr inbounds i32, i32* %2, i64 %77
%81 = load i32, i32* %80
%82 = icmp sgt i32 %79, %81
br i1 %82, label %92, label %83
83: ; preds = %70
%84 = icmp eq i32 %79, %81
br i1 %84, label %85, label %91
85: ; preds = %83
%86 = getelementptr inbounds i32, i32* %3, i64 %74
%87 = load i32, i32* %86
%88 = getelementptr inbounds i32, i32* %3, i64 %77
%89 = load i32, i32* %88
%90 = icmp sgt i32 %87, %89
br i1 %90, label %92, label %91
91: ; preds = %85, %83
br label %92
92: ; preds = %70, %85, %91
%93 = phi i32 [ %81, %91 ], [ %79, %85 ], [ %79, %70 ]
%94 = phi i64 [ %77, %91 ], [ %74, %85 ], [ %74, %70 ]
%95 = icmp sgt i32 %60, %93
br i1 %95, label %102, label %96
96: ; preds = %92
%97 = icmp eq i32 %60, %93
%98 = getelementptr inbounds i32, i32* %3, i64 %94
%99 = load i32, i32* %98
%100 = icmp sgt i32 %62, %99
%101 = select i1 %97, i1 %100, i1 false
br i1 %101, label %102, label %109
102: ; preds = %96, %92
%103 = getelementptr inbounds i32, i32* %2, i64 %72
store i32 %60, i32* %103
%104 = getelementptr inbounds i32, i32* %3, i64 %72
store i32 %62, i32* %104
br i1 %12, label %105, label %245
105: ; preds = %102
%106 = mul nsw i64 %72, %1
%107 = getelementptr double, double* %4, i64 %106
%108 = bitcast double* %107 to i8*
br label %245
109: ; preds = %96
%110 = getelementptr inbounds i32, i32* %2, i64 %72
store i32 %93, i32* %110
%111 = getelementptr inbounds i32, i32* %3, i64 %72
store i32 %99, i32* %111
br i1 %12, label %112, label %228
112: ; preds = %109
%113 = mul nsw i64 %94, %1
%114 = mul nsw i64 %72, %1
br i1 %18, label %179, label %115
115: ; preds = %112
%116 = getelementptr double, double* %4, i64 %114
%117 = bitcast double* %116 to i8*
%118 = shl i64 %72, 3
%119 = add i64 %118, 8
%120 = mul i64 %119, %1
%121 = getelementptr i8, i8* %6, i64 %120
%122 = getelementptr double, double* %4, i64 %113
%123 = bitcast double* %122 to i8*
%124 = shl i64 %94, 3
%125 = add i64 %124, 8
%126 = mul i64 %125, %1
%127 = getelementptr i8, i8* %6, i64 %126
%128 = icmp ugt i8* %127, %117
%129 = icmp ugt i8* %121, %123
%130 = and i1 %128, %129
br i1 %130, label %179, label %131
131: ; preds = %115
br i1 %21, label %163, label %132
132: ; preds = %131, %132
%133 = phi i64 [ %160, %132 ], [ 0, %131 ]
%134 = phi i64 [ %161, %132 ], [ 0, %131 ]
%135 = add nsw i64 %133, %113
%136 = getelementptr inbounds double, double* %4, i64 %135
%137 = bitcast double* %136 to <2 x double>*
%138 = load <2 x double>, <2 x double>* %137
%139 = getelementptr inbounds double, double* %136, i64 2
%140 = bitcast double* %139 to <2 x double>*
%141 = load <2 x double>, <2 x double>* %140
%142 = add nsw i64 %133, %114
%143 = getelementptr inbounds double, double* %4, i64 %142
%144 = bitcast double* %143 to <2 x double>*
store <2 x double> %138, <2 x double>* %144
%145 = getelementptr inbounds double, double* %143, i64 2
%146 = bitcast double* %145 to <2 x double>*
store <2 x double> %141, <2 x double>* %146
%147 = or i64 %133, 4
%148 = add nsw i64 %147, %113
%149 = getelementptr inbounds double, double* %4, i64 %148
%150 = bitcast double* %149 to <2 x double>*
%151 = load <2 x double>, <2 x double>* %150
%152 = getelementptr inbounds double, double* %149, i64 2
%153 = bitcast double* %152 to <2 x double>*
%154 = load <2 x double>, <2 x double>* %153
%155 = add nsw i64 %147, %114
%156 = getelementptr inbounds double, double* %4, i64 %155
%157 = bitcast double* %156 to <2 x double>*
store <2 x double> %151, <2 x double>* %157
%158 = getelementptr inbounds double, double* %156, i64 2
%159 = bitcast double* %158 to <2 x double>*
store <2 x double> %154, <2 x double>* %159
%160 = add nuw i64 %133, 8
%161 = add i64 %134, 2
%162 = icmp eq i64 %161, %22
br i1 %162, label %163, label %132
163: ; preds = %132, %131
%164 = phi i64 [ 0, %131 ], [ %160, %132 ]
br i1 %23, label %178, label %165
165: ; preds = %163
%166 = add nsw i64 %164, %113
%167 = getelementptr inbounds double, double* %4, i64 %166
%168 = bitcast double* %167 to <2 x double>*
%169 = load <2 x double>, <2 x double>* %168
%170 = getelementptr inbounds double, double* %167, i64 2
%171 = bitcast double* %170 to <2 x double>*
%172 = load <2 x double>, <2 x double>* %171
%173 = add nsw i64 %164, %114
%174 = getelementptr inbounds double, double* %4, i64 %173
%175 = bitcast double* %174 to <2 x double>*
store <2 x double> %169, <2 x double>* %175
%176 = getelementptr inbounds double, double* %174, i64 2
%177 = bitcast double* %176 to <2 x double>*
store <2 x double> %172, <2 x double>* %177
br label %178
178: ; preds = %163, %165
br i1 %24, label %224, label %179
179: ; preds = %115, %112, %178
%180 = phi i64 [ 0, %115 ], [ 0, %112 ], [ %19, %178 ]
%181 = xor i64 %180, -1
%182 = add i64 %181, %1
br i1 %26, label %194, label %183
183: ; preds = %179, %183
%184 = phi i64 [ %191, %183 ], [ %180, %179 ]
%185 = phi i64 [ %192, %183 ], [ 0, %179 ]
%186 = add nsw i64 %184, %113
%187 = getelementptr inbounds double, double* %4, i64 %186
%188 = load double, double* %187
%189 = add nsw i64 %184, %114
%190 = getelementptr inbounds double, double* %4, i64 %189
store double %188, double* %190
%191 = add nuw nsw i64 %184, 1
%192 = add i64 %185, 1
%193 = icmp eq i64 %192, %25
br i1 %193, label %194, label %183
194: ; preds = %183, %179
%195 = phi i64 [ %180, %179 ], [ %191, %183 ]
%196 = icmp ult i64 %182, 3
br i1 %196, label %224, label %197
197: ; preds = %194, %197
%198 = phi i64 [ %222, %197 ], [ %195, %194 ]
%199 = add nsw i64 %198, %113
%200 = getelementptr inbounds double, double* %4, i64 %199
%201 = load double, double* %200
%202 = add nsw i64 %198, %114
%203 = getelementptr inbounds double, double* %4, i64 %202
store double %201, double* %203
%204 = add nuw nsw i64 %198, 1
%205 = add nsw i64 %204, %113
%206 = getelementptr inbounds double, double* %4, i64 %205
%207 = load double, double* %206
%208 = add nsw i64 %204, %114
%209 = getelementptr inbounds double, double* %4, i64 %208
store double %207, double* %209
%210 = add nuw nsw i64 %198, 2
%211 = add nsw i64 %210, %113
%212 = getelementptr inbounds double, double* %4, i64 %211
%213 = load double, double* %212
%214 = add nsw i64 %210, %114
%215 = getelementptr inbounds double, double* %4, i64 %214
store double %213, double* %215
%216 = add nuw nsw i64 %198, 3
%217 = add nsw i64 %216, %113
%218 = getelementptr inbounds double, double* %4, i64 %217
%219 = load double, double* %218
%220 = add nsw i64 %216, %114
%221 = getelementptr inbounds double, double* %4, i64 %220
store double %219, double* %221
%222 = add nuw nsw i64 %198, 4
%223 = icmp eq i64 %222, %1
br i1 %223, label %224, label %197
224: ; preds = %194, %197, %178
%225 = shl nsw i64 %94, 1
%226 = or i64 %225, 1
%227 = icmp slt i64 %226, %0
br i1 %227, label %242, label %235
228: ; preds = %109
%229 = shl nsw i64 %94, 1
%230 = or i64 %229, 1
%231 = icmp slt i64 %230, %0
br i1 %231, label %242, label %232
232: ; preds = %228
%233 = getelementptr inbounds i32, i32* %2, i64 %94
%234 = getelementptr inbounds i32, i32* %3, i64 %94
store i32 %60, i32* %233
store i32 %62, i32* %234
br label %245
235: ; preds = %224
%236 = getelementptr inbounds i32, i32* %2, i64 %94
%237 = getelementptr inbounds i32, i32* %3, i64 %94
store i32 %60, i32* %236
store i32 %62, i32* %237
br i1 %12, label %238, label %245
238: ; preds = %235
%239 = mul nsw i64 %94, %1
%240 = getelementptr double, double* %4, i64 %239
%241 = bitcast double* %240 to i8*
br label %245
242: ; preds = %228, %224
%243 = add nuw nsw i64 %71, 1
%244 = icmp eq i64 %243, %0
br i1 %244, label %247, label %70
245: ; preds = %232, %238, %105, %235, %102
%246 = icmp eq i64 %71, %0
br i1 %246, label %247, label %249
247: ; preds = %242, %245
%248 = tail call i32 @cdoAbort(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str, i64 0, i64 0))
br label %249
249: ; preds = %245, %247
%250 = icmp sgt i64 %57, 1
%251 = add nuw nsw i64 %56, 1
br i1 %250, label %55, label %27
252: ; preds = %29, %572
%253 = phi i64 [ 0, %29 ], [ %573, %572 ]
%254 = phi i64 [ %0, %29 ], [ %260, %572 ]
%255 = mul i64 %253, %1
%256 = sub i64 %34, %255
%257 = getelementptr double, double* %4, i64 %256
%258 = sub i64 %35, %255
%259 = getelementptr double, double* %4, i64 %258
%260 = add nsw i64 %254, -1
%261 = getelementptr inbounds i32, i32* %2, i64 %260
%262 = load i32, i32* %261
%263 = load i32, i32* %2
store i32 %263, i32* %261
%264 = getelementptr inbounds i32, i32* %3, i64 %260
%265 = load i32, i32* %264
%266 = load i32, i32* %3
store i32 %266, i32* %264
br i1 %30, label %267, label %392
267: ; preds = %252
%268 = xor i64 %253, -1
%269 = add i64 %268, %0
%270 = mul i64 %269, %1
%271 = getelementptr double, double* %4, i64 %270
%272 = bitcast double* %271 to i8*
%273 = mul nsw i64 %260, %1
br i1 %37, label %352, label %274
274: ; preds = %267
%275 = icmp ult double* %257, %36
%276 = icmp ugt double* %259, %4
%277 = and i1 %275, %276
br i1 %277, label %352, label %278
278: ; preds = %274
br i1 %40, label %332, label %279
279: ; preds = %278, %279
%280 = phi i64 [ %329, %279 ], [ 0, %278 ]
%281 = phi i64 [ %330, %279 ], [ 0, %278 ]
%282 = getelementptr inbounds double, double* %4, i64 %280
%283 = bitcast double* %282 to <2 x double>*
%284 = load <2 x double>, <2 x double>* %283
%285 = getelementptr inbounds double, double* %282, i64 2
%286 = bitcast double* %285 to <2 x double>*
%287 = load <2 x double>, <2 x double>* %286
%288 = add nsw i64 %280, %273
%289 = getelementptr inbounds double, double* %4, i64 %288
%290 = bitcast double* %289 to <2 x double>*
store <2 x double> %284, <2 x double>* %290
%291 = getelementptr inbounds double, double* %289, i64 2
%292 = bitcast double* %291 to <2 x double>*
store <2 x double> %287, <2 x double>* %292
%293 = or i64 %280, 4
%294 = getelementptr inbounds double, double* %4, i64 %293
%295 = bitcast double* %294 to <2 x double>*
%296 = load <2 x double>, <2 x double>* %295
%297 = getelementptr inbounds double, double* %294, i64 2
%298 = bitcast double* %297 to <2 x double>*
%299 = load <2 x double>, <2 x double>* %298
%300 = add nsw i64 %293, %273
%301 = getelementptr inbounds double, double* %4, i64 %300
%302 = bitcast double* %301 to <2 x double>*
store <2 x double> %296, <2 x double>* %302
%303 = getelementptr inbounds double, double* %301, i64 2
%304 = bitcast double* %303 to <2 x double>*
store <2 x double> %299, <2 x double>* %304
%305 = or i64 %280, 8
%306 = getelementptr inbounds double, double* %4, i64 %305
%307 = bitcast double* %306 to <2 x double>*
%308 = load <2 x double>, <2 x double>* %307
%309 = getelementptr inbounds double, double* %306, i64 2
%310 = bitcast double* %309 to <2 x double>*
%311 = load <2 x double>, <2 x double>* %310
%312 = add nsw i64 %305, %273
%313 = getelementptr inbounds double, double* %4, i64 %312
%314 = bitcast double* %313 to <2 x double>*
store <2 x double> %308, <2 x double>* %314
%315 = getelementptr inbounds double, double* %313, i64 2
%316 = bitcast double* %315 to <2 x double>*
store <2 x double> %311, <2 x double>* %316
%317 = or i64 %280, 12
%318 = getelementptr inbounds double, double* %4, i64 %317
%319 = bitcast double* %318 to <2 x double>*
%320 = load <2 x double>, <2 x double>* %319
%321 = getelementptr inbounds double, double* %318, i64 2
%322 = bitcast double* %321 to <2 x double>*
%323 = load <2 x double>, <2 x double>* %322
%324 = add nsw i64 %317, %273
%325 = getelementptr inbounds double, double* %4, i64 %324
%326 = bitcast double* %325 to <2 x double>*
store <2 x double> %320, <2 x double>* %326
%327 = getelementptr inbounds double, double* %325, i64 2
%328 = bitcast double* %327 to <2 x double>*
store <2 x double> %323, <2 x double>* %328
%329 = add nuw i64 %280, 16
%330 = add nuw i64 %281, 4
%331 = icmp eq i64 %330, %41
br i1 %331, label %332, label %279
332: ; preds = %279, %278
%333 = phi i64 [ 0, %278 ], [ %329, %279 ]
br i1 %42, label %351, label %334
334: ; preds = %332, %334
%335 = phi i64 [ %348, %334 ], [ %333, %332 ]
%336 = phi i64 [ %349, %334 ], [ 0, %332 ]
%337 = getelementptr inbounds double, double* %4, i64 %335
%338 = bitcast double* %337 to <2 x double>*
%339 = load <2 x double>, <2 x double>* %338
%340 = getelementptr inbounds double, double* %337, i64 2
%341 = bitcast double* %340 to <2 x double>*
%342 = load <2 x double>, <2 x double>* %341
%343 = add nsw i64 %335, %273
%344 = getelementptr inbounds double, double* %4, i64 %343
%345 = bitcast double* %344 to <2 x double>*
store <2 x double> %339, <2 x double>* %345
%346 = getelementptr inbounds double, double* %344, i64 2
%347 = bitcast double* %346 to <2 x double>*
store <2 x double> %342, <2 x double>* %347
%348 = add nuw i64 %335, 4
%349 = add i64 %336, 1
%350 = icmp eq i64 %349, %39
br i1 %350, label %351, label %334
351: ; preds = %334, %332
br i1 %43, label %392, label %352
352: ; preds = %274, %267, %351
%353 = phi i64 [ 0, %274 ], [ 0, %267 ], [ %38, %351 ]
%354 = xor i64 %353, -1
%355 = add i64 %354, %1
br i1 %45, label %366, label %356
356: ; preds = %352, %356
%357 = phi i64 [ %363, %356 ], [ %353, %352 ]
%358 = phi i64 [ %364, %356 ], [ 0, %352 ]
%359 = getelementptr inbounds double, double* %4, i64 %357
%360 = load double, double* %359
%361 = add nsw i64 %357, %273
%362 = getelementptr inbounds double, double* %4, i64 %361
store double %360, double* %362
%363 = add nuw nsw i64 %357, 1
%364 = add i64 %358, 1
%365 = icmp eq i64 %364, %44
br i1 %365, label %366, label %356
366: ; preds = %356, %352
%367 = phi i64 [ %353, %352 ], [ %363, %356 ]
%368 = icmp ult i64 %355, 3
br i1 %368, label %392, label %369
369: ; preds = %366, %369
%370 = phi i64 [ %390, %369 ], [ %367, %366 ]
%371 = getelementptr inbounds double, double* %4, i64 %370
%372 = load double, double* %371
%373 = add nsw i64 %370, %273
%374 = getelementptr inbounds double, double* %4, i64 %373
store double %372, double* %374
%375 = add nuw nsw i64 %370, 1
%376 = getelementptr inbounds double, double* %4, i64 %375
%377 = load double, double* %376
%378 = add nsw i64 %375, %273
%379 = getelementptr inbounds double, double* %4, i64 %378
store double %377, double* %379
%380 = add nuw nsw i64 %370, 2
%381 = getelementptr inbounds double, double* %4, i64 %380
%382 = load double, double* %381
%383 = add nsw i64 %380, %273
%384 = getelementptr inbounds double, double* %4, i64 %383
store double %382, double* %384
%385 = add nuw nsw i64 %370, 3
%386 = getelementptr inbounds double, double* %4, i64 %385
%387 = load double, double* %386
%388 = add nsw i64 %385, %273
%389 = getelementptr inbounds double, double* %4, i64 %388
store double %387, double* %389
%390 = add nuw nsw i64 %370, 4
%391 = icmp eq i64 %390, %1
br i1 %391, label %392, label %369
392: ; preds = %366, %369, %351, %252
br label %393
393: ; preds = %392, %565
%394 = phi i64 [ %566, %565 ], [ 0, %392 ]
%395 = phi i64 [ %417, %565 ], [ 0, %392 ]
%396 = shl nsw i64 %395, 1
%397 = or i64 %396, 1
%398 = add nsw i64 %396, 2
%399 = icmp slt i64 %398, %260
%400 = select i1 %399, i64 %398, i64 %397
%401 = getelementptr inbounds i32, i32* %2, i64 %397
%402 = load i32, i32* %401
%403 = getelementptr inbounds i32, i32* %2, i64 %400
%404 = load i32, i32* %403
%405 = icmp sgt i32 %402, %404
br i1 %405, label %415, label %406
406: ; preds = %393
%407 = icmp eq i32 %402, %404
br i1 %407, label %408, label %414
408: ; preds = %406
%409 = getelementptr inbounds i32, i32* %3, i64 %397
%410 = load i32, i32* %409
%411 = getelementptr inbounds i32, i32* %3, i64 %400
%412 = load i32, i32* %411
%413 = icmp sgt i32 %410, %412
br i1 %413, label %415, label %414
414: ; preds = %408, %406
br label %415
415: ; preds = %393, %408, %414
%416 = phi i32 [ %404, %414 ], [ %402, %408 ], [ %402, %393 ]
%417 = phi i64 [ %400, %414 ], [ %397, %408 ], [ %397, %393 ]
%418 = icmp sgt i32 %262, %416
br i1 %418, label %425, label %419
419: ; preds = %415
%420 = icmp eq i32 %262, %416
%421 = getelementptr inbounds i32, i32* %3, i64 %417
%422 = load i32, i32* %421
%423 = icmp sgt i32 %265, %422
%424 = select i1 %420, i1 %423, i1 false
br i1 %424, label %425, label %432
425: ; preds = %419, %415
%426 = getelementptr inbounds i32, i32* %2, i64 %395
store i32 %262, i32* %426
%427 = getelementptr inbounds i32, i32* %3, i64 %395
store i32 %265, i32* %427
br i1 %30, label %428, label %568
428: ; preds = %425
%429 = mul nsw i64 %395, %1
%430 = getelementptr double, double* %4, i64 %429
%431 = bitcast double* %430 to i8*
br label %568
432: ; preds = %419
%433 = getelementptr inbounds i32, i32* %2, i64 %395
store i32 %416, i32* %433
%434 = getelementptr inbounds i32, i32* %3, i64 %395
store i32 %422, i32* %434
br i1 %30, label %435, label %551
435: ; preds = %432
%436 = mul nsw i64 %417, %1
%437 = mul nsw i64 %395, %1
br i1 %46, label %502, label %438
438: ; preds = %435
%439 = getelementptr double, double* %4, i64 %437
%440 = bitcast double* %439 to i8*
%441 = shl i64 %395, 3
%442 = add i64 %441, 8
%443 = mul i64 %442, %1
%444 = getelementptr i8, i8* %6, i64 %443
%445 = getelementptr double, double* %4, i64 %436
%446 = bitcast double* %445 to i8*
%447 = shl i64 %417, 3
%448 = add i64 %447, 8
%449 = mul i64 %448, %1
%450 = getelementptr i8, i8* %6, i64 %449
%451 = icmp ugt i8* %450, %440
%452 = icmp ugt i8* %444, %446
%453 = and i1 %451, %452
br i1 %453, label %502, label %454
454: ; preds = %438
br i1 %49, label %486, label %455
455: ; preds = %454, %455
%456 = phi i64 [ %483, %455 ], [ 0, %454 ]
%457 = phi i64 [ %484, %455 ], [ 0, %454 ]
%458 = add nsw i64 %456, %436
%459 = getelementptr inbounds double, double* %4, i64 %458
%460 = bitcast double* %459 to <2 x double>*
%461 = load <2 x double>, <2 x double>* %460
%462 = getelementptr inbounds double, double* %459, i64 2
%463 = bitcast double* %462 to <2 x double>*
%464 = load <2 x double>, <2 x double>* %463
%465 = add nsw i64 %456, %437
%466 = getelementptr inbounds double, double* %4, i64 %465
%467 = bitcast double* %466 to <2 x double>*
store <2 x double> %461, <2 x double>* %467
%468 = getelementptr inbounds double, double* %466, i64 2
%469 = bitcast double* %468 to <2 x double>*
store <2 x double> %464, <2 x double>* %469
%470 = or i64 %456, 4
%471 = add nsw i64 %470, %436
%472 = getelementptr inbounds double, double* %4, i64 %471
%473 = bitcast double* %472 to <2 x double>*
%474 = load <2 x double>, <2 x double>* %473
%475 = getelementptr inbounds double, double* %472, i64 2
%476 = bitcast double* %475 to <2 x double>*
%477 = load <2 x double>, <2 x double>* %476
%478 = add nsw i64 %470, %437
%479 = getelementptr inbounds double, double* %4, i64 %478
%480 = bitcast double* %479 to <2 x double>*
store <2 x double> %474, <2 x double>* %480
%481 = getelementptr inbounds double, double* %479, i64 2
%482 = bitcast double* %481 to <2 x double>*
store <2 x double> %477, <2 x double>* %482
%483 = add nuw i64 %456, 8
%484 = add i64 %457, 2
%485 = icmp eq i64 %484, %50
br i1 %485, label %486, label %455
486: ; preds = %455, %454
%487 = phi i64 [ 0, %454 ], [ %483, %455 ]
br i1 %51, label %501, label %488
488: ; preds = %486
%489 = add nsw i64 %487, %436
%490 = getelementptr inbounds double, double* %4, i64 %489
%491 = bitcast double* %490 to <2 x double>*
%492 = load <2 x double>, <2 x double>* %491
%493 = getelementptr inbounds double, double* %490, i64 2
%494 = bitcast double* %493 to <2 x double>*
%495 = load <2 x double>, <2 x double>* %494
%496 = add nsw i64 %487, %437
%497 = getelementptr inbounds double, double* %4, i64 %496
%498 = bitcast double* %497 to <2 x double>*
store <2 x double> %492, <2 x double>* %498
%499 = getelementptr inbounds double, double* %497, i64 2
%500 = bitcast double* %499 to <2 x double>*
store <2 x double> %495, <2 x double>* %500
br label %501
501: ; preds = %486, %488
br i1 %52, label %547, label %502
502: ; preds = %438, %435, %501
%503 = phi i64 [ 0, %438 ], [ 0, %435 ], [ %47, %501 ]
%504 = xor i64 %503, -1
%505 = add i64 %504, %1
br i1 %54, label %517, label %506
506: ; preds = %502, %506
%507 = phi i64 [ %514, %506 ], [ %503, %502 ]
%508 = phi i64 [ %515, %506 ], [ 0, %502 ]
%509 = add nsw i64 %507, %436
%510 = getelementptr inbounds double, double* %4, i64 %509
%511 = load double, double* %510
%512 = add nsw i64 %507, %437
%513 = getelementptr inbounds double, double* %4, i64 %512
store double %511, double* %513
%514 = add nuw nsw i64 %507, 1
%515 = add i64 %508, 1
%516 = icmp eq i64 %515, %53
br i1 %516, label %517, label %506
517: ; preds = %506, %502
%518 = phi i64 [ %503, %502 ], [ %514, %506 ]
%519 = icmp ult i64 %505, 3
br i1 %519, label %547, label %520
520: ; preds = %517, %520
%521 = phi i64 [ %545, %520 ], [ %518, %517 ]
%522 = add nsw i64 %521, %436
%523 = getelementptr inbounds double, double* %4, i64 %522
%524 = load double, double* %523
%525 = add nsw i64 %521, %437
%526 = getelementptr inbounds double, double* %4, i64 %525
store double %524, double* %526
%527 = add nuw nsw i64 %521, 1
%528 = add nsw i64 %527, %436
%529 = getelementptr inbounds double, double* %4, i64 %528
%530 = load double, double* %529
%531 = add nsw i64 %527, %437
%532 = getelementptr inbounds double, double* %4, i64 %531
store double %530, double* %532
%533 = add nuw nsw i64 %521, 2
%534 = add nsw i64 %533, %436
%535 = getelementptr inbounds double, double* %4, i64 %534
%536 = load double, double* %535
%537 = add nsw i64 %533, %437
%538 = getelementptr inbounds double, double* %4, i64 %537
store double %536, double* %538
%539 = add nuw nsw i64 %521, 3
%540 = add nsw i64 %539, %436
%541 = getelementptr inbounds double, double* %4, i64 %540
%542 = load double, double* %541
%543 = add nsw i64 %539, %437
%544 = getelementptr inbounds double, double* %4, i64 %543
store double %542, double* %544
%545 = add nuw nsw i64 %521, 4
%546 = icmp eq i64 %545, %1
br i1 %546, label %547, label %520
547: ; preds = %517, %520, %501
%548 = shl nsw i64 %417, 1
%549 = or i64 %548, 1
%550 = icmp slt i64 %549, %260
br i1 %550, label %565, label %558
551: ; preds = %432
%552 = shl nsw i64 %417, 1
%553 = or i64 %552, 1
%554 = icmp slt i64 %553, %260
br i1 %554, label %565, label %555
555: ; preds = %551
%556 = getelementptr inbounds i32, i32* %2, i64 %417
%557 = getelementptr inbounds i32, i32* %3, i64 %417
store i32 %262, i32* %556
store i32 %265, i32* %557
br label %568
558: ; preds = %547
%559 = getelementptr inbounds i32, i32* %2, i64 %417
%560 = getelementptr inbounds i32, i32* %3, i64 %417
store i32 %262, i32* %559
store i32 %265, i32* %560
br i1 %30, label %561, label %568
561: ; preds = %558
%562 = mul nsw i64 %417, %1
%563 = getelementptr double, double* %4, i64 %562
%564 = bitcast double* %563 to i8*
br label %568
565: ; preds = %551, %547
%566 = add nuw nsw i64 %394, 1
%567 = icmp eq i64 %566, %0
br i1 %567, label %570, label %393
568: ; preds = %555, %561, %428, %558, %425
%569 = icmp eq i64 %394, %0
br i1 %569, label %570, label %572
570: ; preds = %565, %568
%571 = tail call i32 @cdoAbort(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.1, i64 0, i64 0))
br label %572
572: ; preds = %568, %570
%573 = add nuw nsw i64 %253, 1
%574 = icmp eq i64 %573, %32
br i1 %574, label %575, label %252
575: ; preds = %572, %27
%576 = getelementptr inbounds i32, i32* %2, i64 1
%577 = load i32, i32* %576
%578 = load i32, i32* %2
store i32 %578, i32* %576
store i32 %577, i32* %2
%579 = getelementptr inbounds i32, i32* %3, i64 1
%580 = load i32, i32* %579
%581 = load i32, i32* %3
store i32 %581, i32* %579
store i32 %580, i32* %3
%582 = icmp sgt i64 %1, 0
br i1 %582, label %583, label %682
583: ; preds = %575
%584 = getelementptr double, double* %4, i64 %1
%585 = bitcast double* %584 to i8*
%586 = shl nuw i64 %1, 3
%587 = icmp ult i64 %1, 4
br i1 %587, label %669, label %588
588: ; preds = %583
%589 = and i64 %1, -4
%590 = and i64 %17, 3
%591 = icmp ult i64 %15, 12
br i1 %591, label %647, label %592
592: ; preds = %588
%593 = and i64 %17, 9223372036854775804
br label %594
594: ; preds = %594, %592
%595 = phi i64 [ 0, %592 ], [ %644, %594 ]
%596 = phi i64 [ 0, %592 ], [ %645, %594 ]
%597 = getelementptr inbounds double, double* %4, i64 %595
%598 = bitcast double* %597 to <2 x double>*
%599 = load <2 x double>, <2 x double>* %598
%600 = getelementptr inbounds double, double* %597, i64 2
%601 = bitcast double* %600 to <2 x double>*
%602 = load <2 x double>, <2 x double>* %601
%603 = add nsw i64 %595, %1
%604 = getelementptr inbounds double, double* %4, i64 %603
%605 = bitcast double* %604 to <2 x double>*
store <2 x double> %599, <2 x double>* %605
%606 = getelementptr inbounds double, double* %604, i64 2
%607 = bitcast double* %606 to <2 x double>*
store <2 x double> %602, <2 x double>* %607
%608 = or i64 %595, 4
%609 = getelementptr inbounds double, double* %4, i64 %608
%610 = bitcast double* %609 to <2 x double>*
%611 = load <2 x double>, <2 x double>* %610
%612 = getelementptr inbounds double, double* %609, i64 2
%613 = bitcast double* %612 to <2 x double>*
%614 = load <2 x double>, <2 x double>* %613
%615 = add nsw i64 %608, %1
%616 = getelementptr inbounds double, double* %4, i64 %615
%617 = bitcast double* %616 to <2 x double>*
store <2 x double> %611, <2 x double>* %617
%618 = getelementptr inbounds double, double* %616, i64 2
%619 = bitcast double* %618 to <2 x double>*
store <2 x double> %614, <2 x double>* %619
%620 = or i64 %595, 8
%621 = getelementptr inbounds double, double* %4, i64 %620
%622 = bitcast double* %621 to <2 x double>*
%623 = load <2 x double>, <2 x double>* %622
%624 = getelementptr inbounds double, double* %621, i64 2
%625 = bitcast double* %624 to <2 x double>*
%626 = load <2 x double>, <2 x double>* %625
%627 = add nsw i64 %620, %1
%628 = getelementptr inbounds double, double* %4, i64 %627
%629 = bitcast double* %628 to <2 x double>*
store <2 x double> %623, <2 x double>* %629
%630 = getelementptr inbounds double, double* %628, i64 2
%631 = bitcast double* %630 to <2 x double>*
store <2 x double> %626, <2 x double>* %631
%632 = or i64 %595, 12
%633 = getelementptr inbounds double, double* %4, i64 %632
%634 = bitcast double* %633 to <2 x double>*
%635 = load <2 x double>, <2 x double>* %634
%636 = getelementptr inbounds double, double* %633, i64 2
%637 = bitcast double* %636 to <2 x double>*
%638 = load <2 x double>, <2 x double>* %637
%639 = add nsw i64 %632, %1
%640 = getelementptr inbounds double, double* %4, i64 %639
%641 = bitcast double* %640 to <2 x double>*
store <2 x double> %635, <2 x double>* %641
%642 = getelementptr inbounds double, double* %640, i64 2
%643 = bitcast double* %642 to <2 x double>*
store <2 x double> %638, <2 x double>* %643
%644 = add nuw i64 %595, 16
%645 = add nuw i64 %596, 4
%646 = icmp eq i64 %645, %593
br i1 %646, label %647, label %594
647: ; preds = %594, %588
%648 = phi i64 [ 0, %588 ], [ %644, %594 ]
%649 = icmp eq i64 %590, 0
br i1 %649, label %667, label %650
650: ; preds = %647, %650
%651 = phi i64 [ %664, %650 ], [ %648, %647 ]
%652 = phi i64 [ %665, %650 ], [ 0, %647 ]
%653 = getelementptr inbounds double, double* %4, i64 %651
%654 = bitcast double* %653 to <2 x double>*
%655 = load <2 x double>, <2 x double>* %654
%656 = getelementptr inbounds double, double* %653, i64 2
%657 = bitcast double* %656 to <2 x double>*
%658 = load <2 x double>, <2 x double>* %657
%659 = add nsw i64 %651, %1
%660 = getelementptr inbounds double, double* %4, i64 %659
%661 = bitcast double* %660 to <2 x double>*
store <2 x double> %655, <2 x double>* %661
%662 = getelementptr inbounds double, double* %660, i64 2
%663 = bitcast double* %662 to <2 x double>*
store <2 x double> %658, <2 x double>* %663
%664 = add nuw i64 %651, 4
%665 = add i64 %652, 1
%666 = icmp eq i64 %665, %590
br i1 %666, label %667, label %650
667: ; preds = %650, %647
%668 = icmp eq i64 %589, %1
br i1 %668, label %671, label %669
669: ; preds = %583, %667
%670 = phi i64 [ 0, %583 ], [ %589, %667 ]
br label %674
671: ; preds = %674, %667
br i1 %582, label %672, label %682
672: ; preds = %671
%673 = shl nuw i64 %1, 3
br label %682
674: ; preds = %669, %674
%675 = phi i64 [ %680, %674 ], [ %670, %669 ]
%676 = getelementptr inbounds double, double* %4, i64 %675
%677 = load double, double* %676
%678 = add nsw i64 %675, %1
%679 = getelementptr inbounds double, double* %4, i64 %678
store double %677, double* %679
%680 = add nuw nsw i64 %675, 1
%681 = icmp eq i64 %680, %1
br i1 %681, label %671, label %674
682: ; preds = %575, %672, %671, %5
ret void
}