#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*/ EXIT_FAILURE;
int /*<<< orphan*/ exit(int /*<<< orphan*/);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(size_t *);
size_t *malloc(int);
int /*<<< orphan*/ stderr;
void mergeArrays(size_t *arrayA, size_t *arrayB, size_t sizeA, size_t sizeB) {
  size_t a = 0, b = 0, i;
  const size_t mergedSize = sizeA + sizeB;
  size_t *mergedArray = malloc(sizeof(size_t) * mergedSize);
  if (!mergedArray) {
    fprintf(stderr, "Can not allocate memory for merged array\n");
    exit(EXIT_FAILURE);
  }
  for (i = 0; i < mergedSize; i++) {
    if (b >= sizeB) {
      mergedArray[i] = arrayA[a];
      a++;
    } else if (a >= sizeA) {
      mergedArray[i] = arrayB[b];
      b++;
    } else if (arrayA[a] < arrayB[b]) {
      mergedArray[i] = arrayA[a];
      a++;
    } else {
      mergedArray[i] = arrayB[b];
      b++;
    }
  }
  for (i = 0; i < mergedSize; i++)
    arrayA[i] = mergedArray[i];
  free(mergedArray);
}


x86 assembly (clang, -O0):
<mergeArrays>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x18(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
jne    11b5 <mergeArrays+0x75>
mov    0x2e47(%rip),%rax
mov    (%rax),%edi
lea    0xe5e(%rip),%rsi
call   1040 <fprintf@plt>
mov    0x2e2a(%rip),%rax
mov    (%rax),%edi
call   1060 <exit@plt>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    12c4 <mergeArrays+0x184>
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
jb     1202 <mergeArrays+0xc2>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    12ae <mergeArrays+0x16e>
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     1239 <mergeArrays+0xf9>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    12a9 <mergeArrays+0x169>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jae    1280 <mergeArrays+0x140>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    12a4 <mergeArrays+0x164>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    12a9 <mergeArrays+0x169>
jmp    12ae <mergeArrays+0x16e>
jmp    12b3 <mergeArrays+0x173>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11bd <mergeArrays+0x7d>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x40(%rbp),%rax
jae    1303 <mergeArrays+0x1c3>
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    12cc <mergeArrays+0x18c>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mergeArrays>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rcx,%r12
mov    %rdx,%r13
mov    %rsi,%rbp
mov    %rdi,%r14
lea    (%rcx,%rdx,1),%rbx
lea    0x0(,%rbx,8),%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     120b <mergeArrays+0xbb>
mov    %rax,%r15
test   %rbx,%rbx
je     11f5 <mergeArrays+0xa5>
xor    %eax,%eax
xor    %ecx,%ecx
xor    %edx,%edx
jmp    11a6 <mergeArrays+0x56>
mov    0x0(%rbp,%rcx,8),%rsi
mov    %rsi,(%r15,%rdx,8)
add    $0x1,%rcx
add    $0x1,%rdx
cmp    %rdx,%rbx
je     11de <mergeArrays+0x8e>
cmp    %r12,%rcx
jae    11d0 <mergeArrays+0x80>
cmp    %r13,%rax
jae    1190 <mergeArrays+0x40>
mov    (%r14,%rax,8),%rsi
mov    0x0(%rbp,%rcx,8),%rdi
cmp    %rdi,%rsi
jb     11d4 <mergeArrays+0x84>
mov    %rdi,(%r15,%rdx,8)
jmp    1199 <mergeArrays+0x49>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r14,%rax,8),%rsi
mov    %rsi,(%r15,%rdx,8)
add    $0x1,%rax
jmp    119d <mergeArrays+0x4d>
test   %rbx,%rbx
je     11f5 <mergeArrays+0xa5>
shl    $0x3,%rbx
mov    %r14,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
call   1050 <memcpy@plt>
mov    %r15,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
mov    0x2dce(%rip),%rax
mov    (%rax),%edi
lea    0xde5(%rip),%rsi
call   1040 <fprintf@plt>
mov    0x2db1(%rip),%rax
mov    (%rax),%edi
call   1070 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [42 x i8] c"Can not allocate memory for merged array\0A\00"
@EXIT_FAILURE = global i32 0
define void @mergeArrays(i64* %0, i64* %1, i64 %2, i64 %3) {
%5 = alloca i64*
%6 = alloca i64*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64*
store i64* %0, i64** %5
store i64* %1, i64** %6
store i64 %2, i64* %7
store i64 %3, i64* %8
store i64 0, i64* %9
store i64 0, i64* %10
%14 = load i64, i64* %7
%15 = load i64, i64* %8
%16 = add i64 %14, %15
store i64 %16, i64* %12
%17 = load i64, i64* %12
%18 = mul i64 8, %17
%19 = trunc i64 %18 to i32
%20 = call i64* @malloc(i32 %19)
store i64* %20, i64** %13
%21 = load i64*, i64** %13
%22 = icmp ne i64* %21, null
br i1 %22, label %28, label %23
23: ; preds = %4
%24 = load i32, i32* @stderr
%25 = call i32 @fprintf(i32 %24, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0))
%26 = load i32, i32* @EXIT_FAILURE
%27 = call i32 @exit(i32 %26)
unreachable
28: ; preds = %4
store i64 0, i64* %11
br label %29
29: ; preds = %94, %28
%30 = load i64, i64* %11
%31 = load i64, i64* %12
%32 = icmp ult i64 %30, %31
br i1 %32, label %33, label %97
33: ; preds = %29
%34 = load i64, i64* %10
%35 = load i64, i64* %8
%36 = icmp uge i64 %34, %35
br i1 %36, label %37, label %47
37: ; preds = %33
%38 = load i64*, i64** %5
%39 = load i64, i64* %9
%40 = getelementptr inbounds i64, i64* %38, i64 %39
%41 = load i64, i64* %40
%42 = load i64*, i64** %13
%43 = load i64, i64* %11
%44 = getelementptr inbounds i64, i64* %42, i64 %43
store i64 %41, i64* %44
%45 = load i64, i64* %9
%46 = add i64 %45, 1
store i64 %46, i64* %9
br label %93
47: ; preds = %33
%48 = load i64, i64* %9
%49 = load i64, i64* %7
%50 = icmp uge i64 %48, %49
br i1 %50, label %51, label %61
51: ; preds = %47
%52 = load i64*, i64** %6
%53 = load i64, i64* %10
%54 = getelementptr inbounds i64, i64* %52, i64 %53
%55 = load i64, i64* %54
%56 = load i64*, i64** %13
%57 = load i64, i64* %11
%58 = getelementptr inbounds i64, i64* %56, i64 %57
store i64 %55, i64* %58
%59 = load i64, i64* %10
%60 = add i64 %59, 1
store i64 %60, i64* %10
br label %92
61: ; preds = %47
%62 = load i64*, i64** %5
%63 = load i64, i64* %9
%64 = getelementptr inbounds i64, i64* %62, i64 %63
%65 = load i64, i64* %64
%66 = load i64*, i64** %6
%67 = load i64, i64* %10
%68 = getelementptr inbounds i64, i64* %66, i64 %67
%69 = load i64, i64* %68
%70 = icmp ult i64 %65, %69
br i1 %70, label %71, label %81
71: ; preds = %61
%72 = load i64*, i64** %5
%73 = load i64, i64* %9
%74 = getelementptr inbounds i64, i64* %72, i64 %73
%75 = load i64, i64* %74
%76 = load i64*, i64** %13
%77 = load i64, i64* %11
%78 = getelementptr inbounds i64, i64* %76, i64 %77
store i64 %75, i64* %78
%79 = load i64, i64* %9
%80 = add i64 %79, 1
store i64 %80, i64* %9
br label %91
81: ; preds = %61
%82 = load i64*, i64** %6
%83 = load i64, i64* %10
%84 = getelementptr inbounds i64, i64* %82, i64 %83
%85 = load i64, i64* %84
%86 = load i64*, i64** %13
%87 = load i64, i64* %11
%88 = getelementptr inbounds i64, i64* %86, i64 %87
store i64 %85, i64* %88
%89 = load i64, i64* %10
%90 = add i64 %89, 1
store i64 %90, i64* %10
br label %91
91: ; preds = %81, %71
br label %92
92: ; preds = %91, %51
br label %93
93: ; preds = %92, %37
br label %94
94: ; preds = %93
%95 = load i64, i64* %11
%96 = add i64 %95, 1
store i64 %96, i64* %11
br label %29
97: ; preds = %29
store i64 0, i64* %11
br label %98
98: ; preds = %110, %97
%99 = load i64, i64* %11
%100 = load i64, i64* %12
%101 = icmp ult i64 %99, %100
br i1 %101, label %102, label %113
102: ; preds = %98
%103 = load i64*, i64** %13
%104 = load i64, i64* %11
%105 = getelementptr inbounds i64, i64* %103, i64 %104
%106 = load i64, i64* %105
%107 = load i64*, i64** %5
%108 = load i64, i64* %11
%109 = getelementptr inbounds i64, i64* %107, i64 %108
store i64 %106, i64* %109
br label %110
110: ; preds = %102
%111 = load i64, i64* %11
%112 = add i64 %111, 1
store i64 %112, i64* %11
br label %98
113: ; preds = %98
%114 = load i64*, i64** %13
%115 = call i32 @free(i64* %114)
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [42 x i8] c"Can not allocate memory for merged array\0A\00"
@EXIT_FAILURE = global i32 0
define void @mergeArrays(i64* nocapture %0, i64* nocapture %1, i64 %2, i64 %3) {
%5 = bitcast i64* %0 to i8*
%6 = add i64 %3, %2
%7 = trunc i64 %6 to i32
%8 = shl i32 %7, 3
%9 = tail call i64* @malloc(i32 %8)
%10 = bitcast i64* %9 to i8*
%11 = icmp eq i64* %9, null
br i1 %11, label %14, label %12
12: ; preds = %4
%13 = icmp eq i64 %6, 0
br i1 %13, label %55, label %22
14: ; preds = %4
%15 = load i32, i32* @stderr
%16 = tail call i32 @fprintf(i32 %15, i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0))
%17 = load i32, i32* @EXIT_FAILURE
%18 = tail call i32 @exit(i32 %17)
unreachable
19: ; preds = %50
br i1 %13, label %55, label %20
20: ; preds = %19
%21 = shl nuw i64 %6, 3
br label %55
22: ; preds = %12, %50
%23 = phi i64 [ %52, %50 ], [ 0, %12 ]
%24 = phi i64 [ %51, %50 ], [ 0, %12 ]
%25 = phi i64 [ %53, %50 ], [ 0, %12 ]
%26 = icmp ult i64 %24, %3
br i1 %26, label %32, label %27
27: ; preds = %22
%28 = getelementptr inbounds i64, i64* %0, i64 %23
%29 = load i64, i64* %28
%30 = getelementptr inbounds i64, i64* %9, i64 %25
store i64 %29, i64* %30
%31 = add i64 %23, 1
br label %50
32: ; preds = %22
%33 = icmp ult i64 %23, %2
br i1 %33, label %39, label %34
34: ; preds = %32
%35 = getelementptr inbounds i64, i64* %1, i64 %24
%36 = load i64, i64* %35
%37 = getelementptr inbounds i64, i64* %9, i64 %25
store i64 %36, i64* %37
%38 = add nuw i64 %24, 1
br label %50
39: ; preds = %32
%40 = getelementptr inbounds i64, i64* %0, i64 %23
%41 = load i64, i64* %40
%42 = getelementptr inbounds i64, i64* %1, i64 %24
%43 = load i64, i64* %42
%44 = icmp ult i64 %41, %43
%45 = getelementptr inbounds i64, i64* %9, i64 %25
br i1 %44, label %46, label %48
46: ; preds = %39
store i64 %41, i64* %45
%47 = add nuw i64 %23, 1
br label %50
48: ; preds = %39
store i64 %43, i64* %45
%49 = add nuw i64 %24, 1
br label %50
50: ; preds = %27, %46, %48, %34
%51 = phi i64 [ %24, %27 ], [ %38, %34 ], [ %24, %46 ], [ %49, %48 ]
%52 = phi i64 [ %31, %27 ], [ %23, %34 ], [ %47, %46 ], [ %23, %48 ]
%53 = add nuw i64 %25, 1
%54 = icmp eq i64 %53, %6
br i1 %54, label %19, label %22
55: ; preds = %12, %20, %19
%56 = tail call i32 @free(i64* %9)
ret void
}