#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__ alloca(int);
int lis(int *a, int N) {
  int *best, *prev, i, j, max = 0;
  best = (int *)alloca(sizeof(int) * N);
  prev = (int *)alloca(sizeof(int) * N);
  for (i = 0; i < N; i++)
    best[i] = 1, prev[i] = i;
  for (i = 1; i < N; i++)
    for (j = 0; j < i; j++)
      if (a[i] > a[j] && best[i] < best[j] + 1)
        best[i] = best[j] + 1, prev[i] = j;
  for (i = 0; i < N; i++)
    if (max < best[i])
      max = best[i];
  return max;
}


x86 assembly (clang, -O0):
<lis>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x2c(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <alloca@plt>
mov    %rax,-0x18(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <alloca@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    118a <lis+0x7a>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1153 <lis+0x43>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    123a <lis+0x12a>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1227 <lis+0x117>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x28(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    1214 <lis+0x104>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x28(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1214 <lis+0x104>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1219 <lis+0x109>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a4 <lis+0x94>
jmp    122c <lis+0x11c>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1191 <lis+0x81>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1282 <lis+0x172>
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    126f <lis+0x15f>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
jmp    1274 <lis+0x164>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1241 <lis+0x131>
mov    -0x2c(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<lis>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %esi,%r14d
mov    %rdi,%rbx
lea    0x0(,%r14,4),%ebp
mov    %ebp,%edi
call   1030 <alloca@plt>
mov    %rax,%r15
mov    %ebp,%edi
call   1030 <alloca@plt>
test   %r14d,%r14d
jle    132b <lis+0x21b>
mov    %r14d,%ecx
cmp    $0x8,%r14d
jb     1162 <lis+0x52>
lea    (%rax,%rcx,4),%rdx
cmp    %rdx,%r15
jae    11e9 <lis+0xd9>
lea    (%r15,%rcx,4),%rdx
cmp    %rdx,%rax
jae    11e9 <lis+0xd9>
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
mov    %rcx,%rdi
and    $0x3,%rdi
je     1195 <lis+0x85>
cs nopw 0x0(%rax,%rax,1)
movl   $0x1,(%r15,%rdx,4)
mov    %edx,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1180 <lis+0x70>
cmp    $0x3,%rsi
jb     12d3 <lis+0x1c3>
nop
movl   $0x1,(%r15,%rdx,4)
mov    %edx,(%rax,%rdx,4)
movl   $0x1,0x4(%r15,%rdx,4)
lea    0x1(%rdx),%esi
mov    %esi,0x4(%rax,%rdx,4)
movl   $0x1,0x8(%r15,%rdx,4)
lea    0x2(%rdx),%esi
mov    %esi,0x8(%rax,%rdx,4)
movl   $0x1,0xc(%r15,%rdx,4)
lea    0x3(%rdx),%esi
mov    %esi,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rcx,%rdx
jne    11a0 <lis+0x90>
jmp    12d3 <lis+0x1c3>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     1494 <lis+0x384>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0xdeb(%rip),%xmm0
xor    %edi,%edi
movdqa 0xdf1(%rip),%xmm1
movdqa 0xdf9(%rip),%xmm2
movdqa 0xe01(%rip),%xmm3
movdqa 0xe09(%rip),%xmm4
movdqa 0xe11(%rip),%xmm5
nop
movdqa %xmm0,%xmm6
paddd  %xmm1,%xmm6
movdqu %xmm2,(%r15,%rdi,4)
movdqu %xmm2,0x10(%r15,%rdi,4)
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm6,0x10(%rax,%rdi,4)
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
movdqa %xmm0,%xmm7
paddd  %xmm4,%xmm7
movdqu %xmm2,0x20(%r15,%rdi,4)
movdqu %xmm2,0x30(%r15,%rdi,4)
movdqu %xmm6,0x20(%rax,%rdi,4)
movdqu %xmm7,0x30(%rax,%rdi,4)
add    $0x10,%rdi
paddd  %xmm5,%xmm0
add    $0xfffffffffffffffe,%rsi
jne    1240 <lis+0x130>
test   $0x1,%bpl
je     12ca <lis+0x1ba>
movdqa 0xd6a(%rip),%xmm1
paddd  %xmm0,%xmm1
movdqa 0xd6e(%rip),%xmm2
movdqu %xmm2,(%r15,%rdi,4)
movdqu %xmm2,0x10(%r15,%rdi,4)
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm1,0x10(%rax,%rdi,4)
cmp    %rcx,%rdx
jne    1164 <lis+0x54>
cmp    $0x2,%r14d
jl     1317 <lis+0x207>
mov    $0x1,%edx
jmp    12e9 <lis+0x1d9>
add    $0x1,%rdx
cmp    %rcx,%rdx
je     1317 <lis+0x207>
xor    %esi,%esi
jmp    12f9 <lis+0x1e9>
nopl   (%rax)
add    $0x1,%rsi
cmp    %rsi,%rdx
je     12e0 <lis+0x1d0>
mov    (%rbx,%rdx,4),%edi
cmp    (%rbx,%rsi,4),%edi
jle    12f0 <lis+0x1e0>
mov    (%r15,%rsi,4),%edi
cmp    %edi,(%r15,%rdx,4)
jg     12f0 <lis+0x1e0>
add    $0x1,%edi
mov    %edi,(%r15,%rdx,4)
mov    %esi,(%rax,%rdx,4)
jmp    12f0 <lis+0x1e0>
test   %r14d,%r14d
jle    132b <lis+0x21b>
cmp    $0x8,%r14d
jae    1332 <lis+0x222>
xor    %edx,%edx
xor    %eax,%eax
jmp    1460 <lis+0x350>
xor    %eax,%eax
jmp    1472 <lis+0x362>
mov    %ecx,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rsi,%rsi
je     147d <lis+0x36d>
mov    %rax,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
movdqu (%r15,%rsi,4),%xmm2
movdqu 0x10(%r15,%rsi,4),%xmm3
movdqu 0x20(%r15,%rsi,4),%xmm4
movdqu 0x30(%r15,%rsi,4),%xmm5
movdqa %xmm0,%xmm6
pcmpgtd %xmm2,%xmm6
pand   %xmm6,%xmm0
pandn  %xmm2,%xmm6
por    %xmm0,%xmm6
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm1,%xmm2
movdqa %xmm6,%xmm0
pcmpgtd %xmm4,%xmm0
pand   %xmm0,%xmm6
pandn  %xmm4,%xmm0
por    %xmm6,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm5,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm5,%xmm1
por    %xmm2,%xmm1
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1360 <lis+0x250>
test   $0x1,%al
je     140e <lis+0x2fe>
movdqu (%r15,%rsi,4),%xmm2
movdqu 0x10(%r15,%rsi,4),%xmm3
movdqa %xmm0,%xmm4
pcmpgtd %xmm2,%xmm4
pand   %xmm4,%xmm0
pandn  %xmm2,%xmm4
por    %xmm4,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm3,%xmm2
por    %xmm2,%xmm1
movdqa %xmm0,%xmm2
pcmpgtd %xmm1,%xmm2
pand   %xmm2,%xmm0
pandn  %xmm1,%xmm2
por    %xmm0,%xmm2
pshufd $0xee,%xmm2,%xmm0
movdqa %xmm2,%xmm1
pcmpgtd %xmm0,%xmm1
pand   %xmm1,%xmm2
pandn  %xmm0,%xmm1
por    %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%eax
cmp    %rcx,%rdx
je     1472 <lis+0x362>
nopl   (%rax)
mov    (%r15,%rdx,4),%esi
cmp    %esi,%eax
cmovl  %esi,%eax
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1460 <lis+0x350>
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%al
jne    13d9 <lis+0x2c9>
jmp    140e <lis+0x2fe>
movdqa 0xb64(%rip),%xmm0
xor    %edi,%edi
test   $0x1,%bpl
jne    129e <lis+0x18e>
jmp    12ca <lis+0x1ba>

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

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