#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*/ Merge(int *, int *, int, int *, int);
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
void MergeSort(int *A, int n) {
  int mid, i, *L, *R;
  if (n < 2)
    return;
  mid = n / 2;
  L = (int *)malloc(mid * sizeof(int));
  R = (int *)malloc((n - mid) * sizeof(int));
  for (i = 0; i < mid; i++)
    L[i] = A[i];
  for (i = mid; i < n; i++)
    R[i - mid] = A[i];
  MergeSort(L, mid);
  MergeSort(R, n - mid);
  Merge(A, L, mid, R, n - mid);
  free(L);
  free(R);
}


x86 assembly (clang, -O0):
<MergeSort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x2,-0xc(%rbp)
jge    115e <MergeSort+0x1e>
jmp    1251 <MergeSort+0x111>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x10(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x10(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11cd <MergeSort+0x8d>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    119d <MergeSort+0x5d>
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1208 <MergeSort+0xc8>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11d3 <MergeSort+0x93>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%esi
call   1060 <MergeSort@plt>
mov    -0x28(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    -0x10(%rbp),%esi
call   1060 <MergeSort@plt>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x10(%rbp),%edx
mov    -0x28(%rbp),%rcx
mov    -0xc(%rbp),%r8d
sub    -0x10(%rbp),%r8d
call   1040 <Merge@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MergeSort>:
cmp    $0x2,%esi
jge    1146 <MergeSort+0x6>
ret
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %esi,%ebp
mov    %rdi,%rbx
mov    %esi,%r14d
shr    %r14d
lea    0x0(,%r14,4),%edi
call   1050 <malloc@plt>
mov    %rax,%r15
mov    %ebp,%r12d
sub    %r14d,%r12d
lea    0x0(,%r12,4),%edi
call   1050 <malloc@plt>
mov    %rax,%r13
cmp    $0x10,%ebp
jb     1199 <MergeSort+0x59>
lea    (%rbx,%r14,4),%rax
cmp    %rax,%r15
jae    1200 <MergeSort+0xc0>
lea    (%r15,%r14,4),%rax
cmp    %rbx,%rax
jbe    1200 <MergeSort+0xc0>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r14,%rcx
mov    %r14,%rdx
and    $0x3,%rdx
je     11c1 <MergeSort+0x81>
nopl   (%rax)
mov    (%rbx,%rax,4),%esi
mov    %esi,(%r15,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    11b0 <MergeSort+0x70>
cmp    $0x3,%rcx
jb     12d4 <MergeSort+0x194>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,4),%ecx
mov    %ecx,(%r15,%rax,4)
mov    0x4(%rbx,%rax,4),%ecx
mov    %ecx,0x4(%r15,%rax,4)
mov    0x8(%rbx,%rax,4),%ecx
mov    %ecx,0x8(%r15,%rax,4)
mov    0xc(%rbx,%rax,4),%ecx
mov    %ecx,0xc(%r15,%rax,4)
add    $0x4,%rax
cmp    %rax,%r14
jne    11d0 <MergeSort+0x90>
jmp    12d4 <MergeSort+0x194>
mov    %r14d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    1224 <MergeSort+0xe4>
xor    %esi,%esi
jmp    1290 <MergeSort+0x150>
and    $0xfffffffffffffffc,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rsi,4),%xmm0
movups 0x10(%rbx,%rsi,4),%xmm1
movups %xmm0,(%r15,%rsi,4)
movups %xmm1,0x10(%r15,%rsi,4)
movups 0x20(%rbx,%rsi,4),%xmm0
movups 0x30(%rbx,%rsi,4),%xmm1
movups %xmm0,0x20(%r15,%rsi,4)
movups %xmm1,0x30(%r15,%rsi,4)
movups 0x40(%rbx,%rsi,4),%xmm0
movups 0x50(%rbx,%rsi,4),%xmm1
movups %xmm0,0x40(%r15,%rsi,4)
movups %xmm1,0x50(%r15,%rsi,4)
movups 0x60(%rbx,%rsi,4),%xmm0
movups 0x70(%rbx,%rsi,4),%xmm1
movups %xmm0,0x60(%r15,%rsi,4)
movups %xmm1,0x70(%r15,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    1230 <MergeSort+0xf0>
test   %rcx,%rcx
je     12cb <MergeSort+0x18b>
lea    (%r15,%rsi,4),%rdx
add    $0x10,%rdx
lea    (%rbx,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rdi,1),%xmm0
movups (%rsi,%rdi,1),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,1)
movups %xmm1,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    12b0 <MergeSort+0x170>
cmp    %r14,%rax
jne    119b <MergeSort+0x5b>
cmp    %ebp,%r14d
jge    1446 <MergeSort+0x306>
add    %r14d,%ebp
sub    %r14d,%ebp
mov    %r14d,%ecx
not    %ecx
add    %ebp,%ecx
mov    %r14,%rax
cmp    $0x7,%ecx
jb     13ce <MergeSort+0x28e>
mov    %r14d,%eax
not    %eax
add    %ebp,%eax
lea    (%r14,%rax,1),%rdx
lea    (%rbx,%rdx,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%r13
jae    1329 <MergeSort+0x1e9>
lea    0x4(,%rax,4),%rdx
add    %r13,%rdx
lea    (%rbx,%r14,4),%rsi
mov    %r14,%rax
cmp    %rdx,%rsi
jb     13ce <MergeSort+0x28e>
add    $0x1,%rcx
mov    %rcx,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     148e <MergeSort+0x34e>
movabs $0x3ffffffffffffffc,%rdi
ff ff 3f
or     $0x2,%rdi
and    %r8,%rdi
lea    (%rbx,%r14,4),%rdx
add    $0x30,%rdx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rsi,4),%xmm0
movups -0x20(%rdx,%rsi,4),%xmm1
movups %xmm0,0x0(%r13,%rsi,4)
movups %xmm1,0x10(%r13,%rsi,4)
movups -0x10(%rdx,%rsi,4),%xmm0
movups (%rdx,%rsi,4),%xmm1
movups %xmm0,0x20(%r13,%rsi,4)
movups %xmm1,0x30(%r13,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1370 <MergeSort+0x230>
test   $0x1,%r8b
je     13c6 <MergeSort+0x286>
add    %r14,%rsi
movups (%rbx,%rsi,4),%xmm0
movups 0x10(%rbx,%rsi,4),%xmm1
sub    %r14,%rsi
movups %xmm0,0x0(%r13,%rsi,4)
movups %xmm1,0x10(%r13,%rsi,4)
cmp    %rax,%rcx
je     1446 <MergeSort+0x306>
add    %r14,%rax
mov    %ebp,%edx
sub    %eax,%edx
mov    %eax,%ecx
not    %ecx
add    %ebp,%ecx
and    $0x3,%edx
je     13ff <MergeSort+0x2bf>
lea    0x0(,%r14,4),%rdi
mov    %r13,%rsi
sub    %rdi,%rsi
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rax,4),%edi
mov    %edi,(%rsi,%rax,4)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    13f0 <MergeSort+0x2b0>
cmp    $0x3,%ecx
jb     1446 <MergeSort+0x306>
mov    %ebp,%ecx
mov    $0x3,%edx
sub    %r14,%rdx
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
nopl   0x0(%rax)
mov    (%rbx,%rax,4),%esi
mov    %esi,-0xc(%rdx,%rax,4)
mov    0x4(%rbx,%rax,4),%esi
mov    %esi,-0x8(%rdx,%rax,4)
mov    0x8(%rbx,%rax,4),%esi
mov    %esi,-0x4(%rdx,%rax,4)
mov    0xc(%rbx,%rax,4),%esi
mov    %esi,(%rdx,%rax,4)
add    $0x4,%rax
cmp    %eax,%ecx
jne    1420 <MergeSort+0x2e0>
mov    %r15,%rdi
mov    %r14d,%esi
call   1060 <MergeSort@plt>
mov    %r13,%rdi
mov    %r12d,%esi
call   1060 <MergeSort@plt>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r14d,%edx
mov    %r13,%rcx
mov    %r12d,%r8d
call   1040 <Merge@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
xor    %esi,%esi
test   $0x1,%r8b
jne    13ab <MergeSort+0x26b>
jmp    13c6 <MergeSort+0x286>

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

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