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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ malloc(int);
char *longestPalindrome(char *s) {
  char c;
  int i, j;
  int tempBegin, begin, len, maxLen, isHavePal;
  char *temp;
  tempBegin = begin = len = isHavePal = 0;
  maxLen = 1;
  for (i = 0; s[i] != '\0'; i++) {
    for (j = 0; j <= i; j++) {
      if (s[i - j] == s[i + 1 + j]) {
        tempBegin = i - j;
        len = 2 * j + 2;
        isHavePal = 1;
      } else
        isHavePal = 0;
      if (!isHavePal)
        break;
    }
    if (maxLen < len) {
      begin = tempBegin;
      maxLen = len;
    }
  }
  for (i = 0; s[i] != '\0'; i++) {
    for (j = 0; j <= i - 1; j++) {
      if (s[i - 1 - j] == s[i + 1 + j]) {
        tempBegin = i - 1 - j;
        len = 2 * j + 3;
        isHavePal = 1;
      } else
        isHavePal = 0;
      if (!isHavePal)
        break;
    }
    if (maxLen < len) {
      begin = tempBegin;
      maxLen = len;
    }
  }
  temp = (char *)malloc((maxLen + 1) * sizeof(char));
  for (i = 0; i < maxLen; i++)
    temp[i] = s[i + begin];
  temp[i] = '\0';
  return temp;
}


