#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 */
typedef scalar_t__ int64_t;
typedef int /*<<< orphan*/ dst1;

/* Variables and functions */
int /*<<< orphan*/ sorter_merge_sort_in_place_aswap(scalar_t__ *, scalar_t__ *,
                                                    size_t);
size_t sorter_merge_sort_in_place_backmerge(int64_t *dst1, size_t l1,
                                            int64_t *dst2, size_t l2) {
  size_t res;
  int64_t *dst0 = dst2 + l1;
  if (((dst1[1 - l1]) - (dst2[0])) >= 0) {
    sorter_merge_sort_in_place_aswap(dst1 - l1 + 1, dst0 - l1 + 1, l1);
    return l1;
  }
  do {
    while (((*dst2) - (*dst1)) < 0) {
      {
        int64_t _sort_swap_temp = (*dst1);
        (*dst1) = (*dst0);
        (*dst0) = _sort_swap_temp;
      };
      dst1--;
      dst0--;
      if (--l1 == 0) {
        return 0;
      }
    }
    {
      int64_t _sort_swap_temp = (*dst2);
      (*dst2) = (*dst0);
      (*dst0) = _sort_swap_temp;
    };
    dst2--;
    dst0--;
  } while (--l2);
  res = l1;
  do {
    {
      int64_t _sort_swap_temp = (*dst1);
      (*dst1) = (*dst0);
      (*dst0) = _sort_swap_temp;
    };
    dst1--;
    dst0--;
  } while (--l1);
  return res;
}


