#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 */
scalar_t__ malloc(int);
int *mergeSorted(int *a1, int l1, int *a2, int l2, int order,
                 int (*compare)(int, int)) {
  int *a = (int *)malloc((l1 + l2) * sizeof(int)), i = 0, j = 0, k = 0;
  while (i < l1 && j < l2)
    if (compare(a1[i], a2[j]) == order)
      a[k++] = a1[i++];
    else
      a[k++] = a2[j++];
  while (i < l1)
    a[k++] = a1[i++];
  while (j < l2)
    a[k++] = a2[j++];
  return a;
}


x86 assembly (clang, -O0):
<mergeSorted>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0xc(%rbp),%eax
add    -0x1c(%rbp),%eax
cltq
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x34(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x3d(%rbp)
jge    1177 <mergeSorted+0x67>
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setl   %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    1187 <mergeSorted+0x77>
jmp    120a <mergeSorted+0xfa>
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x34(%rbp),%rdx
mov    (%rcx,%rdx,4),%edi
mov    -0x18(%rbp),%rcx
movslq -0x38(%rbp),%rdx
mov    (%rcx,%rdx,4),%esi
call   *%rax
cmp    -0x20(%rbp),%eax
jne    11db <mergeSorted+0xcb>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1205 <mergeSorted+0xf5>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    115a <mergeSorted+0x4a>
jmp    120f <mergeSorted+0xff>
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    124a <mergeSorted+0x13a>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x34(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    120f <mergeSorted+0xff>
jmp    124f <mergeSorted+0x13f>
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128a <mergeSorted+0x17a>
mov    -0x18(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x38(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    124f <mergeSorted+0x13f>
mov    -0x30(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mergeSorted>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,0x30(%rsp)
mov    %r8d,0x24(%rsp)
mov    %ecx,%r12d
mov    %rdx,%rbx
mov    %esi,%ebp
mov    %rdi,%r13
lea    (%r12,%rbp,1),%edi
shl    $0x2,%edi
call   1030 <malloc@plt>
mov    %rax,%r14
xor    %edx,%edx
test   %ebp,%ebp
mov    %rbx,0x10(%rsp)
jle    12c6 <mergeSorted+0x1b6>
mov    $0x0,%ecx
mov    $0x0,%ebx
test   %r12d,%r12d
jle    11ef <mergeSorted+0xdf>
xor    %ebx,%ebx
xor    %ecx,%ecx
xor    %edx,%edx
mov    %r12,0x28(%rsp)
mov    %rbp,0x8(%rsp)
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %rbx,0x18(%rsp)
mov    %edx,%r12d
mov    %ecx,%ebp
mov    %edx,%eax
mov    %r14,%rbx
lea    0x0(%r13,%rax,4),%r14
mov    0x0(%r13,%rax,4),%edi
mov    %ecx,%eax
mov    0x10(%rsp),%rcx
mov    %r13,%r15
lea    (%rcx,%rax,4),%r13
mov    (%rcx,%rax,4),%esi
call   *0x30(%rsp)
xor    %ecx,%ecx
xor    %edx,%edx
cmp    0x24(%rsp),%eax
setne  %cl
sete   %dl
cmove  %r14,%r13
mov    %rbx,%r14
mov    0x18(%rsp),%rbx
add    %r12d,%edx
add    %ebp,%ecx
mov    0x0(%r13),%eax
mov    %r15,%r13
mov    0x8(%rsp),%rbp
mov    0x28(%rsp),%r12
mov    %eax,(%r14,%rbx,4)
add    $0x1,%rbx
cmp    %ebp,%edx
jge    11ef <mergeSorted+0xdf>
cmp    %r12d,%ecx
jl     1180 <mergeSorted+0x70>
cmp    %ebp,%edx
jge    12d2 <mergeSorted+0x1c2>
mov    %ebx,%ebx
movslq %edx,%rdx
movslq %ebp,%r11
mov    %r11,%r10
sub    %rdx,%r10
cmp    $0x8,%r10
mov    0x10(%rsp),%r8
jb     131b <mergeSorted+0x20b>
lea    (%r14,%rbx,4),%rax
lea    0x0(,%r11,4),%rsi
add    %r13,%rsi
cmp    %rsi,%rax
jae    1247 <mergeSorted+0x137>
lea    (%r11,%rbx,1),%rax
sub    %rdx,%rax
lea    (%r14,%rax,4),%rax
lea    0x0(,%rdx,4),%rsi
add    %r13,%rsi
cmp    %rax,%rsi
jb     131b <mergeSorted+0x20b>
mov    %r10,%rsi
and    $0xfffffffffffffff8,%rsi
lea    -0x8(%rsi),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
mov    %rbp,0x8(%rsp)
mov    %rsi,0x18(%rsp)
je     12dc <mergeSorted+0x1cc>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x30(,%rdx,4),%r15
add    %r13,%r15
lea    (%r14,%rbx,4),%rax
add    $0x30,%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x30(%r15,%rdi,4),%xmm0
movups -0x20(%r15,%rdi,4),%xmm1
movups %xmm0,-0x30(%rax,%rdi,4)
movups %xmm1,-0x20(%rax,%rdi,4)
movups -0x10(%r15,%rdi,4),%xmm0
movups (%r15,%rdi,4),%xmm1
movups %xmm0,-0x10(%rax,%rdi,4)
movups %xmm1,(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1290 <mergeSorted+0x180>
jmp    12de <mergeSorted+0x1ce>
xor    %ecx,%ecx
xor    %ebx,%ebx
cmp    %ebp,%edx
jl     11f7 <mergeSorted+0xe7>
mov    0x10(%rsp),%r8
jmp    139a <mergeSorted+0x28a>
xor    %edi,%edi
test   $0x1,%r9b
mov    0x8(%rsp),%rbp
je     1307 <mergeSorted+0x1f7>
lea    (%rdi,%rdx,1),%rax
add    %rbx,%rdi
movups 0x0(%r13,%rax,4),%xmm0
movups 0x10(%r13,%rax,4),%xmm1
movups %xmm0,(%r14,%rdi,4)
movups %xmm1,0x10(%r14,%rdi,4)
mov    0x18(%rsp),%rax
add    %rax,%rbx
cmp    %rax,%r10
je     139a <mergeSorted+0x28a>
add    %rax,%rdx
sub    %edx,%ebp
mov    %rdx,%rsi
not    %rsi
add    %r11,%rsi
and    $0x3,%rbp
je     1347 <mergeSorted+0x237>
nopl   0x0(%rax)
mov    0x0(%r13,%rdx,4),%eax
add    $0x1,%rdx
mov    %eax,(%r14,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rbp
jne    1330 <mergeSorted+0x220>
cmp    $0x3,%rsi
jb     139a <mergeSorted+0x28a>
sub    %rdx,%r11
lea    0xc(,%rdx,4),%rdx
add    %r13,%rdx
lea    (%r14,%rbx,4),%rsi
add    $0xc,%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0xc(%rdx,%rax,4),%edi
mov    %edi,-0xc(%rsi,%rax,4)
mov    -0x8(%rdx,%rax,4),%edi
mov    %edi,-0x8(%rsi,%rax,4)
mov    -0x4(%rdx,%rax,4),%edi
mov    %edi,-0x4(%rsi,%rax,4)
mov    (%rdx,%rax,4),%edi
mov    %edi,(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    1370 <mergeSorted+0x260>
add    %rax,%rbx
cmp    %r12d,%ecx
jge    14f7 <mergeSorted+0x3e7>
mov    %ebx,%edx
movslq %ecx,%rcx
movslq %r12d,%r11
mov    %r11,%r10
sub    %rcx,%r10
cmp    $0x8,%r10
jb     147e <mergeSorted+0x36e>
lea    (%r14,%rdx,4),%rsi
lea    (%r8,%r11,4),%rdi
cmp    %rdi,%rsi
jae    13e0 <mergeSorted+0x2d0>
lea    (%r11,%rdx,1),%rsi
sub    %rcx,%rsi
lea    (%r14,%rsi,4),%rsi
lea    (%r8,%rcx,4),%rdi
cmp    %rsi,%rdi
jb     147e <mergeSorted+0x36e>
mov    %r10,%rbp
and    $0xfffffffffffffff8,%rbp
lea    -0x8(%rbp),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     1509 <mergeSorted+0x3f9>
mov    %r9,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r8,%rcx,4),%rdi
add    $0x30,%rdi
lea    (%r14,%rdx,4),%rsi
add    $0x30,%rsi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdi,%rbx,4),%xmm0
movups -0x20(%rdi,%rbx,4),%xmm1
movups %xmm0,-0x30(%rsi,%rbx,4)
movups %xmm1,-0x20(%rsi,%rbx,4)
movups -0x10(%rdi,%rbx,4),%xmm0
movups (%rdi,%rbx,4),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,4)
movups %xmm1,(%rsi,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    1420 <mergeSorted+0x310>
test   $0x1,%r9b
je     1473 <mergeSorted+0x363>
lea    (%rbx,%rcx,1),%rsi
add    %rdx,%rbx
movups (%r8,%rsi,4),%xmm0
movups 0x10(%r8,%rsi,4),%xmm1
movups %xmm0,(%r14,%rbx,4)
movups %xmm1,0x10(%r14,%rbx,4)
cmp    %rbp,%r10
je     14f7 <mergeSorted+0x3e7>
add    %rbp,%rcx
add    %rbp,%rdx
sub    %ecx,%r12d
mov    %rcx,%rsi
not    %rsi
add    %r11,%rsi
and    $0x3,%r12
je     14a6 <mergeSorted+0x396>
mov    (%r8,%rcx,4),%edi
add    $0x1,%rcx
mov    %edi,(%r14,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%r12
jne    1490 <mergeSorted+0x380>
cmp    $0x3,%rsi
jb     14f7 <mergeSorted+0x3e7>
sub    %rcx,%r11
lea    (%r8,%rcx,4),%rcx
add    $0xc,%rcx
lea    (%r14,%rdx,4),%rdx
add    $0xc,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0xc(%rcx,%rsi,4),%edi
mov    %edi,-0xc(%rdx,%rsi,4)
mov    -0x8(%rcx,%rsi,4),%edi
mov    %edi,-0x8(%rdx,%rsi,4)
mov    -0x4(%rcx,%rsi,4),%edi
mov    %edi,-0x4(%rdx,%rsi,4)
mov    (%rcx,%rsi,4),%edi
mov    %edi,(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r11
jne    14d0 <mergeSorted+0x3c0>
mov    %r14,%rax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
test   $0x1,%r9b
jne    1456 <mergeSorted+0x346>
jmp    1473 <mergeSorted+0x363>

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

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