#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 array[], int low, int middle, int high) {
  int first = low;
  int second = middle + 1;
  int *temp = (int *)malloc((high - low + 1) * sizeof(int));
  int i = 0;
  while (first <= middle && second <= high)
    temp[i++] = array[first] < array[second] ? array[first++] : array[second++];
  if (first > middle)
    while (second <= high)
      temp[i++] = array[second++];
  else if (second > high)
    while (first <= middle)
      temp[i++] = array[first++];
  i = 0;
  while (low <= high)
    array[low++] = temp[i++];
  free(temp);
}


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    -0xc(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
sub    -0xc(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0x2d(%rbp)
jg     1182 <merge+0x62>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setle  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    1192 <merge+0x72>
jmp    1200 <merge+0xe0>
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
jge    11cb <merge+0xab>
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),%eax
mov    %eax,-0x34(%rbp)
jmp    11e3 <merge+0xc3>
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),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1165 <merge+0x45>
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jle    1251 <merge+0x131>
jmp    1211 <merge+0xf1>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     124c <merge+0x12c>
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
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1211 <merge+0xf1>
jmp    12a7 <merge+0x187>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    12a2 <merge+0x182>
jmp    1262 <merge+0x142>
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     129d <merge+0x17d>
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
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1262 <merge+0x142>
jmp    12a2 <merge+0x182>
jmp    12a7 <merge+0x187>
movl   $0x0,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12e9 <merge+0x1c9>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0xc(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12ae <merge+0x18e>
mov    -0x28(%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
push   %rax
mov    %ecx,%r14d
mov    %edx,%r13d
mov    %esi,%r15d
mov    %rdi,%r12
lea    0x1(%r13),%ebx
mov    %ecx,%eax
sub    %esi,%eax
lea    0x4(,%rax,4),%edi
call   1040 <malloc@plt>
xor    %ecx,%ecx
cmp    %r13d,%r15d
jg     131b <merge+0x1fb>
cmp    %r14d,%r13d
jge    131b <merge+0x1fb>
xor    %ecx,%ecx
mov    %r15d,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq %edi,%rdi
mov    (%r12,%rdi,4),%r8d
movslq %ebx,%rbx
mov    (%r12,%rbx,4),%esi
xor    %ebp,%ebp
xor    %edx,%edx
cmp    %esi,%r8d
setge  %bpl
setl   %dl
cmovl  %r8d,%esi
add    %edx,%edi
add    %ebp,%ebx
mov    %esi,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %r13d,%edi
jg     11a5 <merge+0x85>
cmp    %r14d,%ebx
jle    1170 <merge+0x50>
mov    %ecx,%ecx
cmp    %r13d,%edi
jle    1327 <merge+0x207>
cmp    %r14d,%ebx
jg     1487 <merge+0x367>
movslq %ebx,%rdx
mov    %r14d,%r10d
sub    %ebx,%r10d
cmp    $0x7,%r10d
jb     12a0 <merge+0x180>
lea    (%rax,%rcx,4),%rsi
lea    (%rdx,%r10,1),%rdi
lea    (%r12,%rdi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    11fa <merge+0xda>
lea    (%rcx,%r10,1),%rsi
lea    (%rax,%rsi,4),%rsi
add    $0x4,%rsi
lea    (%r12,%rdx,4),%rdi
cmp    %rsi,%rdi
jb     12a0 <merge+0x180>
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     164f <merge+0x52f>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r12,%rdx,4),%rdi
add    $0x30,%rdi
lea    (%rax,%rcx,4),%rsi
add    $0x30,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rdi,%rbx,4),%xmm0
movups -0x20(%rdi,%rbx,4),%xmm1
movups %xmm0,-0x30(%rsi,%rbx,4)
movups %xmm1,-0x20(%rsi,%rbx,4)
movups -0x10(%rdi,%rbx,4),%xmm0
movups (%rdi,%rbx,4),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,4)
movups %xmm1,(%rsi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1240 <merge+0x120>
test   $0x1,%r9b
je     1291 <merge+0x171>
lea    (%rcx,%rbx,1),%rsi
add    %rdx,%rbx
movups (%r12,%rbx,4),%xmm0
movups 0x10(%r12,%rbx,4),%xmm1
movups %xmm0,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
cmp    %r8,%r10
je     1487 <merge+0x367>
add    %r8,%rdx
add    %r8,%rcx
mov    %r14d,%esi
sub    %edx,%esi
lea    0x1(%rsi),%edi
and    $0x3,%edi
je     12c4 <merge+0x1a4>
nopl   (%rax)
mov    (%r12,%rdx,4),%ebp
add    $0x1,%rdx
mov    %ebp,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%edi
jne    12b0 <merge+0x190>
cmp    $0x3,%esi
jb     1487 <merge+0x367>
mov    %r14d,%esi
sub    %edx,%esi
add    $0x1,%esi
lea    (%r12,%rdx,4),%rdx
add    $0xc,%rdx
lea    (%rax,%rcx,4),%rcx
add    $0xc,%rcx
xor    %edi,%edi
nopw   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    12f0 <merge+0x1d0>
jmp    1487 <merge+0x367>
mov    %r15d,%edi
cmp    %r13d,%edi
jg     11b0 <merge+0x90>
cmp    %r14d,%ebx
jle    1487 <merge+0x367>
movslq %edi,%rdx
mov    %r13d,%r10d
sub    %edi,%r10d
cmp    $0x7,%r10d
jb     1411 <merge+0x2f1>
lea    (%rax,%rcx,4),%rsi
lea    (%rdx,%r10,1),%rdi
lea    (%r12,%rdi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    1371 <merge+0x251>
lea    (%rcx,%r10,1),%rsi
lea    (%rax,%rsi,4),%rsi
add    $0x4,%rsi
lea    (%r12,%rdx,4),%rdi
cmp    %rsi,%rdi
jb     1411 <merge+0x2f1>
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     1660 <merge+0x540>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%r12,%rdx,4),%rsi
add    $0x30,%rsi
lea    (%rax,%rcx,4),%rbp
add    $0x30,%rbp
xor    %edi,%edi
nopl   (%rax)
movups -0x30(%rsi,%rdi,4),%xmm0
movups -0x20(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rdi,4)
movups %xmm1,-0x20(%rbp,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,4)
movups %xmm1,0x0(%rbp,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    13b0 <merge+0x290>
test   $0x1,%r9b
je     1402 <merge+0x2e2>
lea    (%rcx,%rdi,1),%rsi
add    %rdx,%rdi
movups (%r12,%rdi,4),%xmm0
movups 0x10(%r12,%rdi,4),%xmm1
movups %xmm0,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
cmp    %r8,%r10
je     1487 <merge+0x367>
add    %r8,%rdx
add    %r8,%rcx
mov    %r13d,%esi
sub    %edx,%esi
lea    0x1(%rsi),%edi
and    $0x3,%edi
je     1434 <merge+0x314>
xchg   %ax,%ax
mov    (%r12,%rdx,4),%ebp
add    $0x1,%rdx
mov    %ebp,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%edi
jne    1420 <merge+0x300>
cmp    $0x3,%esi
jb     1487 <merge+0x367>
sub    %edx,%r13d
add    $0x1,%r13d
lea    (%r12,%rdx,4),%rdx
add    $0xc,%rdx
lea    (%rax,%rcx,4),%rcx
add    $0xc,%rcx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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,%r13d
jne    1460 <merge+0x340>
sub    %r15d,%r14d
jl     1631 <merge+0x511>
movslq %r15d,%rcx
add    $0x1,%r14d
cmp    $0x8,%r14d
jb     14bf <merge+0x39f>
lea    (%r12,%rcx,4),%rdx
lea    (%rax,%r14,4),%rsi
cmp    %rsi,%rdx
jae    154c <merge+0x42c>
lea    (%rcx,%r14,1),%rdx
lea    (%r12,%rdx,4),%rdx
cmp    %rdx,%rax
jae    154c <merge+0x42c>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %r14,%rsi
mov    %r14,%rdi
and    $0x3,%rdi
je     14f5 <merge+0x3d5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rax,%rdx,4),%ebp
add    $0x1,%rdx
mov    %ebp,(%r12,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    14e0 <merge+0x3c0>
cmp    $0x3,%rsi
jb     1631 <merge+0x511>
lea    (%r12,%rcx,4),%rcx
add    $0xc,%rcx
sub    %rdx,%r14
lea    (%rax,%rdx,4),%rdx
add    $0xc,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    %rsi,%r14
jne    1520 <merge+0x400>
jmp    1631 <merge+0x511>
mov    %r14d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rbp
jae    1570 <merge+0x450>
xor    %ebp,%ebp
jmp    15e8 <merge+0x4c8>
movabs $0x3ffffffffffffffe,%rbp
ff ff 3f
add    $0xfffffffffffffffe,%rbp
and    %rbp,%rdi
lea    (%r12,%rcx,4),%rbx
add    $0x70,%rbx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups (%rax,%rbp,4),%xmm0
movups 0x10(%rax,%rbp,4),%xmm1
movups %xmm0,-0x70(%rbx,%rbp,4)
movups %xmm1,-0x60(%rbx,%rbp,4)
movups 0x20(%rax,%rbp,4),%xmm0
movups 0x30(%rax,%rbp,4),%xmm1
movups %xmm0,-0x50(%rbx,%rbp,4)
movups %xmm1,-0x40(%rbx,%rbp,4)
movups 0x40(%rax,%rbp,4),%xmm0
movups 0x50(%rax,%rbp,4),%xmm1
movups %xmm0,-0x30(%rbx,%rbp,4)
movups %xmm1,-0x20(%rbx,%rbp,4)
movups 0x60(%rax,%rbp,4),%xmm0
movups 0x70(%rax,%rbp,4),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,4)
movups %xmm1,(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1590 <merge+0x470>
test   %rsi,%rsi
je     162c <merge+0x50c>
lea    (%rax,%rbp,4),%rdi
add    $0x10,%rdi
add    %rcx,%rbp
lea    (%r12,%rbp,4),%rbp
add    $0x10,%rbp
shl    $0x5,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1610 <merge+0x4f0>
cmp    %r14,%rdx
jne    1647 <merge+0x527>
mov    %rax,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
add    %rdx,%rcx
jmp    14c1 <merge+0x3a1>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    1276 <merge+0x156>
jmp    1291 <merge+0x171>
xor    %edi,%edi
test   $0x1,%r9b
jne    13e7 <merge+0x2c7>
jmp    1402 <merge+0x2e2>

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

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