#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 rand();
void mksort(const char *x[], int n, int depth, int maxdepth) {
  int a, b, c, d, i, j, k, r, v;
  const char *tmp;
  if (n <= 1)
    return;
  a = rand() % n;
  tmp = x[(0)];
  x[(0)] = x[(a)];
  x[(a)] = tmp;
  v = (int)x[(0)][depth];
  a = b = 1;
  c = d = n - 1;
  for (;;) {
    while (b <= c && (r = (int)x[(b)][depth] - v) <= 0) {
      if (r == 0) {
        tmp = x[(a)];
        x[(a)] = x[(b)];
        x[(b)] = tmp;
        a++;
      }
      b++;
    }
    while (b <= c && (r = (int)x[(c)][depth] - v) >= 0) {
      if (r == 0) {
        tmp = x[(c)];
        x[(c)] = x[(d)];
        x[(d)] = tmp;
        d--;
      }
      c--;
    }
    if (b > c)
      break;
    tmp = x[(b)];
    x[(b)] = x[(c)];
    x[(c)] = tmp;
    b++;
    c--;
  }
  r = ((a) < (b - a)) ? (a) : (b - a);
  for (i = (0), j = (b - r), k = r; k-- > 0; i++, j++) {
    tmp = x[(i)];
    x[(i)] = x[(j)];
    x[(j)] = tmp;
  };
  r = ((d - c) < (n - d - 1)) ? (d - c) : (n - d - 1);
  for (i = (b), j = (n - r), k = r; k-- > 0; i++, j++) {
    tmp = x[(i)];
    x[(i)] = x[(j)];
    x[(j)] = tmp;
  };
  r = b - a;
  mksort(x, r, depth, maxdepth);
  if ((int)x[(r)][depth] != 0 && depth < maxdepth)
    mksort(x + r, a + n - d - 1, depth + 1, maxdepth);
  r = d - c;
  mksort(x + n - r, r, depth, maxdepth);
}


