#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 */
typedef scalar_t__ int64_t;

/* Variables and functions */
int /*<<< orphan*/ memcpy(scalar_t__ *, scalar_t__ *, int);
int /*<<< orphan*/ sorter_grail_merge_left(scalar_t__ *, int, int, int);
int /*<<< orphan*/ sorter_grail_merge_left_with_x_buf(scalar_t__ *, int, int,
                                                      int);
int /*<<< orphan*/ sorter_grail_merge_right(scalar_t__ *, int, int, int);
int /*<<< orphan*/ sorter_grail_rotate(scalar_t__ *, int, int);
int /*<<< orphan*/ sorter_grail_swap1(scalar_t__ *, scalar_t__ *);
void sorter_grail_build_blocks(int64_t *arr, int L, int K, int64_t *extbuf,
                               int LExtBuf) {
  int m, u, h, p0, p1, rest, restk, p, kbuf;
  kbuf = K < LExtBuf ? K : LExtBuf;
  while (kbuf & (kbuf - 1)) {
    kbuf &= kbuf - 1;
  }
  if (kbuf) {
    memcpy(extbuf, arr - kbuf, kbuf * sizeof(int64_t));
    for (m = 1; m < L; m += 2) {
      u = 0;
      if (((*(arr + (m - 1))) - (*(arr + m))) > 0) {
        u = 1;
      }
      arr[m - 3] = arr[m - 1 + u];
      arr[m - 2] = arr[m - u];
    }
    if (L % 2) {
      arr[L - 3] = arr[L - 1];
    }
    arr -= 2;
    for (h = 2; h < kbuf; h *= 2) {
      p0 = 0;
      p1 = L - 2 * h;
      while (p0 <= p1) {
        sorter_grail_merge_left_with_x_buf(arr + p0, h, h, -h);
        p0 += 2 * h;
      }
      rest = L - p0;
      if (rest > h) {
        sorter_grail_merge_left_with_x_buf(arr + p0, h, rest - h, -h);
      } else {
        for (; p0 < L; p0++) {
          arr[p0 - h] = arr[p0];
        }
      }
      arr -= h;
    }
    memcpy(arr + L, extbuf, kbuf * sizeof(int64_t));
  } else {
    for (m = 1; m < L; m += 2) {
      u = 0;
      if (((*(arr + (m - 1))) - (*(arr + m))) > 0) {
        u = 1;
      }
      sorter_grail_swap1(arr + (m - 3), arr + (m - 1 + u));
      sorter_grail_swap1(arr + (m - 2), arr + (m - u));
    }
    if (L % 2) {
      sorter_grail_swap1(arr + (L - 1), arr + (L - 3));
    }
    arr -= 2;
    h = 2;
  }
  for (; h < K; h *= 2) {
    p0 = 0;
    p1 = L - 2 * h;
    while (p0 <= p1) {
      sorter_grail_merge_left(arr + p0, h, h, -h);
      p0 += 2 * h;
    }
    rest = L - p0;
    if (rest > h) {
      sorter_grail_merge_left(arr + p0, h, rest - h, -h);
    } else {
      sorter_grail_rotate(arr + p0 - h, h, rest);
    }
    arr -= h;
  }
  restk = L % (2 * K);
  p = L - restk;
  if (restk <= K) {
    sorter_grail_rotate(arr + p, restk, K);
  } else {
    sorter_grail_merge_right(arr + p, K, restk - K, K);
  }
  while (p > 0) {
    p -= 2 * K;
    sorter_grail_merge_right(arr + p, K, K, K);
  }
}