x86 assembly (clang, -O0):
<longestPalindrome>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x1,-0x24(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     1210 <longestPalindrome+0x100>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     11e5 <longestPalindrome+0xd5>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    -0x14(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    11bc <longestPalindrome+0xac>
mov    -0x10(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
movl   $0x1,-0x28(%rbp)
jmp    11c3 <longestPalindrome+0xb3>
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    11d2 <longestPalindrome+0xc2>
jmp    11e5 <longestPalindrome+0xd5>
jmp    11d7 <longestPalindrome+0xc7>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1162 <longestPalindrome+0x52>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    11fd <longestPalindrome+0xed>
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1202 <longestPalindrome+0xf2>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1146 <longestPalindrome+0x36>
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     12ec <longestPalindrome+0x1dc>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     12c1 <longestPalindrome+0x1b1>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x14(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%edx
add    $0x1,%edx
add    -0x14(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1298 <longestPalindrome+0x188>
mov    -0x10(%rbp),%eax
sub    $0x1,%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1,%eax
add    $0x3,%eax
mov    %eax,-0x20(%rbp)
movl   $0x1,-0x28(%rbp)
jmp    129f <longestPalindrome+0x18f>
movl   $0x0,-0x28(%rbp)
cmpl   $0x0,-0x28(%rbp)
jne    12ae <longestPalindrome+0x19e>
jmp    12c1 <longestPalindrome+0x1b1>
jmp    12b3 <longestPalindrome+0x1a3>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1233 <longestPalindrome+0x123>
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    12d9 <longestPalindrome+0x1c9>
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    12de <longestPalindrome+0x1ce>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1217 <longestPalindrome+0x107>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1030 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    133f <longestPalindrome+0x22f>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    130a <longestPalindrome+0x1fa>
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<longestPalindrome>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r14
mov    (%rdi),%r8b
test   %r8b,%r8b
je     1251 <longestPalindrome+0x141>
xor    %r10d,%r10d
mov    $0x1,%r15d
mov    $0x2,%r13d
mov    $0xffffffffffffffff,%r11
mov    %r14,%rdi
xor    %eax,%eax
xor    %r12d,%r12d
xor    %r9d,%r9d
jmp    1171 <longestPalindrome+0x61>
nopl   (%rax)
mov    %r13d,%eax
cmp    %eax,%r15d
cmovl  %r9d,%r12d
cmovl  %eax,%r15d
add    $0x2,%r13d
add    $0xffffffffffffffff,%r11
add    $0x1,%rdi
cmpb   $0x0,(%r14,%r10,1)
je     11b8 <longestPalindrome+0xa8>
mov    %r10,%rdx
add    $0x1,%r10
mov    (%r14,%rdx,1),%bl
cmp    0x1(%r14,%rdx,1),%bl
jne    1153 <longestPalindrome+0x43>
xor    %r9d,%r9d
mov    $0x2,%ebp
xor    %eax,%eax
xor    %ebx,%ebx
nop
mov    %rdx,%rcx
add    %rbx,%rcx
je     1150 <longestPalindrome+0x40>
movzbl -0x1(%rdi,%rbx,1),%ecx
add    $0xffffffffffffffff,%rbx
add    $0x2,%eax
lea    0x1(%rbp),%rsi
cmp    (%rdi,%rbp,1),%cl
mov    %rsi,%rbp
je     1190 <longestPalindrome+0x80>
sub    %r11d,%ebx
mov    %ebx,%r9d
jmp    1153 <longestPalindrome+0x43>
test   %r8b,%r8b
je     123b <longestPalindrome+0x12b>
mov    $0x1,%edx
xor    %esi,%esi
jmp    11ef <longestPalindrome+0xdf>
cs nopw 0x0(%rax,%rax,1)
mov    $0x1,%ecx
cmp    %eax,%r15d
cmovl  %r9d,%r12d
cmovl  %eax,%r15d
mov    %ecx,%esi
add    $0x2,%edx
cmpb   $0x0,(%r14,%rsi,1)
mov    %rcx,%rsi
je     123b <longestPalindrome+0x12b>
test   %rsi,%rsi
je     11d0 <longestPalindrome+0xc0>
lea    0x1(%rsi),%rcx
mov    -0x1(%rsi,%r14,1),%bl
mov    %ecx,%edi
cmp    (%r14,%rdi,1),%bl
jne    11d5 <longestPalindrome+0xc5>
lea    0x2(%rsi),%rdi
mov    $0x1,%eax
xchg   %ax,%ax
cmp    $0x1,%rsi
je     1234 <longestPalindrome+0x124>
movzbl -0x2(%r14,%rsi,1),%ebx
mov    %edi,%ebp
add    $0xffffffffffffffff,%rsi
add    $0x2,%eax
add    $0x1,%rdi
cmp    (%r14,%rbp,1),%bl
je     1210 <longestPalindrome+0x100>
mov    %esi,%r9d
jmp    11d5 <longestPalindrome+0xc5>
xor    %r9d,%r9d
mov    %edx,%eax
jmp    11d5 <longestPalindrome+0xc5>
lea    0x1(%r15),%edi
call   1030 <malloc@plt>
test   %r15d,%r15d
jg     1264 <longestPalindrome+0x154>
xor    %r15d,%r15d
jmp    12fb <longestPalindrome+0x1eb>
mov    $0x2,%edi
call   1030 <malloc@plt>
xor    %r12d,%r12d
mov    $0x1,%r15d
movslq %r12d,%r8
mov    %r15d,%ecx
cmp    $0x8,%r15d
jb     1291 <longestPalindrome+0x181>
lea    (%r14,%r8,1),%rdi
lea    (%r8,%rcx,1),%rdx
add    %r14,%rdx
cmp    %rdx,%rax
jae    1311 <longestPalindrome+0x201>
lea    (%rax,%rcx,1),%rdx
cmp    %rdx,%rdi
jae    1311 <longestPalindrome+0x201>
xor    %esi,%esi
mov    %rsi,%rdx
not    %rdx
add    %rcx,%rdx
mov    %rcx,%rdi
and    $0x3,%rdi
je     12c2 <longestPalindrome+0x1b2>
lea    (%r14,%r8,1),%rbp
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rsi,1),%ebx
mov    %bl,(%rax,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    12b0 <longestPalindrome+0x1a0>
cmp    $0x3,%rdx
jb     12fb <longestPalindrome+0x1eb>
lea    (%r8,%r14,1),%rdx
add    $0x3,%rdx
movzbl -0x3(%rdx,%rsi,1),%ebx
mov    %bl,(%rax,%rsi,1)
movzbl -0x2(%rdx,%rsi,1),%ebx
mov    %bl,0x1(%rax,%rsi,1)
movzbl -0x1(%rdx,%rsi,1),%ebx
mov    %bl,0x2(%rax,%rsi,1)
movzbl (%rdx,%rsi,1),%ebx
mov    %bl,0x3(%rax,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    12d0 <longestPalindrome+0x1c0>
mov    %r15d,%ecx
movb   $0x0,(%rax,%rcx,1)
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%r15d
jae    131e <longestPalindrome+0x20e>
xor    %esi,%esi
jmp    140e <longestPalindrome+0x2fe>
mov    %ecx,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdx
mov    %rdx,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
mov    %ebp,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdx
jae    1343 <longestPalindrome+0x233>
xor    %edx,%edx
jmp    13b8 <longestPalindrome+0x2a8>
and    $0xfffffffffffffffc,%rbp
lea    (%r8,%r14,1),%rbx
add    $0x70,%rbx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x70(%rbx,%rdx,1),%xmm0
movups -0x60(%rbx,%rdx,1),%xmm1
movups %xmm0,(%rax,%rdx,1)
movups %xmm1,0x10(%rax,%rdx,1)
movups -0x50(%rbx,%rdx,1),%xmm0
movups -0x40(%rbx,%rdx,1),%xmm1
movups %xmm0,0x20(%rax,%rdx,1)
movups %xmm1,0x30(%rax,%rdx,1)
movups -0x30(%rbx,%rdx,1),%xmm0
movups -0x20(%rbx,%rdx,1),%xmm1
movups %xmm0,0x40(%rax,%rdx,1)
movups %xmm1,0x50(%rax,%rdx,1)
movups -0x10(%rbx,%rdx,1),%xmm0
movups (%rbx,%rdx,1),%xmm1
movups %xmm0,0x60(%rax,%rdx,1)
movups %xmm1,0x70(%rax,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%rbp
jne    1360 <longestPalindrome+0x250>
test   %r9,%r9
je     13fc <longestPalindrome+0x2ec>
lea    (%rdx,%rax,1),%rbp
add    $0x10,%rbp
add    %r8,%rdx
add    %r14,%rdx
add    $0x10,%rdx
shl    $0x5,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,1)
movups %xmm1,0x0(%rbp,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    13e0 <longestPalindrome+0x2d0>
cmp    %rcx,%rsi
je     12fb <longestPalindrome+0x1eb>
test   $0x18,%cl
je     1293 <longestPalindrome+0x183>
mov    %rsi,%rdx
mov    %ecx,%esi
and    $0xfffffff8,%esi
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%rdx,1),%rbp
mov    %rbp,(%rax,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rsi
jne    1420 <longestPalindrome+0x310>
cmp    %rcx,%rsi
je     12fb <longestPalindrome+0x1eb>
jmp    1293 <longestPalindrome+0x183>

LLVM IR (-O0):
define i8* @longestPalindrome(i8* %0) {
%2 = alloca i8*
%3 = alloca i8
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i8*
store i8* %0, i8** %2
store i32 0, i32* %10
store i32 0, i32* %8
store i32 0, i32* %7
store i32 0, i32* %6
store i32 1, i32* %9
store i32 0, i32* %4
br label %12
12: ; preds = %68, %1
%13 = load i8*, i8** %2
%14 = load i32, i32* %4
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds i8, i8* %13, i64 %15
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = icmp ne i32 %18, 0
br i1 %19, label %20, label %71
20: ; preds = %12
store i32 0, i32* %5
br label %21
21: ; preds = %57, %20
%22 = load i32, i32* %5
%23 = load i32, i32* %4
%24 = icmp sle i32 %22, %23
br i1 %24, label %25, label %60
25: ; preds = %21
%26 = load i8*, i8** %2
%27 = load i32, i32* %4
%28 = load i32, i32* %5
%29 = sub nsw i32 %27, %28
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds i8, i8* %26, i64 %30
%32 = load i8, i8* %31
%33 = sext i8 %32 to i32
%34 = load i8*, i8** %2
%35 = load i32, i32* %4
%36 = add nsw i32 %35, 1
%37 = load i32, i32* %5
%38 = add nsw i32 %36, %37
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %34, i64 %39
%41 = load i8, i8* %40
%42 = sext i8 %41 to i32
%43 = icmp eq i32 %33, %42
br i1 %43, label %44, label %51
44: ; preds = %25
%45 = load i32, i32* %4
%46 = load i32, i32* %5
%47 = sub nsw i32 %45, %46
store i32 %47, i32* %6
%48 = load i32, i32* %5
%49 = mul nsw i32 2, %48
%50 = add nsw i32 %49, 2
store i32 %50, i32* %8
store i32 1, i32* %10
br label %52
51: ; preds = %25
store i32 0, i32* %10
br label %52
52: ; preds = %51, %44
%53 = load i32, i32* %10
%54 = icmp ne i32 %53, 0
br i1 %54, label %56, label %55
55: ; preds = %52
br label %60
56: ; preds = %52
br label %57
57: ; preds = %56
%58 = load i32, i32* %5
%59 = add nsw i32 %58, 1
store i32 %59, i32* %5
br label %21
60: ; preds = %55, %21
%61 = load i32, i32* %9
%62 = load i32, i32* %8
%63 = icmp slt i32 %61, %62
br i1 %63, label %64, label %67
64: ; preds = %60
%65 = load i32, i32* %6
store i32 %65, i32* %7
%66 = load i32, i32* %8
store i32 %66, i32* %9
br label %67
67: ; preds = %64, %60
br label %68
68: ; preds = %67
%69 = load i32, i32* %4
%70 = add nsw i32 %69, 1
store i32 %70, i32* %4
br label %12
71: ; preds = %12
store i32 0, i32* %4
br label %72
72: ; preds = %131, %71
%73 = load i8*, i8** %2
%74 = load i32, i32* %4
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %73, i64 %75
%77 = load i8, i8* %76
%78 = sext i8 %77 to i32
%79 = icmp ne i32 %78, 0
br i1 %79, label %80, label %134
80: ; preds = %72
store i32 0, i32* %5
br label %81
81: ; preds = %120, %80
%82 = load i32, i32* %5
%83 = load i32, i32* %4
%84 = sub nsw i32 %83, 1
%85 = icmp sle i32 %82, %84
br i1 %85, label %86, label %123
86: ; preds = %81
%87 = load i8*, i8** %2
%88 = load i32, i32* %4
%89 = sub nsw i32 %88, 1
%90 = load i32, i32* %5
%91 = sub nsw i32 %89, %90
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds i8, i8* %87, i64 %92
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = load i8*, i8** %2
%97 = load i32, i32* %4
%98 = add nsw i32 %97, 1
%99 = load i32, i32* %5
%100 = add nsw i32 %98, %99
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i8, i8* %96, i64 %101
%103 = load i8, i8* %102
%104 = sext i8 %103 to i32
%105 = icmp eq i32 %95, %104
br i1 %105, label %106, label %114
106: ; preds = %86
%107 = load i32, i32* %4
%108 = sub nsw i32 %107, 1
%109 = load i32, i32* %5
%110 = sub nsw i32 %108, %109
store i32 %110, i32* %6
%111 = load i32, i32* %5
%112 = mul nsw i32 2, %111
%113 = add nsw i32 %112, 3
store i32 %113, i32* %8
store i32 1, i32* %10
br label %115
114: ; preds = %86
store i32 0, i32* %10
br label %115
115: ; preds = %114, %106
%116 = load i32, i32* %10
%117 = icmp ne i32 %116, 0
br i1 %117, label %119, label %118
118: ; preds = %115
br label %123
119: ; preds = %115
br label %120
120: ; preds = %119
%121 = load i32, i32* %5
%122 = add nsw i32 %121, 1
store i32 %122, i32* %5
br label %81
123: ; preds = %118, %81
%124 = load i32, i32* %9
%125 = load i32, i32* %8
%126 = icmp slt i32 %124, %125
br i1 %126, label %127, label %130
127: ; preds = %123
%128 = load i32, i32* %6
store i32 %128, i32* %7
%129 = load i32, i32* %8
store i32 %129, i32* %9
br label %130
130: ; preds = %127, %123
br label %131
131: ; preds = %130
%132 = load i32, i32* %4
%133 = add nsw i32 %132, 1
store i32 %133, i32* %4
br label %72
134: ; preds = %72
%135 = load i32, i32* %9
%136 = add nsw i32 %135, 1
%137 = sext i32 %136 to i64
%138 = mul i64 %137, 1
%139 = trunc i64 %138 to i32
%140 = call i64 @malloc(i32 %139)
%141 = inttoptr i64 %140 to i8*
store i8* %141, i8** %11
store i32 0, i32* %4
br label %142
142: ; preds = %158, %134
%143 = load i32, i32* %4
%144 = load i32, i32* %9
%145 = icmp slt i32 %143, %144
br i1 %145, label %146, label %161
146: ; preds = %142
%147 = load i8*, i8** %2
%148 = load i32, i32* %4
%149 = load i32, i32* %7
%150 = add nsw i32 %148, %149
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i8, i8* %147, i64 %151
%153 = load i8, i8* %152
%154 = load i8*, i8** %11
%155 = load i32, i32* %4
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %154, i64 %156
store i8 %153, i8* %157
br label %158
158: ; preds = %146
%159 = load i32, i32* %4
%160 = add nsw i32 %159, 1
store i32 %160, i32* %4
br label %142
161: ; preds = %142
%162 = load i8*, i8** %11
%163 = load i32, i32* %4
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i8, i8* %162, i64 %164
store i8 0, i8* %165
%166 = load i8*, i8** %11
ret i8* %166
}

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