void merge(unsigned long long int *A, int *B, int *C, unsigned long long int *X,
           int *Y, int *Z, int low, int mid, int up, int N) {
  int i = low, j = mid + 1, k = low, q = 0;
  for (q = low; q <= up; q++) {
    X[q] = A[q];
    Y[q] = B[q];
    Z[q] = C[q];
  }
  while ((i <= mid) && (j <= up)) {
    if (X[i] < X[j]) {
      A[k] = X[i];
      B[k] = Y[i];
      C[k++] = Z[i++];
    } else {
      A[k] = X[j];
      B[k] = Y[j];
      C[k++] = Z[j++];
    }
  }
  if (i > mid)
    for (q = j; q <= up; q++) {
      A[k] = X[q];
      B[k] = Y[q];
      C[k++] = Z[q];
    }
  else
    for (q = i; q <= mid; q++) {
      A[k] = X[q];
      B[k] = Y[q];
      C[k++] = Z[q];
    }
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     11a8 <merge+0xa8>
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    114a <merge+0x4a>
jmp    11ad <merge+0xad>
mov    -0x34(%rbp),%ecx
xor    %eax,%eax
cmp    0x18(%rbp),%ecx
mov    %al,-0x41(%rbp)
jg     11ca <merge+0xca>
mov    -0x38(%rbp),%eax
cmp    0x20(%rbp),%eax
setle  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    11da <merge+0xda>
jmp    12b2 <merge+0x1b2>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
movslq -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jae    1255 <merge+0x155>
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12ad <merge+0x1ad>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11ad <merge+0xad>
mov    -0x34(%rbp),%eax
cmp    0x18(%rbp),%eax
jle    1331 <merge+0x231>
mov    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x20(%rbp),%eax
jg     132c <merge+0x22c>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12c4 <merge+0x1c4>
jmp    13a4 <merge+0x2a4>
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     139f <merge+0x29f>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1337 <merge+0x237>
jmp    13a4 <merge+0x2a4>
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,-0x18(%rsp)
mov    %rsi,-0x20(%rsp)
mov    %rdi,-0x28(%rsp)
mov    0x48(%rsp),%r10d
mov    0x40(%rsp),%r12d
mov    0x38(%rsp),%edi
mov    %r10d,%r14d
sub    %edi,%r14d
jl     13bb <merge+0x2bb>
movslq %edi,%rdi
cmp    $0x3,%r14d
jb     12de <merge+0x1de>
lea    (%rcx,%rdi,8),%rax
mov    %rax,-0x38(%rsp)
lea    (%r14,%rdi,1),%rdx
lea    (%rcx,%rdx,8),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rsp)
mov    -0x28(%rsp),%rax
lea    (%rax,%rdi,8),%rsi
mov    %rsi,-0x30(%rsp)
lea    0x8(%rax,%rdx,8),%r15
lea    (%r8,%rdi,4),%rsi
lea    0x4(%r8,%rdx,4),%rbp
lea    (%r9,%rdi,4),%r13
lea    0x4(%r9,%rdx,4),%r11
mov    -0x20(%rsp),%rax
lea    (%rax,%rdi,4),%rbx
mov    %rbx,-0x8(%rsp)
cmp    %r15,-0x38(%rsp)
lea    0x4(%rax,%rdx,4),%rbx
mov    -0x18(%rsp),%rax
lea    0x4(%rax,%rdx,4),%rdx
setb   -0x38(%rsp)
mov    -0x30(%rsp),%r15
cmp    -0x10(%rsp),%r15
setb   -0x10(%rsp)
cmp    %r11,%rsi
setb   -0x30(%rsp)
cmp    %rbp,%r13
setb   -0x3a(%rsp)
cmp    %rbx,%rsi
setb   -0x3b(%rsp)
mov    -0x8(%rsp),%r15
cmp    %rbp,%r15
setb   -0x3c(%rsp)
cmp    %rdx,%rsi
lea    (%rax,%rdi,4),%rsi
setb   %al
cmp    %rbp,%rsi
setb   -0x39(%rsp)
cmp    %rbx,%r13
setb   %bl
cmp    %r11,%r15
setb   %r15b
cmp    %rdx,%r13
setb   %bpl
cmp    %r11,%rsi
setb   %sil
mov    -0x10(%rsp),%dl
test   %dl,-0x38(%rsp)
jne    12de <merge+0x1de>
mov    -0x3a(%rsp),%dl
and    %dl,-0x30(%rsp)
jne    12de <merge+0x1de>
mov    -0x3c(%rsp),%dl
and    %dl,-0x3b(%rsp)
jne    12de <merge+0x1de>
and    -0x39(%rsp),%al
jne    12de <merge+0x1de>
and    %r15b,%bl
jne    12de <merge+0x1de>
and    %sil,%bpl
jne    12de <merge+0x1de>
add    $0x1,%r14
mov    %r14,%r13
and    $0xfffffffffffffffc,%r13
lea    (%rdi,%r13,1),%r11
mov    -0x28(%rsp),%rax
lea    (%rax,%rdi,8),%rdx
add    $0x10,%rdx
lea    0x10(%rcx,%rdi,8),%rsi
mov    -0x20(%rsp),%rax
lea    0x8(%rax,%rdi,4),%r15
lea    0x8(%r8,%rdi,4),%rbp
mov    -0x18(%rsp),%rax
lea    (%rax,%rdi,4),%rbx
add    $0x8,%rbx
lea    (%r9,%rdi,4),%rdi
add    $0x8,%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rdx,%rax,8),%xmm0
movups (%rdx,%rax,8),%xmm1
movups %xmm0,-0x10(%rsi,%rax,8)
movups %xmm1,(%rsi,%rax,8)
movups -0x8(%r15,%rax,4),%xmm0
movups %xmm0,-0x8(%rbp,%rax,4)
movups -0x8(%rbx,%rax,4),%xmm0
movups %xmm0,-0x8(%rdi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r13
jne    12a0 <merge+0x1a0>
cmp    %r13,%r14
mov    0x38(%rsp),%edi
jne    12e5 <merge+0x1e5>
jmp    13bb <merge+0x2bb>
mov    %rdi,%r11
mov    0x38(%rsp),%edi
mov    %r10d,%eax
sub    %r11d,%eax
add    $0x1,%eax
test   $0x1,%al
jne    12ff <merge+0x1ff>
mov    %r11,%rdx
cmp    %r10d,%r11d
jne    1336 <merge+0x236>
jmp    13bb <merge+0x2bb>
mov    -0x28(%rsp),%rax
mov    (%rax,%r11,8),%rax
mov    %rax,(%rcx,%r11,8)
mov    -0x20(%rsp),%rax
mov    (%rax,%r11,4),%eax
mov    %eax,(%r8,%r11,4)
mov    -0x18(%rsp),%rax
mov    (%rax,%r11,4),%eax
mov    %eax,(%r9,%r11,4)
mov    %r11,%rdx
add    $0x1,%rdx
cmp    %r10d,%r11d
je     13bb <merge+0x2bb>
mov    %r10d,%r14d
sub    %edx,%r14d
add    $0x1,%r14d
mov    -0x28(%rsp),%rax
lea    (%rax,%rdx,8),%r15
add    $0x8,%r15
lea    0x8(%rcx,%rdx,8),%r13
mov    -0x20(%rsp),%rax
lea    0x4(%rax,%rdx,4),%rax
lea    0x4(%r8,%rdx,4),%rbx
mov    -0x18(%rsp),%rsi
lea    (%rsi,%rdx,4),%rbp
add    $0x4,%rbp
lea    (%r9,%rdx,4),%r11
add    $0x4,%r11
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    -0x8(%r15,%rdx,8),%rsi
mov    %rsi,-0x8(%r13,%rdx,8)
mov    -0x4(%rax,%rdx,4),%esi
mov    %esi,-0x4(%rbx,%rdx,4)
mov    -0x4(%rbp,%rdx,4),%esi
mov    %esi,-0x4(%r11,%rdx,4)
mov    (%r15,%rdx,8),%rsi
mov    %rsi,0x0(%r13,%rdx,8)
mov    (%rax,%rdx,4),%esi
mov    %esi,(%rbx,%rdx,4)
mov    0x0(%rbp,%rdx,4),%esi
mov    %esi,(%r11,%rdx,4)
add    $0x2,%rdx
cmp    %edx,%r14d
jne    1380 <merge+0x280>
lea    0x1(%r12),%r11d
cmp    %r12d,%edi
jg     1491 <merge+0x391>
cmp    %r10d,%r12d
jge    1491 <merge+0x391>
movslq %edi,%rax
mov    -0x28(%rsp),%rdx
lea    (%rdx,%rax,8),%r14
mov    -0x18(%rsp),%rdx
lea    (%rdx,%rax,4),%r15
mov    -0x20(%rsp),%rdx
lea    (%rdx,%rax,4),%r13
xor    %eax,%eax
mov    %edi,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %ebp,%rsi
mov    (%rcx,%rsi,8),%rbx
movslq %r11d,%rdi
mov    (%rcx,%rdi,8),%rdx
cmp    %rdx,%rbx
jae    1430 <merge+0x330>
mov    (%r8,%rsi,4),%edx
mov    %edx,0x0(%r13,%rax,4)
lea    0x1(%rsi),%ebp
jmp    1443 <merge+0x343>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r8,%rdi,4),%esi
mov    %esi,0x0(%r13,%rax,4)
lea    0x1(%rdi),%r11d
mov    %rdx,%rbx
mov    %rdi,%rsi
mov    (%r9,%rsi,4),%edx
mov    %rbx,(%r14,%rax,8)
mov    %edx,(%r15,%rax,4)
add    $0x1,%rax
cmp    %r12d,%ebp
jg     145d <merge+0x35d>
cmp    %r10d,%r11d
jle    1400 <merge+0x300>
mov    0x38(%rsp),%edi
add    %eax,%edi
cmp    %r12d,%ebp
jle    1498 <merge+0x398>
cmp    %r10d,%r11d
jg     19b8 <merge+0x8b8>
movslq %r11d,%r14
movslq %edi,%rsi
mov    %r10d,%r12d
sub    %r11d,%r12d
cmp    $0x3,%r12d
jae    171d <merge+0x61d>
mov    %rsi,-0x38(%rsp)
jmp    18c6 <merge+0x7c6>
mov    %edi,%ebp
cmp    %r12d,%ebp
jg     1468 <merge+0x368>
movslq %ebp,%r10
movslq %edi,%r14
mov    %r12d,%r15d
sub    %ebp,%r15d
cmp    $0x3,%r15d
jb     1640 <merge+0x540>
mov    -0x28(%rsp),%rax
lea    (%rax,%r14,8),%rdx
mov    %rdx,-0x38(%rsp)
lea    (%r14,%r15,1),%rdx
lea    (%rax,%rdx,8),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rsp)
lea    (%rcx,%r10,8),%r13
lea    (%r10,%r15,1),%rbp
lea    0x8(%rcx,%rbp,8),%rbx
mov    -0x20(%rsp),%rax
lea    (%rax,%r14,4),%rsi
lea    0x4(%rax,%rdx,4),%rdi
mov    -0x18(%rsp),%r11
lea    (%r11,%r14,4),%rax
lea    (%r11,%rdx,4),%rdx
add    $0x4,%rdx
lea    (%r8,%r10,4),%r11
cmp    %rbx,-0x38(%rsp)
lea    0x4(%r8,%rbp,4),%rbx
lea    0x4(%r9,%rbp,4),%rbp
setb   -0x38(%rsp)
cmp    -0x10(%rsp),%r13
setb   -0x10(%rsp)
cmp    %rdx,%rsi
setb   %r13b
cmp    %rdi,%rax
setb   -0x30(%rsp)
cmp    %rbx,%rsi
setb   -0x8(%rsp)
cmp    %rdi,%r11
setb   -0x3a(%rsp)
cmp    %rbp,%rsi
lea    (%r9,%r10,4),%rsi
setb   -0x3b(%rsp)
cmp    %rdi,%rsi
setb   -0x3c(%rsp)
cmp    %rbx,%rax
setb   %bl
cmp    %rdx,%r11
setb   %r11b
cmp    %rbp,%rax
setb   %dil
cmp    %rdx,%rsi
setb   %dl
mov    -0x10(%rsp),%al
test   %al,-0x38(%rsp)
jne    1640 <merge+0x540>
and    -0x30(%rsp),%r13b
jne    1640 <merge+0x540>
mov    -0x3a(%rsp),%al
and    %al,-0x8(%rsp)
jne    1640 <merge+0x540>
mov    -0x3c(%rsp),%al
and    %al,-0x3b(%rsp)
jne    1640 <merge+0x540>
and    %r11b,%bl
jne    1640 <merge+0x540>
and    %dl,%dil
jne    1640 <merge+0x540>
add    $0x1,%r15
mov    %r15,%rax
and    $0xfffffffffffffffc,%rax
lea    (%rax,%r14,1),%rdx
mov    %rdx,-0x38(%rsp)
lea    (%rax,%r10,1),%r13
lea    (%rcx,%r10,8),%rdx
add    $0x10,%rdx
lea    0x8(%r8,%r10,4),%r11
lea    0x8(%r9,%r10,4),%r10
mov    -0x28(%rsp),%rsi
lea    0x10(%rsi,%r14,8),%rbx
mov    -0x20(%rsp),%rsi
lea    (%rsi,%r14,4),%rdi
add    $0x8,%rdi
mov    -0x18(%rsp),%rsi
lea    (%rsi,%r14,4),%rsi
add    $0x8,%rsi
xor    %ebp,%ebp
nop
movups -0x10(%rdx,%rbp,8),%xmm0
movups (%rdx,%rbp,8),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,8)
movups %xmm1,(%rbx,%rbp,8)
movups -0x8(%r11,%rbp,4),%xmm0
movups %xmm0,-0x8(%rdi,%rbp,4)
movups -0x8(%r10,%rbp,4),%xmm0
movups %xmm0,-0x8(%rsi,%rbp,4)
add    $0x4,%rbp
cmp    %rbp,%rax
jne    1600 <merge+0x500>
cmp    %rax,%r15
mov    -0x38(%rsp),%r14
jne    1643 <merge+0x543>
jmp    19b8 <merge+0x8b8>
mov    %r10,%r13
mov    %r12d,%eax
sub    %r13d,%eax
add    $0x1,%eax
test   $0x1,%al
jne    165d <merge+0x55d>
mov    %r13,%rbx
cmp    %r12d,%r13d
jne    1698 <merge+0x598>
jmp    19b8 <merge+0x8b8>
mov    (%rcx,%r13,8),%rax
mov    -0x28(%rsp),%rdx
mov    %rax,(%rdx,%r14,8)
mov    (%r8,%r13,4),%eax
mov    -0x20(%rsp),%rdx
mov    %eax,(%rdx,%r14,4)
mov    (%r9,%r13,4),%eax
mov    -0x18(%rsp),%rdx
mov    %eax,(%rdx,%r14,4)
add    $0x1,%r14
mov    %r13,%rbx
add    $0x1,%rbx
cmp    %r12d,%r13d
je     19b8 <merge+0x8b8>
mov    -0x28(%rsp),%rax
lea    (%rax,%r14,8),%r10
add    $0x8,%r10
mov    -0x20(%rsp),%rax
lea    (%rax,%r14,4),%rsi
add    $0x4,%rsi
mov    -0x18(%rsp),%rax
lea    (%rax,%r14,4),%rdx
add    $0x4,%rdx
sub    %ebx,%r12d
add    $0x1,%r12d
lea    (%rcx,%rbx,8),%rcx
add    $0x8,%rcx
lea    (%r8,%rbx,4),%rdi
add    $0x4,%rdi
lea    (%r9,%rbx,4),%rbp
add    $0x4,%rbp
xor    %ebx,%ebx
mov    -0x8(%rcx,%rbx,8),%rax
mov    %rax,-0x8(%r10,%rbx,8)
mov    -0x4(%rdi,%rbx,4),%eax
mov    %eax,-0x4(%rsi,%rbx,4)
mov    -0x4(%rbp,%rbx,4),%eax
mov    %eax,-0x4(%rdx,%rbx,4)
mov    (%rcx,%rbx,8),%rax
mov    %rax,(%r10,%rbx,8)
mov    (%rdi,%rbx,4),%eax
mov    %eax,(%rsi,%rbx,4)
mov    0x0(%rbp,%rbx,4),%eax
mov    %eax,(%rdx,%rbx,4)
add    $0x2,%rbx
cmp    %ebx,%r12d
jne    16e0 <merge+0x5e0>
jmp    19b8 <merge+0x8b8>
mov    -0x28(%rsp),%rax
lea    (%rax,%rsi,8),%rdx
mov    %rdx,-0x38(%rsp)
lea    (%rsi,%r12,1),%rdx
lea    (%rax,%rdx,8),%rax
add    $0x8,%rax
mov    %rax,-0x10(%rsp)
lea    (%rcx,%r14,8),%r13
lea    (%r14,%r12,1),%rbx
lea    0x8(%rcx,%rbx,8),%r15
mov    -0x20(%rsp),%rax
lea    (%rax,%rsi,4),%rdi
lea    0x4(%rax,%rdx,4),%rbp
mov    -0x18(%rsp),%rax
mov    %rsi,-0x30(%rsp)
lea    (%rax,%rsi,4),%rsi
lea    (%rax,%rdx,4),%rdx
add    $0x4,%rdx
lea    (%r8,%r14,4),%r11
cmp    %r15,-0x38(%rsp)
lea    0x4(%r8,%rbx,4),%r15
lea    0x4(%r9,%rbx,4),%rbx
setb   -0x38(%rsp)
cmp    -0x10(%rsp),%r13
setb   -0x10(%rsp)
cmp    %rdx,%rdi
setb   %r13b
cmp    %rbp,%rsi
setb   -0x8(%rsp)
cmp    %r15,%rdi
setb   -0x3a(%rsp)
cmp    %rbp,%r11
setb   -0x3b(%rsp)
cmp    %rbx,%rdi
lea    (%r9,%r14,4),%rdi
setb   -0x3c(%rsp)
cmp    %rbp,%rdi
setb   -0x39(%rsp)
cmp    %r15,%rsi
setb   %bpl
cmp    %rdx,%r11
setb   %r11b
cmp    %rbx,%rsi
setb   %al
cmp    %rdx,%rdi
setb   %bl
mov    -0x10(%rsp),%dl
test   %dl,-0x38(%rsp)
jne    18bc <merge+0x7bc>
and    -0x8(%rsp),%r13b
jne    18bc <merge+0x7bc>
mov    -0x3b(%rsp),%dl
and    %dl,-0x3a(%rsp)
jne    18bc <merge+0x7bc>
mov    -0x39(%rsp),%dl
and    %dl,-0x3c(%rsp)
jne    18bc <merge+0x7bc>
and    %r11b,%bpl
jne    18bc <merge+0x7bc>
and    %bl,%al
jne    18bc <merge+0x7bc>
add    $0x1,%r12
mov    %r12,%rax
and    $0xfffffffffffffffc,%rax
mov    -0x30(%rsp),%r11
lea    (%rax,%r11,1),%rdx
mov    %rdx,-0x38(%rsp)
lea    (%rax,%r14,1),%r13
lea    0x10(%rcx,%r14,8),%rdx
lea    0x8(%r8,%r14,4),%r15
lea    0x8(%r9,%r14,4),%r14
mov    -0x28(%rsp),%rsi
lea    0x10(%rsi,%r11,8),%rbp
mov    -0x20(%rsp),%rsi
lea    (%rsi,%r11,4),%rdi
add    $0x8,%rdi
mov    -0x18(%rsp),%rbx
lea    (%rbx,%r11,4),%rsi
add    $0x8,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x10(%rdx,%rbx,8),%xmm0
movups (%rdx,%rbx,8),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,8)
movups %xmm1,0x0(%rbp,%rbx,8)
movups -0x8(%r15,%rbx,4),%xmm0
movups %xmm0,-0x8(%rdi,%rbx,4)
movups -0x8(%r14,%rbx,4),%xmm0
movups %xmm0,-0x8(%rsi,%rbx,4)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    1880 <merge+0x780>
cmp    %rax,%r12
jne    18c9 <merge+0x7c9>
jmp    19b8 <merge+0x8b8>
mov    -0x30(%rsp),%rax
mov    %rax,-0x38(%rsp)
mov    %r14,%r13
mov    %r10d,%eax
sub    %r13d,%eax
add    $0x1,%eax
test   $0x1,%al
jne    18e3 <merge+0x7e3>
mov    %r13,%rbx
cmp    %r10d,%r13d
jne    1926 <merge+0x826>
jmp    19b8 <merge+0x8b8>
mov    (%rcx,%r13,8),%rax
mov    -0x28(%rsp),%rdx
mov    -0x38(%rsp),%rsi
mov    %rax,(%rdx,%rsi,8)
mov    (%r8,%r13,4),%eax
mov    -0x20(%rsp),%rdx
mov    %eax,(%rdx,%rsi,4)
mov    (%r9,%r13,4),%eax
mov    -0x18(%rsp),%rdx
mov    %eax,(%rdx,%rsi,4)
add    $0x1,%rsi
mov    %rsi,-0x38(%rsp)
mov    %r13,%rbx
add    $0x1,%rbx
cmp    %r10d,%r13d
je     19b8 <merge+0x8b8>
mov    -0x28(%rsp),%rax
mov    -0x38(%rsp),%rdx
lea    (%rax,%rdx,8),%r11
add    $0x8,%r11
mov    -0x20(%rsp),%rax
lea    (%rax,%rdx,4),%rsi
add    $0x4,%rsi
mov    -0x18(%rsp),%rax
lea    (%rax,%rdx,4),%rdx
add    $0x4,%rdx
sub    %ebx,%r10d
add    $0x1,%r10d
lea    (%rcx,%rbx,8),%rcx
add    $0x8,%rcx
lea    (%r8,%rbx,4),%rdi
add    $0x4,%rdi
lea    (%r9,%rbx,4),%rbp
add    $0x4,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x8(%rcx,%rbx,8),%rax
mov    %rax,-0x8(%r11,%rbx,8)
mov    -0x4(%rdi,%rbx,4),%eax
mov    %eax,-0x4(%rsi,%rbx,4)
mov    -0x4(%rbp,%rbx,4),%eax
mov    %eax,-0x4(%rdx,%rbx,4)
mov    (%rcx,%rbx,8),%rax
mov    %rax,(%r11,%rbx,8)
mov    (%rdi,%rbx,4),%eax
mov    %eax,(%rsi,%rbx,4)
mov    0x0(%rbp,%rbx,4),%eax
mov    %eax,(%rdx,%rbx,4)
add    $0x2,%rbx
cmp    %ebx,%r10d
jne    1980 <merge+0x880>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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