x86 assembly (clang, -O0):
<sorter_merge_sort_in_place_backmerge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    $0x1,%ecx
sub    -0x18(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
sub    (%rcx),%rax
cmp    $0x0,%rax
jl     119d <sorter_merge_sort_in_place_backmerge+0x8d>
mov    -0x10(%rbp),%rdi
xor    %eax,%eax
sub    -0x18(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rdi
add    $0x8,%rdi
mov    -0x38(%rbp),%rsi
xor    %eax,%eax
sub    -0x18(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
add    $0x8,%rsi
mov    -0x18(%rbp),%rdx
call   1030 <sorter_merge_sort_in_place_aswap@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12d7 <sorter_merge_sort_in_place_backmerge+0x1c7>
jmp    11a2 <sorter_merge_sort_in_place_backmerge+0x92>
jmp    11a7 <sorter_merge_sort_in_place_backmerge+0x97>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x10(%rbp),%rcx
sub    (%rcx),%rax
cmp    $0x0,%rax
jge    1223 <sorter_merge_sort_in_place_backmerge+0x113>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
jne    121e <sorter_merge_sort_in_place_backmerge+0x10e>
movq   $0x0,-0x8(%rbp)
jmp    12d7 <sorter_merge_sort_in_place_backmerge+0x1c7>
jmp    11a7 <sorter_merge_sort_in_place_backmerge+0x97>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
jne    11a2 <sorter_merge_sort_in_place_backmerge+0x92>
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x50(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
jne    127d <sorter_merge_sort_in_place_backmerge+0x16d>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sorter_merge_sort_in_place_backmerge>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    $0x1,%eax
sub    %rsi,%rax
mov    (%rdi,%rax,8),%rax
cmp    (%rdx),%rax
jge    1287 <sorter_merge_sort_in_place_backmerge+0x177>
lea    (%rdx,%r14,8),%r10
mov    %rdi,%r8
mov    %r10,%r9
lea    -0x20(%r10),%r15
lea    -0x18(%rdi),%r12
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdx),%rdi
mov    (%r8,%rax,1),%rsi
mov    (%r9,%rax,1),%rbx
cmp    %rsi,%rdi
jge    1180 <sorter_merge_sort_in_place_backmerge+0x70>
mov    %rbx,(%r8,%rax,1)
mov    %rsi,(%r9,%rax,1)
add    $0xfffffffffffffff8,%r15
add    $0xfffffffffffffff8,%rax
add    $0xfffffffffffffff8,%r12
add    $0xffffffffffffffff,%r14
jne    1150 <sorter_merge_sort_in_place_backmerge+0x40>
jmp    12a7 <sorter_merge_sort_in_place_backmerge+0x197>
nop
mov    %rbx,(%rdx)
mov    %rdi,(%r9,%rax,1)
add    $0xfffffffffffffff8,%rdx
lea    (%r9,%rax,1),%r10
add    $0xfffffffffffffff8,%r10
lea    (%r8,%rax,1),%rdi
add    $0xffffffffffffffff,%rcx
jne    1134 <sorter_merge_sort_in_place_backmerge+0x24>
lea    (%r8,%rax,1),%rdx
lea    (%r9,%rax,1),%rcx
add    $0xfffffffffffffff8,%rcx
cmp    $0x4,%r14
jb     11ed <sorter_merge_sort_in_place_backmerge+0xdd>
lea    (%r9,%rax,1),%rsi
lea    0x0(,%r14,8),%r11
mov    %r11,%rdi
neg    %rdi
add    %rdx,%rdi
add    $0x8,%rdi
cmp    %rsi,%rdi
jae    12b9 <sorter_merge_sort_in_place_backmerge+0x1a9>
mov    $0x8,%esi
sub    %r11,%rsi
lea    (%r8,%rax,1),%rdi
add    $0x8,%rdi
add    %rcx,%rsi
cmp    %rdi,%rsi
jae    12b9 <sorter_merge_sort_in_place_backmerge+0x1a9>
mov    %r14,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rdi
and    $0x3,%rdi
je     1220 <sorter_merge_sort_in_place_backmerge+0x110>
xor    %ebx,%ebx
nop
mov    (%rdx),%rax
mov    (%rcx),%rsi
mov    %rsi,(%rdx)
mov    %rax,(%rcx)
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffff8,%rcx
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1200 <sorter_merge_sort_in_place_backmerge+0xf0>
sub    %rbx,%r10
cmp    $0x3,%r8
jb     12aa <sorter_merge_sort_in_place_backmerge+0x19a>
neg    %r10
xor    %eax,%eax
nop
mov    (%rdx,%rax,8),%rsi
mov    (%rcx,%rax,8),%rdi
mov    %rdi,(%rdx,%rax,8)
mov    %rsi,(%rcx,%rax,8)
mov    -0x8(%rdx,%rax,8),%rsi
mov    -0x8(%rcx,%rax,8),%rdi
mov    %rdi,-0x8(%rdx,%rax,8)
mov    %rsi,-0x8(%rcx,%rax,8)
mov    -0x10(%rdx,%rax,8),%rsi
mov    -0x10(%rcx,%rax,8),%rdi
mov    %rdi,-0x10(%rdx,%rax,8)
mov    %rsi,-0x10(%rcx,%rax,8)
mov    -0x18(%rdx,%rax,8),%rsi
mov    -0x18(%rcx,%rax,8),%rdi
mov    %rdi,-0x18(%rdx,%rax,8)
mov    %rsi,-0x18(%rcx,%rax,8)
add    $0xfffffffffffffffc,%rax
cmp    %rax,%r10
jne    1230 <sorter_merge_sort_in_place_backmerge+0x120>
jmp    12aa <sorter_merge_sort_in_place_backmerge+0x19a>
lea    0x0(,%r14,8),%rax
sub    %rax,%rdi
add    $0x8,%rdi
add    $0x8,%rdx
mov    %rdx,%rsi
mov    %r14,%rdx
call   1030 <sorter_merge_sort_in_place_aswap@plt>
jmp    12aa <sorter_merge_sort_in_place_backmerge+0x19a>
xor    %r14d,%r14d
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    %r14,%r10
and    $0xfffffffffffffffc,%r10
lea    -0x4(%r10),%rcx
mov    %rcx,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
test   %rcx,%rcx
je     1348 <sorter_merge_sort_in_place_backmerge+0x238>
mov    %rdi,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %edx,%edx
movups (%r12,%rdx,8),%xmm0
movups 0x10(%r12,%rdx,8),%xmm1
movups (%r15,%rdx,8),%xmm2
movups 0x10(%r15,%rdx,8),%xmm3
movups %xmm3,0x10(%r12,%rdx,8)
movups %xmm2,(%r12,%rdx,8)
movups %xmm1,0x10(%r15,%rdx,8)
movups %xmm0,(%r15,%rdx,8)
movups -0x20(%r12,%rdx,8),%xmm0
movups -0x10(%r12,%rdx,8),%xmm1
movups -0x20(%r15,%rdx,8),%xmm2
movups -0x10(%r15,%rdx,8),%xmm3
movups %xmm3,-0x10(%r12,%rdx,8)
movups %xmm2,-0x20(%r12,%rdx,8)
movups %xmm1,-0x10(%r15,%rdx,8)
movups %xmm0,-0x20(%r15,%rdx,8)
add    $0xfffffffffffffff8,%rdx
add    $0xfffffffffffffffe,%rcx
jne    12dd <sorter_merge_sort_in_place_backmerge+0x1cd>
neg    %rdx
jmp    134a <sorter_merge_sort_in_place_backmerge+0x23a>
xor    %edx,%edx
test   $0x1,%dil
je     1388 <sorter_merge_sort_in_place_backmerge+0x278>
shl    $0x3,%rdx
mov    %r8,%rcx
sub    %rdx,%rcx
movups -0x18(%rcx,%rax,1),%xmm0
movups -0x8(%rcx,%rax,1),%xmm1
mov    %r9,%rsi
sub    %rdx,%rsi
movups -0x20(%rsi,%rax,1),%xmm2
movups -0x10(%rsi,%rax,1),%xmm3
movups %xmm3,-0x8(%rcx,%rax,1)
movups %xmm2,-0x18(%rcx,%rax,1)
movups %xmm1,-0x10(%rsi,%rax,1)
movups %xmm0,-0x20(%rsi,%rax,1)
cmp    %r10,%r14
je     12aa <sorter_merge_sort_in_place_backmerge+0x19a>
and    $0xffffffffffffffe0,%r11
sub    %r11,%r9
sub    %r11,%r8
mov    %r14d,%r10d
and    $0x3,%r10d
lea    (%r9,%rax,1),%rcx
add    $0xfffffffffffffff8,%rcx
add    %rax,%r8
mov    %r8,%rdx
jmp    11f0 <sorter_merge_sort_in_place_backmerge+0xe0>

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

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