#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 */
char *malloc(int);
int /*<<< orphan*/ strcat(char *, char *);
char *strdup(char *);
int strlen(char *);
char *shortestPalindrome(char *s) {
  if (!s)
    return (strdup(""));
  int slen, u, i, j, k, start;
  int t, flag, maxlen;
  char *res;
  if ((slen = strlen(s)) == 1)
    return (strdup(s));
  u = slen / 2 - 1;
  if (slen % 2)
    u++;
  maxlen = 0;
  for (i = 0; i <= u; i++) {
    for (t = 1, j = -1, k = 1; (i + j) >= 0; j--, k++) {
      if (s[i + j] == s[i + k])
        t += 2;
      else
        break;
    }
    if ((i + j) < 0 && t > maxlen) {
      maxlen = t;
      start = i;
      flag = 0;
    }
    if (i == u && (slen % 2))
      continue;
    for (t = 0, j = i, k = i + 1; j >= 0; j--, k++) {
      if (s[j] == s[k])
        t += 2;
      else
        break;
    }
    if (j < 0 && t > maxlen) {
      maxlen = t;
      start = i;
      flag = 1;
    }
  }
  res = malloc(slen + slen - maxlen + 8);
  k = 0;
  if (flag) {
    for (j = slen - 1; j > 2 * start + 1; j--)
      res[k++] = s[j];
    res[k] = 0;
  } else {
    for (j = slen - 1; j > 2 * start; j--)
      res[k++] = s[j];
    res[k] = 0;
  }
  strcat(res, s);
  return (res);
}


