#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);
int /*<<< orphan*/ printf(char *, int, int);
int strlen(char *);
int longestpalindrome(char *c) {
  int i, j;
  int max = 1, start = 0;
  if (strlen(c) < 2) {
    printf("The length is %lu and the start is %d\n", strlen(c), start);
    return strlen(c);
  }
  int n = strlen(c);
  int **A = (int **)malloc(sizeof(int *) * n);
  if (NULL == A)
    return 0;
  for (i = 0; i < n; i++) {
    A[i] = (int *)malloc(sizeof(int) * n);
    if (NULL == A[i])
      return 0;
  }
  for (i = 0; i < n; i++) {
    for (j = 0; j < n; j++) {
      A[i][j] = 0;
    }
  }
  for (i = 0; i < n - 1; i++) {
    A[i][i] = 1;
    for (j = i + 1; j < n; j++) {
      if (j - i == 1) {
        if (c[i] == c[j])
          A[i][j] = 1;
        else
          A[i][j] = 0;
      } else if (j - i > 1) {
        if ((c[i] == c[j]) && A[i + 1][j - 1]) {
          A[i][j] = 1;
          if (j - i > max)
            start = i;
          max = ((j - i) > (max) ? (j - i) : (max));
        } else
          A[i][j] = 0;
      }
    }
  }
  printf("The length is %d and the start is %d \n", max, start);
  return max;
}


