void Merge1(int A[], int TmpA[], int L, int R, int RightEnd) {
  int NumElements = RightEnd - L + 1;
  int LeftEnd = R - 1;
  int Tmp = L;
  int i;
  while (L <= LeftEnd && R <= RightEnd) {
    if (A[L] >= A[R])
      TmpA[Tmp++] = A[R++];
    else
      TmpA[Tmp++] = A[L++];
  }
  while (L <= LeftEnd)
    TmpA[Tmp++] = A[L++];
  while (R <= RightEnd)
    TmpA[Tmp++] = A[R++];
  return;
}


x86 assembly (clang, -O0):
<Merge1>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x2d(%rbp)
jg     114e <Merge1+0x4e>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setle  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    115e <Merge1+0x5e>
jmp    11d8 <Merge1+0xd8>
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
jl     11a9 <Merge1+0xa9>
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    -0x10(%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    11d3 <Merge1+0xd3>
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    -0x10(%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    1131 <Merge1+0x31>
jmp    11dd <Merge1+0xdd>
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1218 <Merge1+0x118>
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    -0x10(%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    11dd <Merge1+0xdd>
jmp    121d <Merge1+0x11d>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1258 <Merge1+0x158>
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    -0x10(%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    121d <Merge1+0x11d>
pop    %rbp
ret

x86 assembly (clang, -O2):
<Merge1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    %ecx,%edx
jge    115c <Merge1+0x5c>
cmp    %r8d,%ecx
jg     115c <Merge1+0x5c>
movslq %edx,%rax
lea    (%rsi,%rax,4),%r10
mov    %edx,%ebx
mov    %ecx,%r14d
nop
movslq %ebx,%rbx
mov    (%rdi,%rbx,4),%r9d
movslq %r14d,%r14
mov    (%rdi,%r14,4),%ebp
xor    %r11d,%r11d
xor    %eax,%eax
cmp    %ebp,%r9d
setl   %r11b
setge  %al
cmovl  %r9d,%ebp
add    %eax,%r14d
add    %r11d,%ebx
mov    %ebp,(%r10)
add    $0x1,%edx
cmp    %ecx,%ebx
jge    1161 <Merge1+0x61>
add    $0x4,%r10
cmp    %r8d,%r14d
jle    1120 <Merge1+0x20>
jmp    1161 <Merge1+0x61>
mov    %ecx,%r14d
mov    %edx,%ebx
cmp    %ecx,%ebx
jge    12bb <Merge1+0x1bb>
movslq %ebx,%r10
movslq %edx,%rdx
movslq %ecx,%r9
mov    %r9,%r11
sub    %r10,%r11
cmp    $0x8,%r11
jb     1240 <Merge1+0x140>
lea    (%rsi,%rdx,4),%rax
lea    (%rdi,%r9,4),%rbx
cmp    %rbx,%rax
jae    11a7 <Merge1+0xa7>
lea    (%rdx,%r9,1),%rax
sub    %r10,%rax
lea    (%rsi,%rax,4),%rax
lea    (%rdi,%r10,4),%rbx
cmp    %rax,%rbx
jb     1240 <Merge1+0x140>
mov    %r11,%r15
and    $0xfffffffffffffff8,%r15
lea    -0x8(%r15),%rax
mov    %rax,%r12
shr    $0x3,%r12
add    $0x1,%r12
test   %rax,%rax
je     1432 <Merge1+0x332>
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
lea    (%rsi,%rdx,4),%r13
add    $0x30,%r13
lea    (%rdi,%r10,4),%rbp
add    $0x30,%rbp
xor    %ebx,%ebx
nop
movups -0x30(%rbp,%rbx,4),%xmm0
movups -0x20(%rbp,%rbx,4),%xmm1
movups %xmm0,-0x30(%r13,%rbx,4)
movups %xmm1,-0x20(%r13,%rbx,4)
movups -0x10(%rbp,%rbx,4),%xmm0
movups 0x0(%rbp,%rbx,4),%xmm1
movups %xmm0,-0x10(%r13,%rbx,4)
movups %xmm1,0x0(%r13,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    11e0 <Merge1+0xe0>
test   $0x1,%r12b
je     1235 <Merge1+0x135>
lea    (%rbx,%rdx,1),%rax
add    %r10,%rbx
movups (%rdi,%rbx,4),%xmm0
movups 0x10(%rdi,%rbx,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
add    %r15,%rdx
cmp    %r15,%r11
je     12bb <Merge1+0x1bb>
add    %r15,%r10
sub    %r10d,%ecx
mov    %r10,%rax
not    %rax
add    %r9,%rax
and    $0x3,%rcx
je     1275 <Merge1+0x175>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdi,%r10,4),%ebp
add    $0x1,%r10
mov    %ebp,(%rsi,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1260 <Merge1+0x160>
cmp    $0x3,%rax
jb     12bb <Merge1+0x1bb>
lea    (%rsi,%rdx,4),%rax
add    $0xc,%rax
sub    %r10,%r9
lea    (%rdi,%r10,4),%rbp
add    $0xc,%rbp
xor    %ecx,%ecx
mov    -0xc(%rbp,%rcx,4),%ebx
mov    %ebx,-0xc(%rax,%rcx,4)
mov    -0x8(%rbp,%rcx,4),%ebx
mov    %ebx,-0x8(%rax,%rcx,4)
mov    -0x4(%rbp,%rcx,4),%ebx
mov    %ebx,-0x4(%rax,%rcx,4)
mov    0x0(%rbp,%rcx,4),%ebx
mov    %ebx,(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1290 <Merge1+0x190>
add    %rcx,%rdx
cmp    %r8d,%r14d
jg     1427 <Merge1+0x327>
movslq %edx,%rcx
movslq %r14d,%rdx
mov    %r8d,%r9d
sub    %r14d,%r9d
cmp    $0x7,%r9d
jb     13af <Merge1+0x2af>
lea    (%rsi,%rcx,4),%rax
lea    (%rdx,%r9,1),%rbp
lea    (%rdi,%rbp,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rax
jae    1308 <Merge1+0x208>
lea    (%rcx,%r9,1),%rax
lea    (%rsi,%rax,4),%rax
add    $0x4,%rax
lea    (%rdi,%rdx,4),%rbp
cmp    %rax,%rbp
jb     13af <Merge1+0x2af>
add    $0x1,%r9
mov    %r9,%r10
and    $0xfffffffffffffff8,%r10
lea    -0x8(%r10),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     1443 <Merge1+0x343>
mov    %r11,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rdi,%rdx,4),%r14
add    $0x30,%r14
lea    (%rsi,%rcx,4),%rbp
add    $0x30,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups -0x30(%r14,%rax,4),%xmm0
movups -0x20(%r14,%rax,4),%xmm1
movups %xmm0,-0x30(%rbp,%rax,4)
movups %xmm1,-0x20(%rbp,%rax,4)
movups -0x10(%r14,%rax,4),%xmm0
movups (%r14,%rax,4),%xmm1
movups %xmm0,-0x10(%rbp,%rax,4)
movups %xmm1,0x0(%rbp,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rbx
jne    1350 <Merge1+0x250>
test   $0x1,%r11b
je     13a4 <Merge1+0x2a4>
lea    (%rax,%rdx,1),%rbp
add    %rcx,%rax
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
cmp    %r10,%r9
je     1427 <Merge1+0x327>
add    %r10,%rdx
add    %r10,%rcx
mov    %r8d,%eax
sub    %edx,%eax
lea    0x1(%rax),%ebx
and    $0x3,%ebx
je     13d3 <Merge1+0x2d3>
nopl   0x0(%rax)
mov    (%rdi,%rdx,4),%ebp
add    $0x1,%rdx
mov    %ebp,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%ebx
jne    13c0 <Merge1+0x2c0>
cmp    $0x3,%eax
jb     1427 <Merge1+0x327>
sub    %edx,%r8d
add    $0x1,%r8d
lea    (%rdi,%rdx,4),%rax
add    $0xc,%rax
lea    (%rsi,%rcx,4),%rcx
add    $0xc,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0xc(%rax,%rdx,4),%esi
mov    %esi,-0xc(%rcx,%rdx,4)
mov    -0x8(%rax,%rdx,4),%esi
mov    %esi,-0x8(%rcx,%rdx,4)
mov    -0x4(%rax,%rdx,4),%esi
mov    %esi,-0x4(%rcx,%rdx,4)
mov    (%rax,%rdx,4),%esi
mov    %esi,(%rcx,%rdx,4)
add    $0x4,%rdx
cmp    %edx,%r8d
jne    1400 <Merge1+0x300>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
test   $0x1,%r12b
jne    121c <Merge1+0x11c>
jmp    1235 <Merge1+0x135>
xor    %eax,%eax
test   $0x1,%r11b
jne    138b <Merge1+0x28b>
jmp    13a4 <Merge1+0x2a4>

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

LLVM IR (-O2):
define void @Merge1(i32* nocapture %0, i32* nocapture writeonly %1, i32 %2, i32 %3, i32 %4) {
%6 = icmp slt i32 %2, %3
%7 = icmp sle i32 %3, %4
%8 = and i1 %6, %7
br i1 %8, label %9, label %13
9: ; preds = %5
%10 = sext i32 %2 to i64
br label %118
11: ; preds = %118
%12 = trunc i64 %136 to i32
br label %13
13: ; preds = %11, %5
%14 = phi i32 [ %3, %5 ], [ %132, %11 ]
%15 = phi i32 [ %2, %5 ], [ %12, %11 ]
%16 = phi i32 [ %2, %5 ], [ %134, %11 ]
%17 = icmp slt i32 %16, %3
br i1 %17, label %18, label %143
18: ; preds = %13
%19 = sext i32 %16 to i64
%20 = sext i32 %15 to i64
%21 = sext i32 %3 to i64
%22 = sub nsw i64 %21, %19
%23 = icmp ult i64 %22, 8
br i1 %23, label %94, label %24
24: ; preds = %18
%25 = getelementptr i32, i32* %1, i64 %20
%26 = add nsw i64 %20, %21
%27 = sub nsw i64 %26, %19
%28 = getelementptr i32, i32* %1, i64 %27
%29 = getelementptr i32, i32* %0, i64 %19
%30 = getelementptr i32, i32* %0, i64 %21
%31 = icmp ult i32* %25, %30
%32 = icmp ult i32* %29, %28
%33 = and i1 %31, %32
br i1 %33, label %94, label %34
34: ; preds = %24
%35 = and i64 %22, -8
%36 = add nsw i64 %35, %20
%37 = add nsw i64 %35, %19
%38 = add nsw i64 %35, -8
%39 = lshr exact i64 %38, 3
%40 = add nuw nsw i64 %39, 1
%41 = and i64 %40, 1
%42 = icmp eq i64 %38, 0
br i1 %42, label %76, label %43
43: ; preds = %34
%44 = and i64 %40, 4611686018427387902
br label %45
45: ; preds = %45, %43
%46 = phi i64 [ 0, %43 ], [ %73, %45 ]
%47 = phi i64 [ 0, %43 ], [ %74, %45 ]
%48 = add i64 %46, %20
%49 = add i64 %46, %19
%50 = getelementptr inbounds i32, i32* %0, i64 %49
%51 = bitcast i32* %50 to <4 x i32>*
%52 = load <4 x i32>, <4 x i32>* %51
%53 = getelementptr inbounds i32, i32* %50, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = getelementptr inbounds i32, i32* %1, i64 %48
%57 = bitcast i32* %56 to <4 x i32>*
store <4 x i32> %52, <4 x i32>* %57
%58 = getelementptr inbounds i32, i32* %56, i64 4
%59 = bitcast i32* %58 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %59
%60 = or i64 %46, 8
%61 = add i64 %60, %20
%62 = add i64 %60, %19
%63 = getelementptr inbounds i32, i32* %0, i64 %62
%64 = bitcast i32* %63 to <4 x i32>*
%65 = load <4 x i32>, <4 x i32>* %64
%66 = getelementptr inbounds i32, i32* %63, i64 4
%67 = bitcast i32* %66 to <4 x i32>*
%68 = load <4 x i32>, <4 x i32>* %67
%69 = getelementptr inbounds i32, i32* %1, i64 %61
%70 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %70
%71 = getelementptr inbounds i32, i32* %69, i64 4
%72 = bitcast i32* %71 to <4 x i32>*
store <4 x i32> %68, <4 x i32>* %72
%73 = add nuw i64 %46, 16
%74 = add i64 %47, 2
%75 = icmp eq i64 %74, %44
br i1 %75, label %76, label %45
76: ; preds = %45, %34
%77 = phi i64 [ 0, %34 ], [ %73, %45 ]
%78 = icmp eq i64 %41, 0
br i1 %78, label %92, label %79
79: ; preds = %76
%80 = add i64 %77, %20
%81 = add i64 %77, %19
%82 = getelementptr inbounds i32, i32* %0, i64 %81
%83 = bitcast i32* %82 to <4 x i32>*
%84 = load <4 x i32>, <4 x i32>* %83
%85 = getelementptr inbounds i32, i32* %82, i64 4
%86 = bitcast i32* %85 to <4 x i32>*
%87 = load <4 x i32>, <4 x i32>* %86
%88 = getelementptr inbounds i32, i32* %1, i64 %80
%89 = bitcast i32* %88 to <4 x i32>*
store <4 x i32> %84, <4 x i32>* %89
%90 = getelementptr inbounds i32, i32* %88, i64 4
%91 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> %87, <4 x i32>* %91
br label %92
92: ; preds = %76, %79
%93 = icmp eq i64 %22, %35
br i1 %93, label %140, label %94
94: ; preds = %24, %18, %92
%95 = phi i64 [ %20, %24 ], [ %20, %18 ], [ %36, %92 ]
%96 = phi i64 [ %19, %24 ], [ %19, %18 ], [ %37, %92 ]
%97 = sub nsw i64 %21, %96
%98 = xor i64 %96, -1
%99 = add nsw i64 %98, %21
%100 = and i64 %97, 3
%101 = icmp eq i64 %100, 0
br i1 %101, label %113, label %102
102: ; preds = %94, %102
%103 = phi i64 [ %109, %102 ], [ %95, %94 ]
%104 = phi i64 [ %106, %102 ], [ %96, %94 ]
%105 = phi i64 [ %111, %102 ], [ 0, %94 ]
%106 = add nsw i64 %104, 1
%107 = getelementptr inbounds i32, i32* %0, i64 %104
%108 = load i32, i32* %107
%109 = add nsw i64 %103, 1
%110 = getelementptr inbounds i32, i32* %1, i64 %103
store i32 %108, i32* %110
%111 = add i64 %105, 1
%112 = icmp eq i64 %111, %100
br i1 %112, label %113, label %102
113: ; preds = %102, %94
%114 = phi i64 [ undef, %94 ], [ %109, %102 ]
%115 = phi i64 [ %95, %94 ], [ %109, %102 ]
%116 = phi i64 [ %96, %94 ], [ %106, %102 ]
%117 = icmp ult i64 %99, 3
br i1 %117, label %140, label %252
118: ; preds = %9, %118
%119 = phi i64 [ %10, %9 ], [ %136, %118 ]
%120 = phi i32 [ %2, %9 ], [ %134, %118 ]
%121 = phi i32 [ %3, %9 ], [ %132, %118 ]
%122 = sext i32 %120 to i64
%123 = getelementptr inbounds i32, i32* %0, i64 %122
%124 = load i32, i32* %123
%125 = sext i32 %121 to i64
%126 = getelementptr inbounds i32, i32* %0, i64 %125
%127 = load i32, i32* %126
%128 = icmp slt i32 %124, %127
%129 = select i1 %128, i32 %124, i32 %127
%130 = xor i1 %128, true
%131 = zext i1 %130 to i32
%132 = add nsw i32 %121, %131
%133 = zext i1 %128 to i32
%134 = add nsw i32 %120, %133
%135 = getelementptr inbounds i32, i32* %1, i64 %119
store i32 %129, i32* %135
%136 = add i64 %119, 1
%137 = icmp slt i32 %134, %3
%138 = icmp sle i32 %132, %4
%139 = select i1 %137, i1 %138, i1 false
br i1 %139, label %118, label %11
140: ; preds = %113, %252, %92
%141 = phi i64 [ %36, %92 ], [ %114, %113 ], [ %273, %252 ]
%142 = trunc i64 %141 to i32
br label %143
143: ; preds = %140, %13
%144 = phi i32 [ %15, %13 ], [ %142, %140 ]
%145 = icmp sgt i32 %14, %4
br i1 %145, label %301, label %146
146: ; preds = %143
%147 = sext i32 %144 to i64
%148 = sext i32 %14 to i64
%149 = add i32 %4, 1
%150 = sub i32 %4, %14
%151 = zext i32 %150 to i64
%152 = add nuw nsw i64 %151, 1
%153 = icmp ult i32 %150, 7
br i1 %153, label %228, label %154
154: ; preds = %146
%155 = getelementptr i32, i32* %1, i64 %147
%156 = sub i32 %4, %14
%157 = zext i32 %156 to i64
%158 = add nsw i64 %147, %157
%159 = add nsw i64 %158, 1
%160 = getelementptr i32, i32* %1, i64 %159
%161 = getelementptr i32, i32* %0, i64 %148
%162 = add nsw i64 %148, %157
%163 = add nsw i64 %162, 1
%164 = getelementptr i32, i32* %0, i64 %163
%165 = icmp ult i32* %155, %164
%166 = icmp ult i32* %161, %160
%167 = and i1 %165, %166
br i1 %167, label %228, label %168
168: ; preds = %154
%169 = and i64 %152, 8589934584
%170 = add nsw i64 %169, %148
%171 = add nsw i64 %169, %147
%172 = add nsw i64 %169, -8
%173 = lshr exact i64 %172, 3
%174 = add nuw nsw i64 %173, 1
%175 = and i64 %174, 1
%176 = icmp eq i64 %172, 0
br i1 %176, label %210, label %177
177: ; preds = %168
%178 = and i64 %174, 4611686018427387902
br label %179
179: ; preds = %179, %177
%180 = phi i64 [ 0, %177 ], [ %207, %179 ]
%181 = phi i64 [ 0, %177 ], [ %208, %179 ]
%182 = add i64 %180, %148
%183 = add i64 %180, %147
%184 = getelementptr inbounds i32, i32* %0, i64 %182
%185 = bitcast i32* %184 to <4 x i32>*
%186 = load <4 x i32>, <4 x i32>* %185
%187 = getelementptr inbounds i32, i32* %184, i64 4
%188 = bitcast i32* %187 to <4 x i32>*
%189 = load <4 x i32>, <4 x i32>* %188
%190 = getelementptr inbounds i32, i32* %1, i64 %183
%191 = bitcast i32* %190 to <4 x i32>*
store <4 x i32> %186, <4 x i32>* %191
%192 = getelementptr inbounds i32, i32* %190, i64 4
%193 = bitcast i32* %192 to <4 x i32>*
store <4 x i32> %189, <4 x i32>* %193
%194 = or i64 %180, 8
%195 = add i64 %194, %148
%196 = add i64 %194, %147
%197 = getelementptr inbounds i32, i32* %0, i64 %195
%198 = bitcast i32* %197 to <4 x i32>*
%199 = load <4 x i32>, <4 x i32>* %198
%200 = getelementptr inbounds i32, i32* %197, i64 4
%201 = bitcast i32* %200 to <4 x i32>*
%202 = load <4 x i32>, <4 x i32>* %201
%203 = getelementptr inbounds i32, i32* %1, i64 %196
%204 = bitcast i32* %203 to <4 x i32>*
store <4 x i32> %199, <4 x i32>* %204
%205 = getelementptr inbounds i32, i32* %203, i64 4
%206 = bitcast i32* %205 to <4 x i32>*
store <4 x i32> %202, <4 x i32>* %206
%207 = add nuw i64 %180, 16
%208 = add i64 %181, 2
%209 = icmp eq i64 %208, %178
br i1 %209, label %210, label %179
210: ; preds = %179, %168
%211 = phi i64 [ 0, %168 ], [ %207, %179 ]
%212 = icmp eq i64 %175, 0
br i1 %212, label %226, label %213
213: ; preds = %210
%214 = add i64 %211, %148
%215 = add i64 %211, %147
%216 = getelementptr inbounds i32, i32* %0, i64 %214
%217 = bitcast i32* %216 to <4 x i32>*
%218 = load <4 x i32>, <4 x i32>* %217
%219 = getelementptr inbounds i32, i32* %216, i64 4
%220 = bitcast i32* %219 to <4 x i32>*
%221 = load <4 x i32>, <4 x i32>* %220
%222 = getelementptr inbounds i32, i32* %1, i64 %215
%223 = bitcast i32* %222 to <4 x i32>*
store <4 x i32> %218, <4 x i32>* %223
%224 = getelementptr inbounds i32, i32* %222, i64 4
%225 = bitcast i32* %224 to <4 x i32>*
store <4 x i32> %221, <4 x i32>* %225
br label %226
226: ; preds = %210, %213
%227 = icmp eq i64 %152, %169
br i1 %227, label %301, label %228
228: ; preds = %154, %146, %226
%229 = phi i64 [ %148, %154 ], [ %148, %146 ], [ %170, %226 ]
%230 = phi i64 [ %147, %154 ], [ %147, %146 ], [ %171, %226 ]
%231 = add i32 %4, 1
%232 = trunc i64 %229 to i32
%233 = sub i32 %231, %232
%234 = sub i32 %4, %232
%235 = and i32 %233, 3
%236 = icmp eq i32 %235, 0
br i1 %236, label %248, label %237
237: ; preds = %228, %237
%238 = phi i64 [ %241, %237 ], [ %229, %228 ]
%239 = phi i64 [ %244, %237 ], [ %230, %228 ]
%240 = phi i32 [ %246, %237 ], [ 0, %228 ]
%241 = add nsw i64 %238, 1
%242 = getelementptr inbounds i32, i32* %0, i64 %238
%243 = load i32, i32* %242
%244 = add nsw i64 %239, 1
%245 = getelementptr inbounds i32, i32* %1, i64 %239
store i32 %243, i32* %245
%246 = add i32 %240, 1
%247 = icmp eq i32 %246, %235
br i1 %247, label %248, label %237
248: ; preds = %237, %228
%249 = phi i64 [ %229, %228 ], [ %241, %237 ]
%250 = phi i64 [ %230, %228 ], [ %244, %237 ]
%251 = icmp ult i32 %234, 3
br i1 %251, label %301, label %276
252: ; preds = %113, %252
%253 = phi i64 [ %273, %252 ], [ %115, %113 ]
%254 = phi i64 [ %270, %252 ], [ %116, %113 ]
%255 = add nsw i64 %254, 1
%256 = getelementptr inbounds i32, i32* %0, i64 %254
%257 = load i32, i32* %256
%258 = add nsw i64 %253, 1
%259 = getelementptr inbounds i32, i32* %1, i64 %253
store i32 %257, i32* %259
%260 = add nsw i64 %254, 2
%261 = getelementptr inbounds i32, i32* %0, i64 %255
%262 = load i32, i32* %261
%263 = add nsw i64 %253, 2
%264 = getelementptr inbounds i32, i32* %1, i64 %258
store i32 %262, i32* %264
%265 = add nsw i64 %254, 3
%266 = getelementptr inbounds i32, i32* %0, i64 %260
%267 = load i32, i32* %266
%268 = add nsw i64 %253, 3
%269 = getelementptr inbounds i32, i32* %1, i64 %263
store i32 %267, i32* %269
%270 = add nsw i64 %254, 4
%271 = getelementptr inbounds i32, i32* %0, i64 %265
%272 = load i32, i32* %271
%273 = add nsw i64 %253, 4
%274 = getelementptr inbounds i32, i32* %1, i64 %268
store i32 %272, i32* %274
%275 = icmp eq i64 %270, %21
br i1 %275, label %140, label %252
276: ; preds = %248, %276
%277 = phi i64 [ %294, %276 ], [ %249, %248 ]
%278 = phi i64 [ %297, %276 ], [ %250, %248 ]
%279 = add nsw i64 %277, 1
%280 = getelementptr inbounds i32, i32* %0, i64 %277
%281 = load i32, i32* %280
%282 = add nsw i64 %278, 1
%283 = getelementptr inbounds i32, i32* %1, i64 %278
store i32 %281, i32* %283
%284 = add nsw i64 %277, 2
%285 = getelementptr inbounds i32, i32* %0, i64 %279
%286 = load i32, i32* %285
%287 = add nsw i64 %278, 2
%288 = getelementptr inbounds i32, i32* %1, i64 %282
store i32 %286, i32* %288
%289 = add nsw i64 %277, 3
%290 = getelementptr inbounds i32, i32* %0, i64 %284
%291 = load i32, i32* %290
%292 = add nsw i64 %278, 3
%293 = getelementptr inbounds i32, i32* %1, i64 %287
store i32 %291, i32* %293
%294 = add nsw i64 %277, 4
%295 = getelementptr inbounds i32, i32* %0, i64 %289
%296 = load i32, i32* %295
%297 = add nsw i64 %278, 4
%298 = getelementptr inbounds i32, i32* %1, i64 %292
store i32 %296, i32* %298
%299 = trunc i64 %294 to i32
%300 = icmp eq i32 %149, %299
br i1 %300, label %301, label %276
301: ; preds = %248, %276, %226, %143
ret void
}