void merge(int *Array, int arraySize, int middle) {
  int i, j, k;
  int newArray[arraySize];
  for (i = 0, j = middle, k = 0; k < arraySize; k++) {
    newArray[k] = (j == arraySize)        ? Array[i++]
                  : (i == middle)         ? Array[j++]
                  : (Array[j] < Array[i]) ? Array[j++]
                                          : Array[i++];
  }
  for (i = 0; i < arraySize; i++)
    Array[i] = newArray[i];
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0xc(%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,-0x38(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1224 <merge+0x124>
mov    -0x18(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    1182 <merge+0x82>
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),%eax
mov    %eax,-0x3c(%rbp)
jmp    1208 <merge+0x108>
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jne    11ab <merge+0xab>
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),%eax
mov    %eax,-0x40(%rbp)
jmp    1202 <merge+0x102>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11e4 <merge+0xe4>
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),%eax
mov    %eax,-0x44(%rbp)
jmp    11fc <merge+0xfc>
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),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    114d <merge+0x4d>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    125b <merge+0x15b>
mov    -0x38(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    122b <merge+0x12b>
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
mov    %rsp,%rbp
push   %rbx
push   %rax
mov    %edx,%r8d
mov    %esi,%edx
mov    %rsp,%r9
lea    0xf(,%rdx,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r9
mov    %r9,%rsp
test   %esi,%esi
jle    11ab <merge+0x9b>
xor    %eax,%eax
xor    %r10d,%r10d
mov    %r8d,%r11d
jmp    115a <merge+0x4a>
xchg   %ax,%ax
movslq %r10d,%rcx
add    $0x1,%r10d
mov    (%rdi,%rcx,4),%ecx
mov    %esi,%r11d
mov    %ecx,(%r9,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdx
je     119b <merge+0x8b>
cmp    %esi,%r11d
je     1140 <merge+0x30>
movslq %r11d,%rcx
cmp    %r8d,%r10d
jne    1180 <merge+0x70>
add    $0x1,%r11d
mov    (%rdi,%rcx,4),%ecx
mov    %r8d,%r10d
jmp    114d <merge+0x3d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdi,%rcx,4),%ecx
movslq %r10d,%rbx
mov    (%rdi,%rbx,4),%ebx
cmp    %ebx,%ecx
jge    1193 <merge+0x83>
add    $0x1,%r11d
jmp    114d <merge+0x3d>
add    $0x1,%r10d
mov    %ebx,%ecx
jmp    114d <merge+0x3d>
test   %esi,%esi
jle    11ab <merge+0x9b>
shl    $0x2,%rdx
mov    %r9,%rsi
call   1030 <memcpy@plt>
lea    -0x8(%rbp),%rsp
pop    %rbx
pop    %rbp
ret

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

LLVM IR (-O2):
define void @merge(i32* nocapture %0, i32 %1, i32 %2) {
%4 = bitcast i32* %0 to i8*
%5 = zext i32 %1 to i64
%6 = alloca i32, i64 %5
%7 = bitcast i32* %6 to i8*
%8 = icmp sgt i32 %1, 0
br i1 %8, label %12, label %48
9: ; preds = %41
br i1 %8, label %10, label %48
10: ; preds = %9
%11 = shl nuw nsw i64 %5, 2
br label %48
12: ; preds = %3, %41
%13 = phi i64 [ %46, %41 ], [ 0, %3 ]
%14 = phi i32 [ %43, %41 ], [ 0, %3 ]
%15 = phi i32 [ %42, %41 ], [ %2, %3 ]
%16 = icmp eq i32 %15, %1
br i1 %16, label %17, label %22
17: ; preds = %12
%18 = add nsw i32 %14, 1
%19 = sext i32 %14 to i64
%20 = getelementptr inbounds i32, i32* %0, i64 %19
%21 = load i32, i32* %20
br label %41
22: ; preds = %12
%23 = icmp eq i32 %14, %2
br i1 %23, label %24, label %29
24: ; preds = %22
%25 = add nsw i32 %15, 1
%26 = sext i32 %15 to i64
%27 = getelementptr inbounds i32, i32* %0, i64 %26
%28 = load i32, i32* %27
br label %41
29: ; preds = %22
%30 = sext i32 %15 to i64
%31 = getelementptr inbounds i32, i32* %0, i64 %30
%32 = load i32, i32* %31
%33 = sext i32 %14 to i64
%34 = getelementptr inbounds i32, i32* %0, i64 %33
%35 = load i32, i32* %34
%36 = icmp slt i32 %32, %35
br i1 %36, label %37, label %39
37: ; preds = %29
%38 = add nsw i32 %15, 1
br label %41
39: ; preds = %29
%40 = add nsw i32 %14, 1
br label %41
41: ; preds = %24, %39, %37, %17
%42 = phi i32 [ %1, %17 ], [ %25, %24 ], [ %38, %37 ], [ %15, %39 ]
%43 = phi i32 [ %18, %17 ], [ %2, %24 ], [ %14, %37 ], [ %40, %39 ]
%44 = phi i32 [ %21, %17 ], [ %28, %24 ], [ %32, %37 ], [ %35, %39 ]
%45 = getelementptr inbounds i32, i32* %6, i64 %13
store i32 %44, i32* %45
%46 = add nuw nsw i64 %13, 1
%47 = icmp eq i64 %46, %5
br i1 %47, label %9, label %12
48: ; preds = %3, %10, %9
ret void
}