#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*/ free(double *);
scalar_t__ malloc(int);
int Merge(double *A, int p, int q, int r) {
  int n1 = q - p + 1;
  int n2 = r - q;
  double *L = (double *)malloc(n1 * sizeof(double));
  if (L == NULL) {
    return 1;
  }
  double *R = (double *)malloc(n2 * sizeof(double));
  if (R == NULL) {
    return 1;
  }
  int i = 0;
  int j = 0;
  int k = 0;
  for (i = 0; i < n1; i++) {
    L[i] = A[p + i];
  }
  for (j = 0; j < n2; j++) {
    R[j] = A[q + j + 1];
  }
  i = 0;
  j = 0;
  for (k = p; k < r + 1; k++) {
    if (i < n1 && j < n2) {
      if (L[i] <= R[j]) {
        A[k] = L[i];
        i = i + 1;
      } else {
        A[k] = R[j];
        j = j + 1;
      }
    } else {
      if (i < n1) {
        A[k] = L[i];
        i = i + 1;
      }
      if (j < n2) {
        A[k] = R[j];
        j = j + 1;
      }
    }
  }
  free(L);
  free(R);
  return 0;
}


x86 assembly (clang, -O0):
<Merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    1174 <Merge+0x54>
movl   $0x1,-0x4(%rbp)
jmp    1376 <Merge+0x256>
movslq -0x24(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    119e <Merge+0x7e>
movl   $0x1,-0x4(%rbp)
jmp    1376 <Merge+0x256>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11f3 <Merge+0xd3>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11ba <Merge+0x9a>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1236 <Merge+0x116>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
add    -0x40(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11fa <Merge+0xda>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    135d <Merge+0x23d>
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12e7 <Merge+0x1c7>
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12e7 <Merge+0x1c7>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jb     12bf <Merge+0x19f>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12e2 <Merge+0x1c2>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    134a <Merge+0x22a>
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1316 <Merge+0x1f6>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1345 <Merge+0x225>
mov    -0x38(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    134a <Merge+0x22a>
jmp    134f <Merge+0x22f>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    124a <Merge+0x12a>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %ecx,%r14d
mov    %edx,%ebp
mov    %rdi,%r13
mov    %edx,%eax
mov    %esi,0x14(%rsp)
sub    %esi,%eax
mov    %rax,0x20(%rsp)
lea    0x8(,%rax,8),%edi
call   1040 <malloc@plt>
mov    $0x1,%r12d
test   %rax,%rax
je     152b <Merge+0x40b>
mov    %rax,%rbx
mov    %r14,0x18(%rsp)
mov    %rbp,0x8(%rsp)
sub    %ebp,%r14d
lea    0x0(,%r14,8),%edi
call   1040 <malloc@plt>
test   %rax,%rax
je     152b <Merge+0x40b>
mov    %rax,%r15
mov    0x14(%rsp),%r12d
movslq %r12d,%r8
mov    0x20(%rsp),%r11
test   %r11d,%r11d
js     1358 <Merge+0x238>
lea    0x1(%r11),%ecx
cmp    $0x4,%ecx
jb     11d6 <Merge+0xb6>
lea    (%r8,%rcx,1),%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
cmp    %rax,%rbx
jae    126c <Merge+0x14c>
lea    (%rbx,%rcx,8),%rax
lea    0x0(,%r8,8),%rdx
add    %r13,%rdx
cmp    %rax,%rdx
jae    126c <Merge+0x14c>
xor    %edx,%edx
mov    %rdx,%rax
not    %rax
add    %rcx,%rax
mov    %rcx,%rsi
and    $0x3,%rsi
je     1214 <Merge+0xf4>
lea    0x0(,%r8,8),%rdi
add    %r13,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1200 <Merge+0xe0>
cmp    $0x3,%rax
jb     1358 <Merge+0x238>
lea    0x18(,%r8,8),%rax
add    %r13,%rax
nopl   0x0(%rax)
movsd  -0x18(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rbx,%rdx,8)
movsd  -0x10(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x8(%rbx,%rdx,8)
movsd  -0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x10(%rbx,%rdx,8)
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,0x18(%rbx,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1230 <Merge+0x110>
jmp    1358 <Merge+0x238>
mov    %ecx,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rax
mov    %rax,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0xc,%rax
jae    1291 <Merge+0x171>
xor    %eax,%eax
jmp    130c <Merge+0x1ec>
and    $0xfffffffffffffffc,%rdi
lea    0x70(,%r8,8),%rsi
add    %r13,%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x70(%rsi,%rax,8),%xmm0
movups -0x60(%rsi,%rax,8),%xmm1
movups %xmm0,(%rbx,%rax,8)
movups %xmm1,0x10(%rbx,%rax,8)
movups -0x50(%rsi,%rax,8),%xmm0
movups -0x40(%rsi,%rax,8),%xmm1
movups %xmm0,0x20(%rbx,%rax,8)
movups %xmm1,0x30(%rbx,%rax,8)
movups -0x30(%rsi,%rax,8),%xmm0
movups -0x20(%rsi,%rax,8),%xmm1
movups %xmm0,0x40(%rbx,%rax,8)
movups %xmm1,0x50(%rbx,%rax,8)
movupd -0x10(%rsi,%rax,8),%xmm0
movupd (%rsi,%rax,8),%xmm1
movupd %xmm0,0x60(%rbx,%rax,8)
movupd %xmm1,0x70(%rbx,%rax,8)
add    $0x10,%rax
add    $0xfffffffffffffffc,%rdi
jne    12b0 <Merge+0x190>
test   %r9,%r9
je     134f <Merge+0x22f>
lea    (%rbx,%rax,8),%rsi
add    $0x10,%rsi
add    %r8,%rax
lea    0x10(,%rax,8),%rax
add    %r13,%rax
shl    $0x5,%r9
xor    %edi,%edi
nopl   (%rax)
movupd -0x10(%rax,%rdi,1),%xmm0
movupd (%rax,%rdi,1),%xmm1
movupd %xmm0,-0x10(%rsi,%rdi,1)
movupd %xmm1,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1330 <Merge+0x210>
cmp    %rcx,%rdx
jne    11d8 <Merge+0xb8>
test   %r14d,%r14d
jle    150e <Merge+0x3ee>
mov    %r14d,%r10d
cmp    $0x4,%r14d
jae    13be <Merge+0x29e>
xor    %edx,%edx
mov    %rdx,%r9
not    %r9
add    %r10,%r9
mov    %r10,%rdi
and    $0x3,%rdi
je     149e <Merge+0x37e>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%ecx
nopw   0x0(%rax,%rax,1)
lea    0x1(%rdx),%rsi
lea    (%rcx,%rdx,1),%eax
cltq
movsd  0x0(%r13,%rax,8),%xmm0
movsd  %xmm0,(%r15,%rdx,8)
mov    %rsi,%rdx
add    $0xffffffffffffffff,%rdi
jne    1390 <Merge+0x270>
cmp    $0x3,%r9
jae    14a7 <Merge+0x387>
jmp    150e <Merge+0x3ee>
lea    -0x1(%r10),%rcx
mov    0x8(%rsp),%rdx
lea    0x1(%rdx),%eax
lea    (%rdx,%rcx,1),%esi
add    $0x1,%esi
xor    %edx,%edx
cmp    %eax,%esi
jl     136c <Merge+0x24c>
shr    $0x20,%rcx
jne    136c <Merge+0x24c>
cltq
lea    (%rax,%r10,1),%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
cmp    %rcx,%r15
jae    140a <Merge+0x2ea>
lea    (%r15,%r10,8),%rcx
lea    0x0(,%rax,8),%rax
add    %r13,%rax
cmp    %rcx,%rax
jb     136a <Merge+0x24a>
mov    %r10d,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rax
mov    %rax,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rax,%rax
je     15ca <Merge+0x4aa>
movabs $0x7ffffffffffffffc,%rax
ff ff 7f
or     $0x2,%rax
and    %r9,%rax
mov    0x8(%rsp),%rcx
lea    0x5(%rcx),%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x4(%rsi),%ecx
movslq %ecx,%rcx
movups 0x0(%r13,%rcx,8),%xmm0
movups 0x10(%r13,%rcx,8),%xmm1
movups %xmm0,(%r15,%rdi,8)
movups %xmm1,0x10(%r15,%rdi,8)
movslq %esi,%rsi
movupd 0x0(%r13,%rsi,8),%xmm0
movupd 0x10(%r13,%rsi,8),%xmm1
movupd %xmm0,0x20(%r15,%rdi,8)
movupd %xmm1,0x30(%r15,%rdi,8)
add    $0x8,%rdi
add    $0x8,%esi
add    $0xfffffffffffffffe,%rax
jne    1450 <Merge+0x330>
jmp    15cc <Merge+0x4ac>
mov    %rdx,%rsi
cmp    $0x3,%r9
jb     150e <Merge+0x3ee>
mov    0x8(%rsp),%eax
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rsi,1),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,(%r15,%rsi,8)
lea    0x2(%rax,%rsi,1),%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x8(%r15,%rsi,8)
lea    0x3(%rax,%rsi,1),%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x10(%r15,%rsi,8)
lea    0x4(%rax,%rsi,1),%ecx
movslq %ecx,%rcx
movsd  0x0(%r13,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r15,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r10
jne    14b0 <Merge+0x390>
mov    0x18(%rsp),%rbp
cmp    %ebp,%r12d
jle    153d <Merge+0x41d>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
xor    %r12d,%r12d
mov    %r12d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x0(,%r8,8),%rax
add    %r13,%rax
sub    %r12d,%ebp
add    $0x1,%ebp
xor    %ecx,%ecx
xor    %edx,%edx
xor    %esi,%esi
jmp    1570 <Merge+0x450>
cs nopw 0x0(%rax,%rax,1)
movsd  %xmm1,(%rax,%rcx,8)
add    $0x1,%edx
add    $0x1,%rcx
cmp    %ecx,%ebp
je     1518 <Merge+0x3f8>
cmp    %r11d,%esi
jg     15a0 <Merge+0x480>
cmp    %r14d,%edx
jge    15a0 <Merge+0x480>
movslq %esi,%rdi
movsd  (%rbx,%rdi,8),%xmm0
movslq %edx,%rdi
movsd  (%r15,%rdi,8),%xmm1
ucomisd %xmm0,%xmm1
jb     1560 <Merge+0x440>
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%esi
jmp    1568 <Merge+0x448>
nopl   0x0(%rax,%rax,1)
cmp    %r11d,%esi
jg     15b5 <Merge+0x495>
movslq %esi,%rdi
movsd  (%rbx,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%esi
cmp    %r14d,%edx
jge    1568 <Merge+0x448>
movslq %edx,%rdi
movsd  (%r15,%rdi,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1565 <Merge+0x445>
xor    %edi,%edi
test   $0x1,%r9b
je     15f8 <Merge+0x4d8>
mov    %edi,%eax
or     $0x1,%eax
add    0x8(%rsp),%eax
cltq
movupd 0x0(%r13,%rax,8),%xmm0
movupd 0x10(%r13,%rax,8),%xmm1
movupd %xmm0,(%r15,%rdi,8)
movupd %xmm1,0x10(%r15,%rdi,8)
cmp    %r10,%rdx
jne    136c <Merge+0x24c>
jmp    150e <Merge+0x3ee>

LLVM IR (-O0):
define i32 @Merge(double* %0, i32 %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca double*
%13 = alloca double*
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store double* %0, double** %6
store i32 %1, i32* %7
store i32 %2, i32* %8
store i32 %3, i32* %9
%17 = load i32, i32* %8
%18 = load i32, i32* %7
%19 = sub nsw i32 %17, %18
%20 = add nsw i32 %19, 1
store i32 %20, i32* %10
%21 = load i32, i32* %9
%22 = load i32, i32* %8
%23 = sub nsw i32 %21, %22
store i32 %23, i32* %11
%24 = load i32, i32* %10
%25 = sext i32 %24 to i64
%26 = mul i64 %25, 8
%27 = trunc i64 %26 to i32
%28 = call i64 @malloc(i32 %27)
%29 = inttoptr i64 %28 to double*
store double* %29, double** %12
%30 = load double*, double** %12
%31 = icmp eq double* %30, null
br i1 %31, label %32, label %33
32: ; preds = %4
store i32 1, i32* %5
br label %178
33: ; preds = %4
%34 = load i32, i32* %11
%35 = sext i32 %34 to i64
%36 = mul i64 %35, 8
%37 = trunc i64 %36 to i32
%38 = call i64 @malloc(i32 %37)
%39 = inttoptr i64 %38 to double*
store double* %39, double** %13
%40 = load double*, double** %13
%41 = icmp eq double* %40, null
br i1 %41, label %42, label %43
42: ; preds = %33
store i32 1, i32* %5
br label %178
43: ; preds = %33
store i32 0, i32* %14
store i32 0, i32* %15
store i32 0, i32* %16
store i32 0, i32* %14
br label %44
44: ; preds = %60, %43
%45 = load i32, i32* %14
%46 = load i32, i32* %10
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %63
48: ; preds = %44
%49 = load double*, double** %6
%50 = load i32, i32* %7
%51 = load i32, i32* %14
%52 = add nsw i32 %50, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds double, double* %49, i64 %53
%55 = load double, double* %54
%56 = load double*, double** %12
%57 = load i32, i32* %14
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds double, double* %56, i64 %58
store double %55, double* %59
br label %60
60: ; preds = %48
%61 = load i32, i32* %14
%62 = add nsw i32 %61, 1
store i32 %62, i32* %14
br label %44
63: ; preds = %44
store i32 0, i32* %15
br label %64
64: ; preds = %81, %63
%65 = load i32, i32* %15
%66 = load i32, i32* %11
%67 = icmp slt i32 %65, %66
br i1 %67, label %68, label %84
68: ; preds = %64
%69 = load double*, double** %6
%70 = load i32, i32* %8
%71 = load i32, i32* %15
%72 = add nsw i32 %70, %71
%73 = add nsw i32 %72, 1
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds double, double* %69, i64 %74
%76 = load double, double* %75
%77 = load double*, double** %13
%78 = load i32, i32* %15
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds double, double* %77, i64 %79
store double %76, double* %80
br label %81
81: ; preds = %68
%82 = load i32, i32* %15
%83 = add nsw i32 %82, 1
store i32 %83, i32* %15
br label %64
84: ; preds = %64
store i32 0, i32* %14
store i32 0, i32* %15
%85 = load i32, i32* %7
store i32 %85, i32* %16
br label %86
86: ; preds = %170, %84
%87 = load i32, i32* %16
%88 = load i32, i32* %9
%89 = add nsw i32 %88, 1
%90 = icmp slt i32 %87, %89
br i1 %90, label %91, label %173
91: ; preds = %86
%92 = load i32, i32* %14
%93 = load i32, i32* %10
%94 = icmp slt i32 %92, %93
br i1 %94, label %95, label %136
95: ; preds = %91
%96 = load i32, i32* %15
%97 = load i32, i32* %11
%98 = icmp slt i32 %96, %97
br i1 %98, label %99, label %136
99: ; preds = %95
%100 = load double*, double** %12
%101 = load i32, i32* %14
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds double, double* %100, i64 %102
%104 = load double, double* %103
%105 = load double*, double** %13
%106 = load i32, i32* %15
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds double, double* %105, i64 %107
%109 = load double, double* %108
%110 = fcmp ole double %104, %109
br i1 %110, label %111, label %123
111: ; preds = %99
%112 = load double*, double** %12
%113 = load i32, i32* %14
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %112, i64 %114
%116 = load double, double* %115
%117 = load double*, double** %6
%118 = load i32, i32* %16
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %117, i64 %119
store double %116, double* %120
%121 = load i32, i32* %14
%122 = add nsw i32 %121, 1
store i32 %122, i32* %14
br label %135
123: ; preds = %99
%124 = load double*, double** %13
%125 = load i32, i32* %15
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds double, double* %124, i64 %126
%128 = load double, double* %127
%129 = load double*, double** %6
%130 = load i32, i32* %16
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds double, double* %129, i64 %131
store double %128, double* %132
%133 = load i32, i32* %15
%134 = add nsw i32 %133, 1
store i32 %134, i32* %15
br label %135
135: ; preds = %123, %111
br label %169
136: ; preds = %95, %91
%137 = load i32, i32* %14
%138 = load i32, i32* %10
%139 = icmp slt i32 %137, %138
br i1 %139, label %140, label %152
140: ; preds = %136
%141 = load double*, double** %12
%142 = load i32, i32* %14
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds double, double* %141, i64 %143
%145 = load double, double* %144
%146 = load double*, double** %6
%147 = load i32, i32* %16
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds double, double* %146, i64 %148
store double %145, double* %149
%150 = load i32, i32* %14
%151 = add nsw i32 %150, 1
store i32 %151, i32* %14
br label %152
152: ; preds = %140, %136
%153 = load i32, i32* %15
%154 = load i32, i32* %11
%155 = icmp slt i32 %153, %154
br i1 %155, label %156, label %168
156: ; preds = %152
%157 = load double*, double** %13
%158 = load i32, i32* %15
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds double, double* %157, i64 %159
%161 = load double, double* %160
%162 = load double*, double** %6
%163 = load i32, i32* %16
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds double, double* %162, i64 %164
store double %161, double* %165
%166 = load i32, i32* %15
%167 = add nsw i32 %166, 1
store i32 %167, i32* %15
br label %168
168: ; preds = %156, %152
br label %169
169: ; preds = %168, %135
br label %170
170: ; preds = %169
%171 = load i32, i32* %16
%172 = add nsw i32 %171, 1
store i32 %172, i32* %16
br label %86
173: ; preds = %86
%174 = load double*, double** %12
%175 = call i32 @free(double* %174)
%176 = load double*, double** %13
%177 = call i32 @free(double* %176)
store i32 0, i32* %5
br label %178
178: ; preds = %173, %42, %32
%179 = load i32, i32* %5
ret i32 %179
}

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