#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 */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(int *);
void merge(int data[], int left, int middle, int right) {
  int left_idx, right_idx, merged_idx;
  int left_size = middle - left + 1;
  int right_size = right - middle;
  int *tmp_left = (int *)calloc(left_size, sizeof(int));
  int *tmp_right = (int *)calloc(right_size, sizeof(int));
  for (left_idx = 0; left_idx < left_size; left_idx++)
    tmp_left[left_idx] = data[left + left_idx];
  for (right_idx = 0; right_idx < right_size; right_idx++)
    tmp_right[right_idx] = data[middle + 1 + right_idx];
  left_idx = 0;
  right_idx = 0;
  merged_idx = left;
  while (left_idx < left_size && right_idx < right_size) {
    if (tmp_left[left_idx] <= tmp_right[right_idx]) {
      data[merged_idx] = tmp_left[left_idx];
      left_idx++;
    } else {
      data[merged_idx] = tmp_right[right_idx];
      right_idx++;
    }
    merged_idx++;
  }
  while (left_idx < left_size) {
    data[merged_idx] = tmp_left[left_idx];
    left_idx++;
    merged_idx++;
  }
  while (right_idx < right_size) {
    data[merged_idx] = tmp_right[right_idx];
    right_idx++;
    merged_idx++;
  }
  free(tmp_left);
  free(tmp_right);
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%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,-0x24(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11a8 <merge+0x88>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1173 <merge+0x53>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11e7 <merge+0xc7>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11af <merge+0x8f>
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x39(%rbp)
jge    1218 <merge+0xf8>
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
setl   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    1228 <merge+0x108>
jmp    1295 <merge+0x175>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x38(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1268 <merge+0x148>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1287 <merge+0x167>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11fb <merge+0xdb>
jmp    129a <merge+0x17a>
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12d3 <merge+0x1b3>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    129a <merge+0x17a>
jmp    12d8 <merge+0x1b8>
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1311 <merge+0x1f1>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12d8 <merge+0x1b8>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%ebx
mov    %rdi,%r15
mov    %edx,%ebp
mov    %esi,0x4(%rsp)
sub    %esi,%ebp
lea    0x1(%rbp),%r13d
mov    %rdx,0x8(%rsp)
sub    %edx,%ebx
mov    %r13d,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%r14
mov    %ebx,0x14(%rsp)
mov    %ebx,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rbp,%r10
mov    %rax,%r12
test   %r10d,%r10d
js     1304 <merge+0x1e4>
movslq 0x4(%rsp),%r8
cmp    $0x8,%r13d
jb     11a2 <merge+0x82>
lea    (%r8,%r13,1),%rax
lea    (%r15,%rax,4),%rax
cmp    %rax,%r14
jae    1220 <merge+0x100>
lea    (%r14,%r13,4),%rax
lea    (%r15,%r8,4),%rcx
cmp    %rax,%rcx
jae    1220 <merge+0x100>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r13,%rax
mov    %r13,%rdx
and    $0x3,%rdx
je     11d1 <merge+0xb1>
lea    (%r15,%r8,4),%rsi
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,4),%edi
mov    %edi,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    11c0 <merge+0xa0>
cmp    $0x3,%rax
jb     1304 <merge+0x1e4>
lea    (%r15,%r8,4),%rax
add    $0xc,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xc(%rax,%rcx,4),%edx
mov    %edx,(%r14,%rcx,4)
mov    -0x8(%rax,%rcx,4),%edx
mov    %edx,0x4(%r14,%rcx,4)
mov    -0x4(%rax,%rcx,4),%edx
mov    %edx,0x8(%r14,%rcx,4)
mov    (%rax,%rcx,4),%edx
mov    %edx,0xc(%r14,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    11f0 <merge+0xd0>
jmp    1304 <merge+0x1e4>
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rax
jae    1244 <merge+0x124>
xor    %edi,%edi
jmp    12c0 <merge+0x1a0>
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
add    $0xfffffffffffffffe,%rax
and    %rax,%rsi
lea    (%r15,%r8,4),%rax
add    $0x70,%rax
xor    %edi,%edi
nop
movups -0x70(%rax,%rdi,4),%xmm0
movups -0x60(%rax,%rdi,4),%xmm1
movups %xmm0,(%r14,%rdi,4)
movups %xmm1,0x10(%r14,%rdi,4)
movups -0x50(%rax,%rdi,4),%xmm0
movups -0x40(%rax,%rdi,4),%xmm1
movups %xmm0,0x20(%r14,%rdi,4)
movups %xmm1,0x30(%r14,%rdi,4)
movups -0x30(%rax,%rdi,4),%xmm0
movups -0x20(%rax,%rdi,4),%xmm1
movups %xmm0,0x40(%r14,%rdi,4)
movups %xmm1,0x50(%r14,%rdi,4)
movups -0x10(%rax,%rdi,4),%xmm0
movups (%rax,%rdi,4),%xmm1
movups %xmm0,0x60(%r14,%rdi,4)
movups %xmm1,0x70(%r14,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1260 <merge+0x140>
test   %rdx,%rdx
je     12fb <merge+0x1db>
lea    (%r14,%rdi,4),%rax
add    $0x10,%rax
add    %r8,%rdi
lea    (%r15,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
xchg   %ax,%ax
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    12e0 <merge+0x1c0>
cmp    %r13,%rcx
jne    11a4 <merge+0x84>
mov    0x14(%rsp),%r13d
test   %r13d,%r13d
mov    0x8(%rsp),%r8
jle    1369 <merge+0x249>
mov    %r13d,%r9d
cmp    $0x8,%r13d
jae    1370 <merge+0x250>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdi
and    $0x3,%rdi
je     1428 <merge+0x308>
lea    0x1(%r8),%ebp
nopl   0x0(%rax,%rax,1)
lea    0x1(%rcx),%rdx
lea    (%rcx,%rbp,1),%eax
cltq
mov    (%r15,%rax,4),%eax
mov    %eax,(%r12,%rcx,4)
mov    %rdx,%rcx
add    $0xffffffffffffffff,%rdi
jne    1340 <merge+0x220>
cmp    $0x3,%rsi
jae    1431 <merge+0x311>
jmp    1486 <merge+0x366>
xor    %ecx,%ecx
jmp    14ea <merge+0x3ca>
lea    -0x1(%r9),%rsi
lea    0x1(%r8),%edx
lea    (%r8,%rsi,1),%edi
add    $0x1,%edi
xor    %ecx,%ecx
cmp    %edx,%edi
jl     131e <merge+0x1fe>
shr    $0x20,%rsi
jne    131e <merge+0x1fe>
movslq %edx,%rcx
lea    (%rcx,%r9,1),%rdx
lea    (%r15,%rdx,4),%rdx
cmp    %rdx,%r12
jae    13ac <merge+0x28c>
lea    (%r12,%r9,4),%rdx
lea    (%r15,%rcx,4),%rcx
cmp    %rdx,%rcx
jb     131c <merge+0x1fc>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1750 <merge+0x630>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
mov    0x8(%rsp),%rax
lea    0x9(%rax),%esi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
lea    -0x8(%rsi),%ebp
movslq %ebp,%rbp
movups (%r15,%rbp,4),%xmm0
movups 0x10(%r15,%rbp,4),%xmm1
movups %xmm0,(%r12,%rdx,4)
movups %xmm1,0x10(%r12,%rdx,4)
movslq %esi,%rsi
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups %xmm0,0x20(%r12,%rdx,4)
movups %xmm1,0x30(%r12,%rdx,4)
add    $0x10,%rdx
add    $0x10,%esi
add    $0xfffffffffffffffe,%rdi
jne    13e0 <merge+0x2c0>
jmp    1752 <merge+0x632>
mov    %rcx,%rdx
cmp    $0x3,%rsi
jb     1486 <merge+0x366>
mov    %r8d,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%rcx,%rdx,1),%eax
add    $0x1,%eax
cltq
mov    (%r15,%rax,4),%eax
mov    %eax,(%r12,%rdx,4)
lea    0x2(%rcx,%rdx,1),%eax
cltq
mov    (%r15,%rax,4),%eax
mov    %eax,0x4(%r12,%rdx,4)
lea    0x3(%rcx,%rdx,1),%eax
cltq
mov    (%r15,%rax,4),%eax
mov    %eax,0x8(%r12,%rdx,4)
lea    0x4(%rcx,%rdx,1),%eax
cltq
mov    (%r15,%rax,4),%eax
mov    %eax,0xc(%r12,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    1440 <merge+0x320>
xor    %ecx,%ecx
test   %r10d,%r10d
js     14ea <merge+0x3ca>
mov    0x4(%rsp),%r9d
mov    %r9d,%r11d
mov    $0x0,%esi
test   %r13d,%r13d
jle    14f4 <merge+0x3d4>
movslq %r9d,%rax
lea    (%r15,%rax,4),%rdx
xor    %esi,%esi
mov    %r9d,%r11d
xor    %ecx,%ecx
nopl   (%rax)
mov    %ecx,%edi
mov    %esi,%ebp
mov    %esi,%ecx
mov    (%r14,%rcx,4),%ebx
mov    %edi,%ecx
mov    (%r12,%rcx,4),%eax
xor    %esi,%esi
xor    %ecx,%ecx
cmp    %eax,%ebx
setle  %sil
setg   %cl
cmovg  %eax,%ebx
add    %edi,%ecx
add    %ebp,%esi
mov    %ebx,(%rdx)
add    $0x1,%r11d
cmp    %r10d,%esi
jg     14f4 <merge+0x3d4>
add    $0x4,%rdx
cmp    %r13d,%ecx
jl     14b0 <merge+0x390>
jmp    14f4 <merge+0x3d4>
mov    0x4(%rsp),%r9d
mov    %r9d,%r11d
xor    %esi,%esi
cmp    %r10d,%esi
jg     1611 <merge+0x4f1>
mov    %r10,%rax
movslq %esi,%r10
movslq %r11d,%r11
add    %esi,%r9d
sub    %r9d,%r8d
cmp    $0x7,%r8d
jb     15df <merge+0x4bf>
lea    (%r15,%r11,4),%rdx
lea    (%r10,%r8,1),%rsi
lea    (%r14,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdx
jae    1544 <merge+0x424>
lea    (%r11,%r8,1),%rdx
lea    (%r15,%rdx,4),%rdx
add    $0x4,%rdx
lea    (%r14,%r10,4),%rsi
cmp    %rdx,%rsi
jb     15df <merge+0x4bf>
add    $0x1,%r8
mov    %r8,%rbx
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1731 <merge+0x611>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%r15,%r11,4),%rdx
add    $0x30,%rdx
lea    (%r14,%r10,4),%rbp
add    $0x30,%rbp
xor    %esi,%esi
movups -0x30(%rbp,%rsi,4),%xmm0
movups -0x20(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x30(%rdx,%rsi,4)
movups %xmm1,-0x20(%rdx,%rsi,4)
movups -0x10(%rbp,%rsi,4),%xmm0
movups 0x0(%rbp,%rsi,4),%xmm1
movups %xmm0,-0x10(%rdx,%rsi,4)
movups %xmm1,(%rdx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1580 <merge+0x460>
test   $0x1,%r9b
je     15d4 <merge+0x4b4>
lea    (%rsi,%r11,1),%rdx
add    %r10,%rsi
movups (%r14,%rsi,4),%xmm0
movups 0x10(%r14,%rsi,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
add    %r8,%r11
cmp    %r8,%rbx
je     1611 <merge+0x4f1>
add    %r8,%r10
lea    (%r15,%r11,4),%rdx
lea    (%r14,%r10,4),%rsi
sub    %r10d,%eax
mov    %rax,%rbp
add    $0x1,%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%rdi,4),%eax
mov    %eax,(%rdx,%rdi,4)
add    $0x1,%rdi
cmp    %edi,%ebp
jne    1600 <merge+0x4e0>
add    %rdi,%r11
cmp    %r13d,%ecx
jge    1713 <merge+0x5f3>
movslq %ecx,%rcx
movslq %r13d,%rdx
movslq %r11d,%r10
mov    %rdx,%r11
sub    %rcx,%r11
cmp    $0x8,%r11
jb     16ee <merge+0x5ce>
lea    (%r15,%r10,4),%rax
lea    (%r12,%rdx,4),%rsi
cmp    %rsi,%rax
jae    1658 <merge+0x538>
lea    (%r10,%rdx,1),%rax
sub    %rcx,%rax
lea    (%r15,%rax,4),%rax
lea    (%r12,%rcx,4),%rsi
cmp    %rax,%rsi
jb     16ee <merge+0x5ce>
mov    %r11,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1742 <merge+0x622>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r15,%r10,4),%rax
add    $0x30,%rax
lea    (%r12,%rcx,4),%rsi
add    $0x30,%rsi
xor    %edi,%edi
movups -0x30(%rsi,%rdi,4),%xmm0
movups -0x20(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rax,%rdi,4)
movups %xmm1,-0x20(%rax,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rax,%rdi,4)
movups %xmm1,(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1690 <merge+0x570>
test   $0x1,%r9b
je     16e3 <merge+0x5c3>
lea    (%rdi,%r10,1),%rax
add    %rcx,%rdi
movups (%r12,%rdi,4),%xmm0
movups 0x10(%r12,%rdi,4),%xmm1
movups %xmm0,(%r15,%rax,4)
movups %xmm1,0x10(%r15,%rax,4)
cmp    %r8,%r11
je     1713 <merge+0x5f3>
add    %r8,%r10
add    %r8,%rcx
lea    (%r15,%r10,4),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r12,%rcx,4),%esi
mov    %esi,(%rax)
add    $0x1,%rcx
add    $0x4,%rax
cmp    %rdx,%rcx
jl     1700 <merge+0x5e0>
mov    %r14,%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    %esi,%esi
test   $0x1,%r9b
jne    15b7 <merge+0x497>
jmp    15d4 <merge+0x4b4>
xor    %edi,%edi
test   $0x1,%r9b
jne    16c6 <merge+0x5a6>
jmp    16e3 <merge+0x5c3>
xor    %edx,%edx
test   $0x1,%r8b
mov    0x8(%rsp),%r8
je     177e <merge+0x65e>
mov    %edx,%esi
or     $0x1,%esi
add    %r8d,%esi
movslq %esi,%rsi
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups %xmm0,(%r12,%rdx,4)
movups %xmm1,0x10(%r12,%rdx,4)
cmp    %r9,%rcx
jne    131e <merge+0x1fe>
jmp    1486 <merge+0x366>

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

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