#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);
void sorter_merge_sort_in_place_frontmerge(int64_t *dst1, size_t l1,
                                           int64_t *dst2, size_t l2) {
  int64_t *dst0 = dst2 - l1;
  if (((dst1[l1 - 1]) - (dst2[0])) <= 0) {
    sorter_merge_sort_in_place_aswap(dst1, dst0, l1);
    return;
  }
  do {
    while (((*dst2) - (*dst1)) > 0) {
      {
        int64_t _sort_swap_temp = (*dst1);
        (*dst1) = (*dst0);
        (*dst0) = _sort_swap_temp;
      };
      dst1++;
      dst0++;
      if (--l1 == 0) {
        return;
      }
    }
    {
      int64_t _sort_swap_temp = (*dst2);
      (*dst2) = (*dst0);
      (*dst0) = _sort_swap_temp;
    };
    dst2++;
    dst0++;
  } while (--l2);
  do {
    {
      int64_t _sort_swap_temp = (*dst1);
      (*dst1) = (*dst0);
      (*dst0) = _sort_swap_temp;
    };
    dst1++;
    dst0++;
  } while (--l1);
}


x86 assembly (clang, -O0):
<sorter_merge_sort_in_place_frontmerge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
xor    %ecx,%ecx
sub    -0x10(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
sub    (%rcx),%rax
cmp    $0x0,%rax
jg     1174 <sorter_merge_sort_in_place_frontmerge+0x64>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x10(%rbp),%rdx
call   1030 <sorter_merge_sort_in_place_aswap@plt>
jmp    129b <sorter_merge_sort_in_place_frontmerge+0x18b>
jmp    1179 <sorter_merge_sort_in_place_frontmerge+0x69>
jmp    117e <sorter_merge_sort_in_place_frontmerge+0x6e>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rbp),%rcx
sub    (%rcx),%rax
cmp    $0x0,%rax
jle    11f2 <sorter_merge_sort_in_place_frontmerge+0xe2>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
cmp    $0x0,%rax
jne    11ed <sorter_merge_sort_in_place_frontmerge+0xdd>
jmp    129b <sorter_merge_sort_in_place_frontmerge+0x18b>
jmp    117e <sorter_merge_sort_in_place_frontmerge+0x6e>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x18(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    1179 <sorter_merge_sort_in_place_frontmerge+0x69>
jmp    1249 <sorter_merge_sort_in_place_frontmerge+0x139>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x8(%rbp)
mov    -0x28(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
cmp    $0x0,%rax
jne    1249 <sorter_merge_sort_in_place_frontmerge+0x139>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sorter_merge_sort_in_place_frontmerge>:
push   %r14
push   %rbx
mov    %rsi,%r10
lea    0x0(,%rsi,8),%rax
mov    %rdx,%rsi
sub    %rax,%rsi
mov    -0x8(%rdi,%r10,8),%rax
cmp    (%rdx),%rax
jle    1255 <sorter_merge_sort_in_place_frontmerge+0x145>
mov    %rdi,%r8
mov    %rsi,%r9
lea    0x38(%rsi),%r11
lea    0x30(%rdi),%r14
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rdx),%rsi
mov    (%r8,%rax,1),%rdi
mov    (%r9,%rax,1),%rbx
cmp    %rdi,%rsi
jle    1180 <sorter_merge_sort_in_place_frontmerge+0x70>
mov    %rbx,(%r8,%rax,1)
mov    %rdi,(%r9,%rax,1)
add    $0x8,%r11
add    $0x8,%rax
add    $0x8,%r14
add    $0xffffffffffffffff,%r10
jne    1150 <sorter_merge_sort_in_place_frontmerge+0x40>
jmp    1355 <sorter_merge_sort_in_place_frontmerge+0x245>
nop
mov    %rbx,(%rdx)
mov    %rsi,(%r9,%rax,1)
add    $0x8,%rdx
lea    (%r9,%rax,1),%rsi
add    $0x8,%rsi
lea    (%r8,%rax,1),%rdi
add    $0xffffffffffffffff,%rcx
jne    1132 <sorter_merge_sort_in_place_frontmerge+0x22>
lea    (%r8,%rax,1),%rcx
lea    (%r9,%rax,1),%rdx
add    $0x8,%rdx
cmp    $0x4,%r10
jb     12b4 <sorter_merge_sort_in_place_frontmerge+0x1a4>
lea    (%rdx,%r10,8),%rsi
cmp    %rsi,%rcx
jae    11c9 <sorter_merge_sort_in_place_frontmerge+0xb9>
lea    (%rcx,%r10,8),%rsi
cmp    %rsi,%rdx
jb     12b4 <sorter_merge_sort_in_place_frontmerge+0x1a4>
mov    %r10,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     1260 <sorter_merge_sort_in_place_frontmerge+0x150>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
movups -0x30(%r14,%rsi,8),%xmm0
movups -0x20(%r14,%rsi,8),%xmm1
movups -0x30(%r11,%rsi,8),%xmm2
movups -0x20(%r11,%rsi,8),%xmm3
movups %xmm2,-0x30(%r14,%rsi,8)
movups %xmm3,-0x20(%r14,%rsi,8)
movups %xmm0,-0x30(%r11,%rsi,8)
movups %xmm1,-0x20(%r11,%rsi,8)
movups -0x10(%r14,%rsi,8),%xmm0
movups (%r14,%rsi,8),%xmm1
movups -0x10(%r11,%rsi,8),%xmm2
movups (%r11,%rsi,8),%xmm3
movups %xmm2,-0x10(%r14,%rsi,8)
movups %xmm3,(%r14,%rsi,8)
movups %xmm0,-0x10(%r11,%rsi,8)
movups %xmm1,(%r11,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    11ed <sorter_merge_sort_in_place_frontmerge+0xdd>
jmp    1262 <sorter_merge_sort_in_place_frontmerge+0x152>
mov    %r10,%rdx
pop    %rbx
pop    %r14
jmp    1030 <sorter_merge_sort_in_place_aswap@plt>
xor    %esi,%esi
test   $0x1,%dl
je     1295 <sorter_merge_sort_in_place_frontmerge+0x185>
lea    (%r8,%rsi,8),%rdx
movups (%rax,%rdx,1),%xmm0
movups 0x10(%rax,%rdx,1),%xmm1
lea    (%r9,%rsi,8),%rsi
movups 0x8(%rax,%rsi,1),%xmm2
movups 0x18(%rax,%rsi,1),%xmm3
movups %xmm2,(%rax,%rdx,1)
movups %xmm3,0x10(%rax,%rdx,1)
movups %xmm0,0x8(%rax,%rsi,1)
movups %xmm1,0x18(%rax,%rsi,1)
cmp    %rcx,%r10
je     1355 <sorter_merge_sort_in_place_frontmerge+0x245>
lea    (%r9,%rcx,8),%rdx
lea    (%r8,%rcx,8),%rcx
and    $0x3,%r10d
add    %rax,%rdx
add    $0x8,%rdx
add    %rax,%rcx
lea    -0x1(%r10),%r8
mov    %r10,%rsi
and    $0x3,%rsi
je     12f0 <sorter_merge_sort_in_place_frontmerge+0x1e0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rcx),%rbx
mov    (%rdx),%rax
mov    %rax,(%rcx)
mov    %rbx,(%rdx)
add    $0x8,%rcx
add    $0x8,%rdx
add    $0x1,%rdi
cmp    %rdi,%rsi
jne    12d0 <sorter_merge_sort_in_place_frontmerge+0x1c0>
sub    %rdi,%r10
cmp    $0x3,%r8
jb     1355 <sorter_merge_sort_in_place_frontmerge+0x245>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%rax,8),%rsi
mov    (%rdx,%rax,8),%rdi
mov    %rdi,(%rcx,%rax,8)
mov    %rsi,(%rdx,%rax,8)
mov    0x8(%rcx,%rax,8),%rsi
mov    0x8(%rdx,%rax,8),%rdi
mov    %rdi,0x8(%rcx,%rax,8)
mov    %rsi,0x8(%rdx,%rax,8)
mov    0x10(%rcx,%rax,8),%rsi
mov    0x10(%rdx,%rax,8),%rdi
mov    %rdi,0x10(%rcx,%rax,8)
mov    %rsi,0x10(%rdx,%rax,8)
mov    0x18(%rcx,%rax,8),%rsi
mov    0x18(%rdx,%rax,8),%rdi
mov    %rdi,0x18(%rcx,%rax,8)
mov    %rsi,0x18(%rdx,%rax,8)
add    $0x4,%rax
cmp    %rax,%r10
jne    1300 <sorter_merge_sort_in_place_frontmerge+0x1f0>
pop    %rbx
pop    %r14
ret

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

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