#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_array(int *array1, int count1, int *array2, int count2) {
  int i = 0, j = 0, k = 0;
  int *array = (int *)malloc(sizeof(int) * (count1 + count2));
  while (i < count1 && j < count2)
    array[k++] = (array1[i] < array2[j]) ? array1[i++] : array2[j++];
  while (i < count1)
    array[k++] = array1[i++];
  while (j < count2)
    array[k++] = array2[j++];
  for (i = 0; i < (count1 + count2); ++i)
    array1[i] = array[i];
  free(array);
}


x86 assembly (clang, -O0):
<merge_array>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x31(%rbp)
jge    117f <merge_array+0x5f>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    118f <merge_array+0x6f>
jmp    11fd <merge_array+0xdd>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11c8 <merge_array+0xa8>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
jmp    11e0 <merge_array+0xc0>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1162 <merge_array+0x42>
jmp    1202 <merge_array+0xe2>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    123d <merge_array+0x11d>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1202 <merge_array+0xe2>
jmp    1242 <merge_array+0x122>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    127d <merge_array+0x15d>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1242 <merge_array+0x122>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jge    12b9 <merge_array+0x199>
mov    -0x30(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1284 <merge_array+0x164>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge_array>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%r14d
mov    %rdx,%r15
mov    %esi,%r12d
mov    %rdi,%r13
lea    (%r14,%r12,1),%ebx
lea    0x0(,%rbx,4),%edi
call   1040 <malloc@plt>
xor    %r8d,%r8d
test   %r12d,%r12d
jle    12b8 <merge_array+0x198>
mov    $0x0,%edx
mov    $0x0,%esi
test   %r14d,%r14d
jle    11ae <merge_array+0x8e>
mov    %rbx,%r9
xor    %edx,%edx
xor    %esi,%esi
xor    %r8d,%r8d
nopl   0x0(%rax)
mov    %r8d,%edi
mov    %esi,%ebp
mov    %esi,%ecx
mov    0x0(%r13,%rcx,4),%ebx
mov    %r8d,%ecx
mov    (%r15,%rcx,4),%ecx
xor    %esi,%esi
xor    %r8d,%r8d
cmp    %ecx,%ebx
setl   %sil
setge  %r8b
cmovl  %ebx,%ecx
add    %edi,%r8d
add    %ebp,%esi
mov    %ecx,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %r12d,%esi
jge    11ab <merge_array+0x8b>
cmp    %r14d,%r8d
jl     1170 <merge_array+0x50>
mov    %r9,%rbx
cmp    %r12d,%esi
jge    12e5 <merge_array+0x1c5>
mov    %esi,%edi
mov    %edx,%edx
not    %esi
add    %r12d,%esi
cmp    $0x7,%esi
jb     12d0 <merge_array+0x1b0>
mov    %rbx,(%rsp)
lea    (%rax,%rdx,4),%rbp
lea    (%rdi,%rsi,1),%rbx
lea    0x4(,%rbx,4),%rbx
add    %r13,%rbx
cmp    %rbx,%rbp
jae    1205 <merge_array+0xe5>
lea    (%rdx,%rsi,1),%rbp
lea    (%rax,%rbp,4),%rbp
add    $0x4,%rbp
lea    0x0(,%rdi,4),%rbx
add    %r13,%rbx
cmp    %rbp,%rbx
jb     12ca <merge_array+0x1aa>
add    $0x1,%rsi
mov    %rsi,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rbp
mov    %rbp,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rbp,%rbp
je     158a <merge_array+0x46a>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rax,%rdx,4),%r10
add    $0x30,%r10
lea    0x30(,%rdi,4),%r11
add    %r13,%r11
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%r11,%rbx,4),%xmm0
movups -0x20(%r11,%rbx,4),%xmm1
movups %xmm0,-0x30(%r10,%rbx,4)
movups %xmm1,-0x20(%r10,%rbx,4)
movups -0x10(%r11,%rbx,4),%xmm0
movups (%r11,%rbx,4),%xmm1
movups %xmm0,-0x10(%r10,%rbx,4)
movups %xmm1,(%r10,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1250 <merge_array+0x130>
test   $0x1,%r9b
je     12aa <merge_array+0x18a>
lea    (%rbx,%rdx,1),%rbp
add    %rdi,%rbx
movups 0x0(%r13,%rbx,4),%xmm0
movups 0x10(%r13,%rbx,4),%xmm1
movups %xmm0,(%rax,%rbp,4)
movups %xmm1,0x10(%rax,%rbp,4)
add    %rcx,%rdx
cmp    %rcx,%rsi
jne    12c7 <merge_array+0x1a7>
mov    (%rsp),%rbx
jmp    12e5 <merge_array+0x1c5>
xor    %edx,%edx
xor    %esi,%esi
cmp    %r12d,%esi
jl     11b7 <merge_array+0x97>
jmp    12e5 <merge_array+0x1c5>
add    %rcx,%rdi
mov    (%rsp),%rbx
xchg   %ax,%ax
mov    0x0(%r13,%rdi,4),%ecx
add    $0x1,%rdi
mov    %ecx,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %r12d,%edi
jl     12d0 <merge_array+0x1b0>
cmp    %r14d,%r8d
jge    1403 <merge_array+0x2e3>
mov    %edx,%r10d
mov    %r8d,%edx
not    %r8d
add    %r14d,%r8d
cmp    $0x7,%r8d
jb     13df <merge_array+0x2bf>
lea    (%rax,%r10,4),%rcx
lea    (%rdx,%r8,1),%rsi
lea    (%r15,%rsi,4),%rsi
add    $0x4,%rsi
cmp    %rsi,%rcx
jae    1332 <merge_array+0x212>
lea    (%r10,%r8,1),%rcx
lea    (%rax,%rcx,4),%rcx
add    $0x4,%rcx
lea    (%r15,%rdx,4),%rsi
cmp    %rcx,%rsi
jb     13df <merge_array+0x2bf>
add    $0x1,%r8
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %rbx,%r11
test   %rsi,%rsi
je     159b <merge_array+0x47b>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r15,%rdx,4),%rbx
add    $0x30,%rbx
lea    (%rax,%r10,4),%rsi
add    $0x30,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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    1380 <merge_array+0x260>
test   $0x1,%r9b
je     13d1 <merge_array+0x2b1>
lea    (%rdi,%rdx,1),%rsi
add    %r10,%rdi
movups (%r15,%rsi,4),%xmm0
movups 0x10(%r15,%rsi,4),%xmm1
movups %xmm0,(%rax,%rdi,4)
movups %xmm1,0x10(%rax,%rdi,4)
cmp    %rcx,%r8
mov    %r11,%rbx
je     1403 <merge_array+0x2e3>
add    %rcx,%rdx
add    %rcx,%r10
lea    (%rax,%r10,4),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rdx,4),%esi
add    $0x1,%rdx
mov    %esi,(%rcx)
add    $0x4,%rcx
cmp    %r14d,%edx
jl     13f0 <merge_array+0x2d0>
test   %ebx,%ebx
jle    1574 <merge_array+0x454>
mov    %ebx,%ecx
cmp    $0x8,%ebx
jb     142b <merge_array+0x30b>
lea    (%rax,%rcx,4),%rdx
cmp    %r13,%rdx
jbe    1491 <merge_array+0x371>
lea    0x0(,%rcx,4),%rdx
add    %r13,%rdx
cmp    %rdx,%rax
jae    1491 <merge_array+0x371>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %rcx,%rdi
and    $0x3,%rdi
je     1452 <merge_array+0x332>
nop
mov    (%rax,%rdx,4),%ebp
mov    %ebp,0x0(%r13,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1440 <merge_array+0x320>
cmp    $0x3,%rsi
jb     1574 <merge_array+0x454>
nopl   0x0(%rax)
mov    (%rax,%rdx,4),%esi
mov    %esi,0x0(%r13,%rdx,4)
mov    0x4(%rax,%rdx,4),%esi
mov    %esi,0x4(%r13,%rdx,4)
mov    0x8(%rax,%rdx,4),%esi
mov    %esi,0x8(%r13,%rdx,4)
mov    0xc(%rax,%rdx,4),%esi
mov    %esi,0xc(%r13,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1460 <merge_array+0x340>
jmp    1574 <merge_array+0x454>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rsi
jae    14b6 <merge_array+0x396>
xor    %esi,%esi
jmp    1531 <merge_array+0x411>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rax,%rsi,4),%xmm0
movups 0x10(%rax,%rsi,4),%xmm1
movups %xmm0,0x0(%r13,%rsi,4)
movups %xmm1,0x10(%r13,%rsi,4)
movups 0x20(%rax,%rsi,4),%xmm0
movups 0x30(%rax,%rsi,4),%xmm1
movups %xmm0,0x20(%r13,%rsi,4)
movups %xmm1,0x30(%r13,%rsi,4)
movups 0x40(%rax,%rsi,4),%xmm0
movups 0x50(%rax,%rsi,4),%xmm1
movups %xmm0,0x40(%r13,%rsi,4)
movups %xmm1,0x50(%r13,%rsi,4)
movups 0x60(%rax,%rsi,4),%xmm0
movups 0x70(%rax,%rsi,4),%xmm1
movups %xmm0,0x60(%r13,%rsi,4)
movups %xmm1,0x70(%r13,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    14d0 <merge_array+0x3b0>
test   %r8,%r8
je     156b <merge_array+0x44b>
lea    0x10(,%rsi,4),%rdi
add    %r13,%rdi
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %ebp,%ebp
nop
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    1550 <merge_array+0x430>
cmp    %rcx,%rdx
jne    142d <merge_array+0x30d>
mov    %rax,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %ebx,%ebx
test   $0x1,%r9b
jne    128e <merge_array+0x16e>
jmp    12aa <merge_array+0x18a>
xor    %edi,%edi
test   $0x1,%r9b
jne    13b6 <merge_array+0x296>
jmp    13d1 <merge_array+0x2b1>

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

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