#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 */
void NA_merge_sorted_arrays(size_t *arr1, size_t *arr2, size_t n1, size_t n2,
                            size_t *arr3) {
  size_t i = 0, j = 0, k = 0;
  while (i < n1 && j < n2) {
    if (arr1[i] < arr2[j])
      arr3[k++] = arr1[i++];
    else
      arr3[k++] = arr2[j++];
  }
  while (i < n1)
    arr3[k++] = arr1[i++];
  while (j < n2)
    arr3[k++] = arr2[j++];
}


x86 assembly (clang, -O0):
<NA_merge_sorted_arrays>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x18(%rbp),%rcx
mov    %al,-0x41(%rbp)
jae    1151 <NA_merge_sorted_arrays+0x51>
mov    -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
setb   %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    1161 <NA_merge_sorted_arrays+0x61>
jmp    11e5 <NA_merge_sorted_arrays+0xe5>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x38(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jae    11b2 <NA_merge_sorted_arrays+0xb2>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x40(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    11e0 <NA_merge_sorted_arrays+0xe0>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x40(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    1130 <NA_merge_sorted_arrays+0x30>
jmp    11ea <NA_merge_sorted_arrays+0xea>
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    122b <NA_merge_sorted_arrays+0x12b>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x40(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    11ea <NA_merge_sorted_arrays+0xea>
jmp    1230 <NA_merge_sorted_arrays+0x130>
mov    -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    1271 <NA_merge_sorted_arrays+0x171>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    (%rax,%rcx,8),%rdx
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x40(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    1230 <NA_merge_sorted_arrays+0x130>
pop    %rbp
ret

x86 assembly (clang, -O2):
<NA_merge_sorted_arrays>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
xor    %eax,%eax
test   %rdx,%rdx
je     115e <NA_merge_sorted_arrays+0x5e>
mov    $0x0,%r10d
mov    $0x0,%r11d
test   %rcx,%rcx
je     1164 <NA_merge_sorted_arrays+0x64>
xor    %r11d,%r11d
xor    %r10d,%r10d
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,8),%rbp
mov    (%rsi,%r10,8),%rbx
cmp    %rbx,%rbp
adc    $0x0,%rax
cmp    %rbx,%rbp
cmovb  %rbp,%rbx
sbb    $0xffffffffffffffff,%r10
mov    %rbx,(%r8,%r11,8)
add    $0x1,%r11
cmp    %rdx,%rax
jae    1164 <NA_merge_sorted_arrays+0x64>
cmp    %rcx,%r10
jb     1130 <NA_merge_sorted_arrays+0x30>
jmp    1164 <NA_merge_sorted_arrays+0x64>
xor    %r10d,%r10d
xor    %r11d,%r11d
mov    %r11,%r9
cmp    %rdx,%rax
jae    1291 <NA_merge_sorted_arrays+0x191>
lea    (%r11,%rdx,1),%r13
mov    %r13,%r9
sub    %rax,%r9
mov    %rdx,%r14
sub    %rax,%r14
mov    %r11,%rbx
mov    %rax,%rbp
cmp    $0x4,%r14
jb     126b <NA_merge_sorted_arrays+0x16b>
lea    (%r8,%r11,8),%rbx
lea    (%rdi,%rdx,8),%rbp
cmp    %rbp,%rbx
jae    11b4 <NA_merge_sorted_arrays+0xb4>
lea    (%r8,%r9,8),%r15
lea    (%rdi,%rax,8),%r12
mov    %r11,%rbx
mov    %rax,%rbp
cmp    %r15,%r12
jb     126b <NA_merge_sorted_arrays+0x16b>
mov    %r14,%r15
and    $0xfffffffffffffffc,%r15
lea    -0x4(%r15),%rbx
mov    %rbx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rbx,%rbx
mov    %r15,-0x8(%rsp)
mov    %rbp,-0x10(%rsp)
je     13bc <NA_merge_sorted_arrays+0x2bc>
and    $0xfffffffffffffffe,%rbp
lea    (%r8,%r11,8),%r12
add    $0x30,%r12
lea    (%rdi,%rax,8),%r15
add    $0x30,%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r15,%rbx,8),%xmm0
movups -0x20(%r15,%rbx,8),%xmm1
movups %xmm0,-0x30(%r12,%rbx,8)
movups %xmm1,-0x20(%r12,%rbx,8)
movups -0x10(%r15,%rbx,8),%xmm0
movups (%r15,%rbx,8),%xmm1
movups %xmm0,-0x10(%r12,%rbx,8)
movups %xmm1,(%r12,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1200 <NA_merge_sorted_arrays+0x100>
testb  $0x1,-0x10(%rsp)
je     125a <NA_merge_sorted_arrays+0x15a>
lea    (%r11,%rbx,1),%rbp
add    %rax,%rbx
movups (%rdi,%rbx,8),%xmm0
movups 0x10(%rdi,%rbx,8),%xmm1
movups %xmm0,(%r8,%rbp,8)
movups %xmm1,0x10(%r8,%rbp,8)
mov    -0x8(%rsp),%rbp
cmp    %rbp,%r14
je     1291 <NA_merge_sorted_arrays+0x191>
lea    (%r11,%rbp,1),%rbx
add    %rax,%rbp
sub    %rbx,%r13
sub    %rax,%r13
lea    (%r8,%rbx,8),%r14
lea    (%rdi,%rbp,8),%rdi
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rbp,8),%rbx
mov    %rbx,(%r14,%rbp,8)
add    $0x1,%rbp
cmp    %rbp,%r13
jne    1280 <NA_merge_sorted_arrays+0x180>
cmp    %rcx,%r10
jae    13b1 <NA_merge_sorted_arrays+0x2b1>
mov    %rcx,%rdi
sub    %r10,%rdi
mov    %r9,%rbx
mov    %r10,%r14
cmp    $0x4,%rdi
jb     137e <NA_merge_sorted_arrays+0x27e>
cmp    %rdx,%rax
cmova  %rax,%rdx
lea    (%r8,%r9,8),%rbx
lea    (%rsi,%rcx,8),%rbp
cmp    %rbp,%rbx
jae    12e7 <NA_merge_sorted_arrays+0x1e7>
add    %rcx,%r11
add    %rdx,%r11
add    %r10,%rax
sub    %rax,%r11
lea    (%r8,%r11,8),%rax
lea    (%rsi,%r10,8),%rdx
mov    %r9,%rbx
mov    %r10,%r14
cmp    %rax,%rdx
jb     137e <NA_merge_sorted_arrays+0x27e>
mov    %rdi,%r14
and    $0xfffffffffffffffc,%r14
lea    -0x4(%r14),%rax
mov    %rax,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rax,%rax
je     13ce <NA_merge_sorted_arrays+0x2ce>
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r8,%r9,8),%rbp
add    $0x30,%rbp
lea    (%rsi,%r10,8),%rbx
add    $0x30,%rbx
xor    %edx,%edx
nop
movups -0x30(%rbx,%rdx,8),%xmm0
movups -0x20(%rbx,%rdx,8),%xmm1
movups %xmm0,-0x30(%rbp,%rdx,8)
movups %xmm1,-0x20(%rbp,%rdx,8)
movups -0x10(%rbx,%rdx,8),%xmm0
movups (%rbx,%rdx,8),%xmm1
movups %xmm0,-0x10(%rbp,%rdx,8)
movups %xmm1,0x0(%rbp,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rax
jne    1320 <NA_merge_sorted_arrays+0x220>
test   $0x1,%r11b
je     1372 <NA_merge_sorted_arrays+0x272>
lea    (%r9,%rdx,1),%rax
add    %r10,%rdx
movups (%rsi,%rdx,8),%xmm0
movups 0x10(%rsi,%rdx,8),%xmm1
movups %xmm0,(%r8,%rax,8)
movups %xmm1,0x10(%r8,%rax,8)
cmp    %r14,%rdi
je     13b1 <NA_merge_sorted_arrays+0x2b1>
lea    (%r9,%r14,1),%rbx
add    %r10,%r14
add    %rcx,%r9
sub    %rbx,%r9
sub    %r10,%r9
lea    (%r8,%rbx,8),%rax
lea    (%rsi,%r14,8),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rdx,8),%rsi
mov    %rsi,(%rax,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r9
jne    13a0 <NA_merge_sorted_arrays+0x2a0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
testb  $0x1,-0x10(%rsp)
jne    123f <NA_merge_sorted_arrays+0x13f>
jmp    125a <NA_merge_sorted_arrays+0x15a>
xor    %edx,%edx
test   $0x1,%r11b
jne    1357 <NA_merge_sorted_arrays+0x257>
jmp    1372 <NA_merge_sorted_arrays+0x272>

LLVM IR (-O0):
define void @NA_merge_sorted_arrays(i64* %0, i64* %1, i64 %2, i64 %3, i64* %4) {
%6 = alloca i64*
%7 = alloca i64*
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
store i64* %0, i64** %6
store i64* %1, i64** %7
store i64 %2, i64* %8
store i64 %3, i64* %9
store i64* %4, i64** %10
store i64 0, i64* %11
store i64 0, i64* %12
store i64 0, i64* %13
br label %14
14: ; preds = %54, %5
%15 = load i64, i64* %11
%16 = load i64, i64* %8
%17 = icmp ult i64 %15, %16
br i1 %17, label %18, label %22
18: ; preds = %14
%19 = load i64, i64* %12
%20 = load i64, i64* %9
%21 = icmp ult i64 %19, %20
br label %22
22: ; preds = %18, %14
%23 = phi i1 [ false, %14 ], [ %21, %18 ]
br i1 %23, label %24, label %55
24: ; preds = %22
%25 = load i64*, i64** %6
%26 = load i64, i64* %11
%27 = getelementptr inbounds i64, i64* %25, i64 %26
%28 = load i64, i64* %27
%29 = load i64*, i64** %7
%30 = load i64, i64* %12
%31 = getelementptr inbounds i64, i64* %29, i64 %30
%32 = load i64, i64* %31
%33 = icmp ult i64 %28, %32
br i1 %33, label %34, label %44
34: ; preds = %24
%35 = load i64*, i64** %6
%36 = load i64, i64* %11
%37 = add i64 %36, 1
store i64 %37, i64* %11
%38 = getelementptr inbounds i64, i64* %35, i64 %36
%39 = load i64, i64* %38
%40 = load i64*, i64** %10
%41 = load i64, i64* %13
%42 = add i64 %41, 1
store i64 %42, i64* %13
%43 = getelementptr inbounds i64, i64* %40, i64 %41
store i64 %39, i64* %43
br label %54
44: ; preds = %24
%45 = load i64*, i64** %7
%46 = load i64, i64* %12
%47 = add i64 %46, 1
store i64 %47, i64* %12
%48 = getelementptr inbounds i64, i64* %45, i64 %46
%49 = load i64, i64* %48
%50 = load i64*, i64** %10
%51 = load i64, i64* %13
%52 = add i64 %51, 1
store i64 %52, i64* %13
%53 = getelementptr inbounds i64, i64* %50, i64 %51
store i64 %49, i64* %53
br label %54
54: ; preds = %44, %34
br label %14
55: ; preds = %22
br label %56
56: ; preds = %60, %55
%57 = load i64, i64* %11
%58 = load i64, i64* %8
%59 = icmp ult i64 %57, %58
br i1 %59, label %60, label %70
60: ; preds = %56
%61 = load i64*, i64** %6
%62 = load i64, i64* %11
%63 = add i64 %62, 1
store i64 %63, i64* %11
%64 = getelementptr inbounds i64, i64* %61, i64 %62
%65 = load i64, i64* %64
%66 = load i64*, i64** %10
%67 = load i64, i64* %13
%68 = add i64 %67, 1
store i64 %68, i64* %13
%69 = getelementptr inbounds i64, i64* %66, i64 %67
store i64 %65, i64* %69
br label %56
70: ; preds = %56
br label %71
71: ; preds = %75, %70
%72 = load i64, i64* %12
%73 = load i64, i64* %9
%74 = icmp ult i64 %72, %73
br i1 %74, label %75, label %85
75: ; preds = %71
%76 = load i64*, i64** %7
%77 = load i64, i64* %12
%78 = add i64 %77, 1
store i64 %78, i64* %12
%79 = getelementptr inbounds i64, i64* %76, i64 %77
%80 = load i64, i64* %79
%81 = load i64*, i64** %10
%82 = load i64, i64* %13
%83 = add i64 %82, 1
store i64 %83, i64* %13
%84 = getelementptr inbounds i64, i64* %81, i64 %82
store i64 %80, i64* %84
br label %71
85: ; preds = %71
ret void
}

LLVM IR (-O2):
define void @NA_merge_sorted_arrays(i64* nocapture %0, i64* nocapture %1, i64 %2, i64 %3, i64* nocapture writeonly %4) {
%6 = icmp ne i64 %2, 0
%7 = icmp ne i64 %3, 0
%8 = and i1 %6, %7
br i1 %8, label %90, label %9
9: ; preds = %90, %5
%10 = phi i64 [ 0, %5 ], [ %101, %90 ]
%11 = phi i64 [ 0, %5 ], [ %104, %90 ]
%12 = phi i64 [ 0, %5 ], [ %106, %90 ]
%13 = icmp ult i64 %10, %2
br i1 %13, label %14, label %110
14: ; preds = %9
%15 = add i64 %12, %2
%16 = sub i64 %15, %10
%17 = sub i64 %2, %10
%18 = icmp ult i64 %17, 4
br i1 %18, label %87, label %19
19: ; preds = %14
%20 = getelementptr i64, i64* %4, i64 %12
%21 = getelementptr i64, i64* %4, i64 %16
%22 = getelementptr i64, i64* %0, i64 %10
%23 = getelementptr i64, i64* %0, i64 %2
%24 = icmp ult i64* %20, %23
%25 = icmp ult i64* %22, %21
%26 = and i1 %24, %25
br i1 %26, label %87, label %27
27: ; preds = %19
%28 = and i64 %17, -4
%29 = add i64 %12, %28
%30 = add i64 %10, %28
%31 = add i64 %28, -4
%32 = lshr exact i64 %31, 2
%33 = add nuw nsw i64 %32, 1
%34 = and i64 %33, 1
%35 = icmp eq i64 %31, 0
br i1 %35, label %69, label %36
36: ; preds = %27
%37 = and i64 %33, 9223372036854775806
br label %38
38: ; preds = %38, %36
%39 = phi i64 [ 0, %36 ], [ %66, %38 ]
%40 = phi i64 [ 0, %36 ], [ %67, %38 ]
%41 = add i64 %12, %39
%42 = add i64 %10, %39
%43 = getelementptr inbounds i64, i64* %0, i64 %42
%44 = bitcast i64* %43 to <2 x i64>*
%45 = load <2 x i64>, <2 x i64>* %44
%46 = getelementptr inbounds i64, i64* %43, i64 2
%47 = bitcast i64* %46 to <2 x i64>*
%48 = load <2 x i64>, <2 x i64>* %47
%49 = getelementptr inbounds i64, i64* %4, i64 %41
%50 = bitcast i64* %49 to <2 x i64>*
store <2 x i64> %45, <2 x i64>* %50
%51 = getelementptr inbounds i64, i64* %49, i64 2
%52 = bitcast i64* %51 to <2 x i64>*
store <2 x i64> %48, <2 x i64>* %52
%53 = or i64 %39, 4
%54 = add i64 %12, %53
%55 = add i64 %10, %53
%56 = getelementptr inbounds i64, i64* %0, i64 %55
%57 = bitcast i64* %56 to <2 x i64>*
%58 = load <2 x i64>, <2 x i64>* %57
%59 = getelementptr inbounds i64, i64* %56, i64 2
%60 = bitcast i64* %59 to <2 x i64>*
%61 = load <2 x i64>, <2 x i64>* %60
%62 = getelementptr inbounds i64, i64* %4, i64 %54
%63 = bitcast i64* %62 to <2 x i64>*
store <2 x i64> %58, <2 x i64>* %63
%64 = getelementptr inbounds i64, i64* %62, i64 2
%65 = bitcast i64* %64 to <2 x i64>*
store <2 x i64> %61, <2 x i64>* %65
%66 = add nuw i64 %39, 8
%67 = add i64 %40, 2
%68 = icmp eq i64 %67, %37
br i1 %68, label %69, label %38
69: ; preds = %38, %27
%70 = phi i64 [ 0, %27 ], [ %66, %38 ]
%71 = icmp eq i64 %34, 0
br i1 %71, label %85, label %72
72: ; preds = %69
%73 = add i64 %12, %70
%74 = add i64 %10, %70
%75 = getelementptr inbounds i64, i64* %0, i64 %74
%76 = bitcast i64* %75 to <2 x i64>*
%77 = load <2 x i64>, <2 x i64>* %76
%78 = getelementptr inbounds i64, i64* %75, i64 2
%79 = bitcast i64* %78 to <2 x i64>*
%80 = load <2 x i64>, <2 x i64>* %79
%81 = getelementptr inbounds i64, i64* %4, i64 %73
%82 = bitcast i64* %81 to <2 x i64>*
store <2 x i64> %77, <2 x i64>* %82
%83 = getelementptr inbounds i64, i64* %81, i64 2
%84 = bitcast i64* %83 to <2 x i64>*
store <2 x i64> %80, <2 x i64>* %84
br label %85
85: ; preds = %69, %72
%86 = icmp eq i64 %17, %28
br i1 %86, label %110, label %87
87: ; preds = %19, %14, %85
%88 = phi i64 [ %12, %19 ], [ %12, %14 ], [ %29, %85 ]
%89 = phi i64 [ %10, %19 ], [ %10, %14 ], [ %30, %85 ]
br label %194
90: ; preds = %5, %90
%91 = phi i64 [ %106, %90 ], [ 0, %5 ]
%92 = phi i64 [ %104, %90 ], [ 0, %5 ]
%93 = phi i64 [ %101, %90 ], [ 0, %5 ]
%94 = getelementptr inbounds i64, i64* %0, i64 %93
%95 = load i64, i64* %94
%96 = getelementptr inbounds i64, i64* %1, i64 %92
%97 = load i64, i64* %96
%98 = icmp ult i64 %95, %97
%99 = select i1 %98, i64 %95, i64 %97
%100 = zext i1 %98 to i64
%101 = add nuw i64 %93, %100
%102 = xor i1 %98, true
%103 = zext i1 %102 to i64
%104 = add nuw i64 %92, %103
%105 = getelementptr inbounds i64, i64* %4, i64 %91
store i64 %99, i64* %105
%106 = add i64 %91, 1
%107 = icmp ult i64 %101, %2
%108 = icmp ult i64 %104, %3
%109 = select i1 %107, i1 %108, i1 false
br i1 %109, label %90, label %9
110: ; preds = %194, %85, %9
%111 = phi i64 [ %12, %9 ], [ %16, %85 ], [ %16, %194 ]
%112 = icmp ult i64 %11, %3
br i1 %112, label %113, label %212
113: ; preds = %110
%114 = add i64 %111, %3
%115 = sub i64 %114, %11
%116 = sub i64 %3, %11
%117 = icmp ult i64 %116, 4
br i1 %117, label %191, label %118
118: ; preds = %113
%119 = getelementptr i64, i64* %4, i64 %111
%120 = add i64 %12, %3
%121 = call i64 @llvm.umax.i64(i64 %10, i64 %2)
%122 = add i64 %120, %121
%123 = add i64 %10, %11
%124 = sub i64 %122, %123
%125 = getelementptr i64, i64* %4, i64 %124
%126 = getelementptr i64, i64* %1, i64 %11
%127 = getelementptr i64, i64* %1, i64 %3
%128 = icmp ult i64* %119, %127
%129 = icmp ult i64* %126, %125
%130 = and i1 %128, %129
br i1 %130, label %191, label %131
131: ; preds = %118
%132 = and i64 %116, -4
%133 = add i64 %111, %132
%134 = add i64 %11, %132
%135 = add i64 %132, -4
%136 = lshr exact i64 %135, 2
%137 = add nuw nsw i64 %136, 1
%138 = and i64 %137, 1
%139 = icmp eq i64 %135, 0
br i1 %139, label %173, label %140
140: ; preds = %131
%141 = and i64 %137, 9223372036854775806
br label %142
142: ; preds = %142, %140
%143 = phi i64 [ 0, %140 ], [ %170, %142 ]
%144 = phi i64 [ 0, %140 ], [ %171, %142 ]
%145 = add i64 %111, %143
%146 = add i64 %11, %143
%147 = getelementptr inbounds i64, i64* %1, i64 %146
%148 = bitcast i64* %147 to <2 x i64>*
%149 = load <2 x i64>, <2 x i64>* %148
%150 = getelementptr inbounds i64, i64* %147, i64 2
%151 = bitcast i64* %150 to <2 x i64>*
%152 = load <2 x i64>, <2 x i64>* %151
%153 = getelementptr inbounds i64, i64* %4, i64 %145
%154 = bitcast i64* %153 to <2 x i64>*
store <2 x i64> %149, <2 x i64>* %154
%155 = getelementptr inbounds i64, i64* %153, i64 2
%156 = bitcast i64* %155 to <2 x i64>*
store <2 x i64> %152, <2 x i64>* %156
%157 = or i64 %143, 4
%158 = add i64 %111, %157
%159 = add i64 %11, %157
%160 = getelementptr inbounds i64, i64* %1, i64 %159
%161 = bitcast i64* %160 to <2 x i64>*
%162 = load <2 x i64>, <2 x i64>* %161
%163 = getelementptr inbounds i64, i64* %160, i64 2
%164 = bitcast i64* %163 to <2 x i64>*
%165 = load <2 x i64>, <2 x i64>* %164
%166 = getelementptr inbounds i64, i64* %4, i64 %158
%167 = bitcast i64* %166 to <2 x i64>*
store <2 x i64> %162, <2 x i64>* %167
%168 = getelementptr inbounds i64, i64* %166, i64 2
%169 = bitcast i64* %168 to <2 x i64>*
store <2 x i64> %165, <2 x i64>* %169
%170 = add nuw i64 %143, 8
%171 = add i64 %144, 2
%172 = icmp eq i64 %171, %141
br i1 %172, label %173, label %142
173: ; preds = %142, %131
%174 = phi i64 [ 0, %131 ], [ %170, %142 ]
%175 = icmp eq i64 %138, 0
br i1 %175, label %189, label %176
176: ; preds = %173
%177 = add i64 %111, %174
%178 = add i64 %11, %174
%179 = getelementptr inbounds i64, i64* %1, i64 %178
%180 = bitcast i64* %179 to <2 x i64>*
%181 = load <2 x i64>, <2 x i64>* %180
%182 = getelementptr inbounds i64, i64* %179, i64 2
%183 = bitcast i64* %182 to <2 x i64>*
%184 = load <2 x i64>, <2 x i64>* %183
%185 = getelementptr inbounds i64, i64* %4, i64 %177
%186 = bitcast i64* %185 to <2 x i64>*
store <2 x i64> %181, <2 x i64>* %186
%187 = getelementptr inbounds i64, i64* %185, i64 2
%188 = bitcast i64* %187 to <2 x i64>*
store <2 x i64> %184, <2 x i64>* %188
br label %189
189: ; preds = %173, %176
%190 = icmp eq i64 %116, %132
br i1 %190, label %212, label %191
191: ; preds = %118, %113, %189
%192 = phi i64 [ %111, %118 ], [ %111, %113 ], [ %133, %189 ]
%193 = phi i64 [ %11, %118 ], [ %11, %113 ], [ %134, %189 ]
br label %203
194: ; preds = %87, %194
%195 = phi i64 [ %200, %194 ], [ %88, %87 ]
%196 = phi i64 [ %197, %194 ], [ %89, %87 ]
%197 = add nuw i64 %196, 1
%198 = getelementptr inbounds i64, i64* %0, i64 %196
%199 = load i64, i64* %198
%200 = add i64 %195, 1
%201 = getelementptr inbounds i64, i64* %4, i64 %195
store i64 %199, i64* %201
%202 = icmp eq i64 %200, %16
br i1 %202, label %110, label %194
203: ; preds = %191, %203
%204 = phi i64 [ %209, %203 ], [ %192, %191 ]
%205 = phi i64 [ %206, %203 ], [ %193, %191 ]
%206 = add nuw i64 %205, 1
%207 = getelementptr inbounds i64, i64* %1, i64 %205
%208 = load i64, i64* %207
%209 = add i64 %204, 1
%210 = getelementptr inbounds i64, i64* %4, i64 %204
store i64 %208, i64* %210
%211 = icmp eq i64 %209, %115
br i1 %211, label %212, label %203
212: ; preds = %203, %189, %110
ret void
}