x86 assembly (clang, -O0):
<sorter_grail_build_blocks>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1191 <sorter_grail_build_blocks+0x31>
mov    -0x10(%rbp),%eax
mov    %eax,-0x44(%rbp)
jmp    1197 <sorter_grail_build_blocks+0x37>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     11c2 <sorter_grail_build_blocks+0x62>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
and    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    119d <sorter_grail_build_blocks+0x3d>
cmpl   $0x0,-0x40(%rbp)
je     1402 <sorter_grail_build_blocks+0x2a2>
mov    -0x18(%rbp),%rdi
mov    -0x8(%rbp),%rsi
movslq -0x40(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1290 <sorter_grail_build_blocks+0x130>
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
movslq -0x20(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
cmp    $0x0,%rax
jle    123b <sorter_grail_build_blocks+0xdb>
movl   $0x1,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    11fa <sorter_grail_build_blocks+0x9a>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     12c6 <sorter_grail_build_blocks+0x166>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x8(%rbp)
movl   $0x2,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    13db <sorter_grail_build_blocks+0x27b>
movl   $0x0,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1336 <sorter_grail_build_blocks+0x1d6>
mov    -0x8(%rbp),%rdi
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x28(%rbp),%esi
mov    -0x28(%rbp),%edx
xor    %ecx,%ecx
sub    -0x28(%rbp),%ecx
call   1040 <sorter_grail_merge_left_with_x_buf@plt>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    12fa <sorter_grail_build_blocks+0x19a>
mov    -0xc(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jle    1372 <sorter_grail_build_blocks+0x212>
mov    -0x8(%rbp),%rdi
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x28(%rbp),%esi
mov    -0x34(%rbp),%edx
sub    -0x28(%rbp),%edx
xor    %ecx,%ecx
sub    -0x28(%rbp),%ecx
call   1040 <sorter_grail_merge_left_with_x_buf@plt>
jmp    13b3 <sorter_grail_build_blocks+0x253>
jmp    1377 <sorter_grail_build_blocks+0x217>
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13ae <sorter_grail_build_blocks+0x24e>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1377 <sorter_grail_build_blocks+0x217>
jmp    13b3 <sorter_grail_build_blocks+0x253>
mov    -0x28(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12d9 <sorter_grail_build_blocks+0x179>
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%rsi
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1060 <memcpy@plt>
jmp    1503 <sorter_grail_build_blocks+0x3a3>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14b1 <sorter_grail_build_blocks+0x351>
movl   $0x0,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
movslq -0x20(%rbp),%rdx
sub    (%rcx,%rdx,8),%rax
cmp    $0x0,%rax
jle    144a <sorter_grail_build_blocks+0x2ea>
movl   $0x1,-0x24(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%eax
sub    $0x3,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x20(%rbp),%eax
sub    $0x1,%eax
add    -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
call   1030 <sorter_grail_swap1@plt>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%eax
sub    $0x2,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0x20(%rbp),%eax
sub    -0x24(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
call   1030 <sorter_grail_swap1@plt>
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    1409 <sorter_grail_build_blocks+0x2a9>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     14f0 <sorter_grail_build_blocks+0x390>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x8(%rbp),%rsi
mov    -0xc(%rbp),%eax
sub    $0x3,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
call   1030 <sorter_grail_swap1@plt>
mov    -0x8(%rbp),%rax
add    $0xfffffffffffffff0,%rax
mov    %rax,-0x8(%rbp)
movl   $0x2,-0x28(%rbp)
jmp    1508 <sorter_grail_build_blocks+0x3a8>
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15f3 <sorter_grail_build_blocks+0x493>
movl   $0x0,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
sub    %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     1565 <sorter_grail_build_blocks+0x405>
mov    -0x8(%rbp),%rdi
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x28(%rbp),%esi
mov    -0x28(%rbp),%edx
xor    %ecx,%ecx
sub    -0x28(%rbp),%ecx
call   1070 <sorter_grail_merge_left@plt>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
jmp    1529 <sorter_grail_build_blocks+0x3c9>
mov    -0xc(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jle    15a1 <sorter_grail_build_blocks+0x441>
mov    -0x8(%rbp),%rdi
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x28(%rbp),%esi
mov    -0x34(%rbp),%edx
sub    -0x28(%rbp),%edx
xor    %ecx,%ecx
sub    -0x28(%rbp),%ecx
call   1070 <sorter_grail_merge_left@plt>
jmp    15cb <sorter_grail_build_blocks+0x46b>
mov    -0x8(%rbp),%rdi
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
movslq -0x28(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x28(%rbp),%esi
mov    -0x34(%rbp),%edx
call   1050 <sorter_grail_rotate@plt>
mov    -0x28(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1508 <sorter_grail_build_blocks+0x3a8>
mov    -0xc(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
cltd
idiv   %ecx
mov    %edx,-0x38(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1636 <sorter_grail_build_blocks+0x4d6>
mov    -0x8(%rbp),%rdi
movslq -0x3c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x38(%rbp),%esi
mov    -0x10(%rbp),%edx
call   1050 <sorter_grail_rotate@plt>
jmp    1656 <sorter_grail_build_blocks+0x4f6>
mov    -0x8(%rbp),%rdi
movslq -0x3c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%esi
mov    -0x38(%rbp),%edx
sub    -0x10(%rbp),%edx
mov    -0x10(%rbp),%ecx
call   1080 <sorter_grail_merge_right@plt>
jmp    165b <sorter_grail_build_blocks+0x4fb>
cmpl   $0x0,-0x3c(%rbp)
jle    1695 <sorter_grail_build_blocks+0x535>
mov    -0x10(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rdi
movslq -0x3c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x10(%rbp),%ecx
call   1080 <sorter_grail_merge_right@plt>
jmp    165b <sorter_grail_build_blocks+0x4fb>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sorter_grail_build_blocks>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %edx,%r12d
mov    %esi,%r13d
mov    %rdi,%r14
cmp    %r8d,%edx
cmovl  %edx,%r8d
xchg   %ax,%ax
mov    %r8d,%r15d
lea    -0x1(%r15),%r8d
and    %r15d,%r8d
jne    1180 <sorter_grail_build_blocks+0x20>
test   %r15d,%r15d
mov    %r13,0x30(%rsp)
mov    %r12,0x28(%rsp)
je     14bf <sorter_grail_build_blocks+0x35f>
movslq %r15d,%rax
shl    $0x3,%rax
mov    %r14,%rsi
sub    %rax,%rsi
lea    0x0(,%r15,8),%edx
mov    %rcx,0x38(%rsp)
mov    %rcx,%rdi
mov    %edx,0x24(%rsp)
call   1060 <memcpy@plt>
cmp    $0x2,%r13d
jl     1219 <sorter_grail_build_blocks+0xb9>
mov    %r13d,%eax
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x8(%r14,%rcx,8),%rdx
xor    %esi,%esi
cmp    (%r14,%rcx,8),%rdx
setg   %sil
lea    (%rcx,%rsi,1),%rdx
mov    -0x8(%r14,%rdx,8),%rdx
mov    %rdx,-0x18(%r14,%rcx,8)
shl    $0x3,%rsi
mov    %r14,%rdx
sub    %rsi,%rdx
mov    (%rdx,%rcx,8),%rdx
mov    %rdx,-0x10(%r14,%rcx,8)
add    $0x2,%rcx
cmp    %rax,%rcx
jb     11e0 <sorter_grail_build_blocks+0x80>
movslq %r13d,%rbx
test   $0x1,%r13b
je     122c <sorter_grail_build_blocks+0xcc>
mov    -0x8(%r14,%rbx,8),%rax
mov    %rax,-0x18(%r14,%rbx,8)
add    $0xfffffffffffffff0,%r14
mov    $0x2,%r9d
cmp    $0x3,%r15d
jl     1494 <sorter_grail_build_blocks+0x334>
mov    $0x2,%r9d
mov    %r15,0x40(%rsp)
mov    %rbx,0x8(%rsp)
jmp    128d <sorter_grail_build_blocks+0x12d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ebp,%rax
lea    (%r14,%rax,8),%rdi
mov    %ebx,%ecx
neg    %ecx
mov    %ebx,%esi
mov    %r9,%rbx
call   1040 <sorter_grail_merge_left_with_x_buf@plt>
mov    %rbx,%r9
mov    0x8(%rsp),%rbx
shl    $0x3,%r12
sub    %r12,%r14
cmp    %r15d,%r9d
jge    1494 <sorter_grail_build_blocks+0x334>
mov    %r9d,%ebx
lea    (%rbx,%rbx,1),%r9d
mov    %r13d,%eax
sub    %r9d,%eax
mov    $0x0,%ebp
js     12ff <sorter_grail_build_blocks+0x19f>
mov    %ebx,%r13d
neg    %r13d
mov    %r14,%r12
mov    %r9,0x10(%rsp)
movslq %r9d,%r14
mov    %eax,%eax
mov    %rax,(%rsp)
lea    0x0(,%r14,8),%r15
mov    %r12,0x18(%rsp)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %ebx,%esi
mov    %ebx,%edx
mov    %r13d,%ecx
call   1040 <sorter_grail_merge_left_with_x_buf@plt>
add    %r14,%rbp
add    %r15,%r12
cmp    (%rsp),%rbp
jle    12d0 <sorter_grail_build_blocks+0x170>
mov    0x30(%rsp),%r13
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r9
mov    0x40(%rsp),%r15
mov    %r13d,%edx
sub    %ebp,%edx
movslq %ebx,%r12
sub    %ebx,%edx
jg     1260 <sorter_grail_build_blocks+0x100>
cmp    %r13d,%ebp
mov    0x8(%rsp),%rbx
jge    127d <sorter_grail_build_blocks+0x11d>
movslq %ebp,%rax
mov    %rbx,%rcx
sub    %rax,%rcx
cmp    $0x4,%rcx
jb     1400 <sorter_grail_build_blocks+0x2a0>
mov    %rax,%rdi
sub    %r12,%rdi
lea    (%r14,%rdi,8),%rsi
lea    (%r14,%rbx,8),%rdx
cmp    %rdx,%rsi
jae    135b <sorter_grail_build_blocks+0x1fb>
lea    0x0(,%r12,8),%rsi
sub    %rsi,%rdx
lea    (%r14,%rax,8),%rsi
cmp    %rdx,%rsi
jb     1400 <sorter_grail_build_blocks+0x2a0>
mov    %rcx,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdx
mov    %rdx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
je     13c2 <sorter_grail_build_blocks+0x262>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r14,%rdi,8),%rbx
add    $0x30,%rbx
lea    (%r14,%rax,8),%rdx
add    $0x30,%rdx
xor    %edi,%edi
nop
movups -0x30(%rdx,%rdi,8),%xmm0
movups -0x20(%rdx,%rdi,8),%xmm1
movups %xmm0,-0x30(%rbx,%rdi,8)
movups %xmm1,-0x20(%rbx,%rdi,8)
movups -0x10(%rdx,%rdi,8),%xmm0
movups (%rdx,%rdi,8),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,8)
movups %xmm1,(%rbx,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1390 <sorter_grail_build_blocks+0x230>
jmp    13c4 <sorter_grail_build_blocks+0x264>
xor    %edi,%edi
test   $0x1,%bpl
mov    0x8(%rsp),%rbx
je     13eb <sorter_grail_build_blocks+0x28b>
add    %rax,%rdi
movups (%r14,%rdi,8),%xmm0
movups 0x10(%r14,%rdi,8),%xmm1
sub    %r12,%rdi
movups %xmm0,(%r14,%rdi,8)
movups %xmm1,0x10(%r14,%rdi,8)
cmp    %r8,%rcx
je     127d <sorter_grail_build_blocks+0x11d>
add    %r8,%rax
nopw   0x0(%rax,%rax,1)
mov    %r13d,%edx
sub    %eax,%edx
mov    %rax,%rcx
not    %rcx
add    %rbx,%rcx
and    $0x3,%rdx
je     1442 <sorter_grail_build_blocks+0x2e2>
lea    0x0(,%r12,8),%rdi
mov    %r14,%rsi
sub    %rdi,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r14,%rax,8),%rdi
mov    %rdi,(%rsi,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    1430 <sorter_grail_build_blocks+0x2d0>
cmp    $0x3,%rcx
jb     127d <sorter_grail_build_blocks+0x11d>
lea    0x0(,%r12,8),%rdx
mov    %r14,%rcx
sub    %rdx,%rcx
add    $0x18,%rcx
xchg   %ax,%ax
mov    (%r14,%rax,8),%rdx
mov    %rdx,-0x18(%rcx,%rax,8)
mov    0x8(%r14,%rax,8),%rdx
mov    %rdx,-0x10(%rcx,%rax,8)
mov    0x10(%r14,%rax,8),%rdx
mov    %rdx,-0x8(%rcx,%rax,8)
mov    0x18(%r14,%rax,8),%rdx
mov    %rdx,(%rcx,%rax,8)
add    $0x4,%rax
cmp    %rax,%rbx
jne    1460 <sorter_grail_build_blocks+0x300>
jmp    127d <sorter_grail_build_blocks+0x11d>
lea    (%r14,%rbx,8),%rdi
mov    0x38(%rsp),%rsi
mov    0x24(%rsp),%edx
mov    %r9,%rbx
call   1060 <memcpy@plt>
mov    %rbx,%rsi
mov    0x28(%rsp),%r12
cmp    %r12d,%esi
jl     15b1 <sorter_grail_build_blocks+0x451>
jmp    1555 <sorter_grail_build_blocks+0x3f5>
cmp    $0x2,%r13d
mov    %r14,%r15
jl     1526 <sorter_grail_build_blocks+0x3c6>
mov    %r13d,%eax
mov    %rax,(%rsp)
lea    0x8(%r15),%r14
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x8(%r14),%rax
xor    %ebp,%ebp
cmp    (%r14),%rax
setg   %bpl
lea    -0x18(%r14),%rdi
lea    (%rbx,%rbp,1),%rax
lea    (%r15,%rax,8),%rsi
call   1030 <sorter_grail_swap1@plt>
lea    -0x10(%r14),%rdi
shl    $0x3,%rbp
mov    %r14,%rsi
sub    %rbp,%rsi
call   1030 <sorter_grail_swap1@plt>
add    $0x10,%r14
lea    0x2(%rbx),%rax
add    $0x3,%rbx
cmp    (%rsp),%rbx
mov    %rax,%rbx
jl     14e0 <sorter_grail_build_blocks+0x380>
test   $0x1,%r13b
mov    %r15,%r14
je     1547 <sorter_grail_build_blocks+0x3e7>
movslq %r13d,%rax
lea    (%r14,%rax,8),%rdi
add    $0xfffffffffffffff8,%rdi
lea    (%r14,%rax,8),%rsi
add    $0xffffffffffffffe8,%rsi
call   1030 <sorter_grail_swap1@plt>
add    $0xfffffffffffffff0,%r14
mov    $0x2,%esi
cmp    %r12d,%esi
jl     15b1 <sorter_grail_build_blocks+0x451>
lea    (%r12,%r12,1),%ebx
mov    %r13d,%eax
cltd
idiv   %ebx
sub    %edx,%r13d
mov    %edx,%eax
movslq %r13d,%rcx
lea    (%r14,%rcx,8),%rdi
sub    %r12d,%eax
jle    164f <sorter_grail_build_blocks+0x4ef>
mov    %r12d,%esi
mov    %eax,%edx
mov    %r12d,%ecx
call   1080 <sorter_grail_merge_right@plt>
test   %r13d,%r13d
jg     165e <sorter_grail_build_blocks+0x4fe>
jmp    1691 <sorter_grail_build_blocks+0x531>
nop
mov    %rbx,%rbp
neg    %rbp
shl    $0x3,%rbx
sub    %rbx,%rdi
call   1050 <sorter_grail_rotate@plt>
mov    %rbp,%rbx
lea    (%r14,%rbx,8),%r14
mov    %r15d,%esi
cmp    %r12d,%r15d
jge    1555 <sorter_grail_build_blocks+0x3f5>
lea    (%rsi,%rsi,1),%r15d
mov    %r13d,%eax
sub    %r15d,%eax
mov    $0x0,%ebx
js     1623 <sorter_grail_build_blocks+0x4c3>
mov    %esi,%r13d
neg    %r13d
mov    %r14,%rbp
mov    %r15d,0x10(%rsp)
movslq %r15d,%r14
mov    %eax,%eax
mov    %rax,(%rsp)
lea    0x0(,%r14,8),%r12
mov    %rbp,0x18(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    %rbp,%rdi
mov    %esi,%edx
mov    %r13d,%ecx
mov    %rsi,%r15
call   1070 <sorter_grail_merge_left@plt>
mov    %r15,%rsi
add    %r14,%rbx
add    %r12,%rbp
cmp    (%rsp),%rbx
jle    15f0 <sorter_grail_build_blocks+0x490>
mov    0x28(%rsp),%r12
mov    0x30(%rsp),%r13
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r15d
mov    %r13d,%edx
sub    %ebx,%edx
mov    %edx,%eax
movslq %ebx,%rcx
lea    (%r14,%rcx,8),%rdi
movslq %esi,%rbx
sub    %esi,%eax
jle    1590 <sorter_grail_build_blocks+0x430>
mov    %esi,%ecx
neg    %ecx
mov    %eax,%edx
call   1070 <sorter_grail_merge_left@plt>
neg    %rbx
jmp    15a5 <sorter_grail_build_blocks+0x445>
mov    %edx,%esi
mov    %r12d,%edx
call   1050 <sorter_grail_rotate@plt>
test   %r13d,%r13d
jle    1691 <sorter_grail_build_blocks+0x531>
mov    %ebx,%ebp
neg    %ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(%rbp,%r13,1),%eax
sub    %ebx,%r13d
cltq
lea    (%r14,%rax,8),%rdi
mov    %r12d,%esi
mov    %r12d,%edx
mov    %r12d,%ecx
call   1080 <sorter_grail_merge_right@plt>
test   %r13d,%r13d
jg     1670 <sorter_grail_build_blocks+0x510>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @sorter_grail_build_blocks(i64* %0, i32 %1, i32 %2, i64* %3, i32 %4) {
%6 = alloca i64*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i64*
%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 i32
%19 = alloca i32
store i64* %0, i64** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i64* %3, i64** %9
store i32 %4, i32* %10
%20 = load i32, i32* %8
%21 = load i32, i32* %10
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %25
23: ; preds = %5
%24 = load i32, i32* %8
br label %27
25: ; preds = %5
%26 = load i32, i32* %10
br label %27
27: ; preds = %25, %23
%28 = phi i32 [ %24, %23 ], [ %26, %25 ]
store i32 %28, i32* %19
br label %29
29: ; preds = %35, %27
%30 = load i32, i32* %19
%31 = load i32, i32* %19
%32 = sub nsw i32 %31, 1
%33 = and i32 %30, %32
%34 = icmp ne i32 %33, 0
br i1 %34, label %35, label %40
35: ; preds = %29
%36 = load i32, i32* %19
%37 = sub nsw i32 %36, 1
%38 = load i32, i32* %19
%39 = and i32 %38, %37
store i32 %39, i32* %19
br label %29
40: ; preds = %29
%41 = load i32, i32* %19
%42 = icmp ne i32 %41, 0
br i1 %42, label %43, label %209
43: ; preds = %40
%44 = load i64*, i64** %9
%45 = load i64*, i64** %6
%46 = load i32, i32* %19
%47 = sext i32 %46 to i64
%48 = sub i64 0, %47
%49 = getelementptr inbounds i64, i64* %45, i64 %48
%50 = load i32, i32* %19
%51 = sext i32 %50 to i64
%52 = mul i64 %51, 8
%53 = trunc i64 %52 to i32
%54 = call i32 @memcpy(i64* %44, i64* %49, i32 %53)
store i32 1, i32* %11
br label %55
55: ; preds = %100, %43
%56 = load i32, i32* %11
%57 = load i32, i32* %7
%58 = icmp slt i32 %56, %57
br i1 %58, label %59, label %103
59: ; preds = %55
store i32 0, i32* %12
%60 = load i64*, i64** %6
%61 = load i32, i32* %11
%62 = sub nsw i32 %61, 1
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i64, i64* %60, i64 %63
%65 = load i64, i64* %64
%66 = load i64*, i64** %6
%67 = load i32, i32* %11
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i64, i64* %66, i64 %68
%70 = load i64, i64* %69
%71 = sub nsw i64 %65, %70
%72 = icmp sgt i64 %71, 0
br i1 %72, label %73, label %74
73: ; preds = %59
store i32 1, i32* %12
br label %74
74: ; preds = %73, %59
%75 = load i64*, i64** %6
%76 = load i32, i32* %11
%77 = sub nsw i32 %76, 1
%78 = load i32, i32* %12
%79 = add nsw i32 %77, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i64, i64* %75, i64 %80
%82 = load i64, i64* %81
%83 = load i64*, i64** %6
%84 = load i32, i32* %11
%85 = sub nsw i32 %84, 3
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i64, i64* %83, i64 %86
store i64 %82, i64* %87
%88 = load i64*, i64** %6
%89 = load i32, i32* %11
%90 = load i32, i32* %12
%91 = sub nsw i32 %89, %90
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i64, i64* %88, i64 %92
%94 = load i64, i64* %93
%95 = load i64*, i64** %6
%96 = load i32, i32* %11
%97 = sub nsw i32 %96, 2
%98 = sext i32 %97 to i64
%99 = getelementptr inbounds i64, i64* %95, i64 %98
store i64 %94, i64* %99
br label %100
100: ; preds = %74
%101 = load i32, i32* %11
%102 = add nsw i32 %101, 2
store i32 %102, i32* %11
br label %55
103: ; preds = %55
%104 = load i32, i32* %7
%105 = srem i32 %104, 2
%106 = icmp ne i32 %105, 0
br i1 %106, label %107, label %119
107: ; preds = %103
%108 = load i64*, i64** %6
%109 = load i32, i32* %7
%110 = sub nsw i32 %109, 1
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds i64, i64* %108, i64 %111
%113 = load i64, i64* %112
%114 = load i64*, i64** %6
%115 = load i32, i32* %7
%116 = sub nsw i32 %115, 3
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i64, i64* %114, i64 %117
store i64 %113, i64* %118
br label %119
119: ; preds = %107, %103
%120 = load i64*, i64** %6
%121 = getelementptr inbounds i64, i64* %120, i64 -2
store i64* %121, i64** %6
store i32 2, i32* %13
br label %122
122: ; preds = %195, %119
%123 = load i32, i32* %13
%124 = load i32, i32* %19
%125 = icmp slt i32 %123, %124
br i1 %125, label %126, label %198
126: ; preds = %122
store i32 0, i32* %14
%127 = load i32, i32* %7
%128 = load i32, i32* %13
%129 = mul nsw i32 2, %128
%130 = sub nsw i32 %127, %129
store i32 %130, i32* %15
br label %131
131: ; preds = %135, %126
%132 = load i32, i32* %14
%133 = load i32, i32* %15
%134 = icmp sle i32 %132, %133
br i1 %134, label %135, label %149
135: ; preds = %131
%136 = load i64*, i64** %6
%137 = load i32, i32* %14
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds i64, i64* %136, i64 %138
%140 = load i32, i32* %13
%141 = load i32, i32* %13
%142 = load i32, i32* %13
%143 = sub nsw i32 0, %142
%144 = call i32 @sorter_grail_merge_left_with_x_buf(i64* %139, i32 %140, i32 %141, i32 %143)
%145 = load i32, i32* %13
%146 = mul nsw i32 2, %145
%147 = load i32, i32* %14
%148 = add nsw i32 %147, %146
store i32 %148, i32* %14
br label %131
149: ; preds = %131
%150 = load i32, i32* %7
%151 = load i32, i32* %14
%152 = sub nsw i32 %150, %151
store i32 %152, i32* %16
%153 = load i32, i32* %16
%154 = load i32, i32* %13
%155 = icmp sgt i32 %153, %154
br i1 %155, label %156, label %168
156: ; preds = %149
%157 = load i64*, i64** %6
%158 = load i32, i32* %14
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i64, i64* %157, i64 %159
%161 = load i32, i32* %13
%162 = load i32, i32* %16
%163 = load i32, i32* %13
%164 = sub nsw i32 %162, %163
%165 = load i32, i32* %13
%166 = sub nsw i32 0, %165
%167 = call i32 @sorter_grail_merge_left_with_x_buf(i64* %160, i32 %161, i32 %164, i32 %166)
br label %189
168: ; preds = %149
br label %169
169: ; preds = %185, %168
%170 = load i32, i32* %14
%171 = load i32, i32* %7
%172 = icmp slt i32 %170, %171
br i1 %172, label %173, label %188
173: ; preds = %169
%174 = load i64*, i64** %6
%175 = load i32, i32* %14
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds i64, i64* %174, i64 %176
%178 = load i64, i64* %177
%179 = load i64*, i64** %6
%180 = load i32, i32* %14
%181 = load i32, i32* %13
%182 = sub nsw i32 %180, %181
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i64, i64* %179, i64 %183
store i64 %178, i64* %184
br label %185
185: ; preds = %173
%186 = load i32, i32* %14
%187 = add nsw i32 %186, 1
store i32 %187, i32* %14
br label %169
188: ; preds = %169
br label %189
189: ; preds = %188, %156
%190 = load i32, i32* %13
%191 = load i64*, i64** %6
%192 = sext i32 %190 to i64
%193 = sub i64 0, %192
%194 = getelementptr inbounds i64, i64* %191, i64 %193
store i64* %194, i64** %6
br label %195
195: ; preds = %189
%196 = load i32, i32* %13
%197 = mul nsw i32 %196, 2
store i32 %197, i32* %13
br label %122
198: ; preds = %122
%199 = load i64*, i64** %6
%200 = load i32, i32* %7
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds i64, i64* %199, i64 %201
%203 = load i64*, i64** %9
%204 = load i32, i32* %19
%205 = sext i32 %204 to i64
%206 = mul i64 %205, 8
%207 = trunc i64 %206 to i32
%208 = call i32 @memcpy(i64* %202, i64* %203, i32 %207)
br label %277
209: ; preds = %40
store i32 1, i32* %11
br label %210
210: ; preds = %255, %209
%211 = load i32, i32* %11
%212 = load i32, i32* %7
%213 = icmp slt i32 %211, %212
br i1 %213, label %214, label %258
214: ; preds = %210
store i32 0, i32* %12
%215 = load i64*, i64** %6
%216 = load i32, i32* %11
%217 = sub nsw i32 %216, 1
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds i64, i64* %215, i64 %218
%220 = load i64, i64* %219
%221 = load i64*, i64** %6
%222 = load i32, i32* %11
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i64, i64* %221, i64 %223
%225 = load i64, i64* %224
%226 = sub nsw i64 %220, %225
%227 = icmp sgt i64 %226, 0
br i1 %227, label %228, label %229
228: ; preds = %214
store i32 1, i32* %12
br label %229
229: ; preds = %228, %214
%230 = load i64*, i64** %6
%231 = load i32, i32* %11
%232 = sub nsw i32 %231, 3
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds i64, i64* %230, i64 %233
%235 = load i64*, i64** %6
%236 = load i32, i32* %11
%237 = sub nsw i32 %236, 1
%238 = load i32, i32* %12
%239 = add nsw i32 %237, %238
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i64, i64* %235, i64 %240
%242 = call i32 @sorter_grail_swap1(i64* %234, i64* %241)
%243 = load i64*, i64** %6
%244 = load i32, i32* %11
%245 = sub nsw i32 %244, 2
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds i64, i64* %243, i64 %246
%248 = load i64*, i64** %6
%249 = load i32, i32* %11
%250 = load i32, i32* %12
%251 = sub nsw i32 %249, %250
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds i64, i64* %248, i64 %252
%254 = call i32 @sorter_grail_swap1(i64* %247, i64* %253)
br label %255
255: ; preds = %229
%256 = load i32, i32* %11
%257 = add nsw i32 %256, 2
store i32 %257, i32* %11
br label %210
258: ; preds = %210
%259 = load i32, i32* %7
%260 = srem i32 %259, 2
%261 = icmp ne i32 %260, 0
br i1 %261, label %262, label %274
262: ; preds = %258
%263 = load i64*, i64** %6
%264 = load i32, i32* %7
%265 = sub nsw i32 %264, 1
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds i64, i64* %263, i64 %266
%268 = load i64*, i64** %6
%269 = load i32, i32* %7
%270 = sub nsw i32 %269, 3
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i64, i64* %268, i64 %271
%273 = call i32 @sorter_grail_swap1(i64* %267, i64* %272)
br label %274
274: ; preds = %262, %258
%275 = load i64*, i64** %6
%276 = getelementptr inbounds i64, i64* %275, i64 -2
store i64* %276, i64** %6
store i32 2, i32* %13
br label %277
277: ; preds = %274, %198
br label %278
278: ; preds = %342, %277
%279 = load i32, i32* %13
%280 = load i32, i32* %8
%281 = icmp slt i32 %279, %280
br i1 %281, label %282, label %345
282: ; preds = %278
store i32 0, i32* %14
%283 = load i32, i32* %7
%284 = load i32, i32* %13
%285 = mul nsw i32 2, %284
%286 = sub nsw i32 %283, %285
store i32 %286, i32* %15
br label %287
287: ; preds = %291, %282
%288 = load i32, i32* %14
%289 = load i32, i32* %15
%290 = icmp sle i32 %288, %289
br i1 %290, label %291, label %305
291: ; preds = %287
%292 = load i64*, i64** %6
%293 = load i32, i32* %14
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i64, i64* %292, i64 %294
%296 = load i32, i32* %13
%297 = load i32, i32* %13
%298 = load i32, i32* %13
%299 = sub nsw i32 0, %298
%300 = call i32 @sorter_grail_merge_left(i64* %295, i32 %296, i32 %297, i32 %299)
%301 = load i32, i32* %13
%302 = mul nsw i32 2, %301
%303 = load i32, i32* %14
%304 = add nsw i32 %303, %302
store i32 %304, i32* %14
br label %287
305: ; preds = %287
%306 = load i32, i32* %7
%307 = load i32, i32* %14
%308 = sub nsw i32 %306, %307
store i32 %308, i32* %16
%309 = load i32, i32* %16
%310 = load i32, i32* %13
%311 = icmp sgt i32 %309, %310
br i1 %311, label %312, label %324
312: ; preds = %305
%313 = load i64*, i64** %6
%314 = load i32, i32* %14
%315 = sext i32 %314 to i64
%316 = getelementptr inbounds i64, i64* %313, i64 %315
%317 = load i32, i32* %13
%318 = load i32, i32* %16
%319 = load i32, i32* %13
%320 = sub nsw i32 %318, %319
%321 = load i32, i32* %13
%322 = sub nsw i32 0, %321
%323 = call i32 @sorter_grail_merge_left(i64* %316, i32 %317, i32 %320, i32 %322)
br label %336
324: ; preds = %305
%325 = load i64*, i64** %6
%326 = load i32, i32* %14
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds i64, i64* %325, i64 %327
%329 = load i32, i32* %13
%330 = sext i32 %329 to i64
%331 = sub i64 0, %330
%332 = getelementptr inbounds i64, i64* %328, i64 %331
%333 = load i32, i32* %13
%334 = load i32, i32* %16
%335 = call i32 @sorter_grail_rotate(i64* %332, i32 %333, i32 %334)
br label %336
336: ; preds = %324, %312
%337 = load i32, i32* %13
%338 = load i64*, i64** %6
%339 = sext i32 %337 to i64
%340 = sub i64 0, %339
%341 = getelementptr inbounds i64, i64* %338, i64 %340
store i64* %341, i64** %6
br label %342
342: ; preds = %336
%343 = load i32, i32* %13
%344 = mul nsw i32 %343, 2
store i32 %344, i32* %13
br label %278
345: ; preds = %278
%346 = load i32, i32* %7
%347 = load i32, i32* %8
%348 = mul nsw i32 2, %347
%349 = srem i32 %346, %348
store i32 %349, i32* %17
%350 = load i32, i32* %7
%351 = load i32, i32* %17
%352 = sub nsw i32 %350, %351
store i32 %352, i32* %18
%353 = load i32, i32* %17
%354 = load i32, i32* %8
%355 = icmp sle i32 %353, %354
br i1 %355, label %356, label %364
356: ; preds = %345
%357 = load i64*, i64** %6
%358 = load i32, i32* %18
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds i64, i64* %357, i64 %359
%361 = load i32, i32* %17
%362 = load i32, i32* %8
%363 = call i32 @sorter_grail_rotate(i64* %360, i32 %361, i32 %362)
br label %375
364: ; preds = %345
%365 = load i64*, i64** %6
%366 = load i32, i32* %18
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds i64, i64* %365, i64 %367
%369 = load i32, i32* %8
%370 = load i32, i32* %17
%371 = load i32, i32* %8
%372 = sub nsw i32 %370, %371
%373 = load i32, i32* %8
%374 = call i32 @sorter_grail_merge_right(i64* %368, i32 %369, i32 %372, i32 %373)
br label %375
375: ; preds = %364, %356
br label %376
376: ; preds = %379, %375
%377 = load i32, i32* %18
%378 = icmp sgt i32 %377, 0
br i1 %378, label %379, label %392
379: ; preds = %376
%380 = load i32, i32* %8
%381 = mul nsw i32 2, %380
%382 = load i32, i32* %18
%383 = sub nsw i32 %382, %381
store i32 %383, i32* %18
%384 = load i64*, i64** %6
%385 = load i32, i32* %18
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i64, i64* %384, i64 %386
%388 = load i32, i32* %8
%389 = load i32, i32* %8
%390 = load i32, i32* %8
%391 = call i32 @sorter_grail_merge_right(i64* %387, i32 %388, i32 %389, i32 %390)
br label %376
392: ; preds = %376
ret void
}

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