x86 assembly (clang, -O0):
<shortestPalindrome>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    116c <shortestPalindrome+0x2c>
lea    0xea2(%rip),%rdi
call   1060 <strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    1441 <shortestPalindrome+0x301>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
cmp    $0x1,%eax
jne    1193 <shortestPalindrome+0x53>
mov    -0x10(%rbp),%rdi
call   1060 <strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    1441 <shortestPalindrome+0x301>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11c1 <shortestPalindrome+0x81>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1356 <shortestPalindrome+0x216>
movl   $0x1,-0x2c(%rbp)
movl   $0xffffffff,-0x20(%rbp)
movl   $0x1,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    $0x0,%eax
jl     1258 <shortestPalindrome+0x118>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x1c(%rbp),%edx
add    -0x24(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1237 <shortestPalindrome+0xf7>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    123c <shortestPalindrome+0xfc>
jmp    1258 <shortestPalindrome+0x118>
jmp    1241 <shortestPalindrome+0x101>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11f0 <shortestPalindrome+0xb0>
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cmp    $0x0,%eax
jge    1286 <shortestPalindrome+0x146>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    1286 <shortestPalindrome+0x146>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jne    12ab <shortestPalindrome+0x16b>
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     12ab <shortestPalindrome+0x16b>
jmp    1348 <shortestPalindrome+0x208>
movl   $0x0,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x0,-0x20(%rbp)
jl     131a <shortestPalindrome+0x1da>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    12f9 <shortestPalindrome+0x1b9>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
jmp    12fe <shortestPalindrome+0x1be>
jmp    131a <shortestPalindrome+0x1da>
jmp    1303 <shortestPalindrome+0x1c3>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12c1 <shortestPalindrome+0x181>
cmpl   $0x0,-0x20(%rbp)
jge    1343 <shortestPalindrome+0x203>
mov    -0x2c(%rbp),%eax
cmp    -0x34(%rbp),%eax
jle    1343 <shortestPalindrome+0x203>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x1,-0x30(%rbp)
jmp    1348 <shortestPalindrome+0x208>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11cf <shortestPalindrome+0x8f>
mov    -0x14(%rbp),%edi
add    -0x14(%rbp),%edi
sub    -0x34(%rbp),%edi
add    $0x8,%edi
call   1040 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x0,-0x30(%rbp)
je     13d8 <shortestPalindrome+0x298>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jle    13c7 <shortestPalindrome+0x287>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    1385 <shortestPalindrome+0x245>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    142c <shortestPalindrome+0x2ec>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x28(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jle    1420 <shortestPalindrome+0x2e0>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    13e1 <shortestPalindrome+0x2a1>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x40(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1050 <strcat@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<shortestPalindrome>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
test   %rdi,%rdi
je     1165 <shortestPalindrome+0x25>
mov    %rdi,%r14
call   1030 <strlen@plt>
cmp    $0x1,%eax
jne    117f <shortestPalindrome+0x3f>
mov    %r14,%rdi
jmp    116c <shortestPalindrome+0x2c>
lea    0xe94(%rip),%rdi
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <strdup@plt>
mov    %eax,%r9d
shr    $0x1f,%r9d
add    %eax,%r9d
sar    %r9d
xor    %ecx,%ecx
test   $0x1,%al
sete   %cl
sub    %ecx,%r9d
js     12f4 <shortestPalindrome+0x1b4>
mov    %r9d,%ecx
mov    %rcx,0x10(%rsp)
add    $0x1,%r9d
lea    0x1(%r14),%r13
mov    $0x2,%edi
mov    $0x1,%r12d
mov    $0xffffffff,%r8d
mov    $0xffffffffffffffff,%r10
xor    %ebp,%ebp
xor    %edx,%edx
mov    %r9,0x8(%rsp)
jmp    11fb <shortestPalindrome+0xbb>
nop
mov    %r9d,%esi
mov    %r11d,%edx
mov    0x8(%rsp),%r9
add    $0x1,%rbp
add    $0x2,%r12
add    $0x2,%edi
add    $0x1,%r8d
add    $0x1,%r13
add    $0xffffffffffffffff,%r10
cmp    %r9,%rbp
je     12f6 <shortestPalindrome+0x1b6>
mov    %esi,%r11d
test   %rbp,%rbp
je     1260 <shortestPalindrome+0x120>
mov    %edx,0x4(%rsp)
mov    %r15d,(%rsp)
mov    %r9,%rdx
mov    %rax,%rsi
mov    $0x1,%ebx
xor    %r15d,%r15d
mov    %r8d,%ecx
nopl   0x0(%rax)
mov    %ecx,%r9d
movzbl (%r14,%r9,1),%eax
cmp    0x0(%r13,%r15,1),%al
jne    1246 <shortestPalindrome+0x106>
add    $0x2,%ebx
add    $0xffffffff,%ecx
add    $0x1,%r15
cmp    %r15,%rbp
jne    1220 <shortestPalindrome+0xe0>
mov    $0xffffffff,%ecx
mov    %r12d,%ebx
mov    %rsi,%rax
mov    %rdx,%r9
mov    (%rsp),%r15d
mov    0x4(%rsp),%edx
jmp    1268 <shortestPalindrome+0x128>
cs nopw 0x0(%rax,%rax,1)
lea    -0x1(%rbp),%ecx
mov    $0x1,%ebx
test   %ecx,%ecx
sets   %sil
cmp    %edx,%ebx
setg   %cl
test   %cl,%sil
mov    %r11d,%esi
cmovne %ebp,%esi
mov    $0x0,%ecx
cmovne %ecx,%r15d
cmovne %ebx,%edx
cmp    0x10(%rsp),%rbp
jne    129a <shortestPalindrome+0x15a>
mov    %eax,%ecx
and    $0x1,%ecx
jne    11db <shortestPalindrome+0x9b>
mov    %edx,%r11d
mov    %esi,%r9d
xor    %ecx,%ecx
mov    %ebp,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ebx,%esi
movzbl (%r14,%rsi,1),%edx
cmp    0x0(%r13,%rcx,1),%dl
jne    11d0 <shortestPalindrome+0x90>
add    $0xffffffff,%ebx
add    $0x1,%rcx
mov    %r10,%rsi
add    %rcx,%rsi
jne    12b0 <shortestPalindrome+0x170>
mov    %r11d,%edx
cmp    %r11d,%edi
mov    %r9d,%esi
mov    0x8(%rsp),%r9
jle    11db <shortestPalindrome+0x9b>
mov    $0x1,%r15d
mov    %ebp,%esi
mov    %edi,%edx
jmp    11db <shortestPalindrome+0x9b>
xor    %edx,%edx
lea    (%rax,%rax,1),%edi
sub    %edx,%edi
add    $0x8,%edi
mov    %rax,%rbx
mov    %esi,%ebp
mov    %r15d,%r12d
call   1040 <malloc@plt>
mov    %ebp,%esi
mov    %rax,%r15
add    %ebp,%esi
test   %r12d,%r12d
je     133f <shortestPalindrome+0x1ff>
mov    %esi,%edx
or     $0x1,%edx
lea    -0x1(%rbx),%ecx
xor    %eax,%eax
cmp    %edx,%ecx
jle    15f6 <shortestPalindrome+0x4b6>
movslq %ecx,%rcx
sub    %esi,%ebx
mov    %ebx,%eax
add    $0xfffffffe,%eax
cmp    $0x8,%eax
jae    135d <shortestPalindrome+0x21d>
xor    %edx,%edx
jmp    15b7 <shortestPalindrome+0x477>
add    $0xffffffff,%ebx
xor    %eax,%eax
mov    %ebx,%ecx
sub    %esi,%ecx
jle    15f6 <shortestPalindrome+0x4b6>
movslq %ebx,%rax
cmp    $0x8,%ecx
jae    1369 <shortestPalindrome+0x229>
xor    %edx,%edx
jmp    15d9 <shortestPalindrome+0x499>
cmp    $0x20,%eax
jae    1379 <shortestPalindrome+0x239>
xor    %edx,%edx
jmp    142f <shortestPalindrome+0x2ef>
cmp    $0x20,%ecx
jae    149b <shortestPalindrome+0x35b>
xor    %edx,%edx
jmp    1550 <shortestPalindrome+0x410>
mov    %eax,%edx
and    $0xffffffe0,%edx
lea    0x10(%r15),%rsi
mov    %rdx,%r8
neg    %r8
lea    (%rcx,%r14,1),%rbp
add    $0xfffffffffffffff1,%rbp
xor    %edi,%edi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movdqu -0x10(%rbp,%rdi,1),%xmm1
movdqu 0x0(%rbp,%rdi,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rsi)
movdqu %xmm1,(%rsi)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rdi
cmp    %rdi,%r8
jne    13a0 <shortestPalindrome+0x260>
cmp    %rax,%rdx
je     15f6 <shortestPalindrome+0x4b6>
test   $0x18,%al
je     15b4 <shortestPalindrome+0x474>
mov    %rdx,%rsi
mov    %eax,%edx
and    $0xfffffff8,%edx
mov    %r15,%rdi
add    %rsi,%rdi
mov    %rdx,%rbp
neg    %rbp
neg    %rsi
lea    (%rcx,%r14,1),%rbx
add    $0xfffffffffffffff9,%rbx
sub    %rdx,%rcx
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movq   (%rbx,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdi)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%rbp
jne    1460 <shortestPalindrome+0x320>
cmp    %rax,%rdx
jne    15b7 <shortestPalindrome+0x477>
jmp    15f6 <shortestPalindrome+0x4b6>
mov    %ecx,%edx
and    $0xffffffe0,%edx
lea    0x10(%r15),%rsi
mov    %rdx,%r8
neg    %r8
lea    (%rax,%r14,1),%rbp
add    $0xfffffffffffffff1,%rbp
xor    %edi,%edi
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rbp,%rdi,1),%xmm1
movdqu 0x0(%rbp,%rdi,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm2,-0x10(%rsi)
movdqu %xmm1,(%rsi)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rdi
cmp    %rdi,%r8
jne    14c0 <shortestPalindrome+0x380>
cmp    %rcx,%rdx
je     15f4 <shortestPalindrome+0x4b4>
test   $0x18,%cl
je     15d6 <shortestPalindrome+0x496>
mov    %rdx,%rsi
mov    %ecx,%edx
and    $0xfffffff8,%edx
mov    %r15,%rdi
add    %rsi,%rdi
mov    %rdx,%rbp
neg    %rbp
neg    %rsi
lea    (%rax,%r14,1),%rbx
add    $0xfffffffffffffff9,%rbx
sub    %rdx,%rax
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movq   (%rbx,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdi)
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rsi
cmp    %rsi,%rbp
jne    1580 <shortestPalindrome+0x440>
cmp    %rcx,%rdx
jne    15d9 <shortestPalindrome+0x499>
jmp    15f4 <shortestPalindrome+0x4b4>
sub    %rdx,%rcx
add    %r14,%rcx
nopw   0x0(%rax,%rax,1)
movzbl (%rcx),%ebx
mov    %bl,(%r15,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
cmp    %rdx,%rax
jne    15c0 <shortestPalindrome+0x480>
jmp    15f6 <shortestPalindrome+0x4b6>
sub    %rdx,%rax
add    %r14,%rax
nopl   0x0(%rax)
movzbl (%rax),%ebx
mov    %bl,(%r15,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
cmp    %rdx,%rcx
jne    15e0 <shortestPalindrome+0x4a0>
mov    %ecx,%eax
mov    %eax,%eax
movb   $0x0,(%r15,%rax,1)
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <strcat@plt>
mov    %r15,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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