int Length(int s[], int i) {
  int seq[20], t, j, k, b, m, c;
  int count = 0;
  for (j = 0; j < i; j++) {
    count = 0;
    for (b = 1; b < i && b > j; b++) {
      c = 0;
      for (m = 1; m < b - j + 1; m++) {
        if (s[b] > s[b - m])
          c = c + 1;
      }
      if (s[j] < s[b] && c == b - j)
        count = count + 1;
      else
        continue;
    }
    seq[j] = count + 1;
  }
  int a;
  int num = 0;
  for (t = 0; t < i; t++) {
    num = 0;
    for (k = 0; k < i; k++) {
      if (seq[t] >= seq[k])
        num = num + 1;
    }
    if (num == i)
      a = seq[t];
  }
  return a;
}


x86 assembly (clang, -O0):
<Length>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x7c(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    123b <Length+0x13b>
movl   $0x0,-0x7c(%rbp)
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%ecx
xor    %eax,%eax
cmp    -0xc(%rbp),%ecx
mov    %al,-0x85(%rbp)
jge    115a <Length+0x5a>
mov    -0x70(%rbp),%eax
cmp    -0x68(%rbp),%eax
setg   %al
mov    %al,-0x85(%rbp)
mov    -0x85(%rbp),%al
test   $0x1,%al
jne    116d <Length+0x6d>
jmp    121f <Length+0x11f>
movl   $0x0,-0x78(%rbp)
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x70(%rbp),%ecx
sub    -0x68(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    11cc <Length+0xcc>
mov    -0x8(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x70(%rbp),%edx
sub    -0x74(%rbp),%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jle    11b9 <Length+0xb9>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    11be <Length+0xbe>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    117b <Length+0x7b>
mov    -0x8(%rbp),%rax
movslq -0x68(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1207 <Length+0x107>
mov    -0x78(%rbp),%eax
mov    -0x70(%rbp),%ecx
sub    -0x68(%rbp),%ecx
cmp    %ecx,%eax
jne    1207 <Length+0x107>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    120c <Length+0x10c>
jmp    1211 <Length+0x111>
jmp    1211 <Length+0x111>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1137 <Length+0x37>
mov    -0x7c(%rbp),%ecx
add    $0x1,%ecx
movslq -0x68(%rbp),%rax
mov    %ecx,-0x60(%rbp,%rax,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    111d <Length+0x1d>
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12da <Length+0x1da>
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12ad <Length+0x1ad>
movslq -0x64(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
movslq -0x6c(%rbp),%rcx
cmp    -0x60(%rbp,%rcx,4),%eax
jl     129a <Length+0x19a>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    129f <Length+0x19f>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1269 <Length+0x169>
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    12c7 <Length+0x1c7>
movslq -0x64(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%eax
mov    %eax,-0x80(%rbp)
jmp    12cc <Length+0x1cc>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    124c <Length+0x14c>
mov    -0x80(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Length>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
test   %esi,%esi
jle    14c8 <Length+0x3c8>
mov    %rdi,%r12
mov    %esi,%r14d
lea    -0xc(%rdi),%rax
mov    %rax,-0x58(%rsp)
lea    0x4(%rdi),%rax
mov    %rax,-0x60(%rsp)
movl   $0x2,-0x7c(%rsp)
xor    %eax,%eax
mov    %rax,-0x78(%rsp)
mov    %r14,-0x68(%rsp)
mov    %esi,-0x6c(%rsp)
mov    %rdi,-0x50(%rsp)
jmp    1179 <Length+0x79>
nopl   (%rax)
add    $0x1,%r13d
mov    -0x78(%rsp),%rax
mov    %r13d,-0x40(%rsp,%rax,4)
add    $0x1,%rax
addl   $0xffffffff,-0x7c(%rsp)
mov    %rax,-0x78(%rsp)
cmp    %r14,%rax
mov    -0x6c(%rsp),%esi
je     137a <Length+0x27a>
mov    $0x0,%r13d
cmp    $0x1,%esi
je     1150 <Length+0x50>
mov    $0x0,%r13d
cmpq   $0x0,-0x78(%rsp)
jne    1150 <Length+0x50>
mov    $0x2,%eax
sub    -0x78(%rsp),%eax
mov    %rax,-0x48(%rsp)
mov    (%r12),%edi
mov    $0x1,%eax
xor    %r15d,%r15d
mov    -0x60(%rsp),%rbp
mov    -0x58(%rsp),%rcx
mov    -0x7c(%rsp),%r11d
xor    %r13d,%r13d
jmp    11f5 <Length+0xf5>
mov    -0x68(%rsp),%r14
cmp    %r8d,%edi
setl   %bl
cmp    %eax,%esi
sete   %dl
and    %bl,%dl
movzbl %dl,%edx
add    %edx,%r13d
add    $0x1,%rax
add    $0x1,%r11d
add    $0x1,%r15d
add    $0x4,%rcx
add    $0x4,%rbp
cmp    %r14,%rax
jae    1150 <Length+0x50>
mov    %r11d,%r9d
lea    -0x1(%r9),%rdx
mov    (%r12,%rax,4),%r8d
mov    $0x1,%r10d
mov    $0x0,%esi
cmp    $0x8,%rdx
jb     134c <Length+0x24c>
mov    -0x48(%rsp),%rsi
add    %r15d,%esi
add    $0xfffffffffffffff7,%rsi
mov    %rsi,%r12
shr    $0x3,%r12
add    $0x1,%r12
movd   %r8d,%xmm0
pshufd $0x0,%xmm0,%xmm0
cmp    $0x8,%rsi
jae    1250 <Length+0x150>
pxor   %xmm1,%xmm1
xor    %r14d,%r14d
pxor   %xmm2,%xmm2
jmp    12dc <Length+0x1dc>
nopl   0x0(%rax)
lea    -0x9(%r9),%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
and    $0xfffffffffffffffe,%rbx
pxor   %xmm1,%xmm1
xor    %r14d,%r14d
pxor   %xmm2,%xmm2
nopl   0x0(%rax,%rax,1)
movdqu -0x30(%rcx,%r14,4),%xmm3
movdqu -0x20(%rcx,%r14,4),%xmm4
movdqu -0x10(%rcx,%r14,4),%xmm5
movdqu (%rcx,%r14,4),%xmm6
pshufd $0x1b,%xmm6,%xmm6
pshufd $0x1b,%xmm5,%xmm5
movdqa %xmm0,%xmm7
pcmpgtd %xmm6,%xmm7
psubd  %xmm7,%xmm1
movdqa %xmm0,%xmm6
pcmpgtd %xmm5,%xmm6
psubd  %xmm6,%xmm2
pshufd $0x1b,%xmm4,%xmm4
pshufd $0x1b,%xmm3,%xmm3
movdqa %xmm0,%xmm5
pcmpgtd %xmm4,%xmm5
psubd  %xmm5,%xmm1
movdqa %xmm0,%xmm4
pcmpgtd %xmm3,%xmm4
psubd  %xmm4,%xmm2
add    $0xfffffffffffffff0,%r14
add    $0xfffffffffffffffe,%rbx
jne    1270 <Length+0x170>
neg    %r14
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
test   $0x1,%r12b
mov    -0x50(%rsp),%r12
je     1320 <Length+0x220>
not    %r14
add    %rax,%r14
movdqu -0x1c(%r12,%r14,4),%xmm3
movdqu -0xc(%r12,%r14,4),%xmm4
pshufd $0x1b,%xmm4,%xmm4
pshufd $0x1b,%xmm3,%xmm3
movdqa %xmm0,%xmm5
pcmpgtd %xmm4,%xmm5
psubd  %xmm5,%xmm1
pcmpgtd %xmm3,%xmm0
psubd  %xmm0,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%esi
cmp    %r10,%rdx
je     11c0 <Length+0xc0>
or     $0x1,%r10
mov    -0x68(%rsp),%r14
neg    %r9
neg    %r10
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebx,%ebx
cmp    0x0(%rbp,%r10,4),%r8d
setg   %bl
add    %ebx,%esi
add    $0xffffffffffffffff,%r10
cmp    %r10,%r9
jne    1360 <Length+0x260>
jmp    11c5 <Length+0xc5>
test   %esi,%esi
jle    14c8 <Length+0x3c8>
mov    %r14d,%r11d
and    $0xfffffff8,%r11d
lea    -0x8(%r11),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
xor    %ebx,%ebx
pcmpeqd %xmm8,%xmm8
movdqa 0xc52(%rip),%xmm1
jmp    13bd <Length+0x2bd>
add    $0x1,%rbx
cmp    %r14,%rbx
je     14c8 <Length+0x3c8>
mov    -0x40(%rsp,%rbx,4),%ebp
cmp    $0x8,%esi
jae    13d0 <Length+0x2d0>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    1490 <Length+0x390>
nop
movd   %ebp,%xmm2
pshufd $0x0,%xmm2,%xmm2
test   %r9,%r9
je     14b6 <Length+0x3b6>
pxor   %xmm5,%xmm5
mov    %r8,%rdx
xor    %ecx,%ecx
pxor   %xmm6,%xmm6
nop
movdqa -0x40(%rsp,%rcx,4),%xmm7
movdqa -0x30(%rsp,%rcx,4),%xmm0
movdqa -0x20(%rsp,%rcx,4),%xmm3
movdqa -0x10(%rsp,%rcx,4),%xmm4
pcmpgtd %xmm2,%xmm7
paddd  %xmm5,%xmm7
pcmpgtd %xmm2,%xmm0
paddd  %xmm6,%xmm0
pcmpgtd %xmm2,%xmm3
pcmpgtd %xmm2,%xmm4
paddd  %xmm1,%xmm3
paddd  %xmm7,%xmm3
paddd  %xmm1,%xmm4
paddd  %xmm0,%xmm4
add    $0x10,%rcx
movdqa %xmm3,%xmm5
movdqa %xmm4,%xmm6
add    $0xfffffffffffffffe,%rdx
jne    13f0 <Length+0x2f0>
test   $0x1,%r10b
je     146e <Length+0x36e>
movdqa -0x40(%rsp,%rcx,4),%xmm0
movdqa -0x30(%rsp,%rcx,4),%xmm5
pcmpgtd %xmm2,%xmm0
paddd  %xmm0,%xmm3
pcmpgtd %xmm2,%xmm5
paddd  %xmm5,%xmm4
psubd  %xmm8,%xmm3
psubd  %xmm8,%xmm4
paddd  %xmm4,%xmm3
pshufd $0xee,%xmm3,%xmm0
paddd  %xmm3,%xmm0
pshufd $0x55,%xmm0,%xmm2
paddd  %xmm0,%xmm2
movd   %xmm2,%edx
mov    %r11,%rcx
cmp    %r14,%r11
je     14a5 <Length+0x3a5>
xor    %edi,%edi
cmp    -0x40(%rsp,%rcx,4),%ebp
setge  %dil
add    %edi,%edx
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1490 <Length+0x390>
cmp    %esi,%edx
jne    13b0 <Length+0x2b0>
mov    -0x40(%rsp,%rbx,4),%eax
jmp    13b0 <Length+0x2b0>
pxor   %xmm3,%xmm3
xor    %ecx,%ecx
pxor   %xmm4,%xmm4
test   $0x1,%r10b
jne    1448 <Length+0x348>
jmp    146e <Length+0x36e>
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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