#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(unsigned long long *);
scalar_t__ malloc(unsigned long long);
void combine(unsigned long long int *a, unsigned long long int lower,
             unsigned long long int upper) {
  unsigned long long int i = 0, j = 0, k = 0, mid = 0;
  mid = (lower + upper) / 2;
  unsigned long long int *result;
  result = (unsigned long long int *)malloc((upper - lower) *
                                            sizeof(unsigned long long int));
  for (i = lower, j = mid, k = 0; i < mid && j < upper;) {
    if (*(a + i) < *(a + j))
      *(result + k++) = *(a + i++);
    else
      *(result + k++) = *(a + j++);
  }
  while (i < mid)
    *(result + k++) = *(a + i++);
  while (j < upper)
    *(result + k++) = *(a + j++);
  for (k = 0; k < (upper - lower); k++)
    *(a + lower + k) = *(result + k);
  free(result);
}


x86 assembly (clang, -O0):
<combine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rdi
sub    -0x10(%rbp),%rdi
shl    $0x3,%rdi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x20(%rbp),%rcx
xor    %eax,%eax
cmp    -0x38(%rbp),%rcx
mov    %al,-0x41(%rbp)
jae    11b2 <combine+0x92>
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
setb   %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    11c2 <combine+0xa2>
jmp    1246 <combine+0x126>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
mov    -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jae    1213 <combine+0xf3>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    (%rax,%rcx,8),%rdx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    1241 <combine+0x121>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,8),%rdx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    1191 <combine+0x71>
jmp    124b <combine+0x12b>
mov    -0x20(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    128c <combine+0x16c>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    (%rax,%rcx,8),%rdx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    124b <combine+0x12b>
jmp    1291 <combine+0x171>
mov    -0x28(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    12d2 <combine+0x1b2>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    (%rax,%rcx,8),%rdx
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %rdx,(%rax,%rcx,8)
jmp    1291 <combine+0x171>
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
sub    -0x10(%rbp),%rcx
cmp    %rcx,%rax
jae    1323 <combine+0x203>
mov    -0x40(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x30(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    12da <combine+0x1ba>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<combine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r13
lea    (%rdx,%rsi,1),%r14
shr    %r14
mov    %rdx,%r12
sub    %rsi,%r12
lea    0x0(,%r12,8),%rdi
call   1040 <malloc@plt>
mov    %rbx,%r11
xor    %ecx,%ecx
mov    %r14,%rdx
mov    %rbx,%rsi
cmp    %rbx,%r14
jbe    119e <combine+0x7e>
cmp    %r15,%r14
jae    119e <combine+0x7e>
xor    %ecx,%ecx
mov    %r11,%rsi
mov    %r14,%rdx
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rsi,8),%rdi
mov    0x0(%r13,%rdx,8),%rbp
cmp    %rbp,%rdi
sbb    $0xffffffffffffffff,%rdx
cmp    %rbp,%rdi
cmovb  %rdi,%rbp
adc    $0x0,%rsi
mov    %rbp,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %r14,%rsi
jae    119e <combine+0x7e>
cmp    %r15,%rdx
jb     1170 <combine+0x50>
mov    %r14,%r10
sub    %rsi,%r10
jbe    1333 <combine+0x213>
cmp    $0x4,%r10
jb     129e <combine+0x17e>
lea    (%rax,%rcx,8),%rdi
lea    0x0(,%r14,8),%rbp
add    %r13,%rbp
cmp    %rbp,%rdi
jae    11e7 <combine+0xc7>
lea    (%rcx,%r14,1),%rdi
sub    %rsi,%rdi
lea    (%rax,%rdi,8),%rdi
lea    0x0(,%rsi,8),%rbp
add    %r13,%rbp
cmp    %rdi,%rbp
jb     129e <combine+0x17e>
mov    %r10,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdi
mov    %rdi,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdi,%rdi
mov    %r11,(%rsp)
je     1267 <combine+0x147>
mov    %r9,%rbx
and    $0xfffffffffffffffe,%rbx
lea    0x30(,%rsi,8),%r11
add    %r13,%r11
lea    (%rax,%rcx,8),%rbp
add    $0x30,%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x30(%r11,%rdi,8),%xmm0
movups -0x20(%r11,%rdi,8),%xmm1
movups %xmm0,-0x30(%rbp,%rdi,8)
movups %xmm1,-0x20(%rbp,%rdi,8)
movups -0x10(%r11,%rdi,8),%xmm0
movups (%r11,%rdi,8),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,8)
movups %xmm1,0x0(%rbp,%rdi,8)
add    $0x8,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1230 <combine+0x110>
jmp    1269 <combine+0x149>
xor    %edi,%edi
test   $0x1,%r9b
mov    (%rsp),%r11
je     128f <combine+0x16f>
lea    (%rsi,%rdi,1),%rbp
add    %rcx,%rdi
movups 0x0(%r13,%rbp,8),%xmm0
movups 0x10(%r13,%rbp,8),%xmm1
movups %xmm0,(%rax,%rdi,8)
movups %xmm1,0x10(%rax,%rdi,8)
add    %r8,%rcx
cmp    %r8,%r10
je     1333 <combine+0x213>
add    %r8,%rsi
mov    %r14d,%ebx
sub    %esi,%ebx
mov    %rsi,%rdi
not    %rdi
add    %r14,%rdi
and    $0x3,%rbx
je     12d7 <combine+0x1b7>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x0(%r13,%rsi,8),%rbp
add    $0x1,%rsi
mov    %rbp,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rbx
jne    12c0 <combine+0x1a0>
cmp    $0x3,%rdi
jb     1333 <combine+0x213>
sub    %rsi,%r14
lea    0x18(,%rsi,8),%rdi
add    %r13,%rdi
lea    (%rax,%rcx,8),%rbp
add    $0x18,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x18(%rdi,%rsi,8),%rbx
mov    %rbx,-0x18(%rbp,%rsi,8)
mov    -0x10(%rdi,%rsi,8),%rbx
mov    %rbx,-0x10(%rbp,%rsi,8)
mov    -0x8(%rdi,%rsi,8),%rbx
mov    %rbx,-0x8(%rbp,%rsi,8)
mov    (%rdi,%rsi,8),%rbx
mov    %rbx,0x0(%rbp,%rsi,8)
add    $0x4,%rsi
cmp    %rsi,%r14
jne    1300 <combine+0x1e0>
add    %rsi,%rcx
cmp    %r15,%rdx
jae    1461 <combine+0x341>
mov    %r15,%r10
sub    %rdx,%r10
mov    %rcx,%rsi
mov    %rdx,%r9
cmp    $0x4,%r10
jb     142e <combine+0x30e>
lea    (%rax,%rcx,8),%rsi
lea    0x0(,%r15,8),%rdi
add    %r13,%rdi
cmp    %rdi,%rsi
jae    138b <combine+0x26b>
lea    (%rcx,%r15,1),%rsi
sub    %rdx,%rsi
lea    (%rax,%rsi,8),%rdi
lea    0x0(,%rdx,8),%rbp
add    %r13,%rbp
mov    %rcx,%rsi
mov    %rdx,%r9
cmp    %rdi,%rbp
jb     142e <combine+0x30e>
mov    %r10,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rsi
mov    %rsi,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     158e <combine+0x46e>
mov    %r8,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rax,%rcx,8),%rdi
add    $0x30,%rdi
lea    0x30(,%rdx,8),%rsi
add    %r13,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups -0x30(%rsi,%rbx,8),%xmm0
movups -0x20(%rsi,%rbx,8),%xmm1
movups %xmm0,-0x30(%rdi,%rbx,8)
movups %xmm1,-0x20(%rdi,%rbx,8)
movups -0x10(%rsi,%rbx,8),%xmm0
movups (%rsi,%rbx,8),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,8)
movups %xmm1,(%rdi,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rbp
jne    13d0 <combine+0x2b0>
test   $0x1,%r8b
je     1422 <combine+0x302>
lea    (%rcx,%rbx,1),%rsi
add    %rdx,%rbx
movups 0x0(%r13,%rbx,8),%xmm0
movups 0x10(%r13,%rbx,8),%xmm1
movups %xmm0,(%rax,%rsi,8)
movups %xmm1,0x10(%rax,%rsi,8)
cmp    %r9,%r10
je     1461 <combine+0x341>
lea    (%rcx,%r9,1),%rsi
add    %rdx,%r9
add    %r15,%rcx
sub    %rsi,%rcx
sub    %rdx,%rcx
lea    (%rax,%rsi,8),%rdx
lea    0x0(,%r9,8),%rsi
add    %r13,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%rdi,8),%rbp
mov    %rbp,(%rdx,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1450 <combine+0x330>
test   %r12,%r12
je     15b0 <combine+0x490>
lea    0x0(,%r11,8),%rcx
add    %r13,%rcx
cmp    $0x4,%r12
jb     1494 <combine+0x374>
lea    (%rax,%r12,8),%rdx
cmp    %rdx,%rcx
jae    149b <combine+0x37b>
lea    0x0(,%r15,8),%rdx
add    %r13,%rdx
cmp    %rdx,%rax
jae    149b <combine+0x37b>
xor    %edx,%edx
jmp    159f <combine+0x47f>
mov    %r12,%rdx
and    $0xfffffffffffffffc,%rdx
lea    -0x4(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0xc,%rbp
jae    14c3 <combine+0x3a3>
xor    %ebx,%ebx
jmp    1549 <combine+0x429>
movabs $0x7ffffffffffffffe,%rbp
ff ff 7f
add    $0xfffffffffffffffe,%rbp
and    %rbp,%rdi
lea    0x70(,%r11,8),%rbp
add    %r13,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rax,%rbx,8),%xmm0
movups 0x10(%rax,%rbx,8),%xmm1
movups %xmm0,-0x70(%rbp,%rbx,8)
movups %xmm1,-0x60(%rbp,%rbx,8)
movups 0x20(%rax,%rbx,8),%xmm0
movups 0x30(%rax,%rbx,8),%xmm1
movups %xmm0,-0x50(%rbp,%rbx,8)
movups %xmm1,-0x40(%rbp,%rbx,8)
movups 0x40(%rax,%rbx,8),%xmm0
movups 0x50(%rax,%rbx,8),%xmm1
movups %xmm0,-0x30(%rbp,%rbx,8)
movups %xmm1,-0x20(%rbp,%rbx,8)
movups 0x60(%rax,%rbx,8),%xmm0
movups 0x70(%rax,%rbx,8),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,8)
movups %xmm1,0x0(%rbp,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rdi
jne    14f0 <combine+0x3d0>
test   %rsi,%rsi
je     15ab <combine+0x48b>
add    %rbx,%r11
lea    0x10(,%r11,8),%rdi
add    %r13,%rdi
lea    (%rax,%rbx,8),%rbp
add    $0x10,%rbp
shl    $0x5,%rsi
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbp,%rbx,1),%xmm0
movups 0x0(%rbp,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1570 <combine+0x450>
jmp    15ab <combine+0x48b>
xor    %ebx,%ebx
test   $0x1,%r8b
jne    1406 <combine+0x2e6>
jmp    1422 <combine+0x302>
mov    (%rax,%rdx,8),%rsi
mov    %rsi,(%rcx,%rdx,8)
add    $0x1,%rdx
cmp    %rdx,%r12
jne    159f <combine+0x47f>
mov    %rax,%rdi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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