#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*/ printf(char *, int, int, int, int);
void combine(int a[], int temp[], int p, int q, int r, int s) {
  printf("Called combine for %d %d %d %d\n", p, q, r, s);
  int i = p;
  while (p <= q && r <= s) {
    if (a[r] < a[p]) {
      temp[i++] = a[r++];
    } else {
      temp[i++] = a[p++];
    }
  }
  while (p <= q) {
    temp[i++] = a[p++];
  }
  while (r <= s) {
    temp[i++] = a[r++];
  }
}


x86 assembly (clang, -O0):
<combine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9d,-0x20(%rbp)
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%r8d
lea    0xebe(%rip),%rdi
call   1030 <printf@plt>
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x18(%rbp),%ecx
mov    %al,-0x25(%rbp)
jg     116a <combine+0x5a>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
setle  %al
mov    %al,-0x25(%rbp)
mov    -0x25(%rbp),%al
test   $0x1,%al
jne    117a <combine+0x6a>
jmp    11f4 <combine+0xe4>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x14(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11c5 <combine+0xb5>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11ef <combine+0xdf>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    114d <combine+0x3d>
jmp    11f9 <combine+0xe9>
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1234 <combine+0x124>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x14(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11f9 <combine+0xe9>
jmp    1239 <combine+0x129>
mov    -0x1c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1274 <combine+0x164>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1239 <combine+0x129>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<combine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %r9d,%r15d
mov    %r8d,%ebx
mov    %ecx,%r14d
mov    %edx,%r13d
mov    %rsi,%rbp
mov    %rdi,%r12
lea    0xecc(%rip),%rdi
mov    %edx,%esi
mov    %ecx,%edx
mov    %r8d,%ecx
mov    %r9d,%r8d
call   1030 <printf@plt>
cmp    %r14d,%r13d
jg     11a9 <combine+0x99>
cmp    %r15d,%ebx
jg     11a9 <combine+0x99>
movslq %r13d,%rax
mov    %rbp,%r11
lea    0x0(,%rax,4),%rax
add    %rbp,%rax
mov    %r13d,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rbx
mov    (%r12,%rbx,4),%ecx
movslq %edx,%rdx
mov    (%r12,%rdx,4),%esi
xor    %edi,%edi
xor    %ebp,%ebp
cmp    %esi,%ecx
setge  %dil
setl   %bpl
cmovl  %ecx,%esi
add    %ebp,%ebx
add    %edi,%edx
mov    %esi,(%rax)
add    $0x1,%r13d
cmp    %r14d,%edx
jg     11af <combine+0x9f>
add    $0x4,%rax
cmp    %r15d,%ebx
jle    1170 <combine+0x60>
jmp    11af <combine+0x9f>
mov    %r13d,%edx
mov    %rbp,%r11
cmp    %r14d,%edx
jg     131a <combine+0x20a>
movslq %r13d,%r13
movslq %edx,%rax
mov    %r14d,%r10d
sub    %edx,%r10d
cmp    $0x7,%r10d
jb     129e <combine+0x18e>
lea    (%r11,%r13,4),%rcx
lea    (%rax,%r10,1),%rdx
lea    (%r12,%rdx,4),%rdx
add    $0x4,%rdx
cmp    %rdx,%rcx
jae    11fc <combine+0xec>
lea    (%r10,%r13,1),%rcx
lea    (%r11,%rcx,4),%rcx
add    $0x4,%rcx
lea    (%r12,%rax,4),%rdx
cmp    %rcx,%rdx
jb     129e <combine+0x18e>
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     1496 <combine+0x386>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
lea    (%r12,%rax,4),%rdx
add    $0x30,%rdx
lea    (%r11,%r13,4),%rcx
add    $0x30,%rcx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdx,%rdi,4),%xmm0
movups -0x20(%rdx,%rdi,4),%xmm1
movups %xmm0,-0x30(%rcx,%rdi,4)
movups %xmm1,-0x20(%rcx,%rdi,4)
movups -0x10(%rdx,%rdi,4),%xmm0
movups (%rdx,%rdi,4),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,4)
movups %xmm1,(%rcx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1240 <combine+0x130>
test   $0x1,%r9b
je     1293 <combine+0x183>
lea    (%rdi,%rax,1),%rcx
add    %r13,%rdi
movups (%r12,%rcx,4),%xmm0
movups 0x10(%r12,%rcx,4),%xmm1
movups %xmm0,(%r11,%rdi,4)
movups %xmm1,0x10(%r11,%rdi,4)
add    %r8,%r13
cmp    %r8,%r10
je     131a <combine+0x20a>
add    %r8,%rax
mov    %r14d,%ecx
sub    %eax,%ecx
lea    0x1(%rcx),%edx
and    $0x3,%edx
je     12c5 <combine+0x1b5>
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rax,4),%esi
add    $0x1,%rax
mov    %esi,(%r11,%r13,4)
add    $0x1,%r13
add    $0xffffffff,%edx
jne    12b0 <combine+0x1a0>
cmp    $0x3,%ecx
jb     131a <combine+0x20a>
sub    %eax,%r14d
add    $0x1,%r14d
lea    (%r12,%rax,4),%rcx
add    $0xc,%rcx
lea    (%r11,%r13,4),%rdx
add    $0xc,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xc(%rcx,%rax,4),%esi
mov    %esi,-0xc(%rdx,%rax,4)
mov    -0x8(%rcx,%rax,4),%esi
mov    %esi,-0x8(%rdx,%rax,4)
mov    -0x4(%rcx,%rax,4),%esi
mov    %esi,-0x4(%rdx,%rax,4)
mov    (%rcx,%rax,4),%esi
mov    %esi,(%rdx,%rax,4)
add    $0x4,%rax
cmp    %eax,%r14d
jne    12f0 <combine+0x1e0>
add    %rax,%r13
cmp    %r15d,%ebx
jg     1487 <combine+0x377>
movslq %r13d,%rax
movslq %ebx,%rcx
mov    %r15d,%edx
sub    %ebx,%edx
cmp    $0x7,%edx
jb     140e <combine+0x2fe>
lea    (%r11,%rax,4),%rsi
lea    (%rcx,%rdx,1),%rdi
lea    (%r12,%rdi,4),%rdi
add    $0x4,%rdi
cmp    %rdi,%rsi
jae    1365 <combine+0x255>
lea    (%rax,%rdx,1),%rsi
lea    (%r11,%rsi,4),%rsi
add    $0x4,%rsi
lea    (%r12,%rcx,4),%rdi
cmp    %rsi,%rdi
jb     140e <combine+0x2fe>
add    $0x1,%rdx
mov    %rdx,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rsi,%rsi
je     14a7 <combine+0x397>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%r12,%rcx,4),%rsi
add    $0x30,%rsi
lea    (%r11,%rax,4),%rbx
add    $0x30,%rbx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rbp,4),%xmm0
movups -0x20(%rsi,%rbp,4),%xmm1
movups %xmm0,-0x30(%rbx,%rbp,4)
movups %xmm1,-0x20(%rbx,%rbp,4)
movups -0x10(%rsi,%rbp,4),%xmm0
movups (%rsi,%rbp,4),%xmm1
movups %xmm0,-0x10(%rbx,%rbp,4)
movups %xmm1,(%rbx,%rbp,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rdi
jne    13b0 <combine+0x2a0>
test   $0x1,%r9b
je     1403 <combine+0x2f3>
lea    (%rcx,%rbp,1),%rsi
add    %rax,%rbp
movups (%r12,%rsi,4),%xmm0
movups 0x10(%r12,%rsi,4),%xmm1
movups %xmm0,(%r11,%rbp,4)
movups %xmm1,0x10(%r11,%rbp,4)
cmp    %r8,%rdx
je     1487 <combine+0x377>
add    %r8,%rcx
add    %r8,%rax
mov    %r15d,%edx
sub    %ecx,%edx
lea    0x1(%rdx),%esi
and    $0x3,%esi
je     1435 <combine+0x325>
nopl   0x0(%rax,%rax,1)
mov    (%r12,%rcx,4),%edi
add    $0x1,%rcx
mov    %edi,(%r11,%rax,4)
add    $0x1,%rax
add    $0xffffffff,%esi
jne    1420 <combine+0x310>
cmp    $0x3,%edx
jb     1487 <combine+0x377>
sub    %ecx,%r15d
add    $0x1,%r15d
lea    (%r12,%rcx,4),%rcx
add    $0xc,%rcx
lea    (%r11,%rax,4),%rax
add    $0xc,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0xc(%rcx,%rdx,4),%esi
mov    %esi,-0xc(%rax,%rdx,4)
mov    -0x8(%rcx,%rdx,4),%esi
mov    %esi,-0x8(%rax,%rdx,4)
mov    -0x4(%rcx,%rdx,4),%esi
mov    %esi,-0x4(%rax,%rdx,4)
mov    (%rcx,%rdx,4),%esi
mov    %esi,(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %edx,%r15d
jne    1460 <combine+0x350>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    1276 <combine+0x166>
jmp    1293 <combine+0x183>
xor    %ebp,%ebp
test   $0x1,%r9b
jne    13e6 <combine+0x2d6>
jmp    1403 <combine+0x2f3>

LLVM IR (-O0):
@.str = [32 x i8] c"Called combine for %d %d %d %d\0A\00"
define void @combine(i32* %0, i32* %1, i32 %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = 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 %5, i32* %12
%14 = load i32, i32* %9
%15 = load i32, i32* %10
%16 = load i32, i32* %11
%17 = load i32, i32* %12
%18 = call i32 @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str, i64 0, i64 0), i32 %14, i32 %15, i32 %16, i32 %17)
%19 = load i32, i32* %9
store i32 %19, i32* %13
br label %20
20: ; preds = %66, %6
%21 = load i32, i32* %9
%22 = load i32, i32* %10
%23 = icmp sle i32 %21, %22
br i1 %23, label %24, label %28
24: ; preds = %20
%25 = load i32, i32* %11
%26 = load i32, i32* %12
%27 = icmp sle i32 %25, %26
br label %28
28: ; preds = %24, %20
%29 = phi i1 [ false, %20 ], [ %27, %24 ]
br i1 %29, label %30, label %67
30: ; preds = %28
%31 = load i32*, i32** %7
%32 = load i32, i32* %11
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i32, i32* %31, i64 %33
%35 = load i32, i32* %34
%36 = load i32*, i32** %7
%37 = load i32, i32* %9
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %36, i64 %38
%40 = load i32, i32* %39
%41 = icmp slt i32 %35, %40
br i1 %41, label %42, label %54
42: ; preds = %30
%43 = load i32*, i32** %7
%44 = load i32, i32* %11
%45 = add nsw i32 %44, 1
store i32 %45, i32* %11
%46 = sext i32 %44 to i64
%47 = getelementptr inbounds i32, i32* %43, i64 %46
%48 = load i32, i32* %47
%49 = load i32*, i32** %8
%50 = load i32, i32* %13
%51 = add nsw i32 %50, 1
store i32 %51, i32* %13
%52 = sext i32 %50 to i64
%53 = getelementptr inbounds i32, i32* %49, i64 %52
store i32 %48, i32* %53
br label %66
54: ; preds = %30
%55 = load i32*, i32** %7
%56 = load i32, i32* %9
%57 = add nsw i32 %56, 1
store i32 %57, i32* %9
%58 = sext i32 %56 to i64
%59 = getelementptr inbounds i32, i32* %55, i64 %58
%60 = load i32, i32* %59
%61 = load i32*, i32** %8
%62 = load i32, i32* %13
%63 = add nsw i32 %62, 1
store i32 %63, i32* %13
%64 = sext i32 %62 to i64
%65 = getelementptr inbounds i32, i32* %61, i64 %64
store i32 %60, i32* %65
br label %66
66: ; preds = %54, %42
br label %20
67: ; preds = %28
br label %68
68: ; preds = %72, %67
%69 = load i32, i32* %9
%70 = load i32, i32* %10
%71 = icmp sle i32 %69, %70
br i1 %71, label %72, label %84
72: ; preds = %68
%73 = load i32*, i32** %7
%74 = load i32, i32* %9
%75 = add nsw i32 %74, 1
store i32 %75, i32* %9
%76 = sext i32 %74 to i64
%77 = getelementptr inbounds i32, i32* %73, i64 %76
%78 = load i32, i32* %77
%79 = load i32*, i32** %8
%80 = load i32, i32* %13
%81 = add nsw i32 %80, 1
store i32 %81, i32* %13
%82 = sext i32 %80 to i64
%83 = getelementptr inbounds i32, i32* %79, i64 %82
store i32 %78, i32* %83
br label %68
84: ; preds = %68
br label %85
85: ; preds = %89, %84
%86 = load i32, i32* %11
%87 = load i32, i32* %12
%88 = icmp sle i32 %86, %87
br i1 %88, label %89, label %101
89: ; preds = %85
%90 = load i32*, i32** %7
%91 = load i32, i32* %11
%92 = add nsw i32 %91, 1
store i32 %92, i32* %11
%93 = sext i32 %91 to i64
%94 = getelementptr inbounds i32, i32* %90, i64 %93
%95 = load i32, i32* %94
%96 = load i32*, i32** %8
%97 = load i32, i32* %13
%98 = add nsw i32 %97, 1
store i32 %98, i32* %13
%99 = sext i32 %97 to i64
%100 = getelementptr inbounds i32, i32* %96, i64 %99
store i32 %95, i32* %100
br label %85
101: ; preds = %85
ret void
}

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