void merge_sort_recursive(int arr[], int reg[], int start, int end) {
  if (start >= end)
    return;
  int len = end - start;
  int mid = (len >> 1) + start;
  int start1 = start, end1 = mid;
  int start2 = mid + 1, end2 = end;
  merge_sort_recursive(arr, reg, start1, end1);
  merge_sort_recursive(arr, reg, start2, end2);
  int k = start;
  while (start1 <= end1 && start2 <= end2)
    reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
  while (start1 <= end1)
    reg[k++] = arr[start1++];
  while (start2 <= end2)
    reg[k++] = arr[start2++];
  for (k = start; k <= end; k++)
    arr[k] = reg[k];
}


x86 assembly (clang, -O0):
<merge_sort_recursive>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jl     1137 <merge_sort_recursive+0x27>
jmp    12e4 <merge_sort_recursive+0x1d4>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
sar    $0x1,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%edx
mov    -0x28(%rbp),%ecx
call   1030 <merge_sort_recursive@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x2c(%rbp),%edx
mov    -0x30(%rbp),%ecx
call   1030 <merge_sort_recursive@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x24(%rbp),%ecx
xor    %eax,%eax
cmp    -0x28(%rbp),%ecx
mov    %al,-0x35(%rbp)
jg     11b0 <merge_sort_recursive+0xa0>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
setle  %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    11c0 <merge_sort_recursive+0xb0>
jmp    122e <merge_sort_recursive+0x11e>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11f9 <merge_sort_recursive+0xe9>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
jmp    1211 <merge_sort_recursive+0x101>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1193 <merge_sort_recursive+0x83>
jmp    1233 <merge_sort_recursive+0x123>
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     126e <merge_sort_recursive+0x15e>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1233 <merge_sort_recursive+0x123>
jmp    1273 <merge_sort_recursive+0x163>
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jg     12ae <merge_sort_recursive+0x19e>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x2c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x34(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1273 <merge_sort_recursive+0x163>
mov    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     12e4 <merge_sort_recursive+0x1d4>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b4 <merge_sort_recursive+0x1a4>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge_sort_recursive>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%ebp
sub    %edx,%ebp
jle    168f <merge_sort_recursive+0x57f>
mov    %ecx,%r15d
mov    %rsi,%r14
mov    %rdi,%r13
mov    %ebp,%r12d
sar    %r12d
lea    (%r12,%rdx,1),%ebx
add    $0x1,%ebx
add    %edx,%r12d
mov    %rdx,(%rsp)
mov    %r12d,%ecx
call   1030 <merge_sort_recursive@plt>
mov    %r13,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
mov    %r15d,%ecx
call   1030 <merge_sort_recursive@plt>
mov    %ebp,%r8d
test   %ebp,%ebp
js     11c5 <merge_sort_recursive+0xb5>
cmp    %r15d,%r12d
jge    11c5 <merge_sort_recursive+0xb5>
mov    (%rsp),%r9
movslq %r9d,%rax
lea    (%r14,%rax,4),%rcx
mov    %r9d,%r11d
mov    %r9d,%esi
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
mov    0x0(%r13,%rsi,4),%edx
movslq %ebx,%rbx
mov    0x0(%r13,%rbx,4),%edi
xor    %ebp,%ebp
xor    %eax,%eax
cmp    %edi,%edx
setl   %bpl
setge  %al
cmovl  %edx,%edi
add    %eax,%ebx
add    %ebp,%esi
mov    %edi,(%rcx)
add    $0x1,%r11d
cmp    %r12d,%esi
jg     11b8 <merge_sort_recursive+0xa8>
add    $0x4,%rcx
cmp    %r15d,%ebx
jle    1180 <merge_sort_recursive+0x70>
cmp    %r12d,%esi
jle    11d4 <merge_sort_recursive+0xc4>
mov    %r8d,%ebp
jmp    1358 <merge_sort_recursive+0x248>
mov    (%rsp),%r9
mov    %r9d,%esi
mov    %r9d,%r11d
cmp    %r12d,%esi
jg     11bd <merge_sort_recursive+0xad>
movslq %r11d,%r11
movslq %esi,%rcx
mov    %r12d,%r10d
sub    %esi,%r10d
cmp    $0x7,%r10d
jb     1222 <merge_sort_recursive+0x112>
lea    (%r14,%r11,4),%rdx
lea    (%rcx,%r10,1),%rsi
lea    0x4(,%rsi,4),%rsi
add    %r13,%rsi
cmp    %rsi,%rdx
jae    12af <merge_sort_recursive+0x19f>
lea    (%r11,%r10,1),%rdx
lea    (%r14,%rdx,4),%rdx
add    $0x4,%rdx
lea    0x0(,%rcx,4),%rsi
add    %r13,%rsi
cmp    %rdx,%rsi
jae    12af <merge_sort_recursive+0x19f>
mov    %r8d,%ebp
mov    %r12d,%edx
sub    %ecx,%edx
lea    0x1(%rdx),%esi
and    $0x3,%esi
je     1256 <merge_sort_recursive+0x146>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rcx,4),%edi
add    $0x1,%rcx
mov    %edi,(%r14,%r11,4)
add    $0x1,%r11
add    $0xffffffff,%esi
jne    1240 <merge_sort_recursive+0x130>
cmp    $0x3,%edx
jb     1358 <merge_sort_recursive+0x248>
sub    %ecx,%r12d
add    $0x1,%r12d
lea    0xc(,%rcx,4),%rdx
add    %r13,%rdx
lea    (%r14,%r11,4),%rsi
add    $0xc,%rsi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
mov    -0xc(%rdx,%rcx,4),%eax
mov    %eax,-0xc(%rsi,%rcx,4)
mov    -0x8(%rdx,%rcx,4),%eax
mov    %eax,-0x8(%rsi,%rcx,4)
mov    -0x4(%rdx,%rcx,4),%eax
mov    %eax,-0x4(%rsi,%rcx,4)
mov    (%rdx,%rcx,4),%eax
mov    %eax,(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %ecx,%r12d
jne    1280 <merge_sort_recursive+0x170>
add    %rcx,%r11
jmp    1358 <merge_sort_recursive+0x248>
add    $0x1,%r10
mov    %r10,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     169e <merge_sort_recursive+0x58e>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x30(,%rcx,4),%rdx
add    %r13,%rdx
lea    (%r14,%r11,4),%rbp
add    $0x30,%rbp
xor    %esi,%esi
xchg   %ax,%ax
movups -0x30(%rdx,%rsi,4),%xmm0
movups -0x20(%rdx,%rsi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rsi,4)
movups %xmm1,-0x20(%rbp,%rsi,4)
movups -0x10(%rdx,%rsi,4),%xmm0
movups (%rdx,%rsi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rsi,4)
movups %xmm1,0x0(%rbp,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    12f0 <merge_sort_recursive+0x1e0>
test   $0x1,%r9b
je     1345 <merge_sort_recursive+0x235>
lea    (%rsi,%rcx,1),%rdx
add    %r11,%rsi
movups 0x0(%r13,%rdx,4),%xmm0
movups 0x10(%r13,%rdx,4),%xmm1
movups %xmm0,(%r14,%rsi,4)
movups %xmm1,0x10(%r14,%rsi,4)
add    %rax,%r11
cmp    %rax,%r10
mov    %r8d,%ebp
mov    (%rsp),%r9
jne    154d <merge_sort_recursive+0x43d>
cmp    %r15d,%ebx
jg     14d6 <merge_sort_recursive+0x3c6>
movslq %r11d,%rax
movslq %ebx,%rcx
mov    %r15d,%edx
sub    %ebx,%edx
cmp    $0x7,%edx
jb     145a <merge_sort_recursive+0x34a>
lea    (%r14,%rax,4),%rsi
lea    (%rcx,%rdx,1),%rdi
lea    0x4(,%rdi,4),%rdi
add    %r13,%rdi
cmp    %rdi,%rsi
jae    13ad <merge_sort_recursive+0x29d>
lea    (%rax,%rdx,1),%rsi
lea    (%r14,%rsi,4),%rsi
add    $0x4,%rsi
lea    0x0(,%rcx,4),%rdi
add    %r13,%rdi
cmp    %rsi,%rdi
jb     145a <merge_sort_recursive+0x34a>
mov    %ebp,%r10d
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     16af <merge_sort_recursive+0x59f>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    0x30(,%rcx,4),%rsi
add    %r13,%rsi
lea    (%r14,%rax,4),%rbx
add    $0x30,%rbx
xor    %ebp,%ebp
nop
movups -0x30(%rsi,%rbp,4),%xmm0
movups -0x20(%rsi,%rbp,4),%xmm1
movups %xmm0,-0x30(%rbx,%rbp,4)
movups %xmm1,-0x20(%rbx,%rbp,4)
movups -0x10(%rsi,%rbp,4),%xmm0
movups (%rsi,%rbp,4),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,4)
movups %xmm1,(%rbx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    13f0 <merge_sort_recursive+0x2e0>
test   $0x1,%r9b
je     1444 <merge_sort_recursive+0x334>
lea    (%rcx,%rbp,1),%rsi
add    %rax,%rbp
movups 0x0(%r13,%rsi,4),%xmm0
movups 0x10(%r13,%rsi,4),%xmm1
movups %xmm0,(%r14,%rbp,4)
movups %xmm1,0x10(%r14,%rbp,4)
cmp    %r8,%rdx
mov    %r10d,%ebp
mov    (%rsp),%r9
je     14d6 <merge_sort_recursive+0x3c6>
add    %r8,%rcx
add    %r8,%rax
mov    %r15d,%edx
sub    %ecx,%edx
lea    0x1(%rdx),%esi
and    $0x3,%esi
je     1486 <merge_sort_recursive+0x376>
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rcx,4),%edi
add    $0x1,%rcx
mov    %edi,(%r14,%rax,4)
add    $0x1,%rax
add    $0xffffffff,%esi
jne    1470 <merge_sort_recursive+0x360>
cmp    $0x3,%edx
jb     14d6 <merge_sort_recursive+0x3c6>
mov    %r15d,%edx
sub    %ecx,%edx
add    $0x1,%edx
lea    0xc(,%rcx,4),%rcx
add    %r13,%rcx
lea    (%r14,%rax,4),%rax
add    $0xc,%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    -0xc(%rcx,%rsi,4),%edi
mov    %edi,-0xc(%rax,%rsi,4)
mov    -0x8(%rcx,%rsi,4),%edi
mov    %edi,-0x8(%rax,%rsi,4)
mov    -0x4(%rcx,%rsi,4),%edi
mov    %edi,-0x4(%rax,%rsi,4)
mov    (%rcx,%rsi,4),%edi
mov    %edi,(%rax,%rsi,4)
add    $0x4,%rsi
cmp    %esi,%edx
jne    14b0 <merge_sort_recursive+0x3a0>
cmp    %r9d,%r15d
jl     168f <merge_sort_recursive+0x57f>
movslq %r9d,%rax
cmp    $0x7,%ebp
jb     1623 <merge_sort_recursive+0x513>
mov    %ebp,%ecx
lea    0x0(,%rax,4),%rsi
add    %r13,%rsi
lea    (%rcx,%rax,1),%rdx
lea    (%r14,%rdx,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    1521 <merge_sort_recursive+0x411>
lea    0x4(,%rdx,4),%rdx
add    %r13,%rdx
lea    (%r14,%rax,4),%rsi
cmp    %rdx,%rsi
jb     1623 <merge_sort_recursive+0x513>
add    $0x1,%rcx
mov    %rcx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rdx
jae    1555 <merge_sort_recursive+0x445>
xor    %ebp,%ebp
jmp    15d8 <merge_sort_recursive+0x4c8>
add    %rax,%rcx
jmp    1225 <merge_sort_recursive+0x115>
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
add    $0xfffffffffffffffe,%rdx
and    %rdx,%rdi
lea    0x70(,%rax,4),%rbx
add    %r13,%rbx
lea    (%r14,%rax,4),%rdx
add    $0x70,%rdx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x70(%rdx,%rbp,4),%xmm0
movups -0x60(%rdx,%rbp,4),%xmm1
movups %xmm0,-0x70(%rbx,%rbp,4)
movups %xmm1,-0x60(%rbx,%rbp,4)
movups -0x50(%rdx,%rbp,4),%xmm0
movups -0x40(%rdx,%rbp,4),%xmm1
movups %xmm0,-0x50(%rbx,%rbp,4)
movups %xmm1,-0x40(%rbx,%rbp,4)
movups -0x30(%rdx,%rbp,4),%xmm0
movups -0x20(%rdx,%rbp,4),%xmm1
movups %xmm0,-0x30(%rbx,%rbp,4)
movups %xmm1,-0x20(%rbx,%rbp,4)
movups -0x10(%rdx,%rbp,4),%xmm0
movups (%rdx,%rbp,4),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,4)
movups %xmm1,(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1580 <merge_sort_recursive+0x470>
test   %rsi,%rsi
je     161b <merge_sort_recursive+0x50b>
add    %rax,%rbp
lea    0x10(,%rbp,4),%rdx
add    %r13,%rdx
lea    (%r14,%rbp,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rsi
jne    1600 <merge_sort_recursive+0x4f0>
cmp    %r8,%rcx
je     168f <merge_sort_recursive+0x57f>
add    %r8,%rax
lea    0x1(%r15),%ecx
mov    %ecx,%edx
sub    %eax,%edx
sub    %eax,%r15d
and    $0x3,%edx
je     1652 <merge_sort_recursive+0x542>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r14,%rax,4),%esi
mov    %esi,0x0(%r13,%rax,4)
add    $0x1,%rax
add    $0xffffffff,%edx
jne    1640 <merge_sort_recursive+0x530>
cmp    $0x3,%r15d
jb     168f <merge_sort_recursive+0x57f>
mov    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rax,4),%edx
mov    %edx,0x0(%r13,%rax,4)
mov    0x4(%r14,%rax,4),%edx
mov    %edx,0x4(%r13,%rax,4)
mov    0x8(%r14,%rax,4),%edx
mov    %edx,0x8(%r13,%rax,4)
mov    0xc(%r14,%rax,4),%edx
mov    %edx,0xc(%r13,%rax,4)
add    $0x4,%rax
cmp    %eax,%ecx
jne    1660 <merge_sort_recursive+0x550>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%r9b
jne    1327 <merge_sort_recursive+0x217>
jmp    1345 <merge_sort_recursive+0x235>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    1426 <merge_sort_recursive+0x316>
jmp    1444 <merge_sort_recursive+0x334>

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

LLVM IR (-O2):
define void @merge_sort_recursive(i32* %0, i32* %1, i32 %2, i32 %3) {
%5 = icmp sgt i32 %3, %2
br i1 %5, label %6, label %460
6: ; preds = %4
%7 = sub nsw i32 %3, %2
%8 = ashr i32 %7, 1
%9 = add i32 %8, %2
%10 = add i32 %9, 1
tail call void @merge_sort_recursive(i32* %0, i32* %1, i32 %2, i32 %9)
tail call void @merge_sort_recursive(i32* %0, i32* %1, i32 %10, i32 %3)
%11 = icmp sgt i32 %7, -1
%12 = icmp slt i32 %9, %3
%13 = and i1 %11, %12
br i1 %13, label %14, label %18
14: ; preds = %6
%15 = sext i32 %2 to i64
br label %132
16: ; preds = %132
%17 = trunc i64 %149 to i32
br label %18
18: ; preds = %16, %6
%19 = phi i32 [ %10, %6 ], [ %145, %16 ]
%20 = phi i32 [ %2, %6 ], [ %147, %16 ]
%21 = phi i32 [ %2, %6 ], [ %17, %16 ]
%22 = icmp sgt i32 %20, %9
br i1 %22, label %157, label %23
23: ; preds = %18
%24 = sext i32 %21 to i64
%25 = sext i32 %20 to i64
%26 = add i32 %8, %2
%27 = sub i32 %26, %20
%28 = zext i32 %27 to i64
%29 = add nuw nsw i64 %28, 1
%30 = icmp ult i32 %27, 7
br i1 %30, label %106, label %31
31: ; preds = %23
%32 = getelementptr i32, i32* %1, i64 %24
%33 = add i32 %8, %2
%34 = sub i32 %33, %20
%35 = zext i32 %34 to i64
%36 = add nsw i64 %24, %35
%37 = add nsw i64 %36, 1
%38 = getelementptr i32, i32* %1, i64 %37
%39 = getelementptr i32, i32* %0, i64 %25
%40 = add nsw i64 %25, %35
%41 = add nsw i64 %40, 1
%42 = getelementptr i32, i32* %0, i64 %41
%43 = icmp ult i32* %32, %42
%44 = icmp ult i32* %39, %38
%45 = and i1 %43, %44
br i1 %45, label %106, label %46
46: ; preds = %31
%47 = and i64 %29, 8589934584
%48 = add nsw i64 %47, %25
%49 = add nsw i64 %47, %24
%50 = add nsw i64 %47, -8
%51 = lshr exact i64 %50, 3
%52 = add nuw nsw i64 %51, 1
%53 = and i64 %52, 1
%54 = icmp eq i64 %50, 0
br i1 %54, label %88, label %55
55: ; preds = %46
%56 = and i64 %52, 4611686018427387902
br label %57
57: ; preds = %57, %55
%58 = phi i64 [ 0, %55 ], [ %85, %57 ]
%59 = phi i64 [ 0, %55 ], [ %86, %57 ]
%60 = add i64 %58, %25
%61 = add i64 %58, %24
%62 = getelementptr inbounds i32, i32* %0, i64 %60
%63 = bitcast i32* %62 to <4 x i32>*
%64 = load <4 x i32>, <4 x i32>* %63
%65 = getelementptr inbounds i32, i32* %62, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
%67 = load <4 x i32>, <4 x i32>* %66
%68 = getelementptr inbounds i32, i32* %1, i64 %61
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %64, <4 x i32>* %69
%70 = getelementptr inbounds i32, i32* %68, i64 4
%71 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> %67, <4 x i32>* %71
%72 = or i64 %58, 8
%73 = add i64 %72, %25
%74 = add i64 %72, %24
%75 = getelementptr inbounds i32, i32* %0, i64 %73
%76 = bitcast i32* %75 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = getelementptr inbounds i32, i32* %75, i64 4
%79 = bitcast i32* %78 to <4 x i32>*
%80 = load <4 x i32>, <4 x i32>* %79
%81 = getelementptr inbounds i32, i32* %1, i64 %74
%82 = bitcast i32* %81 to <4 x i32>*
store <4 x i32> %77, <4 x i32>* %82
%83 = getelementptr inbounds i32, i32* %81, i64 4
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> %80, <4 x i32>* %84
%85 = add nuw i64 %58, 16
%86 = add i64 %59, 2
%87 = icmp eq i64 %86, %56
br i1 %87, label %88, label %57
88: ; preds = %57, %46
%89 = phi i64 [ 0, %46 ], [ %85, %57 ]
%90 = icmp eq i64 %53, 0
br i1 %90, label %104, label %91
91: ; preds = %88
%92 = add i64 %89, %25
%93 = add i64 %89, %24
%94 = getelementptr inbounds i32, i32* %0, i64 %92
%95 = bitcast i32* %94 to <4 x i32>*
%96 = load <4 x i32>, <4 x i32>* %95
%97 = getelementptr inbounds i32, i32* %94, i64 4
%98 = bitcast i32* %97 to <4 x i32>*
%99 = load <4 x i32>, <4 x i32>* %98
%100 = getelementptr inbounds i32, i32* %1, i64 %93
%101 = bitcast i32* %100 to <4 x i32>*
store <4 x i32> %96, <4 x i32>* %101
%102 = getelementptr inbounds i32, i32* %100, i64 4
%103 = bitcast i32* %102 to <4 x i32>*
store <4 x i32> %99, <4 x i32>* %103
br label %104
104: ; preds = %88, %91
%105 = icmp eq i64 %29, %47
br i1 %105, label %154, label %106
106: ; preds = %31, %23, %104
%107 = phi i64 [ %25, %31 ], [ %25, %23 ], [ %48, %104 ]
%108 = phi i64 [ %24, %31 ], [ %24, %23 ], [ %49, %104 ]
%109 = add i32 %8, %2
%110 = add i32 %109, 1
%111 = trunc i64 %107 to i32
%112 = sub i32 %110, %111
%113 = sub i32 %109, %111
%114 = and i32 %112, 3
%115 = icmp eq i32 %114, 0
br i1 %115, label %127, label %116
116: ; preds = %106, %116
%117 = phi i64 [ %120, %116 ], [ %107, %106 ]
%118 = phi i64 [ %123, %116 ], [ %108, %106 ]
%119 = phi i32 [ %125, %116 ], [ 0, %106 ]
%120 = add nsw i64 %117, 1
%121 = getelementptr inbounds i32, i32* %0, i64 %117
%122 = load i32, i32* %121
%123 = add nsw i64 %118, 1
%124 = getelementptr inbounds i32, i32* %1, i64 %118
store i32 %122, i32* %124
%125 = add i32 %119, 1
%126 = icmp eq i32 %125, %114
br i1 %126, label %127, label %116
127: ; preds = %116, %106
%128 = phi i64 [ undef, %106 ], [ %123, %116 ]
%129 = phi i64 [ %107, %106 ], [ %120, %116 ]
%130 = phi i64 [ %108, %106 ], [ %123, %116 ]
%131 = icmp ult i32 %113, 3
br i1 %131, label %154, label %266
132: ; preds = %14, %132
%133 = phi i64 [ %15, %14 ], [ %149, %132 ]
%134 = phi i32 [ %2, %14 ], [ %147, %132 ]
%135 = phi i32 [ %10, %14 ], [ %145, %132 ]
%136 = sext i32 %134 to i64
%137 = getelementptr inbounds i32, i32* %0, i64 %136
%138 = load i32, i32* %137
%139 = sext i32 %135 to i64
%140 = getelementptr inbounds i32, i32* %0, i64 %139
%141 = load i32, i32* %140
%142 = icmp slt i32 %138, %141
%143 = xor i1 %142, true
%144 = zext i1 %143 to i32
%145 = add nsw i32 %135, %144
%146 = zext i1 %142 to i32
%147 = add nsw i32 %134, %146
%148 = select i1 %142, i32 %138, i32 %141
%149 = add i64 %133, 1
%150 = getelementptr inbounds i32, i32* %1, i64 %133
store i32 %148, i32* %150
%151 = icmp sle i32 %147, %9
%152 = icmp sle i32 %145, %3
%153 = select i1 %151, i1 %152, i1 false
br i1 %153, label %132, label %16
154: ; preds = %127, %266, %104
%155 = phi i64 [ %49, %104 ], [ %128, %127 ], [ %287, %266 ]
%156 = trunc i64 %155 to i32
br label %157
157: ; preds = %154, %18
%158 = phi i32 [ %21, %18 ], [ %156, %154 ]
%159 = icmp sgt i32 %19, %3
br i1 %159, label %291, label %160
160: ; preds = %157
%161 = sext i32 %158 to i64
%162 = sext i32 %19 to i64
%163 = add i32 %3, 1
%164 = sub i32 %3, %19
%165 = zext i32 %164 to i64
%166 = add nuw nsw i64 %165, 1
%167 = icmp ult i32 %164, 7
br i1 %167, label %242, label %168
168: ; preds = %160
%169 = getelementptr i32, i32* %1, i64 %161
%170 = sub i32 %3, %19
%171 = zext i32 %170 to i64
%172 = add nsw i64 %161, %171
%173 = add nsw i64 %172, 1
%174 = getelementptr i32, i32* %1, i64 %173
%175 = getelementptr i32, i32* %0, i64 %162
%176 = add nsw i64 %162, %171
%177 = add nsw i64 %176, 1
%178 = getelementptr i32, i32* %0, i64 %177
%179 = icmp ult i32* %169, %178
%180 = icmp ult i32* %175, %174
%181 = and i1 %179, %180
br i1 %181, label %242, label %182
182: ; preds = %168
%183 = and i64 %166, 8589934584
%184 = add nsw i64 %183, %162
%185 = add nsw i64 %183, %161
%186 = add nsw i64 %183, -8
%187 = lshr exact i64 %186, 3
%188 = add nuw nsw i64 %187, 1
%189 = and i64 %188, 1
%190 = icmp eq i64 %186, 0
br i1 %190, label %224, label %191
191: ; preds = %182
%192 = and i64 %188, 4611686018427387902
br label %193
193: ; preds = %193, %191
%194 = phi i64 [ 0, %191 ], [ %221, %193 ]
%195 = phi i64 [ 0, %191 ], [ %222, %193 ]
%196 = add i64 %194, %162
%197 = add i64 %194, %161
%198 = getelementptr inbounds i32, i32* %0, i64 %196
%199 = bitcast i32* %198 to <4 x i32>*
%200 = load <4 x i32>, <4 x i32>* %199
%201 = getelementptr inbounds i32, i32* %198, i64 4
%202 = bitcast i32* %201 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = getelementptr inbounds i32, i32* %1, i64 %197
%205 = bitcast i32* %204 to <4 x i32>*
store <4 x i32> %200, <4 x i32>* %205
%206 = getelementptr inbounds i32, i32* %204, i64 4
%207 = bitcast i32* %206 to <4 x i32>*
store <4 x i32> %203, <4 x i32>* %207
%208 = or i64 %194, 8
%209 = add i64 %208, %162
%210 = add i64 %208, %161
%211 = getelementptr inbounds i32, i32* %0, i64 %209
%212 = bitcast i32* %211 to <4 x i32>*
%213 = load <4 x i32>, <4 x i32>* %212
%214 = getelementptr inbounds i32, i32* %211, i64 4
%215 = bitcast i32* %214 to <4 x i32>*
%216 = load <4 x i32>, <4 x i32>* %215
%217 = getelementptr inbounds i32, i32* %1, i64 %210
%218 = bitcast i32* %217 to <4 x i32>*
store <4 x i32> %213, <4 x i32>* %218
%219 = getelementptr inbounds i32, i32* %217, i64 4
%220 = bitcast i32* %219 to <4 x i32>*
store <4 x i32> %216, <4 x i32>* %220
%221 = add nuw i64 %194, 16
%222 = add i64 %195, 2
%223 = icmp eq i64 %222, %192
br i1 %223, label %224, label %193
224: ; preds = %193, %182
%225 = phi i64 [ 0, %182 ], [ %221, %193 ]
%226 = icmp eq i64 %189, 0
br i1 %226, label %240, label %227
227: ; preds = %224
%228 = add i64 %225, %162
%229 = add i64 %225, %161
%230 = getelementptr inbounds i32, i32* %0, i64 %228
%231 = bitcast i32* %230 to <4 x i32>*
%232 = load <4 x i32>, <4 x i32>* %231
%233 = getelementptr inbounds i32, i32* %230, i64 4
%234 = bitcast i32* %233 to <4 x i32>*
%235 = load <4 x i32>, <4 x i32>* %234
%236 = getelementptr inbounds i32, i32* %1, i64 %229
%237 = bitcast i32* %236 to <4 x i32>*
store <4 x i32> %232, <4 x i32>* %237
%238 = getelementptr inbounds i32, i32* %236, i64 4
%239 = bitcast i32* %238 to <4 x i32>*
store <4 x i32> %235, <4 x i32>* %239
br label %240
240: ; preds = %224, %227
%241 = icmp eq i64 %166, %183
br i1 %241, label %291, label %242
242: ; preds = %168, %160, %240
%243 = phi i64 [ %162, %168 ], [ %162, %160 ], [ %184, %240 ]
%244 = phi i64 [ %161, %168 ], [ %161, %160 ], [ %185, %240 ]
%245 = add i32 %3, 1
%246 = trunc i64 %243 to i32
%247 = sub i32 %245, %246
%248 = sub i32 %3, %246
%249 = and i32 %247, 3
%250 = icmp eq i32 %249, 0
br i1 %250, label %262, label %251
251: ; preds = %242, %251
%252 = phi i64 [ %255, %251 ], [ %243, %242 ]
%253 = phi i64 [ %258, %251 ], [ %244, %242 ]
%254 = phi i32 [ %260, %251 ], [ 0, %242 ]
%255 = add nsw i64 %252, 1
%256 = getelementptr inbounds i32, i32* %0, i64 %252
%257 = load i32, i32* %256
%258 = add nsw i64 %253, 1
%259 = getelementptr inbounds i32, i32* %1, i64 %253
store i32 %257, i32* %259
%260 = add i32 %254, 1
%261 = icmp eq i32 %260, %249
br i1 %261, label %262, label %251
262: ; preds = %251, %242
%263 = phi i64 [ %243, %242 ], [ %255, %251 ]
%264 = phi i64 [ %244, %242 ], [ %258, %251 ]
%265 = icmp ult i32 %248, 3
br i1 %265, label %291, label %415
266: ; preds = %127, %266
%267 = phi i64 [ %284, %266 ], [ %129, %127 ]
%268 = phi i64 [ %287, %266 ], [ %130, %127 ]
%269 = add nsw i64 %267, 1
%270 = getelementptr inbounds i32, i32* %0, i64 %267
%271 = load i32, i32* %270
%272 = add nsw i64 %268, 1
%273 = getelementptr inbounds i32, i32* %1, i64 %268
store i32 %271, i32* %273
%274 = add nsw i64 %267, 2
%275 = getelementptr inbounds i32, i32* %0, i64 %269
%276 = load i32, i32* %275
%277 = add nsw i64 %268, 2
%278 = getelementptr inbounds i32, i32* %1, i64 %272
store i32 %276, i32* %278
%279 = add nsw i64 %267, 3
%280 = getelementptr inbounds i32, i32* %0, i64 %274
%281 = load i32, i32* %280
%282 = add nsw i64 %268, 3
%283 = getelementptr inbounds i32, i32* %1, i64 %277
store i32 %281, i32* %283
%284 = add nsw i64 %267, 4
%285 = getelementptr inbounds i32, i32* %0, i64 %279
%286 = load i32, i32* %285
%287 = add nsw i64 %268, 4
%288 = getelementptr inbounds i32, i32* %1, i64 %282
store i32 %286, i32* %288
%289 = trunc i64 %284 to i32
%290 = icmp eq i32 %10, %289
br i1 %290, label %154, label %266
291: ; preds = %262, %415, %240, %157
%292 = icmp slt i32 %3, %2
br i1 %292, label %460, label %293
293: ; preds = %291
%294 = sext i32 %2 to i64
%295 = add i32 %3, 1
%296 = zext i32 %7 to i64
%297 = add nuw nsw i64 %296, 1
%298 = icmp ult i32 %7, 7
br i1 %298, label %395, label %299
299: ; preds = %293
%300 = getelementptr i32, i32* %0, i64 %294
%301 = zext i32 %7 to i64
%302 = add nsw i64 %294, %301
%303 = add nsw i64 %302, 1
%304 = getelementptr i32, i32* %0, i64 %303
%305 = getelementptr i32, i32* %1, i64 %294
%306 = getelementptr i32, i32* %1, i64 %303
%307 = icmp ult i32* %300, %306
%308 = icmp ult i32* %305, %304
%309 = and i1 %307, %308
br i1 %309, label %395, label %310
310: ; preds = %299
%311 = and i64 %297, 8589934584
%312 = add nsw i64 %311, %294
%313 = add nsw i64 %311, -8
%314 = lshr exact i64 %313, 3
%315 = add nuw nsw i64 %314, 1
%316 = and i64 %315, 3
%317 = icmp ult i64 %313, 24
br i1 %317, label %373, label %318
318: ; preds = %310
%319 = and i64 %315, 4611686018427387900
br label %320
320: ; preds = %320, %318
%321 = phi i64 [ 0, %318 ], [ %370, %320 ]
%322 = phi i64 [ 0, %318 ], [ %371, %320 ]
%323 = add i64 %321, %294
%324 = getelementptr inbounds i32, i32* %1, i64 %323
%325 = bitcast i32* %324 to <4 x i32>*
%326 = load <4 x i32>, <4 x i32>* %325
%327 = getelementptr inbounds i32, i32* %324, i64 4
%328 = bitcast i32* %327 to <4 x i32>*
%329 = load <4 x i32>, <4 x i32>* %328
%330 = getelementptr inbounds i32, i32* %0, i64 %323
%331 = bitcast i32* %330 to <4 x i32>*
store <4 x i32> %326, <4 x i32>* %331
%332 = getelementptr inbounds i32, i32* %330, i64 4
%333 = bitcast i32* %332 to <4 x i32>*
store <4 x i32> %329, <4 x i32>* %333
%334 = or i64 %321, 8
%335 = add i64 %334, %294
%336 = getelementptr inbounds i32, i32* %1, i64 %335
%337 = bitcast i32* %336 to <4 x i32>*
%338 = load <4 x i32>, <4 x i32>* %337
%339 = getelementptr inbounds i32, i32* %336, i64 4
%340 = bitcast i32* %339 to <4 x i32>*
%341 = load <4 x i32>, <4 x i32>* %340
%342 = getelementptr inbounds i32, i32* %0, i64 %335
%343 = bitcast i32* %342 to <4 x i32>*
store <4 x i32> %338, <4 x i32>* %343
%344 = getelementptr inbounds i32, i32* %342, i64 4
%345 = bitcast i32* %344 to <4 x i32>*
store <4 x i32> %341, <4 x i32>* %345
%346 = or i64 %321, 16
%347 = add i64 %346, %294
%348 = getelementptr inbounds i32, i32* %1, i64 %347
%349 = bitcast i32* %348 to <4 x i32>*
%350 = load <4 x i32>, <4 x i32>* %349
%351 = getelementptr inbounds i32, i32* %348, i64 4
%352 = bitcast i32* %351 to <4 x i32>*
%353 = load <4 x i32>, <4 x i32>* %352
%354 = getelementptr inbounds i32, i32* %0, i64 %347
%355 = bitcast i32* %354 to <4 x i32>*
store <4 x i32> %350, <4 x i32>* %355
%356 = getelementptr inbounds i32, i32* %354, i64 4
%357 = bitcast i32* %356 to <4 x i32>*
store <4 x i32> %353, <4 x i32>* %357
%358 = or i64 %321, 24
%359 = add i64 %358, %294
%360 = getelementptr inbounds i32, i32* %1, i64 %359
%361 = bitcast i32* %360 to <4 x i32>*
%362 = load <4 x i32>, <4 x i32>* %361
%363 = getelementptr inbounds i32, i32* %360, i64 4
%364 = bitcast i32* %363 to <4 x i32>*
%365 = load <4 x i32>, <4 x i32>* %364
%366 = getelementptr inbounds i32, i32* %0, i64 %359
%367 = bitcast i32* %366 to <4 x i32>*
store <4 x i32> %362, <4 x i32>* %367
%368 = getelementptr inbounds i32, i32* %366, i64 4
%369 = bitcast i32* %368 to <4 x i32>*
store <4 x i32> %365, <4 x i32>* %369
%370 = add nuw i64 %321, 32
%371 = add i64 %322, 4
%372 = icmp eq i64 %371, %319
br i1 %372, label %373, label %320
373: ; preds = %320, %310
%374 = phi i64 [ 0, %310 ], [ %370, %320 ]
%375 = icmp eq i64 %316, 0
br i1 %375, label %393, label %376
376: ; preds = %373, %376
%377 = phi i64 [ %390, %376 ], [ %374, %373 ]
%378 = phi i64 [ %391, %376 ], [ 0, %373 ]
%379 = add i64 %377, %294
%380 = getelementptr inbounds i32, i32* %1, i64 %379
%381 = bitcast i32* %380 to <4 x i32>*
%382 = load <4 x i32>, <4 x i32>* %381
%383 = getelementptr inbounds i32, i32* %380, i64 4
%384 = bitcast i32* %383 to <4 x i32>*
%385 = load <4 x i32>, <4 x i32>* %384
%386 = getelementptr inbounds i32, i32* %0, i64 %379
%387 = bitcast i32* %386 to <4 x i32>*
store <4 x i32> %382, <4 x i32>* %387
%388 = getelementptr inbounds i32, i32* %386, i64 4
%389 = bitcast i32* %388 to <4 x i32>*
store <4 x i32> %385, <4 x i32>* %389
%390 = add nuw i64 %377, 8
%391 = add i64 %378, 1
%392 = icmp eq i64 %391, %316
br i1 %392, label %393, label %376
393: ; preds = %376, %373
%394 = icmp eq i64 %297, %311
br i1 %394, label %460, label %395
395: ; preds = %299, %293, %393
%396 = phi i64 [ %294, %299 ], [ %294, %293 ], [ %312, %393 ]
%397 = add i32 %3, 1
%398 = trunc i64 %396 to i32
%399 = sub i32 %397, %398
%400 = sub i32 %3, %398
%401 = and i32 %399, 3
%402 = icmp eq i32 %401, 0
br i1 %402, label %412, label %403
403: ; preds = %395, %403
%404 = phi i64 [ %409, %403 ], [ %396, %395 ]
%405 = phi i32 [ %410, %403 ], [ 0, %395 ]
%406 = getelementptr inbounds i32, i32* %1, i64 %404
%407 = load i32, i32* %406
%408 = getelementptr inbounds i32, i32* %0, i64 %404
store i32 %407, i32* %408
%409 = add nsw i64 %404, 1
%410 = add i32 %405, 1
%411 = icmp eq i32 %410, %401
br i1 %411, label %412, label %403
412: ; preds = %403, %395
%413 = phi i64 [ %396, %395 ], [ %409, %403 ]
%414 = icmp ult i32 %400, 3
br i1 %414, label %460, label %440
415: ; preds = %262, %415
%416 = phi i64 [ %433, %415 ], [ %263, %262 ]
%417 = phi i64 [ %436, %415 ], [ %264, %262 ]
%418 = add nsw i64 %416, 1
%419 = getelementptr inbounds i32, i32* %0, i64 %416
%420 = load i32, i32* %419
%421 = add nsw i64 %417, 1
%422 = getelementptr inbounds i32, i32* %1, i64 %417
store i32 %420, i32* %422
%423 = add nsw i64 %416, 2
%424 = getelementptr inbounds i32, i32* %0, i64 %418
%425 = load i32, i32* %424
%426 = add nsw i64 %417, 2
%427 = getelementptr inbounds i32, i32* %1, i64 %421
store i32 %425, i32* %427
%428 = add nsw i64 %416, 3
%429 = getelementptr inbounds i32, i32* %0, i64 %423
%430 = load i32, i32* %429
%431 = add nsw i64 %417, 3
%432 = getelementptr inbounds i32, i32* %1, i64 %426
store i32 %430, i32* %432
%433 = add nsw i64 %416, 4
%434 = getelementptr inbounds i32, i32* %0, i64 %428
%435 = load i32, i32* %434
%436 = add nsw i64 %417, 4
%437 = getelementptr inbounds i32, i32* %1, i64 %431
store i32 %435, i32* %437
%438 = trunc i64 %433 to i32
%439 = icmp eq i32 %163, %438
br i1 %439, label %291, label %415
440: ; preds = %412, %440
%441 = phi i64 [ %457, %440 ], [ %413, %412 ]
%442 = getelementptr inbounds i32, i32* %1, i64 %441
%443 = load i32, i32* %442
%444 = getelementptr inbounds i32, i32* %0, i64 %441
store i32 %443, i32* %444
%445 = add nsw i64 %441, 1
%446 = getelementptr inbounds i32, i32* %1, i64 %445
%447 = load i32, i32* %446
%448 = getelementptr inbounds i32, i32* %0, i64 %445
store i32 %447, i32* %448
%449 = add nsw i64 %441, 2
%450 = getelementptr inbounds i32, i32* %1, i64 %449
%451 = load i32, i32* %450
%452 = getelementptr inbounds i32, i32* %0, i64 %449
store i32 %451, i32* %452
%453 = add nsw i64 %441, 3
%454 = getelementptr inbounds i32, i32* %1, i64 %453
%455 = load i32, i32* %454
%456 = getelementptr inbounds i32, i32* %0, i64 %453
store i32 %455, i32* %456
%457 = add nsw i64 %441, 4
%458 = trunc i64 %457 to i32
%459 = icmp eq i32 %295, %458
br i1 %459, label %460, label %440
460: ; preds = %412, %440, %393, %291, %4
ret void
}