x86 assembly (clang, -O0):
<mksort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
cmpl   $0x1,-0xc(%rbp)
jg     1144 <mksort+0x24>
jmp    1546 <mksort+0x426>
mov    $0x0,%al
call   1040 <rand@plt>
cltd
idivl  -0xc(%rbp)
mov    %edx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
movl   $0x1,-0x1c(%rbp)
movl   $0x1,-0x18(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    %eax,-0x20(%rbp)
jmp    11b1 <mksort+0x91>
mov    -0x1c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x20(%rbp),%ecx
mov    %al,-0x41(%rbp)
jg     11e5 <mksort+0xc5>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
cmp    $0x0,%eax
setle  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    11f5 <mksort+0xd5>
jmp    124e <mksort+0x12e>
cmpl   $0x0,-0x34(%rbp)
jne    1240 <mksort+0x120>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11b1 <mksort+0x91>
jmp    1253 <mksort+0x133>
mov    -0x1c(%rbp),%ecx
xor    %eax,%eax
cmp    -0x20(%rbp),%ecx
mov    %al,-0x42(%rbp)
jg     1287 <mksort+0x167>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
cmp    $0x0,%eax
setge  %al
mov    %al,-0x42(%rbp)
mov    -0x42(%rbp),%al
test   $0x1,%al
jne    1297 <mksort+0x177>
jmp    12f0 <mksort+0x1d0>
cmpl   $0x0,-0x34(%rbp)
jne    12e2 <mksort+0x1c2>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1253 <mksort+0x133>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jle    1301 <mksort+0x1e1>
jmp    1350 <mksort+0x230>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    11ac <mksort+0x8c>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    -0x18(%rbp),%ecx
cmp    %ecx,%eax
jge    136c <mksort+0x24c>
mov    -0x18(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1375 <mksort+0x255>
mov    -0x1c(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cmp    $0x0,%eax
jle    13f4 <mksort+0x2d4>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1391 <mksort+0x271>
mov    -0x24(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1419 <mksort+0x2f9>
mov    -0x24(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x4c(%rbp)
jmp    1425 <mksort+0x305>
mov    -0xc(%rbp),%eax
sub    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x34(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x30(%rbp)
cmp    $0x0,%eax
jle    14a3 <mksort+0x383>
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x40(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1440 <mksort+0x320>
mov    -0x1c(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
call   1030 <mksort@plt>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1510 <mksort+0x3f0>
mov    -0x10(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1510 <mksort+0x3f0>
mov    -0x8(%rbp),%rdi
movslq -0x34(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x18(%rbp),%esi
add    -0xc(%rbp),%esi
sub    -0x24(%rbp),%esi
sub    $0x1,%esi
mov    -0x10(%rbp),%edx
add    $0x1,%edx
mov    -0x14(%rbp),%ecx
call   1030 <mksort@plt>
mov    -0x24(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
movslq -0x34(%rbp),%rcx
xor    %eax,%eax
sub    %rcx,%rax
shl    $0x3,%rax
add    %rax,%rdi
mov    -0x34(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x14(%rbp),%ecx
call   1030 <mksort@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mksort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %ecx,0x10(%rsp)
mov    %edx,0xc(%rsp)
cmp    $0x2,%esi
jge    114a <mksort+0x2a>
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rdi,%r15
movslq 0xc(%rsp),%r14
lea    0x1(%r14),%eax
mov    %eax,0x20(%rsp)
jmp    117c <mksort+0x5c>
nopl   0x0(%rax)
movslq 0x18(%rsp),%rax
lea    (%r15,%rax,8),%r15
mov    0x24(%rsp),%esi
movslq %esi,%rax
shl    $0x3,%rax
sub    %rax,%r15
cmp    $0x1,%esi
jle    113b <mksort+0x1b>
mov    %esi,%ebx
xor    %eax,%eax
call   1040 <rand@plt>
cltd
idiv   %ebx
mov    (%r15),%rax
movslq %edx,%rcx
mov    (%r15,%rcx,8),%rdx
mov    %rdx,(%r15)
mov    %rax,(%r15,%rcx,8)
mov    (%r15),%rax
movsbl (%rax,%r14,1),%esi
mov    %rbx,0x18(%rsp)
lea    -0x1(%rbx),%ecx
mov    $0x1,%edx
mov    %ecx,%r12d
mov    $0x1,%r13d
movabs $0xffffffff00000000,%r9
ff ff ff
movslq %ecx,%rbx
cmp    %ecx,%edx
jg     1223 <mksort+0x103>
movslq %edx,%rax
lea    0x1(%rcx),%r8d
add    $0xffffffffffffffff,%rax
jmp    11ec <mksort+0xcc>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%edx
add    $0x1,%rax
cmp    %rbx,%rax
jge    1220 <mksort+0x100>
mov    0x8(%r15,%rax,8),%rdi
movsbl (%rdi,%r14,1),%ebp
sub    %esi,%ebp
jg     1223 <mksort+0x103>
jne    11e0 <mksort+0xc0>
movslq %r13d,%r13
mov    (%r15,%r13,8),%rbp
mov    %rdi,(%r15,%r13,8)
mov    %rbp,0x8(%r15,%rax,8)
add    $0x1,%r13d
jmp    11e0 <mksort+0xc0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8d,%edx
movslq %edx,%r11
cmp    %ecx,%edx
jg     12b0 <mksort+0x190>
mov    %rbx,%rdi
shl    $0x20,%rdi
add    $0x1,%rbx
jmp    124f <mksort+0x12f>
nopl   0x0(%rax,%rax,1)
add    %r9,%rdi
add    $0xffffffff,%ecx
add    $0xffffffffffffffff,%rbx
cmp    %r11,%rbx
jle    12b0 <mksort+0x190>
mov    -0x8(%r15,%rbx,8),%rax
movsbl (%rax,%r14,1),%ebp
sub    %esi,%ebp
js     1280 <mksort+0x160>
jne    1240 <mksort+0x120>
movslq %r12d,%r12
mov    (%r15,%r12,8),%rbp
mov    %rbp,-0x8(%r15,%rbx,8)
mov    %rax,(%r15,%r12,8)
add    $0xffffffff,%r12d
jmp    1240 <mksort+0x120>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%r11,8),%rax
sar    $0x1d,%rdi
mov    (%r15,%rdi,1),%rdx
mov    %rdx,(%r15,%r11,8)
mov    %rax,(%r15,%rdi,1)
add    $0x1,%r11d
add    $0xffffffff,%ecx
mov    %r11d,%edx
jmp    11c1 <mksort+0xa1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edx,%eax
sub    %r13d,%eax
cmp    %eax,%r13d
mov    %eax,0x14(%rsp)
cmovl  %r13d,%eax
test   %eax,%eax
jle    145d <mksort+0x33d>
sub    %eax,%edx
movslq %edx,%r9
mov    %eax,%edx
cmp    $0x4,%eax
jb     12ee <mksort+0x1ce>
lea    (%r9,%rdx,1),%rax
lea    (%r15,%rax,8),%rax
cmp    %rax,%r15
jae    1302 <mksort+0x1e2>
lea    (%r15,%rdx,8),%rax
lea    (%r15,%r9,8),%rsi
cmp    %rax,%rsi
jae    1302 <mksort+0x1e2>
xor    %r10d,%r10d
test   $0x1,%dl
jne    13f0 <mksort+0x2d0>
mov    %r10,%rax
jmp    140b <mksort+0x2eb>
mov    %edx,%r10d
and    $0xfffffffc,%r10d
lea    -0x4(%r10),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     1628 <mksort+0x508>
mov    %r8,%rsi
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rsi
lea    (%r15,%r9,8),%rdi
add    $0x30,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups (%r15,%rbx,8),%xmm0
movups 0x10(%r15,%rbx,8),%xmm1
movups -0x30(%rdi,%rbx,8),%xmm2
movups -0x20(%rdi,%rbx,8),%xmm3
movups %xmm2,(%r15,%rbx,8)
movups %xmm3,0x10(%r15,%rbx,8)
movups %xmm0,-0x30(%rdi,%rbx,8)
movups %xmm1,-0x20(%rdi,%rbx,8)
movups 0x20(%r15,%rbx,8),%xmm0
movups 0x30(%r15,%rbx,8),%xmm1
movups -0x10(%rdi,%rbx,8),%xmm2
movups (%rdi,%rbx,8),%xmm3
movups %xmm2,0x20(%r15,%rbx,8)
movups %xmm3,0x30(%r15,%rbx,8)
movups %xmm0,-0x10(%rdi,%rbx,8)
movups %xmm1,(%rdi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rsi
jne    1340 <mksort+0x220>
test   $0x1,%r8b
je     13d4 <mksort+0x2b4>
lea    (%rbx,%r9,1),%rax
movups (%r15,%rbx,8),%xmm0
movups 0x10(%r15,%rbx,8),%xmm1
movups (%r15,%rax,8),%xmm2
movups 0x10(%r15,%rax,8),%xmm3
movups %xmm2,(%r15,%rbx,8)
movups %xmm3,0x10(%r15,%rbx,8)
movups %xmm0,(%r15,%rax,8)
movups %xmm1,0x10(%r15,%rax,8)
cmp    %rdx,%r10
je     145d <mksort+0x33d>
add    %r10,%r9
test   $0x1,%dl
je     12fa <mksort+0x1da>
nopl   0x0(%rax)
mov    (%r15,%r10,8),%rax
mov    (%r15,%r9,8),%rsi
mov    %rsi,(%r15,%r10,8)
mov    %rax,(%r15,%r9,8)
mov    %r10,%rax
or     $0x1,%rax
add    $0x1,%r9
not    %r10
add    %rdx,%r10
je     145d <mksort+0x33d>
sub    %rax,%rdx
lea    (%r15,%rax,8),%rax
add    $0x8,%rax
lea    (%r15,%r9,8),%rsi
add    $0x8,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    -0x8(%rax,%rdi,8),%rbp
mov    -0x8(%rsi,%rdi,8),%rbx
mov    %rbx,-0x8(%rax,%rdi,8)
mov    %rbp,-0x8(%rsi,%rdi,8)
mov    (%rax,%rdi,8),%rbp
mov    (%rsi,%rdi,8),%rbx
mov    %rbx,(%rax,%rdi,8)
mov    %rbp,(%rsi,%rdi,8)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    1430 <mksort+0x310>
mov    %r12d,%eax
sub    %ecx,%eax
not    %r12d
add    0x18(%rsp),%r12d
cmp    %r12d,%eax
mov    %r12d,%ecx
mov    %eax,0x24(%rsp)
cmovl  %eax,%ecx
test   %ecx,%ecx
mov    0x14(%rsp),%esi
jle    15dc <mksort+0x4bc>
mov    0x18(%rsp),%rax
sub    %ecx,%eax
movslq %eax,%rdx
lea    -0x1(%rcx),%r10d
cmp    $0x3,%r10d
jb     15b0 <mksort+0x490>
lea    (%r15,%r11,8),%rax
lea    (%rdx,%r10,1),%rdi
lea    (%r15,%rdi,8),%rdi
add    $0x8,%rdi
cmp    %rdi,%rax
jae    14c9 <mksort+0x3a9>
lea    (%r11,%r10,1),%rax
lea    (%r15,%rax,8),%rax
add    $0x8,%rax
lea    (%r15,%rdx,8),%rdi
cmp    %rax,%rdi
jb     15b0 <mksort+0x490>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     1639 <mksort+0x519>
mov    %r9,%rbx
movabs $0x7ffffffffffffffe,%rax
ff ff 7f
and    %rax,%rbx
lea    (%r15,%r11,8),%rbp
add    $0x30,%rbp
lea    (%r15,%rdx,8),%rax
add    $0x30,%rax
xor    %edi,%edi
xchg   %ax,%ax
movups -0x30(%rbp,%rdi,8),%xmm0
movups -0x20(%rbp,%rdi,8),%xmm1
movups -0x30(%rax,%rdi,8),%xmm2
movups -0x20(%rax,%rdi,8),%xmm3
movups %xmm2,-0x30(%rbp,%rdi,8)
movups %xmm3,-0x20(%rbp,%rdi,8)
movups %xmm0,-0x30(%rax,%rdi,8)
movups %xmm1,-0x20(%rax,%rdi,8)
movups -0x10(%rbp,%rdi,8),%xmm0
movups 0x0(%rbp,%rdi,8),%xmm1
movups -0x10(%rax,%rdi,8),%xmm2
movups (%rax,%rdi,8),%xmm3
movups %xmm2,-0x10(%rbp,%rdi,8)
movups %xmm3,0x0(%rbp,%rdi,8)
movups %xmm0,-0x10(%rax,%rdi,8)
movups %xmm1,(%rax,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1510 <mksort+0x3f0>
test   $0x1,%r9b
je     15a1 <mksort+0x481>
lea    (%rdi,%r11,1),%rax
add    %rdx,%rdi
movups (%r15,%rax,8),%xmm0
movups 0x10(%r15,%rax,8),%xmm1
movups (%r15,%rdi,8),%xmm2
movups 0x10(%r15,%rdi,8),%xmm3
movups %xmm2,(%r15,%rax,8)
movups %xmm3,0x10(%r15,%rax,8)
movups %xmm0,(%r15,%rdi,8)
movups %xmm1,0x10(%r15,%rdi,8)
cmp    %r8,%r10
je     15dc <mksort+0x4bc>
add    %r8,%r11
add    %r8,%rdx
sub    %r8d,%ecx
nop
add    $0x1,%ecx
mov    %r15,%rax
cs nopw 0x0(%rax,%rax,1)
mov    (%rax,%r11,8),%rbp
mov    (%rax,%rdx,8),%rdi
mov    %rdi,(%rax,%r11,8)
mov    %rbp,(%rax,%rdx,8)
add    $0x8,%rax
add    $0xffffffff,%ecx
cmp    $0x1,%ecx
ja     15c0 <mksort+0x4a0>
mov    %r15,%rdi
mov    0xc(%rsp),%ebp
mov    %ebp,%edx
mov    0x10(%rsp),%ebx
mov    %ebx,%ecx
call   1030 <mksort@plt>
cmp    %ebx,%ebp
jge    1160 <mksort+0x40>
movslq 0x14(%rsp),%rax
mov    (%r15,%rax,8),%rcx
cmpb   $0x0,(%rcx,%r14,1)
je     1160 <mksort+0x40>
lea    (%r15,%rax,8),%rdi
add    %r13d,%r12d
mov    %r12d,%esi
mov    0x20(%rsp),%edx
mov    0x10(%rsp),%ecx
call   1030 <mksort@plt>
jmp    1160 <mksort+0x40>
xor    %ebx,%ebx
test   $0x1,%r8b
jne    13a4 <mksort+0x284>
jmp    13d4 <mksort+0x2b4>
xor    %edi,%edi
test   $0x1,%r9b
jne    156e <mksort+0x44e>
jmp    15a1 <mksort+0x481>

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

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