#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 arr[], int left, int mid, int right) {
  int fIdx = left;
  int rIdx = mid + 1;
  int i;
  int *sortArr = (int *)malloc(sizeof(int) * (right + 1));
  int sIdx = left;
  while (fIdx <= mid && rIdx <= right) {
    if (arr[fIdx] <= arr[rIdx])
      sortArr[sIdx] = arr[fIdx++];
    else
      sortArr[sIdx] = arr[rIdx++];
    sIdx++;
  }
  if (fIdx > mid) {
    for (i = rIdx; i <= right; i++, sIdx++)
      sortArr[sIdx] = arr[i];
  } else {
    for (i = fIdx; i <= mid; i++, sIdx++)
      sortArr[sIdx] = arr[i];
  }
  for (i = left; i <= right; i++) {
    arr[i] = sortArr[i];
  }
  free(sortArr);
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0x2d(%rbp)
jg     117e <merge+0x5e>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setle  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    118e <merge+0x6e>
jmp    11fd <merge+0xdd>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     11cf <merge+0xaf>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11ef <merge+0xcf>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1161 <merge+0x41>
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    124d <merge+0x12d>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1248 <merge+0x128>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    120f <merge+0xef>
jmp    1291 <merge+0x171>
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     128c <merge+0x16c>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1253 <merge+0x133>
jmp    1291 <merge+0x171>
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12c7 <merge+0x1a7>
mov    -0x28(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1297 <merge+0x177>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%r14d
mov    %edx,%r12d
mov    %esi,%r15d
mov    %rdi,%r13
lea    0x1(%r12),%ebp
lea    0x4(,%r14,4),%edi
call   1040 <malloc@plt>
cmp    %r12d,%r15d
jg     132b <merge+0x20b>
cmp    %r14d,%r12d
jge    132b <merge+0x20b>
movslq %r15d,%rcx
lea    (%rax,%rcx,4),%rdx
mov    %r15d,%r8d
mov    %r15d,%edi
nopl   0x0(%rax,%rax,1)
movslq %edi,%rdi
mov    0x0(%r13,%rdi,4),%esi
movslq %ebp,%rbp
mov    0x0(%r13,%rbp,4),%r9d
xor    %ecx,%ecx
xor    %ebx,%ebx
cmp    %r9d,%esi
setle  %cl
setg   %bl
cmovg  %r9d,%esi
add    %ebx,%ebp
add    %ecx,%edi
mov    %esi,(%rdx)
add    $0x1,%r8d
cmp    %r12d,%edi
jg     11a9 <merge+0x89>
add    $0x4,%rdx
cmp    %r14d,%ebp
jle    1170 <merge+0x50>
cmp    %r12d,%edi
jle    133a <merge+0x21a>
cmp    %r14d,%ebp
jg     14a7 <merge+0x387>
movslq %r8d,%rcx
movslq %ebp,%rdx
mov    %r14d,%r10d
sub    %ebp,%r10d
cmp    $0x7,%r10d
jb     12b1 <merge+0x191>
lea    (%rax,%rcx,4),%rsi
lea    (%rdx,%r10,1),%rdi
lea    0x4(,%rdi,4),%rdi
add    %r13,%rdi
cmp    %rdi,%rsi
jae    1209 <merge+0xe9>
lea    (%rcx,%r10,1),%rsi
lea    (%rax,%rsi,4),%rsi
add    $0x4,%rsi
lea    0x0(,%rdx,4),%rdi
add    %r13,%rdi
cmp    %rsi,%rdi
jb     12b1 <merge+0x191>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1682 <merge+0x562>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    0x30(,%rdx,4),%rsi
add    %r13,%rsi
lea    (%rax,%rcx,4),%rbx
add    $0x30,%rbx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rdi,4),%xmm0
movups -0x20(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbx,%rdi,4)
movups %xmm1,-0x20(%rbx,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,4)
movups %xmm1,(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1250 <merge+0x130>
test   $0x1,%r9b
je     12a2 <merge+0x182>
lea    (%rdi,%rdx,1),%rsi
add    %rcx,%rdi
movups 0x0(%r13,%rsi,4),%xmm0
movups 0x10(%r13,%rsi,4),%xmm1
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
cmp    %r8,%r10
je     14a7 <merge+0x387>
add    %r8,%rdx
add    %r8,%rcx
mov    %r14d,%esi
sub    %edx,%esi
lea    0x1(%rsi),%edi
and    $0x3,%edi
je     12d5 <merge+0x1b5>
xchg   %ax,%ax
mov    0x0(%r13,%rdx,4),%ebp
mov    %ebp,(%rax,%rcx,4)
add    $0x1,%rdx
add    $0x1,%rcx
add    $0xffffffff,%edi
jne    12c0 <merge+0x1a0>
cmp    $0x3,%esi
jb     14a7 <merge+0x387>
mov    %r14d,%esi
sub    %edx,%esi
add    $0x1,%esi
lea    0xc(,%rdx,4),%rdx
add    %r13,%rdx
lea    (%rax,%rcx,4),%rcx
add    $0xc,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    -0xc(%rdx,%rdi,4),%ebp
mov    %ebp,-0xc(%rcx,%rdi,4)
mov    -0x8(%rdx,%rdi,4),%ebp
mov    %ebp,-0x8(%rcx,%rdi,4)
mov    -0x4(%rdx,%rdi,4),%ebp
mov    %ebp,-0x4(%rcx,%rdi,4)
mov    (%rdx,%rdi,4),%ebp
mov    %ebp,(%rcx,%rdi,4)
add    $0x4,%rdi
cmp    %edi,%esi
jne    1300 <merge+0x1e0>
jmp    14a7 <merge+0x387>
mov    %r15d,%edi
mov    %r15d,%r8d
cmp    %r12d,%edi
jg     11b2 <merge+0x92>
movslq %r8d,%rcx
movslq %edi,%rdx
mov    %r12d,%r10d
sub    %edi,%r10d
cmp    $0x7,%r10d
jb     1431 <merge+0x311>
lea    (%rax,%rcx,4),%rsi
lea    (%rdx,%r10,1),%rdi
lea    0x4(,%rdi,4),%rdi
add    %r13,%rdi
cmp    %rdi,%rsi
jae    1388 <merge+0x268>
lea    (%rcx,%r10,1),%rsi
lea    (%rax,%rsi,4),%rsi
add    $0x4,%rsi
lea    0x0(,%rdx,4),%rdi
add    %r13,%rdi
cmp    %rsi,%rdi
jb     1431 <merge+0x311>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1671 <merge+0x551>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    0x30(,%rdx,4),%rsi
add    %r13,%rsi
lea    (%rax,%rcx,4),%rbx
add    $0x30,%rbx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rdi,4),%xmm0
movups -0x20(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbx,%rdi,4)
movups %xmm1,-0x20(%rbx,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,4)
movups %xmm1,(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    13d0 <merge+0x2b0>
test   $0x1,%r9b
je     1422 <merge+0x302>
lea    (%rdi,%rdx,1),%rsi
add    %rcx,%rdi
movups 0x0(%r13,%rsi,4),%xmm0
movups 0x10(%r13,%rsi,4),%xmm1
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
cmp    %r8,%r10
je     14a7 <merge+0x387>
add    %r8,%rdx
add    %r8,%rcx
mov    %r12d,%esi
sub    %edx,%esi
lea    0x1(%rsi),%edi
and    $0x3,%edi
je     1455 <merge+0x335>
xchg   %ax,%ax
mov    0x0(%r13,%rdx,4),%ebp
mov    %ebp,(%rax,%rcx,4)
add    $0x1,%rdx
add    $0x1,%rcx
add    $0xffffffff,%edi
jne    1440 <merge+0x320>
cmp    $0x3,%esi
jb     14a7 <merge+0x387>
sub    %edx,%r12d
add    $0x1,%r12d
lea    0xc(,%rdx,4),%rdx
add    %r13,%rdx
lea    (%rax,%rcx,4),%rcx
add    $0xc,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
mov    -0xc(%rdx,%rsi,4),%edi
mov    %edi,-0xc(%rcx,%rsi,4)
mov    -0x8(%rdx,%rsi,4),%edi
mov    %edi,-0x8(%rcx,%rsi,4)
mov    -0x4(%rdx,%rsi,4),%edi
mov    %edi,-0x4(%rcx,%rsi,4)
mov    (%rdx,%rsi,4),%edi
mov    %edi,(%rcx,%rsi,4)
add    $0x4,%rsi
cmp    %esi,%r12d
jne    1480 <merge+0x360>
mov    %r14d,%r10d
sub    %r15d,%r10d
jl     165b <merge+0x53b>
movslq %r15d,%rcx
cmp    $0x7,%r10d
jb     15f3 <merge+0x4d3>
lea    0x0(,%rcx,4),%rsi
add    %r13,%rsi
lea    (%r10,%rcx,1),%rdx
lea    (%rax,%rdx,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    14f4 <merge+0x3d4>
lea    0x4(,%rdx,4),%rdx
add    %r13,%rdx
lea    (%rax,%rcx,4),%rsi
cmp    %rdx,%rsi
jb     15f3 <merge+0x4d3>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x18,%rdx
jae    1522 <merge+0x402>
xor    %esi,%esi
jmp    15a9 <merge+0x489>
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
add    $0xfffffffffffffffe,%rdx
and    %rdx,%rdi
lea    0x70(,%rcx,4),%rbp
add    %r13,%rbp
lea    (%rax,%rcx,4),%rdx
add    $0x70,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movups -0x70(%rdx,%rsi,4),%xmm0
movups -0x60(%rdx,%rsi,4),%xmm1
movups %xmm0,-0x70(%rbp,%rsi,4)
movups %xmm1,-0x60(%rbp,%rsi,4)
movups -0x50(%rdx,%rsi,4),%xmm0
movups -0x40(%rdx,%rsi,4),%xmm1
movups %xmm0,-0x50(%rbp,%rsi,4)
movups %xmm1,-0x40(%rbp,%rsi,4)
movups -0x30(%rdx,%rsi,4),%xmm0
movups -0x20(%rdx,%rsi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rsi,4)
movups %xmm1,-0x20(%rbp,%rsi,4)
movups -0x10(%rdx,%rsi,4),%xmm0
movups (%rdx,%rsi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rsi,4)
movups %xmm1,0x0(%rbp,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1550 <merge+0x430>
test   %r9,%r9
je     15eb <merge+0x4cb>
add    %rcx,%rsi
lea    0x10(,%rsi,4),%rdx
add    %r13,%rdx
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r9
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    15d0 <merge+0x4b0>
cmp    %r8,%r10
je     165b <merge+0x53b>
add    %r8,%rcx
lea    0x1(%r14),%edx
mov    %edx,%esi
sub    %ecx,%esi
sub    %ecx,%r14d
and    $0x3,%esi
je     1621 <merge+0x501>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax,%rcx,4),%edi
mov    %edi,0x0(%r13,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%esi
jne    1610 <merge+0x4f0>
cmp    $0x3,%r14d
jb     165b <merge+0x53b>
mov    %edx,%edx
nopl   0x0(%rax)
mov    (%rax,%rcx,4),%esi
mov    %esi,0x0(%r13,%rcx,4)
mov    0x4(%rax,%rcx,4),%esi
mov    %esi,0x4(%r13,%rcx,4)
mov    0x8(%rax,%rcx,4),%esi
mov    %esi,0x8(%r13,%rcx,4)
mov    0xc(%rax,%rcx,4),%esi
mov    %esi,0xc(%r13,%rcx,4)
add    $0x4,%rcx
cmp    %ecx,%edx
jne    1630 <merge+0x510>
mov    %rax,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %edi,%edi
test   $0x1,%r9b
jne    1406 <merge+0x2e6>
jmp    1422 <merge+0x302>
xor    %edi,%edi
test   $0x1,%r9b
jne    1286 <merge+0x166>
jmp    12a2 <merge+0x182>

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

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