x86 assembly (clang, -O0):
<longestpalindrome>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
movl   $0x1,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x2,%eax
jge    1187 <longestpalindrome+0x57>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%esi
mov    -0x20(%rbp),%edx
lea    0xe8f(%rip),%rdi
call   1040 <printf@plt>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x4(%rbp)
jmp    1437 <longestpalindrome+0x307>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x24(%rbp)
movslq -0x24(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
xor    %eax,%eax
cmp    -0x30(%rbp),%rax
jne    11be <longestpalindrome+0x8e>
movl   $0x0,-0x4(%rbp)
jmp    1437 <longestpalindrome+0x307>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1222 <longestpalindrome+0xf2>
movslq -0x24(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x30(%rbp),%rcx
movslq -0x14(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,8),%rax
jne    120f <longestpalindrome+0xdf>
movl   $0x0,-0x4(%rbp)
jmp    1437 <longestpalindrome+0x307>
jmp    1214 <longestpalindrome+0xe4>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11c5 <longestpalindrome+0x95>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1280 <longestpalindrome+0x150>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    126d <longestpalindrome+0x13d>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    123c <longestpalindrome+0x10c>
jmp    1272 <longestpalindrome+0x142>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1229 <longestpalindrome+0xf9>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    141f <longestpalindrome+0x2ef>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    140c <longestpalindrome+0x2dc>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
cmp    $0x1,%eax
jne    132b <longestpalindrome+0x1fb>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    130f <longestpalindrome+0x1df>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
jmp    1326 <longestpalindrome+0x1f6>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    13f9 <longestpalindrome+0x2c9>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
cmp    $0x1,%eax
jle    13f4 <longestpalindrome+0x2c4>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x18(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    13d8 <longestpalindrome+0x2a8>
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13d8 <longestpalindrome+0x2a8>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    13aa <longestpalindrome+0x27a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jle    13c7 <longestpalindrome+0x297>
mov    -0x18(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    13cd <longestpalindrome+0x29d>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    13ef <longestpalindrome+0x2bf>
mov    -0x30(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    13f4 <longestpalindrome+0x2c4>
jmp    13f9 <longestpalindrome+0x2c9>
jmp    13fe <longestpalindrome+0x2ce>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    12b8 <longestpalindrome+0x188>
jmp    1411 <longestpalindrome+0x2e1>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1287 <longestpalindrome+0x157>
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
lea    0xbfb(%rip),%rdi
call   1040 <printf@plt>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<longestpalindrome>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r12
call   1030 <strlen@plt>
mov    %eax,%ebx
mov    %r12,%rdi
call   1030 <strlen@plt>
mov    %eax,%r14d
cmp    $0x1,%ebx
jg     118f <longestpalindrome+0x4f>
lea    0xe91(%rip),%rdi
mov    %r14d,%esi
xor    %edx,%edx
call   1040 <printf@plt>
mov    %r12,%rdi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <strlen@plt>
lea    0x0(,%r14,8),%edi
call   1060 <malloc@plt>
test   %rax,%rax
je     1218 <longestpalindrome+0xd8>
mov    $0x1,%r15d
test   %r14d,%r14d
jle    121f <longestpalindrome+0xdf>
mov    %rax,%r13
lea    0x0(,%r14,4),%ebp
mov    %r14,(%rsp)
mov    %r14d,%r14d
xor    %ebx,%ebx
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x0(%r13,%r15,8)
test   %rax,%rax
je     1418 <longestpalindrome+0x2d8>
add    $0x1,%r15
cmp    %r15,%r14
jne    11d0 <longestpalindrome+0x90>
cmpl   $0x0,(%rsp)
jle    1226 <longestpalindrome+0xe6>
lea    0x0(,%r14,4),%rbx
lea    -0x1(%r14),%rax
mov    %r14d,%ecx
and    $0x7,%ecx
mov    %rcx,0x8(%rsp)
cmp    $0x7,%rax
jae    1233 <longestpalindrome+0xf3>
xor    %ebp,%ebp
jmp    12c5 <longestpalindrome+0x185>
xor    %ebx,%ebx
jmp    1418 <longestpalindrome+0x2d8>
xor    %edx,%edx
jmp    1406 <longestpalindrome+0x2c6>
xor    %edx,%edx
mov    $0x1,%r15d
jmp    1406 <longestpalindrome+0x2c6>
mov    %r14d,%r15d
and    $0xfffffff8,%r15d
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    0x0(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    0x8(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    0x10(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    0x18(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    0x20(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    0x28(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    0x30(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
mov    0x38(%r13,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
add    $0x8,%rbp
cmp    %rbp,%r15
jne    1240 <longestpalindrome+0x100>
mov    %r14,0x10(%rsp)
mov    0x8(%rsp),%r14
test   %r14,%r14
je     1307 <longestpalindrome+0x1c7>
lea    0x0(,%rbp,8),%r15
add    %r13,%r15
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r15,%rbp,8),%rdi
xor    %esi,%esi
mov    %rbx,%rdx
call   1050 <memset@plt>
add    $0x1,%rbp
cmp    %rbp,%r14
jne    12f0 <longestpalindrome+0x1b0>
xor    %edx,%edx
mov    (%rsp),%r11
cmp    $0x2,%r11d
mov    $0x1,%r15d
mov    0x10(%rsp),%r14
jl     1406 <longestpalindrome+0x2c6>
add    $0xffffffff,%r11d
lea    -0x1(%r14),%r10
mov    $0x1,%r15d
xor    %ecx,%ecx
mov    $0x1,%edi
xor    %r9d,%r9d
xor    %edx,%edx
jmp    1357 <longestpalindrome+0x217>
xchg   %ax,%ax
add    $0x1,%rdi
mov    %rdi,%r8
add    $0xffffffffffffffff,%rcx
mov    %r8,%rdi
cmp    %r11,%r9
je     1406 <longestpalindrome+0x2c6>
mov    %r9,%rsi
mov    0x0(%r13,%r9,8),%rbp
movl   $0x1,0x0(%rbp,%r9,4)
add    $0x1,%r9
cmp    %r14,%r9
jae    1340 <longestpalindrome+0x200>
mov    (%r12,%rsi,1),%r8b
xor    %ebx,%ebx
cmp    (%r12,%rdi,1),%r8b
sete   %bl
mov    %ebx,0x0(%rbp,%rdi,4)
lea    0x1(%rdi),%r8
cmp    %r14,%r8
jne    13a1 <longestpalindrome+0x261>
jmp    1347 <longestpalindrome+0x207>
nopl   (%rax)
movl   $0x0,0x4(%rbp,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%r10
je     1347 <longestpalindrome+0x207>
lea    (%rcx,%rdi,1),%rbx
test   %ebx,%ebx
je     13f0 <longestpalindrome+0x2b0>
lea    (%rcx,%rdi,1),%rbx
add    $0x1,%rbx
cmp    $0x2,%rbx
jb     1398 <longestpalindrome+0x258>
movzbl (%r12,%rsi,1),%eax
cmp    0x1(%r12,%rdi,1),%al
jne    1390 <longestpalindrome+0x250>
mov    0x0(%r13,%r9,8),%rax
cmpl   $0x0,(%rax,%rdi,4)
je     1390 <longestpalindrome+0x250>
movl   $0x1,0x4(%rbp,%rdi,4)
movslq %r15d,%r15
cmp    %r15,%rbx
cmovg  %ebx,%r15d
cmovg  %esi,%edx
jmp    1398 <longestpalindrome+0x258>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%r12,%rsi,1),%ebx
cmp    0x1(%r12,%rdi,1),%bl
jne    1390 <longestpalindrome+0x250>
movl   $0x1,0x4(%rbp,%rdi,4)
jmp    1398 <longestpalindrome+0x258>
lea    0xc1a(%rip),%rdi
mov    %r15d,%esi
call   1040 <printf@plt>
mov    %r15d,%ebx
mov    %ebx,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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