#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 INT_MAX;
int *merge(int a[], int p, int q, int r, char *text) {
  int leftLength = q - p + 1;
  int rightLength = r - q;
  int leftArray[leftLength + 1];
  int rightArray[rightLength + 1];
  int i;
  for (i = 0; i < leftLength; i++) {
    leftArray[i] = a[p + i];
  }
  int j;
  for (j = 0; j < rightLength; j++) {
    rightArray[j] = a[q + j + 1];
  }
  leftArray[leftLength] = INT_MAX;
  rightArray[rightLength] = INT_MAX;
  i = 0;
  j = 0;
  for (int k = p; k <= r; k++) {
    if (leftArray[i] <= rightArray[j]) {
      a[k] = leftArray[i];
      i = i + 1;
    } else {
      a[k] = rightArray[j];
      j = j + 1;
    }
  }
  return a;
}


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    %r8,-0x20(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11bb <merge+0xbb>
mov    -0x60(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    -0x44(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x44(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1186 <merge+0x86>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11fa <merge+0xfa>
mov    -0x58(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%edx
add    -0x48(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11c2 <merge+0xc2>
mov    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    0x2ddf(%rip),%rdx
mov    (%rdx),%esi
movslq -0x24(%rbp),%rdx
mov    %esi,(%rcx,%rdx,4)
mov    0x2dcf(%rip),%rcx
mov    (%rcx),%edx
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12b4 <merge+0x1b4>
mov    -0x58(%rbp),%rcx
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rdx
mov    (%rax,%rdx,4),%eax
movslq -0x48(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     1282 <merge+0x182>
mov    -0x60(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12a1 <merge+0x1a1>
mov    -0x58(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12a6 <merge+0x1a6>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1236 <merge+0x136>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%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    $0x28,%rsp
mov    %esi,%r10d
mov    %rdi,%r13
mov    %edx,%eax
sub    %esi,%eax
lea    0x1(%rax),%r8d
mov    %ecx,%r11d
mov    %rdx,-0x30(%rbp)
sub    %edx,%r11d
lea    0x2(%rax),%edx
lea    0xf(,%rdx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%r14
sub    %rdx,%r14
mov    %r14,%rsp
lea    0x1(%r11),%edx
lea    0xf(,%rdx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%r15
sub    %rdx,%r15
mov    %r15,%rsp
movslq %esi,%r12
test   %eax,%eax
mov    %r8,-0x38(%rbp)
js     11a8 <merge+0x98>
lea    0x0(,%r12,4),%rsi
add    %r13,%rsi
lea    0x0(,%r8,4),%rdx
mov    %r14,%rdi
mov    %ecx,-0x3c(%rbp)
mov    %r10d,%ebx
mov    %r11,-0x48(%rbp)
call   1030 <memcpy@plt>
mov    -0x38(%rbp),%r8
mov    -0x48(%rbp),%r11
mov    %ebx,%r10d
mov    -0x3c(%rbp),%ecx
test   %r11d,%r11d
jle    132a <merge+0x21a>
mov    %r11d,%r9d
cmp    $0x8,%r11d
jae    1200 <merge+0xf0>
xor    %ebx,%ebx
mov    %rbx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rdi
and    $0x3,%rdi
je     12ca <merge+0x1ba>
mov    -0x30(%rbp),%rax
lea    0x1(%rax),%esi
nopl   0x0(%rax)
lea    0x1(%rbx),%rdx
lea    (%rsi,%rbx,1),%eax
cltq
mov    0x0(%r13,%rax,4),%eax
mov    %eax,(%r15,%rbx,4)
mov    %rdx,%rbx
add    $0xffffffffffffffff,%rdi
jne    11e0 <merge+0xd0>
jmp    12cd <merge+0x1bd>
lea    -0x1(%r9),%rdx
mov    -0x30(%rbp),%rax
lea    0x1(%rax),%esi
lea    (%rax,%rdx,1),%edi
add    $0x1,%edi
xor    %ebx,%ebx
cmp    %esi,%edi
jl     11bc <merge+0xac>
shr    $0x20,%rdx
jne    11bc <merge+0xac>
mov    %r9d,%ebx
and    $0xfffffff8,%ebx
lea    -0x8(%rbx),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     13ee <merge+0x2de>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
mov    -0x30(%rbp),%rax
lea    0x9(%rax),%esi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
lea    -0x8(%rsi),%eax
cltq
movups 0x0(%r13,%rax,4),%xmm0
movups 0x10(%r13,%rax,4),%xmm1
movaps %xmm0,(%r15,%rdx,4)
movaps %xmm1,0x10(%r15,%rdx,4)
movslq %esi,%rsi
movups 0x0(%r13,%rsi,4),%xmm0
movups 0x10(%r13,%rsi,4),%xmm1
movaps %xmm0,0x20(%r15,%rdx,4)
movaps %xmm1,0x30(%r15,%rdx,4)
add    $0x10,%rdx
add    $0x10,%esi
add    $0xfffffffffffffffe,%rdi
jne    1250 <merge+0x140>
test   $0x1,%r8b
je     12bb <merge+0x1ab>
mov    %edx,%eax
or     $0x1,%eax
add    -0x30(%rbp),%eax
cltq
movups 0x0(%r13,%rax,4),%xmm0
movups 0x10(%r13,%rax,4),%xmm1
movaps %xmm0,(%r15,%rdx,4)
movaps %xmm1,0x10(%r15,%rdx,4)
cmp    %r9,%rbx
mov    -0x38(%rbp),%r8
jne    11bc <merge+0xac>
jmp    132a <merge+0x21a>
mov    %rbx,%rdx
cmp    $0x3,%r8
mov    -0x38(%rbp),%r8
jb     132a <merge+0x21a>
mov    -0x30(%rbp),%esi
nopw   0x0(%rax,%rax,1)
lea    (%rsi,%rdx,1),%eax
add    $0x1,%eax
cltq
mov    0x0(%r13,%rax,4),%eax
mov    %eax,(%r15,%rdx,4)
lea    0x2(%rsi,%rdx,1),%eax
cltq
mov    0x0(%r13,%rax,4),%eax
mov    %eax,0x4(%r15,%rdx,4)
lea    0x3(%rsi,%rdx,1),%eax
cltq
mov    0x0(%r13,%rax,4),%eax
mov    %eax,0x8(%r15,%rdx,4)
lea    0x4(%rsi,%rdx,1),%eax
cltq
mov    0x0(%r13,%rax,4),%eax
mov    %eax,0xc(%r15,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r9
jne    12e0 <merge+0x1d0>
mov    0x2cb7(%rip),%rax
mov    (%rax),%eax
movslq %r8d,%rdx
mov    %eax,(%r14,%rdx,4)
movslq %r11d,%rdx
mov    %eax,(%r15,%rdx,4)
mov    %ecx,%r8d
sub    %r10d,%r8d
jl     13dc <merge+0x2cc>
add    $0x1,%r8d
xor    %ebx,%ebx
cmp    %r10d,%ecx
jne    1362 <merge+0x252>
xor    %eax,%eax
test   $0x1,%r8b
jne    13ca <merge+0x2ba>
jmp    13dc <merge+0x2cc>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    %esi,%eax
mov    (%r14,%rax,4),%ecx
mov    %ebx,%eax
mov    (%r15,%rax,4),%edx
xor    %edi,%edi
xor    %eax,%eax
cmp    %edx,%ecx
setg   %dil
setle  %al
cmovg  %edx,%ecx
add    %esi,%eax
add    %ebx,%edi
mov    %ecx,0x0(%r13,%r12,4)
mov    (%r14,%rax,4),%edx
mov    (%r15,%rdi,4),%ecx
xor    %ebx,%ebx
xor    %esi,%esi
cmp    %ecx,%edx
setg   %bl
setle  %sil
cmovg  %ecx,%edx
add    %eax,%esi
add    %edi,%ebx
mov    %edx,0x4(%r13,%r12,4)
add    $0x2,%r12
add    $0xfffffffe,%r9d
jne    1370 <merge+0x260>
mov    %esi,%eax
mov    %ebx,%ebx
test   $0x1,%r8b
je     13dc <merge+0x2cc>
mov    (%r14,%rax,4),%eax
mov    (%r15,%rbx,4),%ecx
cmp    %ecx,%eax
cmovg  %ecx,%eax
mov    %eax,0x0(%r13,%r12,4)
mov    %r13,%rax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r8b
jne    129a <merge+0x18a>
jmp    12bb <merge+0x1ab>

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

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