void Merge(char *dst, int low, int mid, int high) {
  int i = 0, j = 0, k = low;
  int len_l = mid - low + 1;
  int len_r = high - mid;
  char src_l[len_l];
  char src_r[len_r];
  for (int i = 0; i < len_l; i++) {
    src_l[i] = dst[low + i];
  }
  for (int j = 0; j < len_r; j++) {
    src_r[j] = dst[mid + 1 + j];
  }
  while (i < len_l && j < len_r) {
    if (src_l[i] < src_r[j]) {
      dst[k] = src_l[i];
      i++;
    } else {
      dst[k] = src_r[j];
      j++;
    }
    k++;
  }
  while (i < len_l) {
    dst[k] = src_l[i];
    i++;
    k++;
  }
  while (j < len_r) {
    dst[k] = src_r[j];
    j++;
    k++;
  }
}


x86 assembly (clang, -O0):
<Merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    %ecx,%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%eax
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x50(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11c3 <Merge+0xc3>
mov    -0x58(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0xc(%rbp),%edx
add    -0x44(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,1),%dl
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    118e <Merge+0x8e>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1202 <Merge+0x102>
mov    -0x50(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    -0x48(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,1),%dl
movslq -0x48(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11ca <Merge+0xca>
jmp    1207 <Merge+0x107>
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x59(%rbp)
jge    1224 <Merge+0x124>
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
setl   %al
mov    %al,-0x59(%rbp)
mov    -0x59(%rbp),%al
test   $0x1,%al
jne    1234 <Merge+0x134>
jmp    12a5 <Merge+0x1a5>
mov    -0x50(%rbp),%rcx
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rdx
movsbl (%rax,%rdx,1),%eax
movslq -0x1c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jge    1278 <Merge+0x178>
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1297 <Merge+0x197>
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1207 <Merge+0x107>
jmp    12aa <Merge+0x1aa>
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    12e3 <Merge+0x1e3>
mov    -0x58(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12aa <Merge+0x1aa>
jmp    12e8 <Merge+0x1e8>
mov    -0x1c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    1321 <Merge+0x221>
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12e8 <Merge+0x1e8>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Merge>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %ecx,%r15d
mov    %edx,%r11d
mov    %rdi,%r14
mov    %edx,%ecx
sub    %esi,%ecx
lea    0x1(%rcx),%edx
mov    %r15d,%r8d
sub    %r11d,%r8d
lea    0xf(%rdx),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r10
sub    %rax,%r10
mov    %r10,%rsp
lea    0xf(%r8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %rcx,-0x40(%rbp)
test   %ecx,%ecx
mov    %r8,-0x38(%rbp)
mov    %esi,-0x2c(%rbp)
js     1189 <Merge+0x79>
movslq %esi,%rsi
add    %r14,%rsi
mov    %r10,%rdi
mov    %r11,%rbx
mov    %r10,%r13
call   1030 <memcpy@plt>
mov    %r13,%r10
mov    -0x2c(%rbp),%esi
mov    -0x38(%rbp),%r8
mov    %rbx,%r11
test   %r8d,%r8d
mov    %r15d,-0x4c(%rbp)
jle    11e7 <Merge+0xd7>
cmp    $0x8,%r8d
mov    %r10,-0x48(%rbp)
jae    11fd <Merge+0xed>
xor    %eax,%eax
mov    %rax,%rdx
not    %rdx
mov    -0x38(%rbp),%rsi
add    %rsi,%rdx
and    $0x3,%rsi
je     122d <Merge+0x11d>
lea    0x1(%r11),%edi
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%rax),%rcx
lea    (%rdi,%rax,1),%ebx
movslq %ebx,%rbx
movzbl (%r14,%rbx,1),%ebx
mov    %bl,(%r12,%rax,1)
mov    %rcx,%rax
add    $0xffffffffffffffff,%rsi
jne    11c0 <Merge+0xb0>
cmp    $0x3,%rdx
jae    1236 <Merge+0x126>
jmp    12ab <Merge+0x19b>
xor    %r13d,%r13d
mov    %esi,%r15d
xor    %eax,%eax
cmp    -0x40(%rbp),%eax
jle    132a <Merge+0x21a>
jmp    145b <Merge+0x34b>
lea    -0x1(%r8),%rdx
lea    0x1(%r11),%ecx
lea    (%r11,%rdx,1),%esi
add    $0x1,%esi
xor    %eax,%eax
cmp    %ecx,%esi
jl     119e <Merge+0x8e>
shr    $0x20,%rdx
jne    119e <Merge+0x8e>
mov    -0x38(%rbp),%r9
cmp    $0x20,%r9d
jae    1497 <Merge+0x387>
xor    %eax,%eax
jmp    1555 <Merge+0x445>
mov    %rax,%rcx
cmp    $0x3,%rdx
jb     12ab <Merge+0x19b>
lea    0x4(%r11),%r8d
lea    0x3(%r12),%rdx
lea    0x3(%r11),%r9d
lea    0x2(%r11),%r10d
lea    0x1(%r11),%edi
mov    -0x38(%rbp),%rax
nop
lea    (%rcx,%rdi,1),%esi
movslq %esi,%rsi
movzbl (%r14,%rsi,1),%ebx
mov    %bl,-0x3(%rdx,%rcx,1)
lea    (%r10,%rcx,1),%esi
movslq %esi,%rsi
movzbl (%r14,%rsi,1),%ebx
mov    %bl,-0x2(%rdx,%rcx,1)
lea    (%r9,%rcx,1),%esi
movslq %esi,%rsi
movzbl (%r14,%rsi,1),%ebx
mov    %bl,-0x1(%rdx,%rcx,1)
lea    (%r8,%rcx,1),%esi
movslq %esi,%rsi
movzbl (%r14,%rsi,1),%ebx
mov    %bl,(%rdx,%rcx,1)
add    $0xfffffffffffffffc,%rax
add    $0x4,%r8
add    $0x4,%rdx
add    $0x4,%r9
add    $0x4,%r10
add    $0x4,%rdi
cmp    %rax,%rcx
jne    1250 <Merge+0x140>
xor    %r13d,%r13d
cmpl   $0x0,-0x40(%rbp)
js     13aa <Merge+0x29a>
mov    -0x2c(%rbp),%esi
mov    %esi,%r15d
mov    $0x0,%eax
mov    -0x38(%rbp),%r8
test   %r8d,%r8d
mov    -0x48(%rbp),%r10
jle    1321 <Merge+0x211>
movslq %esi,%rcx
add    %r14,%rcx
xor    %eax,%eax
mov    %esi,%r15d
xor    %r13d,%r13d
xchg   %ax,%ax
mov    %r13d,%edx
mov    %eax,%r9d
mov    %eax,%eax
movzbl (%r10,%rax,1),%edi
mov    %r13d,%eax
movzbl (%r12,%rax,1),%ebx
xor    %eax,%eax
xor    %r13d,%r13d
cmp    %bl,%dil
setl   %al
setge  %r13b
cmovl  %edi,%ebx
add    %edx,%r13d
add    %r9d,%eax
mov    %bl,(%rcx)
add    $0x1,%r15d
cmp    -0x40(%rbp),%eax
jg     1321 <Merge+0x211>
add    $0x1,%rcx
cmp    %r8d,%r13d
jl     12e0 <Merge+0x1d0>
cmp    -0x40(%rbp),%eax
jg     145b <Merge+0x34b>
movslq %r15d,%r15
lea    (%r14,%r15,1),%rdi
movslq %eax,%rcx
mov    %rcx,-0x58(%rbp)
add    %rcx,%r10
add    %esi,%eax
mov    %r11,-0x40(%rbp)
mov    %r11d,%ebx
sub    %eax,%ebx
lea    0x1(%rbx),%rdx
mov    %r10,%rsi
mov    %rdx,-0x48(%rbp)
call   1030 <memcpy@plt>
cmp    $0x3,%ebx
jae    136f <Merge+0x25f>
mov    -0x40(%rbp),%r11
mov    -0x38(%rbp),%r8
mov    -0x2c(%rbp),%esi
mov    -0x58(%rbp),%rax
jmp    143f <Merge+0x32f>
mov    -0x48(%rbp),%rdi
mov    %rdi,%rax
and    $0xfffffffffffffffc,%rax
movq   %r15,%xmm0
lea    -0x4(%rax),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x1c,%rsi
jae    13c8 <Merge+0x2b8>
pxor   %xmm1,%xmm1
mov    -0x40(%rbp),%r11
mov    -0x38(%rbp),%r8
mov    -0x2c(%rbp),%esi
jmp    13fe <Merge+0x2ee>
mov    -0x2c(%rbp),%esi
mov    %esi,%r15d
xor    %eax,%eax
mov    -0x38(%rbp),%r8
mov    -0x48(%rbp),%r10
cmp    -0x40(%rbp),%eax
jle    132a <Merge+0x21a>
jmp    145b <Merge+0x34b>
and    $0xfffffffffffffff8,%rdx
pxor   %xmm1,%xmm1
movdqa 0xc28(%rip),%xmm2
mov    -0x40(%rbp),%r11
mov    -0x38(%rbp),%r8
mov    -0x2c(%rbp),%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
paddq  %xmm2,%xmm0
paddq  %xmm2,%xmm1
add    $0xfffffffffffffff8,%rdx
jne    13f0 <Merge+0x2e0>
test   %rcx,%rcx
je     141e <Merge+0x30e>
pcmpeqd %xmm2,%xmm2
nopw   0x0(%rax,%rax,1)
psubq  %xmm2,%xmm0
psubq  %xmm2,%xmm1
add    $0xffffffffffffffff,%rcx
jne    1410 <Merge+0x300>
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%r15
cmp    %rax,%rdi
je     145b <Merge+0x34b>
mov    -0x58(%rbp),%rcx
add    %rax,%rcx
mov    %rcx,%rax
add    %eax,%esi
mov    %r11d,%eax
not    %eax
add    %esi,%eax
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rcx
cmp    %ecx,%eax
jne    1450 <Merge+0x340>
sub    %rcx,%r15
cmp    %r8d,%r13d
jge    1488 <Merge+0x378>
movslq %r15d,%rax
add    %rax,%r14
movslq %r13d,%rax
add    %rax,%r12
not    %r13d
add    -0x4c(%rbp),%r13d
sub    %r11d,%r13d
add    $0x1,%r13
mov    %r14,%rdi
mov    %r12,%rsi
mov    %r13,%rdx
call   1030 <memcpy@plt>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r9d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rdx
mov    %rdx,%r8
shr    $0x5,%r8
add    $0x1,%r8
test   %rdx,%rdx
je     1595 <Merge+0x485>
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x21(%r11),%ebx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    -0x20(%rbx),%esi
movslq %esi,%rsi
movups (%r14,%rsi,1),%xmm0
movups 0x10(%r14,%rsi,1),%xmm1
movaps %xmm0,(%r12,%rdx,1)
movaps %xmm1,0x10(%r12,%rdx,1)
movslq %ebx,%rbx
movdqu (%r14,%rbx,1),%xmm0
movdqu 0x10(%r14,%rbx,1),%xmm1
movdqa %xmm0,0x20(%r12,%rdx,1)
movdqa %xmm1,0x30(%r12,%rdx,1)
add    $0x40,%rdx
add    $0x40,%ebx
add    $0xfffffffffffffffe,%rdi
jne    14d0 <Merge+0x3c0>
test   $0x1,%r8b
je     1542 <Merge+0x432>
mov    %edx,%esi
or     $0x1,%esi
add    %r11d,%esi
movslq %esi,%rsi
movdqu (%r14,%rsi,1),%xmm0
movdqu 0x10(%r14,%rsi,1),%xmm1
movdqa %xmm0,(%r12,%rdx,1)
movdqa %xmm1,0x10(%r12,%rdx,1)
cmp    %r9,%rax
je     12ab <Merge+0x19b>
testb  $0x18,-0x38(%rbp)
je     119e <Merge+0x8e>
mov    %rax,%rdx
mov    -0x38(%rbp),%rdi
mov    %edi,%eax
and    $0xfffffff8,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rdx,1),%esi
movslq %esi,%rsi
mov    (%r14,%rsi,1),%rsi
mov    %rsi,(%r12,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    1570 <Merge+0x460>
cmp    %rdi,%rax
jne    119e <Merge+0x8e>
jmp    12ab <Merge+0x19b>
xor    %edx,%edx
test   $0x1,%r8b
jne    151d <Merge+0x40d>
jmp    1542 <Merge+0x432>

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

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