#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ printArray(int *, int);
int /*<<< orphan*/ printf(char *, int, int, ...);
int mergeSort(int *arr, int low, int mid, int high) {
  printf("low = %d mid=%d high=%d \n", low, mid, high);
  int n1 = mid - low;
  int n2 = high - mid;
  printf("n1 = %d n2=%d\n", n1, n2);
  int *a = (int *)malloc(n1 * sizeof(int));
  int *b = (int *)malloc(n2 * sizeof(int));
  int i, j, k, temp;
  j = low;
  for (i = 0; i < n1; i++) {
    a[i] = arr[j++];
  }
  j = mid;
  for (i = 0; i < n2; i++) {
    b[i] = arr[mid + i];
  }
  printArray(a, n1);
  printArray(b, n2);
  printArray(arr, n1 + n2);
  i = 0, j = 0, k = 0;
  while (j < n1 && k < n2) {
    if (a[j] < b[k]) {
      arr[i++] = a[j++];
    } else {
      arr[i++] = b[k++];
    }
  }
  while (j < n1) {
    arr[i++] = a[j++];
  }
  while (k < n2) {
    arr[i++] = b[k++];
  }
  printArray(arr, n1 + n2);
  free(a);
  free(b);
}


x86 assembly (clang, -O0):
<mergeSort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x1c(%rbp),%ecx
lea    0xe9b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    0xe8f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11ff <mergeSort+0xbf>
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11c5 <mergeSort+0x85>
mov    -0x18(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1241 <mergeSort+0x101>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    120c <mergeSort+0xcc>
mov    -0x30(%rbp),%rdi
mov    -0x20(%rbp),%esi
call   1060 <printArray@plt>
mov    -0x38(%rbp),%rdi
mov    -0x24(%rbp),%esi
call   1060 <printArray@plt>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%esi
add    -0x24(%rbp),%esi
call   1060 <printArray@plt>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x20(%rbp),%ecx
mov    %al,-0x49(%rbp)
jge    129a <mergeSort+0x15a>
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
setl   %al
mov    %al,-0x49(%rbp)
mov    -0x49(%rbp),%al
test   $0x1,%al
jne    12aa <mergeSort+0x16a>
jmp    1324 <mergeSort+0x1e4>
mov    -0x30(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0x44(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    12f5 <mergeSort+0x1b5>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%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    131f <mergeSort+0x1df>
mov    -0x38(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%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    127d <mergeSort+0x13d>
jmp    1329 <mergeSort+0x1e9>
mov    -0x40(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1364 <mergeSort+0x224>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x40(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%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    1329 <mergeSort+0x1e9>
jmp    1369 <mergeSort+0x229>
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    13a4 <mergeSort+0x264>
mov    -0x38(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x44(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%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    1369 <mergeSort+0x229>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%esi
add    -0x24(%rbp),%esi
call   1060 <printArray@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mergeSort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%ebx
mov    %edx,%ebp
mov    %esi,%r15d
mov    %rdi,%r14
lea    0xea1(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    %ebp,%r13d
mov    %r15d,0x8(%rsp)
sub    %r15d,%r13d
mov    %ebp,0xc(%rsp)
sub    %ebp,%ebx
lea    0xe9c(%rip),%rdi
mov    %r13d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0x0(,%r13,4),%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %rbx,0x10(%rsp)
lea    0x0(,%rbx,4),%edi
call   1050 <malloc@plt>
mov    %rax,%r12
test   %r13d,%r13d
jle    1344 <mergeSort+0x204>
movslq 0x8(%rsp),%rcx
mov    %r13d,%eax
cmp    $0x8,%r13d
jb     11e7 <mergeSort+0xa7>
lea    (%rcx,%rax,1),%rdx
lea    (%r14,%rdx,4),%rdx
cmp    %rdx,%r15
jae    126c <mergeSort+0x12c>
lea    (%r15,%rax,4),%rdx
lea    (%r14,%rcx,4),%rsi
cmp    %rdx,%rsi
jae    126c <mergeSort+0x12c>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rax,%rsi
mov    %rax,%rdi
and    $0x3,%rdi
je     1216 <mergeSort+0xd6>
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rcx,4),%ebp
add    $0x1,%rcx
mov    %ebp,(%r15,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1200 <mergeSort+0xc0>
cmp    $0x3,%rsi
jb     1344 <mergeSort+0x204>
lea    (%r14,%rcx,4),%rcx
add    $0xc,%rcx
sub    %rdx,%rax
lea    (%r15,%rdx,4),%rdx
add    $0xc,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0xc(%rcx,%rsi,4),%edi
mov    %edi,-0xc(%rdx,%rsi,4)
mov    -0x8(%rcx,%rsi,4),%edi
mov    %edi,-0x8(%rdx,%rsi,4)
mov    -0x4(%rcx,%rsi,4),%edi
mov    %edi,-0x4(%rdx,%rsi,4)
mov    (%rcx,%rsi,4),%edi
mov    %edi,(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%rax
jne    1240 <mergeSort+0x100>
jmp    1344 <mergeSort+0x204>
mov    %eax,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rsi
jae    1291 <mergeSort+0x151>
xor    %ebp,%ebp
jmp    1300 <mergeSort+0x1c0>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%rcx,4),%rsi
add    $0x70,%rsi
xor    %ebp,%ebp
nop
movups -0x70(%rsi,%rbp,4),%xmm0
movups -0x60(%rsi,%rbp,4),%xmm1
movups %xmm0,(%r15,%rbp,4)
movups %xmm1,0x10(%r15,%rbp,4)
movups -0x50(%rsi,%rbp,4),%xmm0
movups -0x40(%rsi,%rbp,4),%xmm1
movups %xmm0,0x20(%r15,%rbp,4)
movups %xmm1,0x30(%r15,%rbp,4)
movups -0x30(%rsi,%rbp,4),%xmm0
movups -0x20(%rsi,%rbp,4),%xmm1
movups %xmm0,0x40(%r15,%rbp,4)
movups %xmm1,0x50(%r15,%rbp,4)
movups -0x10(%rsi,%rbp,4),%xmm0
movups (%rsi,%rbp,4),%xmm1
movups %xmm0,0x60(%r15,%rbp,4)
movups %xmm1,0x70(%r15,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    12a0 <mergeSort+0x160>
test   %r8,%r8
je     133b <mergeSort+0x1fb>
lea    (%r15,%rbp,4),%rsi
add    $0x10,%rsi
add    %rcx,%rbp
lea    (%r14,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebp,%ebp
xchg   %ax,%ax
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    1320 <mergeSort+0x1e0>
cmp    %rax,%rdx
jne    1426 <mergeSort+0x2e6>
mov    0x10(%rsp),%rbx
test   %ebx,%ebx
jle    14e4 <mergeSort+0x3a4>
movslq 0xc(%rsp),%r8
mov    %ebx,%eax
cmp    $0x8,%ebx
jb     137f <mergeSort+0x23f>
lea    (%r8,%rax,1),%rcx
lea    (%r14,%rcx,4),%rcx
cmp    %rcx,%r12
jae    1400 <mergeSort+0x2c0>
lea    (%r12,%rax,4),%rcx
lea    (%r14,%r8,4),%rdx
cmp    %rcx,%rdx
jae    1400 <mergeSort+0x2c0>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %rax,%rcx
mov    %rax,%rsi
and    $0x3,%rsi
je     13b1 <mergeSort+0x271>
lea    (%r14,%r8,4),%rdi
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rdx,4),%ebp
mov    %ebp,(%r12,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    13a0 <mergeSort+0x260>
cmp    $0x3,%rcx
jb     14e4 <mergeSort+0x3a4>
lea    (%r14,%r8,4),%rcx
add    $0xc,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xc(%rcx,%rdx,4),%esi
mov    %esi,(%r12,%rdx,4)
mov    -0x8(%rcx,%rdx,4),%esi
mov    %esi,0x4(%r12,%rdx,4)
mov    -0x4(%rcx,%rdx,4),%esi
mov    %esi,0x8(%r12,%rdx,4)
mov    (%rcx,%rdx,4),%esi
mov    %esi,0xc(%r12,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    13d0 <mergeSort+0x290>
jmp    14e4 <mergeSort+0x3a4>
mov    %eax,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rcx
jae    142e <mergeSort+0x2ee>
xor    %ebp,%ebp
jmp    14a0 <mergeSort+0x360>
add    %rdx,%rcx
jmp    11e9 <mergeSort+0xa9>
and    $0xfffffffffffffffc,%rdi
lea    (%r14,%r8,4),%rcx
add    $0x70,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x70(%rcx,%rbp,4),%xmm0
movups -0x60(%rcx,%rbp,4),%xmm1
movups %xmm0,(%r12,%rbp,4)
movups %xmm1,0x10(%r12,%rbp,4)
movups -0x50(%rcx,%rbp,4),%xmm0
movups -0x40(%rcx,%rbp,4),%xmm1
movups %xmm0,0x20(%r12,%rbp,4)
movups %xmm1,0x30(%r12,%rbp,4)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,0x40(%r12,%rbp,4)
movups %xmm1,0x50(%r12,%rbp,4)
movups -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movups %xmm0,0x60(%r12,%rbp,4)
movups %xmm1,0x70(%r12,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1440 <mergeSort+0x300>
test   %rsi,%rsi
je     14db <mergeSort+0x39b>
lea    (%r12,%rbp,4),%rcx
add    $0x10,%rcx
add    %r8,%rbp
lea    (%r14,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
xchg   %ax,%ax
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    14c0 <mergeSort+0x380>
cmp    %rax,%rdx
jne    1381 <mergeSort+0x241>
mov    %r15,%rdi
mov    %r13d,%esi
call   1060 <printArray@plt>
mov    %r12,%rdi
mov    %ebx,%esi
call   1060 <printArray@plt>
lea    (%rbx,%r13,1),%ebp
mov    %r14,%rdi
mov    %ebp,%esi
call   1060 <printArray@plt>
xor    %edx,%edx
test   %r13d,%r13d
jle    1675 <mergeSort+0x535>
mov    $0x0,%ecx
mov    $0x0,%eax
test   %ebx,%ebx
mov    %rbx,%r9
jle    1568 <mergeSort+0x428>
mov    %ebp,%r8d
xor    %eax,%eax
xor    %ecx,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
mov    %edx,%esi
mov    %ecx,%edi
mov    %edx,%ecx
mov    (%r15,%rcx,4),%ebp
mov    %edi,%ecx
mov    (%r12,%rcx,4),%ebx
xor    %ecx,%ecx
xor    %edx,%edx
cmp    %ebx,%ebp
setge  %cl
setl   %dl
cmovl  %ebp,%ebx
add    %esi,%edx
add    %edi,%ecx
mov    %ebx,(%r14,%rax,4)
add    $0x1,%rax
cmp    %r13d,%edx
jge    1565 <mergeSort+0x425>
cmp    %r9d,%ecx
jl     1530 <mergeSort+0x3f0>
mov    %r8d,%ebp
cmp    %r13d,%edx
jge    16a5 <mergeSort+0x565>
mov    %eax,%eax
movslq %edx,%rdx
movslq %r13d,%r11
lea    0x1(%rdx),%rsi
cmp    %rsi,%r11
mov    %rsi,%r10
cmovg  %r11,%r10
sub    %rdx,%r10
cmp    $0x8,%r10
jb     1690 <mergeSort+0x550>
mov    %ebp,%r13d
lea    (%r14,%rax,4),%rdi
cmp    %rsi,%r11
cmovg  %r11,%rsi
lea    (%r15,%rsi,4),%rbp
cmp    %rbp,%rdi
jae    15c2 <mergeSort+0x482>
add    %rax,%rsi
sub    %rdx,%rsi
lea    (%r14,%rsi,4),%rsi
lea    (%r15,%rdx,4),%rdi
cmp    %rsi,%rdi
jb     168a <mergeSort+0x54a>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     17fb <mergeSort+0x6bb>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %r9,%rdi
lea    (%r15,%rdx,4),%rsi
add    $0x30,%rsi
lea    (%r14,%rax,4),%rbx
add    $0x30,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%rsi,%rbp,4),%xmm0
movups -0x20(%rsi,%rbp,4),%xmm1
movups %xmm0,-0x30(%rbx,%rbp,4)
movups %xmm1,-0x20(%rbx,%rbp,4)
movups -0x10(%rsi,%rbp,4),%xmm0
movups (%rsi,%rbp,4),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,4)
movups %xmm1,(%rbx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    1610 <mergeSort+0x4d0>
test   $0x1,%r9b
je     1663 <mergeSort+0x523>
lea    (%rdx,%rbp,1),%rsi
add    %rax,%rbp
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups %xmm0,(%r14,%rbp,4)
movups %xmm1,0x10(%r14,%rbp,4)
add    %r8,%rax
cmp    %r8,%r10
mov    0x10(%rsp),%r9
jne    1687 <mergeSort+0x547>
mov    %r13d,%ebp
jmp    16a5 <mergeSort+0x565>
xor    %ecx,%ecx
xor    %eax,%eax
mov    %rbx,%r9
cmp    %r13d,%edx
jl     1571 <mergeSort+0x431>
jmp    16a5 <mergeSort+0x565>
add    %r8,%rdx
mov    %r13d,%ebp
nopl   (%rax)
mov    (%r15,%rdx,4),%esi
add    $0x1,%rdx
mov    %esi,(%r14,%rax,4)
add    $0x1,%rax
cmp    %r11,%rdx
jl     1690 <mergeSort+0x550>
cmp    %r9d,%ecx
jge    17d3 <mergeSort+0x693>
mov    %eax,%r10d
movslq %ecx,%rax
movslq %r9d,%rcx
lea    0x1(%rax),%rdx
cmp    %rdx,%rcx
mov    %rdx,%rsi
cmovg  %rcx,%rsi
sub    %rax,%rsi
cmp    $0x8,%rsi
jb     17b1 <mergeSort+0x671>
mov    %ebp,%r11d
lea    (%r14,%r10,4),%rdi
cmp    %rdx,%rcx
cmovg  %rcx,%rdx
lea    (%r12,%rdx,4),%rbp
cmp    %rbp,%rdi
jae    1704 <mergeSort+0x5c4>
add    %r10,%rdx
sub    %rax,%rdx
lea    (%r14,%rdx,4),%rdx
lea    (%r12,%rax,4),%rdi
cmp    %rdx,%rdi
jae    1704 <mergeSort+0x5c4>
mov    %r11d,%ebp
jmp    17b1 <mergeSort+0x671>
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     180c <mergeSort+0x6cc>
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
or     $0x2,%rbp
and    %r9,%rbp
lea    (%r12,%rax,4),%rdx
add    $0x30,%rdx
lea    (%r14,%r10,4),%rbx
add    $0x30,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rdx,%rdi,4),%xmm0
movups -0x20(%rdx,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbx,%rdi,4)
movups %xmm1,-0x20(%rbx,%rdi,4)
movups -0x10(%rdx,%rdi,4),%xmm0
movups (%rdx,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,4)
movups %xmm1,(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1750 <mergeSort+0x610>
test   $0x1,%r9b
je     17a3 <mergeSort+0x663>
lea    (%rdi,%rax,1),%rdx
add    %r10,%rdi
movups (%r12,%rdx,4),%xmm0
movups 0x10(%r12,%rdx,4),%xmm1
movups %xmm0,(%r14,%rdi,4)
movups %xmm1,0x10(%r14,%rdi,4)
cmp    %r8,%rsi
mov    %r11d,%ebp
je     17d3 <mergeSort+0x693>
add    %r8,%rax
add    %r8,%r10
lea    (%r14,%r10,4),%rdx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%rax,4),%esi
add    $0x1,%rax
mov    %esi,(%rdx)
add    $0x4,%rdx
cmp    %rcx,%rax
jl     17c0 <mergeSort+0x680>
mov    %r14,%rdi
mov    %ebp,%esi
call   1060 <printArray@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    1646 <mergeSort+0x506>
jmp    1663 <mergeSort+0x523>
xor    %edi,%edi
test   $0x1,%r9b
jne    1786 <mergeSort+0x646>
jmp    17a3 <mergeSort+0x663>

LLVM IR (-O0):
@.str = [26 x i8] c"low = %d mid=%d high=%d \0A\00"
@.str.1 = [15 x i8] c"n1 = %d n2=%d\0A\00"
define i32 @mergeSort(i32* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%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
store i32* %0, i32** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
%18 = load i32, i32* %7
%19 = load i32, i32* %8
%20 = load i32, i32* %9
%21 = call i32 (i8*, i32, i32, ...) @printf(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i32 %18, i32 %19, i32 %20)
%22 = load i32, i32* %8
%23 = load i32, i32* %7
%24 = sub nsw i32 %22, %23
store i32 %24, i32* %10
%25 = load i32, i32* %9
%26 = load i32, i32* %8
%27 = sub nsw i32 %25, %26
store i32 %27, i32* %11
%28 = load i32, i32* %10
%29 = load i32, i32* %11
%30 = call i32 (i8*, i32, i32, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str.1, i64 0, i64 0), i32 %28, i32 %29)
%31 = load i32, i32* %10
%32 = sext i32 %31 to i64
%33 = mul i64 %32, 4
%34 = trunc i64 %33 to i32
%35 = call i64 @malloc(i32 %34)
%36 = inttoptr i64 %35 to i32*
store i32* %36, i32** %12
%37 = load i32, i32* %11
%38 = sext i32 %37 to i64
%39 = mul i64 %38, 4
%40 = trunc i64 %39 to i32
%41 = call i64 @malloc(i32 %40)
%42 = inttoptr i64 %41 to i32*
store i32* %42, i32** %13
%43 = load i32, i32* %7
store i32 %43, i32* %15
store i32 0, i32* %14
br label %44
44: ; preds = %59, %4
%45 = load i32, i32* %14
%46 = load i32, i32* %10
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %62
48: ; preds = %44
%49 = load i32*, i32** %6
%50 = load i32, i32* %15
%51 = add nsw i32 %50, 1
store i32 %51, i32* %15
%52 = sext i32 %50 to i64
%53 = getelementptr inbounds i32, i32* %49, i64 %52
%54 = load i32, i32* %53
%55 = load i32*, i32** %12
%56 = load i32, i32* %14
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
store i32 %54, i32* %58
br label %59
59: ; preds = %48
%60 = load i32, i32* %14
%61 = add nsw i32 %60, 1
store i32 %61, i32* %14
br label %44
62: ; preds = %44
%63 = load i32, i32* %8
store i32 %63, i32* %15
store i32 0, i32* %14
br label %64
64: ; preds = %80, %62
%65 = load i32, i32* %14
%66 = load i32, i32* %11
%67 = icmp slt i32 %65, %66
br i1 %67, label %68, label %83
68: ; preds = %64
%69 = load i32*, i32** %6
%70 = load i32, i32* %8
%71 = load i32, i32* %14
%72 = add nsw i32 %70, %71
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %69, i64 %73
%75 = load i32, i32* %74
%76 = load i32*, i32** %13
%77 = load i32, i32* %14
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i32, i32* %76, i64 %78
store i32 %75, i32* %79
br label %80
80: ; preds = %68
%81 = load i32, i32* %14
%82 = add nsw i32 %81, 1
store i32 %82, i32* %14
br label %64
83: ; preds = %64
%84 = load i32*, i32** %12
%85 = load i32, i32* %10
%86 = call i32 @printArray(i32* %84, i32 %85)
%87 = load i32*, i32** %13
%88 = load i32, i32* %11
%89 = call i32 @printArray(i32* %87, i32 %88)
%90 = load i32*, i32** %6
%91 = load i32, i32* %10
%92 = load i32, i32* %11
%93 = add nsw i32 %91, %92
%94 = call i32 @printArray(i32* %90, i32 %93)
store i32 0, i32* %14
store i32 0, i32* %15
store i32 0, i32* %16
br label %95
95: ; preds = %141, %83
%96 = load i32, i32* %15
%97 = load i32, i32* %10
%98 = icmp slt i32 %96, %97
br i1 %98, label %99, label %103
99: ; preds = %95
%100 = load i32, i32* %16
%101 = load i32, i32* %11
%102 = icmp slt i32 %100, %101
br label %103
103: ; preds = %99, %95
%104 = phi i1 [ false, %95 ], [ %102, %99 ]
br i1 %104, label %105, label %142
105: ; preds = %103
%106 = load i32*, i32** %12
%107 = load i32, i32* %15
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %106, i64 %108
%110 = load i32, i32* %109
%111 = load i32*, i32** %13
%112 = load i32, i32* %16
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %111, i64 %113
%115 = load i32, i32* %114
%116 = icmp slt i32 %110, %115
br i1 %116, label %117, label %129
117: ; preds = %105
%118 = load i32*, i32** %12
%119 = load i32, i32* %15
%120 = add nsw i32 %119, 1
store i32 %120, i32* %15
%121 = sext i32 %119 to i64
%122 = getelementptr inbounds i32, i32* %118, i64 %121
%123 = load i32, i32* %122
%124 = load i32*, i32** %6
%125 = load i32, i32* %14
%126 = add nsw i32 %125, 1
store i32 %126, i32* %14
%127 = sext i32 %125 to i64
%128 = getelementptr inbounds i32, i32* %124, i64 %127
store i32 %123, i32* %128
br label %141
129: ; preds = %105
%130 = load i32*, i32** %13
%131 = load i32, i32* %16
%132 = add nsw i32 %131, 1
store i32 %132, i32* %16
%133 = sext i32 %131 to i64
%134 = getelementptr inbounds i32, i32* %130, i64 %133
%135 = load i32, i32* %134
%136 = load i32*, i32** %6
%137 = load i32, i32* %14
%138 = add nsw i32 %137, 1
store i32 %138, i32* %14
%139 = sext i32 %137 to i64
%140 = getelementptr inbounds i32, i32* %136, i64 %139
store i32 %135, i32* %140
br label %141
141: ; preds = %129, %117
br label %95
142: ; preds = %103
br label %143
143: ; preds = %147, %142
%144 = load i32, i32* %15
%145 = load i32, i32* %10
%146 = icmp slt i32 %144, %145
br i1 %146, label %147, label %159
147: ; preds = %143
%148 = load i32*, i32** %12
%149 = load i32, i32* %15
%150 = add nsw i32 %149, 1
store i32 %150, i32* %15
%151 = sext i32 %149 to i64
%152 = getelementptr inbounds i32, i32* %148, i64 %151
%153 = load i32, i32* %152
%154 = load i32*, i32** %6
%155 = load i32, i32* %14
%156 = add nsw i32 %155, 1
store i32 %156, i32* %14
%157 = sext i32 %155 to i64
%158 = getelementptr inbounds i32, i32* %154, i64 %157
store i32 %153, i32* %158
br label %143
159: ; preds = %143
br label %160
160: ; preds = %164, %159
%161 = load i32, i32* %16
%162 = load i32, i32* %11
%163 = icmp slt i32 %161, %162
br i1 %163, label %164, label %176
164: ; preds = %160
%165 = load i32*, i32** %13
%166 = load i32, i32* %16
%167 = add nsw i32 %166, 1
store i32 %167, i32* %16
%168 = sext i32 %166 to i64
%169 = getelementptr inbounds i32, i32* %165, i64 %168
%170 = load i32, i32* %169
%171 = load i32*, i32** %6
%172 = load i32, i32* %14
%173 = add nsw i32 %172, 1
store i32 %173, i32* %14
%174 = sext i32 %172 to i64
%175 = getelementptr inbounds i32, i32* %171, i64 %174
store i32 %170, i32* %175
br label %160
176: ; preds = %160
%177 = load i32*, i32** %6
%178 = load i32, i32* %10
%179 = load i32, i32* %11
%180 = add nsw i32 %178, %179
%181 = call i32 @printArray(i32* %177, i32 %180)
%182 = load i32*, i32** %12
%183 = call i32 @free(i32* %182)
%184 = load i32*, i32** %13
%185 = call i32 @free(i32* %184)
%186 = load i32, i32* %5
ret i32 %186
}

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