#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(int *);
void merge(int *A, int start, int middle, int end) {
  int i = start;
  int j = middle + 1;
  int l = start;
  int *B = (int *)calloc(end + 1, sizeof(int));
  while (i <= middle && j <= end) {
    if (A[i] < A[j]) {
      B[l] = A[i];
      i++;
      l++;
    } else {
      B[l] = A[j];
      j++;
      l++;
    }
  }
  while (i <= middle) {
    B[l] = A[i];
    i++;
    l++;
  }
  while (j <= end) {
    B[l] = A[j];
    j++;
    l++;
  }
  for (int i = start; i <= end; i++) {
    A[i] = B[i];
  }
  free(B);
}


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    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%edi
add    $0x1,%edi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0x2d(%rbp)
jg     117b <merge+0x5b>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setle  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    118b <merge+0x6b>
jmp    1201 <merge+0xe1>
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    11d4 <merge+0xb4>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%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    11fc <merge+0xdc>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%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    115e <merge+0x3e>
jmp    1206 <merge+0xe6>
mov    -0x18(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     123f <merge+0x11f>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%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    1206 <merge+0xe6>
jmp    1244 <merge+0x124>
mov    -0x1c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     127d <merge+0x15d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%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    1244 <merge+0x124>
mov    -0xc(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12b3 <merge+0x193>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1283 <merge+0x163>
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,%r13d
mov    %esi,%ebx
mov    %rdi,%r15
lea    0x1(%r13),%r12d
lea    0x1(%r14),%edi
mov    %edi,0x4(%rsp)
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %ebx,%r11d
cmp    %r13d,%ebx
jg     11a9 <merge+0x89>
cmp    %r14d,%r13d
jge    11a9 <merge+0x89>
movslq %r11d,%rcx
lea    (%rax,%rcx,4),%rdx
mov    %r11d,%r8d
mov    %r11d,%edi
cs nopw 0x0(%rax,%rax,1)
movslq %edi,%rdi
mov    (%r15,%rdi,4),%esi
movslq %r12d,%r12
mov    (%r15,%r12,4),%ebx
xor    %ecx,%ecx
xor    %ebp,%ebp
cmp    %ebx,%esi
setl   %cl
setge  %bpl
cmovl  %esi,%ebx
add    %ebp,%r12d
add    %ecx,%edi
mov    %ebx,(%rdx)
add    $0x1,%r8d
cmp    %r13d,%edi
jg     11af <merge+0x8f>
add    $0x4,%rdx
cmp    %r14d,%r12d
jle    1170 <merge+0x50>
jmp    11af <merge+0x8f>
mov    %r11d,%r8d
mov    %r11d,%edi
cmp    %r13d,%edi
jg     132a <merge+0x20a>
movslq %edi,%rdx
movslq %r8d,%r8
mov    %r13d,%r10d
sub    %edi,%r10d
cmp    $0x7,%r10d
jb     12ab <merge+0x18b>
lea    (%rax,%r8,4),%rsi
lea    (%rdx,%r10,1),%rdi
lea    (%r15,%rdi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    11fc <merge+0xdc>
lea    (%r8,%r10,1),%rsi
lea    (%rax,%rsi,4),%rsi
add    $0x4,%rsi
lea    (%r15,%rdx,4),%rdi
cmp    %rsi,%rdi
jb     12ab <merge+0x18b>
add    $0x1,%r10
mov    %r10,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %r11d,%ebp
test   %rsi,%rsi
je     1276 <merge+0x156>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%rax,%r8,4),%r11
add    $0x30,%r11
lea    (%r15,%rdx,4),%rbx
add    $0x30,%rbx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rbx,%rdi,4),%xmm0
movups -0x20(%rbx,%rdi,4),%xmm1
movups %xmm0,-0x30(%r11,%rdi,4)
movups %xmm1,-0x20(%r11,%rdi,4)
movups -0x10(%rbx,%rdi,4),%xmm0
movups (%rbx,%rdi,4),%xmm1
movups %xmm0,-0x10(%r11,%rdi,4)
movups %xmm1,(%r11,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1240 <merge+0x120>
jmp    1278 <merge+0x158>
xor    %edi,%edi
test   $0x1,%r9b
mov    %ebp,%r11d
je     129c <merge+0x17c>
lea    (%rdi,%r8,1),%rsi
add    %rdx,%rdi
movups (%r15,%rdi,4),%xmm0
movups 0x10(%r15,%rdi,4),%xmm1
movups %xmm0,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
add    %rcx,%r8
cmp    %rcx,%r10
je     132a <merge+0x20a>
add    %rcx,%rdx
mov    %r13d,%esi
sub    %edx,%esi
lea    0x1(%rsi),%edi
and    $0x3,%edi
je     12d5 <merge+0x1b5>
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rdx,4),%ebx
mov    %ebx,(%rax,%r8,4)
add    $0x1,%rdx
add    $0x1,%r8
add    $0xffffffff,%edi
jne    12c0 <merge+0x1a0>
cmp    $0x3,%esi
jb     132a <merge+0x20a>
lea    (%rax,%r8,4),%rsi
add    $0xc,%rsi
sub    %edx,%r13d
add    $0x1,%r13d
lea    (%r15,%rdx,4),%rdi
add    $0xc,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xc(%rdi,%rdx,4),%ecx
mov    %ecx,-0xc(%rsi,%rdx,4)
mov    -0x8(%rdi,%rdx,4),%ecx
mov    %ecx,-0x8(%rsi,%rdx,4)
mov    -0x4(%rdi,%rdx,4),%ecx
mov    %ecx,-0x4(%rsi,%rdx,4)
mov    (%rdi,%rdx,4),%ecx
mov    %ecx,(%rsi,%rdx,4)
add    $0x4,%rdx
cmp    %edx,%r13d
jne    1300 <merge+0x1e0>
add    %rdx,%r8
cmp    %r14d,%r12d
jg     1496 <merge+0x376>
movslq %r8d,%rcx
movslq %r12d,%rdx
mov    %r14d,%r10d
sub    %r12d,%r10d
cmp    $0x7,%r10d
jb     1420 <merge+0x300>
lea    (%rax,%rcx,4),%rsi
lea    (%rdx,%r10,1),%rdi
lea    (%r15,%rdi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    1377 <merge+0x257>
lea    (%rcx,%r10,1),%rsi
lea    (%rax,%rsi,4),%rsi
add    $0x4,%rsi
lea    (%r15,%rdx,4),%rdi
cmp    %rsi,%rdi
jb     1420 <merge+0x300>
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     1650 <merge+0x530>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r15,%rdx,4),%rbx
add    $0x30,%rbx
lea    (%rax,%rcx,4),%rsi
add    $0x30,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%rbx,%rdi,4),%xmm0
movups -0x20(%rbx,%rdi,4),%xmm1
movups %xmm0,-0x30(%rsi,%rdi,4)
movups %xmm1,-0x20(%rsi,%rdi,4)
movups -0x10(%rbx,%rdi,4),%xmm0
movups (%rbx,%rdi,4),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,4)
movups %xmm1,(%rsi,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    13c0 <merge+0x2a0>
test   $0x1,%r9b
je     1411 <merge+0x2f1>
lea    (%rdi,%rdx,1),%rsi
add    %rcx,%rdi
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
cmp    %r8,%r10
je     1496 <merge+0x376>
add    %r8,%rdx
add    %r8,%rcx
mov    %r14d,%esi
sub    %edx,%esi
lea    0x1(%rsi),%edi
and    $0x3,%edi
je     1444 <merge+0x324>
nopl   (%rax)
mov    (%r15,%rdx,4),%ebp
mov    %ebp,(%rax,%rcx,4)
add    $0x1,%rdx
add    $0x1,%rcx
add    $0xffffffff,%edi
jne    1430 <merge+0x310>
cmp    $0x3,%esi
jb     1496 <merge+0x376>
mov    %r14d,%esi
sub    %edx,%esi
add    $0x1,%esi
lea    (%r15,%rdx,4),%rdx
add    $0xc,%rdx
lea    (%rax,%rcx,4),%rcx
add    $0xc,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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    1470 <merge+0x350>
mov    %r14d,%r10d
sub    %r11d,%r10d
jl     163a <merge+0x51a>
movslq %r11d,%rcx
cmp    $0x7,%r10d
jb     15d3 <merge+0x4b3>
lea    (%r15,%rcx,4),%rsi
lea    (%r10,%rcx,1),%rdx
lea    (%rax,%rdx,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    14d9 <merge+0x3b9>
lea    (%r15,%rdx,4),%rdx
add    $0x4,%rdx
lea    (%rax,%rcx,4),%rsi
cmp    %rdx,%rsi
jb     15d3 <merge+0x4b3>
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    1507 <merge+0x3e7>
xor    %esi,%esi
jmp    1589 <merge+0x469>
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
add    $0xfffffffffffffffe,%rdx
and    %rdx,%rdi
lea    (%r15,%rcx,4),%rbp
add    $0x70,%rbp
lea    (%rax,%rcx,4),%rdx
add    $0x70,%rdx
xor    %esi,%esi
nopw   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    1530 <merge+0x410>
test   %r9,%r9
je     15cb <merge+0x4ab>
add    %rcx,%rsi
lea    (%r15,%rsi,4),%rdx
add    $0x10,%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    15b0 <merge+0x490>
cmp    %r8,%r10
je     163a <merge+0x51a>
add    %r8,%rcx
mov    0x4(%rsp),%edx
sub    %ecx,%edx
sub    %ecx,%r14d
and    $0x3,%edx
je     1600 <merge+0x4e0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rcx,4),%esi
mov    %esi,(%r15,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%edx
jne    15f0 <merge+0x4d0>
cmp    $0x3,%r14d
jb     163a <merge+0x51a>
mov    0x4(%rsp),%edx
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rcx,4),%esi
mov    %esi,(%r15,%rcx,4)
mov    0x4(%rax,%rcx,4),%esi
mov    %esi,0x4(%r15,%rcx,4)
mov    0x8(%rax,%rcx,4),%esi
mov    %esi,0x8(%r15,%rcx,4)
mov    0xc(%rax,%rcx,4),%esi
mov    %esi,0xc(%r15,%rcx,4)
add    $0x4,%rcx
cmp    %ecx,%edx
jne    1610 <merge+0x4f0>
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    13f6 <merge+0x2d6>
jmp    1411 <merge+0x2f1>

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