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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
int strlen(char *);
int longestPalindromeSubseq(char *s) {
  int len, *dp, i, j, n, t, ret = 0;
  if (!(s && *s))
    return 0;
  len = strlen(s);
  dp = (int *)malloc(len * sizeof(int));
  for (i = 0; i < len; ++i)
    dp[i] = 1;
  for (i = len - 1; i >= 0; --i) {
    n = 0;
    for (j = i + 1; j < len; ++j) {
      t = dp[j];
      if (s[i] == s[j])
        dp[j] = n + 2;
      n = ((n) > (t) ? (n) : (t));
    }
  }
  for (i = 0; i < len; ++i)
    ret = ((ret) > (dp[i]) ? (ret) : (dp[i]));
  free(dp);
  return ret;
}


x86 assembly (clang, -O0):
<longestPalindromeSubseq>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x0,-0x34(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     115e <longestPalindromeSubseq+0x2e>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    116a <longestPalindromeSubseq+0x3a>
movl   $0x0,-0x4(%rbp)
jmp    12ce <longestPalindromeSubseq+0x19e>
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x14(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11b9 <longestPalindromeSubseq+0x89>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1190 <longestPalindromeSubseq+0x60>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jl     126b <longestPalindromeSubseq+0x13b>
movl   $0x0,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1258 <longestPalindromeSubseq+0x128>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1227 <longestPalindromeSubseq+0xf7>
mov    -0x2c(%rbp),%edx
add    $0x2,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
cmp    -0x30(%rbp),%eax
jle    123e <longestPalindromeSubseq+0x10e>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1244 <longestPalindromeSubseq+0x114>
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11dc <longestPalindromeSubseq+0xac>
jmp    125d <longestPalindromeSubseq+0x12d>
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
jmp    11c2 <longestPalindromeSubseq+0x92>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12bf <longestPalindromeSubseq+0x18f>
mov    -0x34(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jle    129d <longestPalindromeSubseq+0x16d>
mov    -0x34(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    12ab <longestPalindromeSubseq+0x17b>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1272 <longestPalindromeSubseq+0x142>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<longestPalindromeSubseq>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
xor    %ebp,%ebp
test   %rdi,%rdi
je     1384 <longestPalindromeSubseq+0x254>
mov    %rdi,%r15
cmpb   $0x0,(%rdi)
je     1384 <longestPalindromeSubseq+0x254>
mov    %r15,%rdi
call   1040 <strlen@plt>
mov    %eax,%r14d
lea    0x0(,%r14,4),%edi
call   1050 <malloc@plt>
test   %r14d,%r14d
jle    137a <longestPalindromeSubseq+0x24a>
mov    %r14d,%r8d
cmp    $0x8,%r14d
jae    1183 <longestPalindromeSubseq+0x53>
xor    %edx,%edx
jmp    1280 <longestPalindromeSubseq+0x150>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x7,%ecx
cmp    $0x38,%rdi
jae    11aa <longestPalindromeSubseq+0x7a>
xor    %edi,%edi
jmp    1245 <longestPalindromeSubseq+0x115>
and    $0xfffffffffffffff8,%rsi
xor    %edi,%edi
movdqa 0xe48(%rip),%xmm0
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,(%rax,%rdi,4)
movdqu %xmm0,0x10(%rax,%rdi,4)
movdqu %xmm0,0x20(%rax,%rdi,4)
movdqu %xmm0,0x30(%rax,%rdi,4)
movdqu %xmm0,0x40(%rax,%rdi,4)
movdqu %xmm0,0x50(%rax,%rdi,4)
movdqu %xmm0,0x60(%rax,%rdi,4)
movdqu %xmm0,0x70(%rax,%rdi,4)
movdqu %xmm0,0x80(%rax,%rdi,4)
movdqu %xmm0,0x90(%rax,%rdi,4)
movdqu %xmm0,0xa0(%rax,%rdi,4)
movdqu %xmm0,0xb0(%rax,%rdi,4)
movdqu %xmm0,0xc0(%rax,%rdi,4)
movdqu %xmm0,0xd0(%rax,%rdi,4)
movdqu %xmm0,0xe0(%rax,%rdi,4)
movdqu %xmm0,0xf0(%rax,%rdi,4)
add    $0x40,%rdi
add    $0xfffffffffffffff8,%rsi
jne    11c0 <longestPalindromeSubseq+0x90>
test   %rcx,%rcx
je     1274 <longestPalindromeSubseq+0x144>
lea    (%rax,%rdi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
movdqa 0xda0(%rip),%xmm0
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1260 <longestPalindromeSubseq+0x130>
cmp    %r8,%rdx
je     1290 <longestPalindromeSubseq+0x160>
nopl   0x0(%rax)
movl   $0x1,(%rax,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1280 <longestPalindromeSubseq+0x150>
test   %r14d,%r14d
jle    137a <longestPalindromeSubseq+0x24a>
mov    %r8,%r10
neg    %r10
lea    (%rax,%r8,4),%rsi
add    $0x4,%rsi
lea    (%r15,%r8,1),%rdi
add    $0x1,%rdi
xor    %r11d,%r11d
mov    %r8,%r13
jmp    12da <longestPalindromeSubseq+0x1aa>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11
add    $0x1,%r10
add    $0xfffffffffffffffc,%rsi
add    $0xffffffffffffffff,%rdi
cmp    $0x2,%r9
jl     1366 <longestPalindromeSubseq+0x236>
mov    %r13,%r9
add    $0xffffffffffffffff,%r13
cmp    %r8,%r9
jge    12c0 <longestPalindromeSubseq+0x190>
xor    %ebp,%ebp
mov    %r9,%rdx
cmp    $0x1,%r11d
je     1343 <longestPalindromeSubseq+0x213>
mov    %r11,%r12
and    $0xfffffffffffffffe,%r12
xor    %edx,%edx
xor    %ebp,%ebp
jmp    130e <longestPalindromeSubseq+0x1de>
xchg   %ax,%ax
cmp    %ebp,%ebx
cmovg  %ebx,%ebp
add    $0x2,%rdx
cmp    %edx,%r12d
je     1340 <longestPalindromeSubseq+0x210>
mov    -0x4(%rsi,%rdx,4),%ebx
movzbl (%r15,%r13,1),%ecx
cmp    -0x1(%rdi,%rdx,1),%cl
jne    1324 <longestPalindromeSubseq+0x1f4>
lea    0x2(%rbp),%ecx
mov    %ecx,-0x4(%rsi,%rdx,4)
cmp    %ebx,%ebp
cmovg  %ebp,%ebx
mov    (%rsi,%rdx,4),%ebp
movzbl (%r15,%r13,1),%ecx
cmp    (%rdi,%rdx,1),%cl
jne    1300 <longestPalindromeSubseq+0x1d0>
lea    0x2(%rbx),%ecx
mov    %ecx,(%rsi,%rdx,4)
jmp    1300 <longestPalindromeSubseq+0x1d0>
xchg   %ax,%ax
sub    %r10,%rdx
test   $0x1,%r11b
je     12c0 <longestPalindromeSubseq+0x190>
mov    (%r15,%r13,1),%bl
cmp    (%r15,%rdx,1),%bl
jne    12c0 <longestPalindromeSubseq+0x190>
add    $0x2,%ebp
mov    %ebp,(%rax,%rdx,4)
jmp    12c0 <longestPalindromeSubseq+0x190>
test   %r14d,%r14d
jle    137a <longestPalindromeSubseq+0x24a>
cmp    $0x8,%r14d
jae    1395 <longestPalindromeSubseq+0x265>
xor    %edx,%edx
xor    %ebp,%ebp
jmp    14d0 <longestPalindromeSubseq+0x3a0>
xor    %ebp,%ebp
mov    %rax,%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rsi,%rsi
je     14e6 <longestPalindromeSubseq+0x3b6>
movabs $0x3ffffffffffffff8,%rdi
ff ff 3f
or     $0x6,%rdi
and    %rcx,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
xchg   %ax,%ax
movdqu (%rax,%rsi,4),%xmm2
movdqu 0x10(%rax,%rsi,4),%xmm3
movdqu 0x20(%rax,%rsi,4),%xmm4
movdqu 0x30(%rax,%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    13d0 <longestPalindromeSubseq+0x2a0>
test   $0x1,%cl
je     1479 <longestPalindromeSubseq+0x349>
movdqu (%rax,%rsi,4),%xmm2
movdqu 0x10(%rax,%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,%ebp
cmp    %r8,%rdx
je     137c <longestPalindromeSubseq+0x24c>
nopl   0x0(%rax)
mov    (%rax,%rdx,4),%ecx
cmp    %ecx,%ebp
cmovle %ecx,%ebp
add    $0x1,%rdx
cmp    %rdx,%r8
jne    14d0 <longestPalindromeSubseq+0x3a0>
jmp    137c <longestPalindromeSubseq+0x24c>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
test   $0x1,%cl
jne    1446 <longestPalindromeSubseq+0x316>
jmp    1479 <longestPalindromeSubseq+0x349>

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

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