#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*/ printArray(int *, int);
void merge(int a[], int p, int q, int r) {
  int n1 = q - p + 1;
  int n2 = r - q;
  int L[n1], R[n2];
  int i, j, k;
  for (i = 0; i < n1; i++) {
    L[i] = a[p + i - 1];
  }
  printArray(L, n1);
  for (j = 0; j < n2; j++) {
    R[j] = a[q + j];
  }
  L[n1] = 999;
  R[n2] = 999;
  i = 0;
  j = 0;
  for (k = p; k < r; k++) {
    if (L[i] <= R[j]) {
      a[k] = L[i];
      ++i;
    } else {
      a[k] = R[j];
      ++j;
    }
  }
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x28(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    11c4 <merge+0xb4>
mov    -0x58(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    -0x3c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    118c <merge+0x7c>
mov    -0x58(%rbp),%rdi
mov    -0x18(%rbp),%esi
call   1030 <printArray@plt>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    120c <merge+0xfc>
mov    -0x50(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%edx
add    -0x40(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11d7 <merge+0xc7>
mov    -0x50(%rbp),%rax
mov    -0x58(%rbp),%rcx
movslq -0x18(%rbp),%rdx
movl   $0x3e7,(%rcx,%rdx,4)
movslq -0x1c(%rbp),%rcx
movl   $0x3e7,(%rax,%rcx,4)
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12bc <merge+0x1ac>
mov    -0x50(%rbp),%rcx
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
movslq -0x40(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     128a <merge+0x17a>
mov    -0x58(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12a9 <merge+0x199>
mov    -0x50(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12ae <merge+0x19e>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    123e <merge+0x12e>
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %ecx,%r12d
mov    %esi,%r10d
mov    %rdi,%r14
mov    %edx,%eax
sub    %esi,%eax
lea    0x1(%rax),%r11d
mov    %ecx,%esi
mov    %rdx,-0x38(%rbp)
sub    %edx,%esi
lea    0xf(,%r11,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%r13
sub    %rcx,%r13
mov    %r13,%rsp
mov    %rsi,-0x30(%rbp)
lea    0xf(,%rsi,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%r15
sub    %rcx,%r15
mov    %r15,%rsp
test   %eax,%eax
js     12f0 <merge+0x1d0>
lea    -0x1(%r10),%eax
cmp    $0x8,%r11d
jae    122b <merge+0x10b>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r11,%rdx
mov    %r11,%rsi
and    $0x3,%rsi
je     11c9 <merge+0xa9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rax,%rcx,1),%edi
movslq %edi,%rdi
mov    (%r14,%rdi,4),%edi
mov    %edi,0x0(%r13,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11b0 <merge+0x90>
cmp    $0x3,%rdx
jb     12f0 <merge+0x1d0>
mov    %r10d,%edx
cs nopw 0x0(%rax,%rax,1)
lea    (%rax,%rcx,1),%esi
movslq %esi,%rsi
mov    (%r14,%rsi,4),%esi
mov    %esi,0x0(%r13,%rcx,4)
lea    (%rdx,%rcx,1),%rsi
movslq %esi,%rsi
mov    (%r14,%rsi,4),%edi
mov    %edi,0x4(%r13,%rcx,4)
lea    0x1(%rsi),%edi
movslq %edi,%rdi
mov    (%r14,%rdi,4),%edi
mov    %edi,0x8(%r13,%rcx,4)
add    $0x2,%esi
movslq %esi,%rsi
mov    (%r14,%rsi,4),%esi
mov    %esi,0xc(%r13,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    11e0 <merge+0xc0>
jmp    12f0 <merge+0x1d0>
lea    -0x1(%r11),%rdx
lea    (%r10,%rdx,1),%esi
add    $0xffffffff,%esi
xor    %ecx,%ecx
cmp    %eax,%esi
jl     1190 <merge+0x70>
shr    $0x20,%rdx
jne    1190 <merge+0x70>
mov    %r11d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     13fb <merge+0x2db>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x7(%r10),%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
lea    -0x8(%rdx),%ebx
movslq %ebx,%rbx
movups (%r14,%rbx,4),%xmm0
movups 0x10(%r14,%rbx,4),%xmm1
movaps %xmm0,0x0(%r13,%rsi,4)
movaps %xmm1,0x10(%r13,%rsi,4)
movslq %edx,%rdx
movups (%r14,%rdx,4),%xmm0
movups 0x10(%r14,%rdx,4),%xmm1
movaps %xmm0,0x20(%r13,%rsi,4)
movaps %xmm1,0x30(%r13,%rsi,4)
add    $0x10,%rsi
add    $0x10,%edx
add    $0xfffffffffffffffe,%rdi
jne    1280 <merge+0x160>
test   $0x1,%r8b
je     12e7 <merge+0x1c7>
lea    (%rax,%rsi,1),%edx
movslq %edx,%rdx
movups (%r14,%rdx,4),%xmm0
movups 0x10(%r14,%rdx,4),%xmm1
movaps %xmm0,0x0(%r13,%rsi,4)
movaps %xmm1,0x10(%r13,%rsi,4)
cmp    %r11,%rcx
jne    1190 <merge+0x70>
mov    %r10,-0x40(%rbp)
mov    %r13,%rdi
mov    %r11,%rbx
mov    %r11d,%esi
call   1040 <printArray@plt>
cmpl   $0x0,-0x30(%rbp)
jle    1328 <merge+0x208>
mov    -0x38(%rbp),%rcx
movslq %ecx,%rax
lea    (%r14,%rax,4),%rsi
not    %ecx
add    %r12d,%ecx
lea    0x4(,%rcx,4),%rdx
mov    %r15,%rdi
call   1030 <memcpy@plt>
movslq %ebx,%rax
movl   $0x3e7,0x0(%r13,%rax,4)
movslq -0x30(%rbp),%rax
movl   $0x3e7,(%r15,%rax,4)
mov    -0x40(%rbp),%rbx
cmp    %r12d,%ebx
jge    13ec <merge+0x2cc>
movslq %ebx,%r9
movslq %r12d,%rcx
mov    %rcx,%r8
sub    %r9,%r8
mov    %r9,%rsi
not    %rsi
xor    %edx,%edx
add    %rcx,%rsi
jne    1373 <merge+0x253>
xor    %ecx,%ecx
test   $0x1,%r8b
jne    13da <merge+0x2ba>
jmp    13ec <merge+0x2cc>
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
xor    %edi,%edi
nopl   0x0(%rax)
mov    %edi,%ecx
mov    0x0(%r13,%rcx,4),%eax
mov    %edx,%ecx
mov    (%r15,%rcx,4),%esi
xor    %ecx,%ecx
xor    %ebx,%ebx
cmp    %esi,%eax
setg   %cl
setle  %bl
cmovg  %esi,%eax
add    %edi,%ebx
add    %edx,%ecx
mov    %eax,(%r14,%r9,4)
mov    0x0(%r13,%rbx,4),%eax
mov    (%r15,%rcx,4),%esi
xor    %edx,%edx
xor    %edi,%edi
cmp    %esi,%eax
setg   %dl
setle  %dil
cmovg  %esi,%eax
add    %ebx,%edi
add    %ecx,%edx
mov    %eax,0x4(%r14,%r9,4)
add    $0x2,%r9
add    $0xfffffffffffffffe,%r10
jne    1380 <merge+0x260>
mov    %edi,%ecx
mov    %edx,%edx
test   $0x1,%r8b
je     13ec <merge+0x2cc>
mov    0x0(%r13,%rcx,4),%eax
mov    (%r15,%rdx,4),%ecx
cmp    %ecx,%eax
cmovg  %ecx,%eax
mov    %eax,(%r14,%r9,4)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%r8b
jne    12ca <merge+0x1aa>
jmp    12e7 <merge+0x1c7>

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

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