#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 *a, int l, int m, int r) {
  int i, j, k;
  int len1 = m - l + 1;
  int len2 = r - m;
  int *a1;
  a1 = (int *)malloc(len1 * sizeof(int));
  int *a2;
  a2 = (int *)malloc(len2 * sizeof(int));
  for (i = 0; i < len1; i++) {
    *(a1 + i) = *(a + l + i);
  }
  for (i = 0; i < len2; i++) {
    *(a2 + i) = *(a + m + 1 + i);
  }
  i = 0;
  j = 0;
  k = l;
  while (i < len1 && j < len2) {
    if (*(a1 + i) <= *(a2 + j)) {
      *(a + k) = *(a1 + i);
      i++;
    } else {
      *(a + k) = *(a2 + j);
      j++;
    }
    k++;
  }
  while (i < len1) {
    *(a + k) = *(a1 + i);
    i++;
    k++;
  }
  while (j < len2) {
    *(a + k) = *(a2 + j);
    j++;
    k++;
  }
  free(a1);
  free(a2);
}


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)
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
movslq -0x28(%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    -0x24(%rbp),%eax
jge    11b2 <merge+0x92>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%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    -0x28(%rbp),%eax
jge    11f5 <merge+0xd5>
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    0x4(%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    11b9 <merge+0x99>
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    1226 <merge+0x106>
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
setl   %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    1236 <merge+0x116>
jmp    12a3 <merge+0x183>
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     1276 <merge+0x156>
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    1295 <merge+0x175>
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    1209 <merge+0xe9>
jmp    12a8 <merge+0x188>
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12e1 <merge+0x1c1>
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    12a8 <merge+0x188>
jmp    12e6 <merge+0x1c6>
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    131f <merge+0x1ff>
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    12e6 <merge+0x1c6>
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,%r12d
mov    %rdi,%rbx
mov    %edx,%r13d
mov    %esi,0xc(%rsp)
sub    %esi,%r13d
mov    %rdx,0x10(%rsp)
sub    %edx,%r12d
lea    0x4(,%r13,4),%edi
call   1040 <malloc@plt>
mov    %rax,%r14
lea    0x0(,%r12,4),%edi
call   1040 <malloc@plt>
mov    %rax,%r15
test   %r13d,%r13d
js     12f4 <merge+0x1d4>
movslq 0xc(%rsp),%r8
lea    (%rbx,%r8,4),%rsi
lea    0x1(%r13),%eax
cmp    $0x8,%eax
jb     119b <merge+0x7b>
lea    (%r8,%rax,1),%rcx
lea    (%rbx,%rcx,4),%rcx
cmp    %rcx,%r14
jae    1210 <merge+0xf0>
lea    (%r14,%rax,4),%rcx
cmp    %rcx,%rsi
jae    1210 <merge+0xf0>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %rax,%rcx
mov    %rax,%rdi
and    $0x3,%rdi
je     11c1 <merge+0xa1>
nop
mov    (%rsi,%rdx,4),%ebp
mov    %ebp,(%r14,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    11b0 <merge+0x90>
cmp    $0x3,%rcx
jb     12f4 <merge+0x1d4>
lea    (%rbx,%r8,4),%rcx
add    $0xc,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xc(%rcx,%rdx,4),%esi
mov    %esi,(%r14,%rdx,4)
mov    -0x8(%rcx,%rdx,4),%esi
mov    %esi,0x4(%r14,%rdx,4)
mov    -0x4(%rcx,%rdx,4),%esi
mov    %esi,0x8(%r14,%rdx,4)
mov    (%rcx,%rdx,4),%esi
mov    %esi,0xc(%r14,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    11e0 <merge+0xc0>
jmp    12f4 <merge+0x1d4>
mov    %eax,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rcx
jae    1235 <merge+0x115>
xor    %ebp,%ebp
jmp    12b0 <merge+0x190>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r8,4),%rcx
add    $0x70,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x70(%rcx,%rbp,4),%xmm0
movups -0x60(%rcx,%rbp,4),%xmm1
movups %xmm0,(%r14,%rbp,4)
movups %xmm1,0x10(%r14,%rbp,4)
movups -0x50(%rcx,%rbp,4),%xmm0
movups -0x40(%rcx,%rbp,4),%xmm1
movups %xmm0,0x20(%r14,%rbp,4)
movups %xmm1,0x30(%r14,%rbp,4)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,0x40(%r14,%rbp,4)
movups %xmm1,0x50(%r14,%rbp,4)
movups -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movups %xmm0,0x60(%r14,%rbp,4)
movups %xmm1,0x70(%r14,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1250 <merge+0x130>
test   %r9,%r9
je     12eb <merge+0x1cb>
lea    (%r14,%rbp,4),%rcx
add    $0x10,%rcx
add    %r8,%rbp
lea    (%rbx,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%r9
xor    %ebp,%ebp
xchg   %ax,%ax
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    12d0 <merge+0x1b0>
cmp    %rax,%rdx
jne    119d <merge+0x7d>
test   %r12d,%r12d
jle    13b0 <merge+0x290>
mov    0x10(%rsp),%r9
movslq %r9d,%r8
lea    (%rbx,%r8,4),%rsi
add    $0x4,%rsi
mov    %r12d,%eax
cmp    $0x8,%r12d
jb     1338 <merge+0x218>
lea    (%r8,%rax,1),%rcx
lea    (%rbx,%rcx,4),%rcx
add    $0x4,%rcx
cmp    %rcx,%r15
jae    1500 <merge+0x3e0>
lea    (%r15,%rax,4),%rcx
cmp    %rcx,%rsi
jae    1500 <merge+0x3e0>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %rax,%rcx
mov    %rax,%rdi
and    $0x3,%rdi
je     1361 <merge+0x241>
nopl   0x0(%rax)
mov    (%rsi,%rdx,4),%ebp
mov    %ebp,(%r15,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1350 <merge+0x230>
cmp    $0x3,%rcx
jb     15e9 <merge+0x4c9>
lea    (%rbx,%r8,4),%rcx
add    $0x10,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xc(%rcx,%rdx,4),%esi
mov    %esi,(%r15,%rdx,4)
mov    -0x8(%rcx,%rdx,4),%esi
mov    %esi,0x4(%r15,%rdx,4)
mov    -0x4(%rcx,%rdx,4),%esi
mov    %esi,0x8(%r15,%rdx,4)
mov    (%rcx,%rdx,4),%esi
mov    %esi,0xc(%r15,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rax
jne    1380 <merge+0x260>
jmp    15e9 <merge+0x4c9>
mov    %rbx,%r8
xor    %ecx,%ecx
mov    0xc(%rsp),%eax
mov    %eax,%r11d
xor    %esi,%esi
mov    0x10(%rsp),%r9
cmp    %r13d,%esi
jg     1661 <merge+0x541>
movslq %esi,%r10
movslq %r11d,%r11
mov    0xc(%rsp),%eax
add    %esi,%eax
sub    %eax,%r9d
cmp    $0x7,%r9d
jae    13e9 <merge+0x2c9>
mov    %r8,%rbx
jmp    14cc <merge+0x3ac>
mov    %r8,%rbx
lea    (%r8,%r11,4),%rdx
lea    (%r10,%r9,1),%rsi
lea    (%r14,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rdx
jae    141a <merge+0x2fa>
lea    (%r11,%r9,1),%rdx
lea    (%rbx,%rdx,4),%rdx
add    $0x4,%rdx
lea    (%r14,%r10,4),%rsi
cmp    %rdx,%rsi
jb     14cc <merge+0x3ac>
add    $0x1,%r9
mov    %r9,%rax
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1798 <merge+0x678>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
or     $0x2,%rsi
and    %r9,%rsi
lea    (%rbx,%r11,4),%rdi
add    $0x30,%rdi
lea    (%r14,%r10,4),%rdx
add    $0x30,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rdx,%rbp,4),%xmm0
movups -0x20(%rdx,%rbp,4),%xmm1
movups %xmm0,-0x30(%rdi,%rbp,4)
movups %xmm1,-0x20(%rdi,%rbp,4)
movups -0x10(%rdx,%rbp,4),%xmm0
movups (%rdx,%rbp,4),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,4)
movups %xmm1,(%rdi,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1470 <merge+0x350>
test   $0x1,%r9b
je     14c1 <merge+0x3a1>
lea    (%r11,%rbp,1),%rdx
add    %r10,%rbp
movups (%r14,%rbp,4),%xmm0
movups 0x10(%r14,%rbp,4),%xmm1
movups %xmm0,(%rbx,%rdx,4)
movups %xmm1,0x10(%rbx,%rdx,4)
add    %r8,%r11
cmp    %r8,%rax
je     14f2 <merge+0x3d2>
add    %r8,%r10
lea    (%rbx,%r11,4),%rdx
lea    (%r14,%r10,4),%rsi
sub    %r10d,%r13d
add    $0x1,%r13d
xor    %edi,%edi
nopl   (%rax)
mov    (%rsi,%rdi,4),%eax
mov    %eax,(%rdx,%rdi,4)
add    $0x1,%rdi
cmp    %edi,%r13d
jne    14e0 <merge+0x3c0>
add    %rdi,%r11
cmp    %r12d,%ecx
jge    1763 <merge+0x643>
jmp    166d <merge+0x54d>
mov    %eax,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rcx
jae    1525 <merge+0x405>
xor    %ebp,%ebp
jmp    15a0 <merge+0x480>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r8,4),%rcx
add    $0x74,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x70(%rcx,%rbp,4),%xmm0
movups -0x60(%rcx,%rbp,4),%xmm1
movups %xmm0,(%r15,%rbp,4)
movups %xmm1,0x10(%r15,%rbp,4)
movups -0x50(%rcx,%rbp,4),%xmm0
movups -0x40(%rcx,%rbp,4),%xmm1
movups %xmm0,0x20(%r15,%rbp,4)
movups %xmm1,0x30(%r15,%rbp,4)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,0x40(%r15,%rbp,4)
movups %xmm1,0x50(%r15,%rbp,4)
movups -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movups %xmm0,0x60(%r15,%rbp,4)
movups %xmm1,0x70(%r15,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1540 <merge+0x420>
test   %r9,%r9
je     15db <merge+0x4bb>
lea    (%r15,%rbp,4),%rcx
add    $0x10,%rcx
add    %r8,%rbp
lea    (%rbx,%rbp,4),%rdi
add    $0x14,%rdi
shl    $0x5,%r9
xor    %ebp,%ebp
xchg   %ax,%ax
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    15c0 <merge+0x4a0>
cmp    %rax,%rdx
mov    0x10(%rsp),%r9
jne    133a <merge+0x21a>
xor    %ecx,%ecx
mov    %rbx,%r8
test   %r13d,%r13d
js     1781 <merge+0x661>
mov    0xc(%rsp),%eax
mov    %eax,%r11d
mov    $0x0,%esi
test   %r12d,%r12d
jle    1658 <merge+0x538>
mov    0xc(%rsp),%ecx
movslq %ecx,%rax
lea    (%r8,%rax,4),%rdx
xor    %esi,%esi
mov    %ecx,%r11d
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    %ecx,%edi
mov    %esi,%ebp
mov    %esi,%ecx
mov    (%r14,%rcx,4),%ebx
mov    %edi,%ecx
mov    (%r15,%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    %r13d,%esi
jg     1658 <merge+0x538>
add    $0x4,%rdx
cmp    %r12d,%ecx
jl     1620 <merge+0x500>
cmp    %r13d,%esi
jle    13cc <merge+0x2ac>
mov    %r8,%rbx
cmp    %r12d,%ecx
jge    1763 <merge+0x643>
movslq %ecx,%rcx
movslq %r12d,%rdx
movslq %r11d,%r10
mov    %rdx,%r11
sub    %rcx,%r11
cmp    $0x8,%r11
jb     174c <merge+0x62c>
lea    (%rbx,%r10,4),%rax
lea    (%r15,%rdx,4),%rsi
cmp    %rsi,%rax
jae    16ab <merge+0x58b>
lea    (%r10,%rdx,1),%rax
sub    %rcx,%rax
lea    (%rbx,%rax,4),%rax
lea    (%r15,%rcx,4),%rsi
cmp    %rax,%rsi
jb     174c <merge+0x62c>
mov    %r11,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     17a9 <merge+0x689>
movabs $0x3ffffffffffffffc,%rbp
ff ff 3f
or     $0x2,%rbp
and    %r9,%rbp
lea    (%rbx,%r10,4),%rax
add    $0x30,%rax
lea    (%r15,%rcx,4),%rsi
add    $0x30,%rsi
xor    %edi,%edi
nopl   (%rax)
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    16f0 <merge+0x5d0>
test   $0x1,%r9b
je     1741 <merge+0x621>
lea    (%rdi,%r10,1),%rax
add    %rcx,%rdi
movups (%r15,%rdi,4),%xmm0
movups 0x10(%r15,%rdi,4),%xmm1
movups %xmm0,(%rbx,%rax,4)
movups %xmm1,0x10(%rbx,%rax,4)
cmp    %r8,%r11
je     1763 <merge+0x643>
add    %r8,%r10
add    %r8,%rcx
lea    (%rbx,%r10,4),%rax
mov    (%r15,%rcx,4),%esi
mov    %esi,(%rax)
add    $0x1,%rcx
add    $0x4,%rax
cmp    %rdx,%rcx
jl     1750 <merge+0x630>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    0xc(%rsp),%eax
mov    %eax,%r11d
xor    %esi,%esi
cmp    %r13d,%esi
jg     1661 <merge+0x541>
jmp    13cc <merge+0x2ac>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    14a6 <merge+0x386>
jmp    14c1 <merge+0x3a1>
xor    %edi,%edi
test   $0x1,%r9b
jne    1726 <merge+0x606>
jmp    1741 <merge+0x621>

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