#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 nums[], int l, int m, int r) {
  int i, j;
  int n1 = m - l + 1;
  int n2 = r - m;
  int *L = (int *)malloc(n1 * sizeof(int));
  int *R = (int *)malloc(n2 * sizeof(int));
  for (i = 0; i < n1; i++)
    L[i] = nums[l + i];
  for (i = 0; i < n2; i++)
    R[i] = nums[m + 1 + i];
  i = j = 0;
  while (i < n1 && j < n2) {
    if (L[i] <= R[j]) {
      nums[l + i + j] = L[i];
      i++;
    } else {
      nums[l + i + j] = R[j];
      j++;
    }
  }
  while (i < n1) {
    nums[l + i + j] = L[i];
    i++;
  }
  while (j < n2) {
    nums[l + i + j] = R[j];
    j++;
  }
  free(L);
  free(R);
}


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,-0x20(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x10(%rbp),%eax
mov    %eax,-0x24(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11ac <merge+0x8c>
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    1177 <merge+0x57>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11eb <merge+0xcb>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x38(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    11b3 <merge+0x93>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x20(%rbp),%ecx
mov    %al,-0x39(%rbp)
jge    1216 <merge+0xf6>
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
setl   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    1226 <merge+0x106>
jmp    129a <merge+0x17a>
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     126e <merge+0x14e>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1295 <merge+0x175>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11f9 <merge+0xd9>
jmp    129f <merge+0x17f>
mov    -0x18(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12d7 <merge+0x1b7>
mov    -0x30(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    129f <merge+0x17f>
jmp    12dc <merge+0x1bc>
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1314 <merge+0x1f4>
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0x18(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12dc <merge+0x1bc>
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    $0x28,%rsp
mov    %ecx,%r12d
mov    %esi,%ebp
mov    %rdi,%r14
mov    %edx,%r13d
sub    %esi,%r13d
mov    %rdx,0x8(%rsp)
sub    %edx,%r12d
lea    0x4(,%r13,4),%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
lea    0x0(,%r12,4),%edi
call   1040 <malloc@plt>
mov    %rax,%r15
test   %r13d,%r13d
mov    %rbp,(%rsp)
js     1308 <merge+0x1e8>
movslq %ebp,%r8
lea    0x1(%r13),%eax
cmp    $0x8,%eax
jb     119f <merge+0x7f>
lea    (%r8,%rax,1),%rcx
lea    (%r14,%rcx,4),%rcx
cmp    %rcx,%rbx
jae    121c <merge+0xfc>
lea    (%rbx,%rax,4),%rcx
lea    (%r14,%r8,4),%rdx
cmp    %rcx,%rdx
jae    121c <merge+0xfc>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %rax,%rcx
mov    %rax,%rsi
and    $0x3,%rsi
je     11d0 <merge+0xb0>
lea    (%r14,%r8,4),%rdi
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rdx,4),%ebp
mov    %ebp,(%rbx,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    11c0 <merge+0xa0>
cmp    $0x3,%rcx
mov    (%rsp),%rbp
jb     1308 <merge+0x1e8>
lea    (%r14,%r8,4),%rcx
add    $0xc,%rcx
cs nopw 0x0(%rax,%rax,1)
mov    -0xc(%rcx,%rdx,4),%esi
mov    %esi,(%rbx,%rdx,4)
mov    -0x8(%rcx,%rdx,4),%esi
mov    %esi,0x4(%rbx,%rdx,4)
mov    -0x4(%rcx,%rdx,4),%esi
mov    %esi,0x8(%rbx,%rdx,4)
mov    (%rcx,%rdx,4),%esi
mov    %esi,0xc(%rbx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    11f0 <merge+0xd0>
jmp    1308 <merge+0x1e8>
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    123f <merge+0x11f>
xor    %ecx,%ecx
jmp    12b9 <merge+0x199>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rdi
lea    (%r14,%r8,4),%rbp
add    $0x70,%rbp
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x70(%rbp,%rcx,4),%xmm0
movups -0x60(%rbp,%rcx,4),%xmm1
movups %xmm0,(%rbx,%rcx,4)
movups %xmm1,0x10(%rbx,%rcx,4)
movups -0x50(%rbp,%rcx,4),%xmm0
movups -0x40(%rbp,%rcx,4),%xmm1
movups %xmm0,0x20(%rbx,%rcx,4)
movups %xmm1,0x30(%rbx,%rcx,4)
movups -0x30(%rbp,%rcx,4),%xmm0
movups -0x20(%rbp,%rcx,4),%xmm1
movups %xmm0,0x40(%rbx,%rcx,4)
movups %xmm1,0x50(%rbx,%rcx,4)
movups -0x10(%rbp,%rcx,4),%xmm0
movups 0x0(%rbp,%rcx,4),%xmm1
movups %xmm0,0x60(%rbx,%rcx,4)
movups %xmm1,0x70(%rbx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1260 <merge+0x140>
test   %rsi,%rsi
je     12fb <merge+0x1db>
lea    (%rbx,%rcx,4),%rdi
add    $0x10,%rdi
add    %r8,%rcx
lea    (%r14,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rbp,1),%xmm0
movups (%rcx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    12e0 <merge+0x1c0>
cmp    %rax,%rdx
mov    (%rsp),%rbp
jne    11a1 <merge+0x81>
test   %r12d,%r12d
mov    0x8(%rsp),%r11
jle    135f <merge+0x23f>
mov    %r12d,%r9d
cmp    $0x8,%r12d
jae    1366 <merge+0x246>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdi
and    $0x3,%rdi
je     1449 <merge+0x329>
lea    0x1(%r11),%ebp
nopw   0x0(%rax,%rax,1)
lea    0x1(%rcx),%rdx
lea    (%rcx,%rbp,1),%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,(%r15,%rcx,4)
mov    %rdx,%rcx
add    $0xffffffffffffffff,%rdi
jne    1340 <merge+0x220>
jmp    144c <merge+0x32c>
xor    %eax,%eax
jmp    14f8 <merge+0x3d8>
lea    -0x1(%r9),%rsi
lea    0x1(%r11),%edx
lea    (%r11,%rsi,1),%edi
add    $0x1,%edi
xor    %ecx,%ecx
cmp    %edx,%edi
jl     131d <merge+0x1fd>
shr    $0x20,%rsi
jne    131d <merge+0x1fd>
movslq %edx,%rcx
lea    (%rcx,%r9,1),%rdx
lea    (%r14,%rdx,4),%rdx
cmp    %rdx,%r15
jae    13a2 <merge+0x282>
lea    (%r15,%r9,4),%rdx
lea    (%r14,%rcx,4),%rcx
cmp    %rdx,%rcx
jb     131b <merge+0x1fb>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     177c <merge+0x65c>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x9(%r11),%ebp
xor    %edx,%edx
nopl   (%rax)
lea    -0x8(%rbp),%esi
movslq %esi,%rsi
movups (%r14,%rsi,4),%xmm0
movups 0x10(%r14,%rsi,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
movslq %ebp,%rbp
movups (%r14,%rbp,4),%xmm0
movups 0x10(%r14,%rbp,4),%xmm1
movups %xmm0,0x20(%r15,%rdx,4)
movups %xmm1,0x30(%r15,%rdx,4)
add    $0x10,%rdx
add    $0x10,%ebp
add    $0xfffffffffffffffe,%rdi
jne    13d0 <merge+0x2b0>
test   $0x1,%r8b
je     143a <merge+0x31a>
mov    %edx,%esi
or     $0x1,%esi
add    %r11d,%esi
movslq %esi,%rsi
movups (%r14,%rsi,4),%xmm0
movups 0x10(%r14,%rsi,4),%xmm1
movups %xmm0,(%r15,%rdx,4)
movups %xmm1,0x10(%r15,%rdx,4)
cmp    %r9,%rcx
mov    (%rsp),%rbp
jne    131d <merge+0x1fd>
jmp    14a6 <merge+0x386>
mov    %rcx,%rdx
cmp    $0x3,%rsi
mov    (%rsp),%rbp
jb     14a6 <merge+0x386>
mov    %r11d,%ecx
nopl   0x0(%rax)
lea    (%rcx,%rdx,1),%eax
add    $0x1,%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,(%r15,%rdx,4)
lea    0x2(%rcx,%rdx,1),%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,0x4(%r15,%rdx,4)
lea    0x3(%rcx,%rdx,1),%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,0x8(%r15,%rdx,4)
lea    0x4(%rcx,%rdx,1),%eax
cltq
mov    (%r14,%rax,4),%eax
mov    %eax,0xc(%r15,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    1460 <merge+0x340>
xor    %eax,%eax
test   %r13d,%r13d
js     14f8 <merge+0x3d8>
mov    $0x0,%ecx
test   %r12d,%r12d
jle    14fa <merge+0x3da>
xor    %ecx,%ecx
xor    %eax,%eax
jmp    14d1 <merge+0x3b1>
nopl   (%rax)
mov    %edx,(%r14,%rdi,4)
add    $0x1,%ecx
cmp    %r13d,%ecx
jg     14fa <merge+0x3da>
cmp    %r12d,%eax
jge    14fa <merge+0x3da>
movslq %ecx,%rdx
mov    (%rbx,%rdx,4),%edx
movslq %eax,%rsi
mov    (%r15,%rsi,4),%esi
lea    (%rax,%rbp,1),%edi
add    %ecx,%edi
movslq %edi,%rdi
cmp    %esi,%edx
jle    14c0 <merge+0x3a0>
mov    %esi,(%r14,%rdi,4)
add    $0x1,%eax
cmp    %r13d,%ecx
jle    14cc <merge+0x3ac>
jmp    14fa <merge+0x3da>
xor    %ecx,%ecx
cmp    %r13d,%ecx
jg     1579 <merge+0x459>
lea    (%rax,%rbp,1),%r10d
movslq %ecx,%rsi
add    $0x1,%r13d
sub    %ecx,%r11d
sub    %ebp,%r11d
cmp    $0x7,%r11d
jb     155d <merge+0x43d>
lea    (%rcx,%rax,1),%edx
lea    (%rdx,%rbp,1),%edi
lea    (%rdi,%r11,1),%ebp
cmp    %edi,%ebp
jl     1559 <merge+0x439>
lea    (%rbx,%rsi,4),%r8
movslq %edi,%r9
lea    (%r9,%r11,1),%rbp
lea    (%r14,%rbp,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%r8
jae    168e <merge+0x56e>
lea    (%rsi,%r11,1),%rbp
lea    (%rbx,%rbp,4),%r8
add    $0x4,%r8
lea    (%r14,%r9,4),%rbp
cmp    %r8,%rbp
jae    168e <merge+0x56e>
mov    (%rsp),%rbp
mov    %r13d,%ecx
mov    (%rbx,%rsi,4),%edx
lea    (%r10,%rsi,1),%edi
movslq %edi,%rdi
mov    %edx,(%r14,%rdi,4)
add    $0x1,%rsi
cmp    %esi,%ecx
jne    1560 <merge+0x440>
mov    %r13d,%ecx
cmp    %r12d,%eax
jge    1670 <merge+0x550>
add    %ebp,%ecx
cltq
movslq %ecx,%r10
movslq %r12d,%rcx
mov    %rcx,%r11
sub    %rax,%r11
cmp    $0x8,%r11
jb     165a <merge+0x53a>
lea    (%rax,%r10,1),%rdx
lea    (%r14,%rdx,4),%rsi
lea    (%r15,%rcx,4),%rdi
cmp    %rdi,%rsi
jae    15c2 <merge+0x4a2>
lea    (%r10,%rcx,1),%rsi
lea    (%r14,%rsi,4),%rsi
lea    (%r15,%rax,4),%rdi
cmp    %rsi,%rdi
jb     165a <merge+0x53a>
mov    %r11,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     176b <merge+0x64b>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r14,%rdx,4),%rdx
add    $0x30,%rdx
lea    (%r15,%rax,4),%rsi
add    $0x30,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rdi,4),%xmm0
movups -0x20(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rdx,%rdi,4)
movups %xmm1,-0x20(%rdx,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,4)
movups %xmm1,(%rdx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1600 <merge+0x4e0>
test   $0x1,%r9b
je     1652 <merge+0x532>
add    %rax,%rdi
movups (%r15,%rdi,4),%xmm0
movups 0x10(%r15,%rdi,4),%xmm1
add    %r10,%rdi
movups %xmm0,(%r14,%rdi,4)
movups %xmm1,0x10(%r14,%rdi,4)
cmp    %r8,%r11
je     1670 <merge+0x550>
add    %r8,%rax
lea    (%r14,%r10,4),%rdx
xchg   %ax,%ax
mov    (%r15,%rax,4),%esi
mov    %esi,(%rdx,%rax,4)
add    $0x1,%rax
cmp    %rcx,%rax
jl     1660 <merge+0x540>
mov    %rbx,%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>
mov    %rdx,%r8
add    $0x1,%r11
mov    %r11,0x8(%rsp)
and    $0xfffffffffffffff8,%r11
mov    %r11,0x18(%rsp)
lea    -0x8(%r11),%rdx
mov    %rdx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rdx,%rdx
mov    %rbp,0x10(%rsp)
je     178d <merge+0x66d>
and    $0xfffffffffffffffe,%rbp
lea    (%rbx,%rsi,4),%r11
add    $0x30,%r11
mov    (%rsp),%rdx
add    %r8d,%edx
add    $0x8,%edx
mov    %rdx,0x20(%rsp)
mov    %edi,%r8d
xor    %edi,%edi
movups -0x30(%r11,%rdi,4),%xmm0
movups -0x20(%r11,%rdi,4),%xmm1
lea    (%r8,%rdi,1),%r9d
movslq %r9d,%rdx
movups %xmm0,(%r14,%rdx,4)
movups %xmm1,0x10(%r14,%rdx,4)
movups -0x10(%r11,%rdi,4),%xmm0
movups (%r11,%rdi,4),%xmm1
mov    0x20(%rsp),%rdx
add    %edi,%edx
movslq %edx,%rdx
movups %xmm0,(%r14,%rdx,4)
movups %xmm1,0x10(%r14,%rdx,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    16e0 <merge+0x5c0>
testb  $0x1,0x10(%rsp)
je     174f <merge+0x62f>
lea    (%rdi,%rsi,1),%rdx
add    %edi,%ecx
movups (%rbx,%rdx,4),%xmm0
movups 0x10(%rbx,%rdx,4),%xmm1
add    %r10d,%ecx
movslq %ecx,%rcx
movups %xmm0,(%r14,%rcx,4)
movups %xmm1,0x10(%r14,%rcx,4)
mov    0x18(%rsp),%rcx
cmp    %rcx,0x8(%rsp)
mov    (%rsp),%rbp
je     1576 <merge+0x456>
add    %rcx,%rsi
jmp    155d <merge+0x43d>
xor    %edi,%edi
test   $0x1,%r9b
jne    1636 <merge+0x516>
jmp    1652 <merge+0x532>
xor    %edx,%edx
test   $0x1,%r8b
jne    1419 <merge+0x2f9>
jmp    143a <merge+0x31a>
xor    %edi,%edi
testb  $0x1,0x10(%rsp)
jne    172f <merge+0x60f>
jmp    174f <merge+0x62f>

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