#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*/ exit(int);
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
void merge(int vec[], int vetsize) {
  int md;
  int i, j, k;
  int *tmp;
  tmp = (int *)malloc(vetsize * sizeof(int));
  if (tmp == NULL) {
    exit(1);
  }
  md = vetsize / 2;
  i = 0;
  j = md;
  k = 0;
  while (i < md && j < vetsize) {
    if (vec[i] <= vec[j]) {
      tmp[k] = vec[i++];
    } else {
      tmp[k] = vec[j++];
    }
    ++k;
  }
  if (i == md) {
    while (j < vetsize) {
      tmp[k++] = vec[j++];
    }
  } else {
    while (i < md) {
      tmp[k++] = vec[i++];
    }
  }
  for (i = 0; i < vetsize; ++i) {
    vec[i] = tmp[i];
  }
  free(tmp);
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    1167 <merge+0x37>
mov    $0x1,%edi
call   1050 <exit@plt>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0x29(%rbp)
jge    11a6 <merge+0x76>
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
setl   %al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
test   $0x1,%al
jne    11b6 <merge+0x86>
jmp    1225 <merge+0xf5>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     11f7 <merge+0xc7>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1217 <merge+0xe7>
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 -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1189 <merge+0x59>
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    1276 <merge+0x146>
jmp    1236 <merge+0x106>
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1271 <merge+0x141>
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    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1236 <merge+0x106>
jmp    12bb <merge+0x18b>
jmp    127b <merge+0x14b>
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12b6 <merge+0x186>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x1c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    127b <merge+0x14b>
jmp    12bb <merge+0x18b>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12f2 <merge+0x1c2>
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    12c2 <merge+0x192>
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    %esi,%r13d
mov    %rdi,%r14
lea    0x0(,%r13,4),%edi
call   1040 <malloc@plt>
test   %rax,%rax
je     164c <merge+0x51c>
mov    %r13d,%r9d
shr    $0x1f,%r9d
add    %r13d,%r9d
sar    %r9d
xor    %ecx,%ecx
mov    %r9d,%esi
cmp    $0x2,%r13d
jl     133c <merge+0x20c>
mov    $0x0,%edi
cmp    %r13d,%r9d
jge    11c8 <merge+0x98>
xor    %ecx,%ecx
xor    %edi,%edi
mov    %r9d,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %edi,%r8d
mov    %edi,%edi
mov    (%r14,%rdi,4),%ebp
movslq %esi,%rsi
mov    (%r14,%rsi,4),%edx
xor    %edi,%edi
xor    %ebx,%ebx
cmp    %edx,%ebp
setle  %dil
setg   %bl
cmovg  %edx,%ebp
add    %ebx,%esi
add    %r8d,%edi
mov    %ebp,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %r9d,%edi
jge    11c6 <merge+0x96>
cmp    %r13d,%esi
jl     1190 <merge+0x60>
mov    %ecx,%ecx
cmp    %r9d,%edi
jne    1347 <merge+0x217>
cmp    %r13d,%esi
jge    14a7 <merge+0x377>
movslq %esi,%rsi
movslq %r13d,%r11
mov    %r11,%r10
sub    %rsi,%r10
cmp    $0x8,%r10
jb     12b8 <merge+0x188>
lea    (%rax,%rcx,4),%rdx
lea    (%r14,%r11,4),%rdi
cmp    %rdi,%rdx
jae    1215 <merge+0xe5>
lea    (%rcx,%r11,1),%rdx
sub    %rsi,%rdx
lea    (%rax,%rdx,4),%rdx
lea    (%r14,%rsi,4),%rdi
cmp    %rdx,%rdi
jb     12b8 <merge+0x188>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     162a <merge+0x4fa>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%r14,%rsi,4),%r15
add    $0x30,%r15
lea    (%rax,%rcx,4),%r12
add    $0x30,%r12
xor    %edi,%edi
nopl   (%rax)
movups -0x30(%r15,%rdi,4),%xmm0
movups -0x20(%r15,%rdi,4),%xmm1
movups %xmm0,-0x30(%r12,%rdi,4)
movups %xmm1,-0x20(%r12,%rdi,4)
movups -0x10(%r15,%rdi,4),%xmm0
movups (%r15,%rdi,4),%xmm1
movups %xmm0,-0x10(%r12,%rdi,4)
movups %xmm1,(%r12,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1250 <merge+0x120>
test   $0x1,%r9b
je     12a9 <merge+0x179>
lea    (%rcx,%rdi,1),%rdx
add    %rsi,%rdi
movups (%r14,%rdi,4),%xmm0
movups 0x10(%r14,%rdi,4),%xmm1
movups %xmm0,(%rax,%rdx,4)
movups %xmm1,0x10(%rax,%rdx,4)
cmp    %r8,%r10
je     14a7 <merge+0x377>
add    %r8,%rsi
add    %r8,%rcx
mov    %r13d,%edi
sub    %esi,%edi
mov    %rsi,%r8
not    %r8
add    %r11,%r8
and    $0x3,%rdi
je     12e5 <merge+0x1b5>
nopl   0x0(%rax)
mov    (%r14,%rsi,4),%edx
add    $0x1,%rsi
mov    %edx,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12d0 <merge+0x1a0>
cmp    $0x3,%r8
jb     14a7 <merge+0x377>
sub    %rsi,%r11
lea    (%r14,%rsi,4),%rdx
add    $0xc,%rdx
lea    (%rax,%rcx,4),%rcx
add    $0xc,%rcx
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,%r11
jne    1310 <merge+0x1e0>
jmp    14a7 <merge+0x377>
xor    %edi,%edi
cmp    %r9d,%edi
je     11d1 <merge+0xa1>
jge    14a7 <merge+0x377>
movslq %edi,%rdi
movslq %r9d,%r11
mov    %r11,%r8
sub    %rdi,%r8
cmp    $0x8,%r8
jb     1438 <merge+0x308>
lea    (%rax,%rcx,4),%rdx
lea    (%r14,%r11,4),%rsi
cmp    %rsi,%rdx
jae    1388 <merge+0x258>
lea    (%rcx,%r11,1),%rdx
sub    %rdi,%rdx
lea    (%rax,%rdx,4),%rdx
lea    (%r14,%rdi,4),%rsi
cmp    %rdx,%rsi
jb     1438 <merge+0x308>
mov    %r13,%rbx
mov    %r8,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rsi
mov    %rsi,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rsi,%rsi
je     163b <merge+0x50b>
mov    %r10,%r15
and    $0xfffffffffffffffe,%r15
lea    (%rax,%rcx,4),%r12
add    $0x30,%r12
lea    (%r14,%rdi,4),%r13
add    $0x30,%r13
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r13,%rsi,4),%xmm0
movups -0x20(%r13,%rsi,4),%xmm1
movups %xmm0,-0x30(%r12,%rsi,4)
movups %xmm1,-0x20(%r12,%rsi,4)
movups -0x10(%r13,%rsi,4),%xmm0
movups 0x0(%r13,%rsi,4),%xmm1
movups %xmm0,-0x10(%r12,%rsi,4)
movups %xmm1,(%r12,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%r15
jne    13d0 <merge+0x2a0>
test   $0x1,%r10b
je     142a <merge+0x2fa>
lea    (%rcx,%rsi,1),%rbp
add    %rdi,%rsi
movups (%r14,%rsi,4),%xmm0
movups 0x10(%r14,%rsi,4),%xmm1
movups %xmm0,(%rax,%rbp,4)
movups %xmm1,0x10(%rax,%rbp,4)
cmp    %rdx,%r8
mov    %rbx,%r13
je     14a7 <merge+0x377>
add    %rdx,%rcx
add    %rdx,%rdi
sub    %edi,%r9d
mov    %rdi,%rsi
not    %rsi
add    %r11,%rsi
and    $0x3,%r9
je     1465 <merge+0x335>
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rdi,4),%edx
add    $0x1,%rdi
mov    %edx,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%r9
jne    1450 <merge+0x320>
cmp    $0x3,%rsi
jb     14a7 <merge+0x377>
lea    (%rax,%rcx,4),%rcx
add    $0xc,%rcx
sub    %rdi,%r11
lea    (%r14,%rdi,4),%rdx
add    $0xc,%rdx
xor    %esi,%esi
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,%r11
jne    1480 <merge+0x350>
test   %r13d,%r13d
jle    1614 <merge+0x4e4>
mov    %r13d,%r9d
cmp    $0x8,%r13d
jb     14cb <merge+0x39b>
lea    (%rax,%r9,4),%rcx
cmp    %r14,%rcx
jbe    1530 <merge+0x400>
lea    (%r14,%r9,4),%rcx
cmp    %rcx,%rax
jae    1530 <merge+0x400>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdi
and    $0x3,%rdi
je     14f1 <merge+0x3c1>
nop
mov    (%rax,%rdx,4),%ecx
mov    %ecx,(%r14,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    14e0 <merge+0x3b0>
cmp    $0x3,%rsi
jb     1614 <merge+0x4e4>
nopl   0x0(%rax,%rax,1)
mov    (%rax,%rdx,4),%ecx
mov    %ecx,(%r14,%rdx,4)
mov    0x4(%rax,%rdx,4),%ecx
mov    %ecx,0x4(%r14,%rdx,4)
mov    0x8(%rax,%rdx,4),%ecx
mov    %ecx,0x8(%r14,%rdx,4)
mov    0xc(%rax,%rdx,4),%ecx
mov    %ecx,0xc(%r14,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    1500 <merge+0x3d0>
jmp    1614 <merge+0x4e4>
mov    %r9d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rcx
jae    1556 <merge+0x426>
xor    %esi,%esi
jmp    15d0 <merge+0x4a0>
movabs $0x3ffffffffffffffe,%rcx
ff ff 3f
add    $0xfffffffffffffffe,%rcx
and    %rcx,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
movups %xmm0,(%r14,%rsi,4)
movups %xmm1,0x10(%r14,%rsi,4)
movups 0x20(%rax,%rsi,4),%xmm0
movups 0x30(%rax,%rsi,4),%xmm1
movups %xmm0,0x20(%r14,%rsi,4)
movups %xmm1,0x30(%r14,%rsi,4)
movups 0x40(%rax,%rsi,4),%xmm0
movups 0x50(%rax,%rsi,4),%xmm1
movups %xmm0,0x40(%r14,%rsi,4)
movups %xmm1,0x50(%r14,%rsi,4)
movups 0x60(%rax,%rsi,4),%xmm0
movups 0x70(%rax,%rsi,4),%xmm1
movups %xmm0,0x60(%r14,%rsi,4)
movups %xmm1,0x70(%r14,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1570 <merge+0x440>
test   %r8,%r8
je     160b <merge+0x4db>
lea    (%r14,%rsi,4),%rdi
add    $0x10,%rdi
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rcx,1),%xmm0
movups (%rsi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rcx,1)
movups %xmm1,(%rdi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r8
jne    15f0 <merge+0x4c0>
cmp    %r9,%rdx
jne    14cd <merge+0x39d>
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    128e <merge+0x15e>
jmp    12a9 <merge+0x179>
xor    %esi,%esi
test   $0x1,%r10b
jne    140f <merge+0x2df>
jmp    142a <merge+0x2fa>
mov    $0x1,%edi
call   1050 <exit@plt>

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

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