#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);
void merge(int data[], int start, int middle, int end) {
  int leftLen = middle - start + 1;
  int rightLen = end - middle;
  int *left = (int *)malloc(leftLen * sizeof(int));
  int *right = (int *)malloc(rightLen * sizeof(int));
  int i = start, j = middle + 1;
  for (; i <= middle; i++) {
    left[i - start] = data[i];
  }
  for (; j <= end; j++) {
    right[j - middle - 1] = data[j];
  }
  int k = start, leftPostion = 0, rightPostion = 0;
  while (leftPostion < leftLen && rightPostion < rightLen) {
    if (left[leftPostion] <= right[rightPostion]) {
      data[k++] = left[leftPostion++];
    } else {
      data[k++] = right[rightPostion++];
    }
  }
  while (leftPostion < leftLen) {
    data[k++] = left[leftPostion++];
  }
  while (rightPostion < rightLen) {
    data[k++] = right[rightPostion++];
  }
  free(left);
  free(right);
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0x10(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movslq -0x18(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     11b4 <merge+0x94>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    -0xc(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    117f <merge+0x5f>
jmp    11b9 <merge+0x99>
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     11f1 <merge+0xd1>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11b9 <merge+0x99>
mov    -0xc(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x40(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x45(%rbp)
jge    1222 <merge+0x102>
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
mov    %al,-0x45(%rbp)
mov    -0x45(%rbp),%al
test   $0x1,%al
jne    1232 <merge+0x112>
jmp    12ac <merge+0x18c>
mov    -0x28(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x44(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     127d <merge+0x15d>
mov    -0x28(%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    -0x8(%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    12a7 <merge+0x187>
mov    -0x30(%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    -0x8(%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    1205 <merge+0xe5>
jmp    12b1 <merge+0x191>
mov    -0x40(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    12ec <merge+0x1cc>
mov    -0x28(%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    -0x8(%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    12b1 <merge+0x191>
jmp    12f1 <merge+0x1d1>
mov    -0x44(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    132c <merge+0x20c>
mov    -0x30(%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    -0x8(%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    12f1 <merge+0x1d1>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %ecx,%ebp
mov    %edx,%r15d
mov    %esi,%r12d
mov    %rdi,%r13
mov    %ecx,%ebx
sub    %edx,%ebx
mov    %edx,%eax
sub    %esi,%eax
lea    0x4(,%rax,4),%edi
call   1040 <malloc@plt>
mov    %rax,%r14
mov    %rbx,0x10(%rsp)
lea    0x0(,%rbx,4),%edi
mov    %r15,%rbx
call   1040 <malloc@plt>
mov    %r12d,%r10d
mov    %rax,%r15
mov    %ebx,%r12d
sub    %r10d,%r12d
jl     134b <merge+0x22b>
movslq %r10d,%r9
mov    %r9,%rcx
cmp    $0x7,%r12d
jb     12ca <merge+0x1aa>
mov    %r12d,%r8d
lea    (%r9,%r8,1),%rax
lea    0x4(,%rax,4),%rax
add    %r13,%rax
cmp    %rax,%r14
jae    11bc <merge+0x9c>
lea    (%r14,%r8,4),%rax
add    $0x4,%rax
lea    0x0(,%r9,4),%rdx
add    %r13,%rdx
mov    %r9,%rcx
cmp    %rax,%rdx
jb     12ca <merge+0x1aa>
mov    %r10d,%r11d
add    $0x1,%r8
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rax
mov    %rax,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0x18,%rax
jae    11ed <merge+0xcd>
xor    %edx,%edx
jmp    1270 <merge+0x150>
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
add    $0xfffffffffffffffe,%rax
and    %rax,%rdi
lea    0x70(,%r9,4),%rsi
add    %r13,%rsi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups -0x70(%rsi,%rdx,4),%xmm0
movups -0x60(%rsi,%rdx,4),%xmm1
movups %xmm0,(%r14,%rdx,4)
movups %xmm1,0x10(%r14,%rdx,4)
movups -0x50(%rsi,%rdx,4),%xmm0
movups -0x40(%rsi,%rdx,4),%xmm1
movups %xmm0,0x20(%r14,%rdx,4)
movups %xmm1,0x30(%r14,%rdx,4)
movups -0x30(%rsi,%rdx,4),%xmm0
movups -0x20(%rsi,%rdx,4),%xmm1
movups %xmm0,0x40(%r14,%rdx,4)
movups %xmm1,0x50(%r14,%rdx,4)
movups -0x10(%rsi,%rdx,4),%xmm0
movups (%rsi,%rdx,4),%xmm1
movups %xmm0,0x60(%r14,%rdx,4)
movups %xmm1,0x70(%r14,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rdi
jne    1210 <merge+0xf0>
test   %r10,%r10
je     12bb <merge+0x19b>
lea    (%r14,%rdx,4),%rax
add    $0x10,%rax
add    %r9,%rdx
lea    0x10(,%rdx,4),%rdx
add    %r13,%rdx
shl    $0x5,%r10
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdx,%rsi,1),%xmm0
movups (%rdx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rax,%rsi,1)
movups %xmm1,(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r10
jne    12a0 <merge+0x180>
cmp    %rcx,%r8
mov    %r11d,%r10d
je     134b <merge+0x22b>
add    %r9,%rcx
lea    0x1(%rbx),%r8d
mov    %r8d,%edi
sub    %ecx,%edi
mov    %ebx,%esi
sub    %ecx,%esi
and    $0x3,%edi
je     1301 <merge+0x1e1>
lea    0x0(,%r9,4),%rdx
mov    %r14,%rax
sub    %rdx,%rax
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rcx,4),%edx
mov    %edx,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%edi
jne    12f0 <merge+0x1d0>
cmp    $0x3,%esi
jb     134b <merge+0x22b>
mov    %r8d,%edx
mov    $0x3,%eax
sub    %r9,%rax
lea    (%r14,%rax,4),%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x0(%r13,%rcx,4),%esi
mov    %esi,-0xc(%rax,%rcx,4)
mov    0x4(%r13,%rcx,4),%esi
mov    %esi,-0x8(%rax,%rcx,4)
mov    0x8(%r13,%rcx,4),%esi
mov    %esi,-0x4(%rax,%rcx,4)
mov    0xc(%r13,%rcx,4),%esi
mov    %esi,(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %ecx,%edx
jne    1320 <merge+0x200>
cmp    %ebx,%ebp
mov    0x10(%rsp),%r8
jle    1536 <merge+0x416>
mov    %r10d,0xc(%rsp)
movslq %ebx,%rdx
movslq %ebp,%r11
mov    %r11,%r10
sub    %rdx,%r10
cmp    $0x8,%r10
jb     148e <merge+0x36e>
mov    %rdx,%rax
not    %rax
add    %r11,%rax
cmp    $0x7fffffff,%rax
ja     148e <merge+0x36e>
lea    0x4(,%rdx,4),%rax
add    %r13,%rax
lea    (%r15,%r10,4),%rcx
cmp    %rcx,%rax
jae    13b0 <merge+0x290>
lea    0x4(,%r11,4),%rax
add    %r13,%rax
cmp    %rax,%r15
jb     148e <merge+0x36e>
mov    %r10,%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x20(%rsp)
add    $0xfffffffffffffff8,%rax
mov    %rax,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rax,%rax
mov    %rcx,0x18(%rsp)
je     1860 <merge+0x740>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x34(,%rdx,4),%rcx
add    %r13,%rcx
xor    %r8d,%r8d
movabs $0x1000000000,%r9
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rdi,4),%xmm0
movups -0x20(%rcx,%rdi,4),%xmm1
mov    %r8,%rax
sar    $0x1e,%rax
movups %xmm0,(%r15,%rax,1)
movups %xmm1,0x10(%r15,%rax,1)
movups -0x10(%rcx,%rdi,4),%xmm0
movups (%rcx,%rdi,4),%xmm1
movabs $0x800000000,%rax
add    %r8,%rax
sar    $0x1e,%rax
movups %xmm0,(%r15,%rax,1)
movups %xmm1,0x10(%r15,%rax,1)
add    $0x10,%rdi
add    %r9,%r8
add    $0xfffffffffffffffe,%rsi
jne    1400 <merge+0x2e0>
testb  $0x1,0x18(%rsp)
je     1473 <merge+0x353>
lea    (%rdi,%rdx,1),%rax
movups 0x4(%r13,%rax,4),%xmm0
movups 0x14(%r13,%rax,4),%xmm1
movslq %edi,%rax
movups %xmm0,(%r15,%rax,4)
movups %xmm1,0x10(%r15,%rax,4)
mov    0x20(%rsp),%rax
cmp    %rax,%r10
mov    0x10(%rsp),%r8
mov    0xc(%rsp),%r10d
je     1536 <merge+0x416>
add    %rax,%rdx
sub    %edx,%ebp
mov    %rdx,%rcx
not    %rcx
add    %r11,%rcx
and    $0x3,%rbp
je     14d3 <merge+0x3b3>
mov    %ebx,%eax
neg    %eax
mov    0xc(%rsp),%r10d
nopl   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rsi
mov    0x4(%r13,%rdx,4),%edi
add    %eax,%edx
movslq %edx,%rdx
mov    %edi,(%r15,%rdx,4)
mov    %rsi,%rdx
add    $0xffffffffffffffff,%rbp
jne    14b0 <merge+0x390>
cmp    $0x3,%rcx
jae    14e1 <merge+0x3c1>
jmp    1536 <merge+0x416>
mov    %rdx,%rsi
mov    0xc(%rsp),%r10d
cmp    $0x3,%rcx
jb     1536 <merge+0x416>
mov    %ebx,%ecx
neg    %ecx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%r13,%rsi,4),%eax
lea    (%rcx,%rsi,1),%rdx
movslq %edx,%rdx
mov    %eax,(%r15,%rdx,4)
mov    0x8(%r13,%rsi,4),%eax
lea    0x1(%rdx),%edi
movslq %edi,%rdi
mov    %eax,(%r15,%rdi,4)
mov    0xc(%r13,%rsi,4),%eax
lea    0x2(%rdx),%edi
movslq %edi,%rdi
mov    %eax,(%r15,%rdi,4)
mov    0x10(%r13,%rsi,4),%eax
add    $0x4,%rsi
add    $0x3,%edx
movslq %edx,%rdx
mov    %eax,(%r15,%rdx,4)
cmp    %rsi,%r11
jne    14f0 <merge+0x3d0>
xor    %edi,%edi
mov    %rbx,%r9
mov    %r10d,%r11d
test   %r12d,%r12d
js     16b3 <merge+0x593>
mov    $0x0,%edx
test   %r8d,%r8d
jle    15a8 <merge+0x488>
movslq %r10d,%rax
lea    0x0(,%rax,4),%rsi
add    %r13,%rsi
xor    %edx,%edx
mov    %r10d,%r11d
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
mov    %edi,%eax
mov    %edx,%ebp
mov    %edi,%edx
mov    (%r14,%rdx,4),%ebx
mov    %ebp,%edx
mov    (%r15,%rdx,4),%ecx
xor    %edx,%edx
xor    %edi,%edi
cmp    %ecx,%ebx
setg   %dl
setle  %dil
cmovg  %ecx,%ebx
add    %eax,%edi
add    %ebp,%edx
mov    %ebx,(%rsi)
add    $0x1,%r11d
cmp    %r12d,%edi
jg     15a8 <merge+0x488>
add    $0x4,%rsi
cmp    %r8d,%edx
jl     1570 <merge+0x450>
cmp    %r12d,%edi
jg     16f2 <merge+0x5d2>
mov    %r10d,%eax
movslq %edi,%r10
movslq %r11d,%r11
add    %edi,%eax
mov    %r9,%rcx
sub    %eax,%ecx
cmp    $0x7,%ecx
jb     16c8 <merge+0x5a8>
lea    0x0(,%r11,4),%rax
add    %r13,%rax
lea    (%r10,%rcx,1),%rsi
lea    (%r14,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rax
jae    1602 <merge+0x4e2>
lea    (%r11,%rcx,1),%rax
lea    0x4(,%rax,4),%rax
add    %r13,%rax
lea    (%r14,%r10,4),%rsi
cmp    %rax,%rsi
jb     16c8 <merge+0x5a8>
add    $0x1,%rcx
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1841 <merge+0x721>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    0x30(,%r11,4),%rsi
add    %r13,%rsi
lea    (%r14,%r10,4),%rax
add    $0x30,%rax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rax,%rdi,4),%xmm0
movups -0x20(%rax,%rdi,4),%xmm1
movups %xmm0,-0x30(%rsi,%rdi,4)
movups %xmm1,-0x20(%rsi,%rdi,4)
movups -0x10(%rax,%rdi,4),%xmm0
movups (%rax,%rdi,4),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,4)
movups %xmm1,(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1650 <merge+0x530>
test   $0x1,%r9b
je     16a4 <merge+0x584>
lea    (%rdi,%r11,1),%rax
add    %r10,%rdi
movups (%r14,%rdi,4),%xmm0
movups 0x10(%r14,%rdi,4),%xmm1
movups %xmm0,0x0(%r13,%rax,4)
movups %xmm1,0x10(%r13,%rax,4)
add    %r8,%r11
cmp    %r8,%rcx
jne    16c0 <merge+0x5a0>
mov    0x10(%rsp),%r8
jmp    16f2 <merge+0x5d2>
xor    %edx,%edx
cmp    %r12d,%edi
jle    15b1 <merge+0x491>
jmp    16f2 <merge+0x5d2>
add    %r8,%r10
mov    0x10(%rsp),%r8
lea    0x0(,%r11,4),%rax
add    %r13,%rax
lea    (%r14,%r10,4),%rsi
sub    %r10d,%r12d
add    $0x1,%r12d
xor    %edi,%edi
mov    (%rsi,%rdi,4),%ecx
mov    %ecx,(%rax,%rdi,4)
add    $0x1,%rdi
cmp    %edi,%r12d
jne    16e0 <merge+0x5c0>
add    %rdi,%r11
cmp    %r8d,%edx
jge    1823 <merge+0x703>
movslq %edx,%rax
movslq %r8d,%rdx
movslq %r11d,%r10
lea    0x1(%rax),%rcx
cmp    %rcx,%rdx
mov    %rcx,%r11
cmovg  %rdx,%r11
sub    %rax,%r11
cmp    $0x8,%r11
jb     17ff <merge+0x6df>
lea    0x0(,%r10,4),%rsi
add    %r13,%rsi
cmp    %rcx,%rdx
cmovg  %rdx,%rcx
lea    (%r15,%rcx,4),%rdi
cmp    %rdi,%rsi
jae    1758 <merge+0x638>
add    %r10,%rcx
sub    %rax,%rcx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
lea    (%r15,%rax,4),%rsi
cmp    %rcx,%rsi
jb     17ff <merge+0x6df>
mov    %r11,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1852 <merge+0x732>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    0x30(,%r10,4),%rcx
add    %r13,%rcx
lea    (%r15,%rax,4),%rsi
add    $0x30,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rsi,%rdi,4),%xmm0
movups -0x20(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rcx,%rdi,4)
movups %xmm1,-0x20(%rcx,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,4)
movups %xmm1,(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    17a0 <merge+0x680>
test   $0x1,%r9b
je     17f4 <merge+0x6d4>
lea    (%rdi,%r10,1),%rcx
add    %rax,%rdi
movups (%r15,%rdi,4),%xmm0
movups 0x10(%r15,%rdi,4),%xmm1
movups %xmm0,0x0(%r13,%rcx,4)
movups %xmm1,0x10(%r13,%rcx,4)
cmp    %r8,%r11
je     1823 <merge+0x703>
add    %r8,%r10
add    %r8,%rax
lea    0x0(,%r10,4),%rcx
add    %r13,%rcx
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rax,4),%esi
add    $0x1,%rax
mov    %esi,(%rcx)
add    $0x4,%rcx
cmp    %rdx,%rax
jl     1810 <merge+0x6f0>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %edi,%edi
test   $0x1,%r9b
jne    1686 <merge+0x566>
jmp    16a4 <merge+0x584>
xor    %edi,%edi
test   $0x1,%r9b
jne    17d6 <merge+0x6b6>
jmp    17f4 <merge+0x6d4>
xor    %edi,%edi
testb  $0x1,0x18(%rsp)
jne    1455 <merge+0x335>
jmp    1473 <merge+0x353>

LLVM IR (-O0):
define void @merge(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** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32 %3, i32* %8
%18 = load i32, i32* %7
%19 = load i32, i32* %6
%20 = sub nsw i32 %18, %19
%21 = add nsw i32 %20, 1
store i32 %21, i32* %9
%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 = sext i32 %25 to i64
%27 = mul i64 %26, 4
%28 = trunc i64 %27 to i32
%29 = call i64 @malloc(i32 %28)
%30 = inttoptr i64 %29 to i32*
store i32* %30, i32** %11
%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* %6
store i32 %37, i32* %13
%38 = load i32, i32* %7
%39 = add nsw i32 %38, 1
store i32 %39, i32* %14
br label %40
40: ; preds = %56, %4
%41 = load i32, i32* %13
%42 = load i32, i32* %7
%43 = icmp sle i32 %41, %42
br i1 %43, label %44, label %59
44: ; preds = %40
%45 = load i32*, i32** %5
%46 = load i32, i32* %13
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
%49 = load i32, i32* %48
%50 = load i32*, i32** %11
%51 = load i32, i32* %13
%52 = load i32, i32* %6
%53 = sub nsw i32 %51, %52
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i32, i32* %50, i64 %54
store i32 %49, i32* %55
br label %56
56: ; preds = %44
%57 = load i32, i32* %13
%58 = add nsw i32 %57, 1
store i32 %58, i32* %13
br label %40
59: ; preds = %40
br label %60
60: ; preds = %77, %59
%61 = load i32, i32* %14
%62 = load i32, i32* %8
%63 = icmp sle i32 %61, %62
br i1 %63, label %64, label %80
64: ; preds = %60
%65 = load i32*, i32** %5
%66 = load i32, i32* %14
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %65, i64 %67
%69 = load i32, i32* %68
%70 = load i32*, i32** %12
%71 = load i32, i32* %14
%72 = load i32, i32* %7
%73 = sub nsw i32 %71, %72
%74 = sub nsw i32 %73, 1
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i32, i32* %70, i64 %75
store i32 %69, i32* %76
br label %77
77: ; preds = %64
%78 = load i32, i32* %14
%79 = add nsw i32 %78, 1
store i32 %79, i32* %14
br label %60
80: ; preds = %60
%81 = load i32, i32* %6
store i32 %81, i32* %15
store i32 0, i32* %16
store i32 0, i32* %17
br label %82
82: ; preds = %128, %80
%83 = load i32, i32* %16
%84 = load i32, i32* %9
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %90
86: ; preds = %82
%87 = load i32, i32* %17
%88 = load i32, i32* %10
%89 = icmp slt i32 %87, %88
br label %90
90: ; preds = %86, %82
%91 = phi i1 [ false, %82 ], [ %89, %86 ]
br i1 %91, label %92, label %129
92: ; preds = %90
%93 = load i32*, i32** %11
%94 = load i32, i32* %16
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %93, i64 %95
%97 = load i32, i32* %96
%98 = load i32*, i32** %12
%99 = load i32, i32* %17
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %98, i64 %100
%102 = load i32, i32* %101
%103 = icmp sle i32 %97, %102
br i1 %103, label %104, label %116
104: ; preds = %92
%105 = load i32*, i32** %11
%106 = load i32, i32* %16
%107 = add nsw i32 %106, 1
store i32 %107, i32* %16
%108 = sext i32 %106 to i64
%109 = getelementptr inbounds i32, i32* %105, i64 %108
%110 = load i32, i32* %109
%111 = load i32*, i32** %5
%112 = load i32, i32* %15
%113 = add nsw i32 %112, 1
store i32 %113, i32* %15
%114 = sext i32 %112 to i64
%115 = getelementptr inbounds i32, i32* %111, i64 %114
store i32 %110, i32* %115
br label %128
116: ; preds = %92
%117 = load i32*, i32** %12
%118 = load i32, i32* %17
%119 = add nsw i32 %118, 1
store i32 %119, i32* %17
%120 = sext i32 %118 to i64
%121 = getelementptr inbounds i32, i32* %117, i64 %120
%122 = load i32, i32* %121
%123 = load i32*, i32** %5
%124 = load i32, i32* %15
%125 = add nsw i32 %124, 1
store i32 %125, i32* %15
%126 = sext i32 %124 to i64
%127 = getelementptr inbounds i32, i32* %123, i64 %126
store i32 %122, i32* %127
br label %128
128: ; preds = %116, %104
br label %82
129: ; preds = %90
br label %130
130: ; preds = %134, %129
%131 = load i32, i32* %16
%132 = load i32, i32* %9
%133 = icmp slt i32 %131, %132
br i1 %133, label %134, label %146
134: ; preds = %130
%135 = load i32*, i32** %11
%136 = load i32, i32* %16
%137 = add nsw i32 %136, 1
store i32 %137, i32* %16
%138 = sext i32 %136 to i64
%139 = getelementptr inbounds i32, i32* %135, i64 %138
%140 = load i32, i32* %139
%141 = load i32*, i32** %5
%142 = load i32, i32* %15
%143 = add nsw i32 %142, 1
store i32 %143, i32* %15
%144 = sext i32 %142 to i64
%145 = getelementptr inbounds i32, i32* %141, i64 %144
store i32 %140, i32* %145
br label %130
146: ; preds = %130
br label %147
147: ; preds = %151, %146
%148 = load i32, i32* %17
%149 = load i32, i32* %10
%150 = icmp slt i32 %148, %149
br i1 %150, label %151, label %163
151: ; preds = %147
%152 = load i32*, i32** %12
%153 = load i32, i32* %17
%154 = add nsw i32 %153, 1
store i32 %154, i32* %17
%155 = sext i32 %153 to i64
%156 = getelementptr inbounds i32, i32* %152, i64 %155
%157 = load i32, i32* %156
%158 = load i32*, i32** %5
%159 = load i32, i32* %15
%160 = add nsw i32 %159, 1
store i32 %160, i32* %15
%161 = sext i32 %159 to i64
%162 = getelementptr inbounds i32, i32* %158, i64 %161
store i32 %157, i32* %162
br label %147
163: ; preds = %147
%164 = load i32*, i32** %11
%165 = call i32 @free(i32* %164)
%166 = load i32*, i32** %12
%167 = call i32 @free(i32* %166)
ret void
}

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