#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*/ strcpy(char *, char *);
char *strdup(char *);
int strlen(char *);
char *shortestPalindrome(char *s) {
  if (!s || !*s)
    return strdup("");
  const int N = strlen(s);
  const int HN = (N >> 1);
  int next[HN], k, i, ch;
  k = next[0] = 0;
  for (i = 1; i < HN; i++) {
    ch = s[i];
    while ((k > 0) && (ch != s[k]))
      k = next[k - 1];
    if (ch == s[k])
      k++;
    next[i] = k;
  }
  for (i = N - 1, k = 0; i >= k; i--) {
    ch = s[i];
    while ((k > 0) && (ch != s[k]))
      k = next[k - 1];
    if (ch == s[k])
      k++;
  }
  int len = N - (i + k);
  char *ret = (char *)malloc((len + N) * sizeof(char));
  if (ret != NULL) {
    char *p = ret;
    for (i = N - 1; i > N - len; i--)
      *p++ = s[i];
    strcpy(p, s);
  }
  return ret;
}


x86 assembly (clang, -O0):
<shortestPalindrome>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1164 <shortestPalindrome+0x24>
mov    -0x10(%rbp),%rax
cmpb   $0x0,(%rax)
jne    1179 <shortestPalindrome+0x39>
lea    0xe95(%rip),%rdi
call   1060 <strdup@plt>
mov    %rax,-0x8(%rbp)
jmp    13b3 <shortestPalindrome+0x273>
mov    -0x10(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
sar    %eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,%ecx
mov    %rsp,%rax
mov    %rax,-0x20(%rbp)
lea    0xf(,%rcx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0x50(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x28(%rbp)
movl   $0x0,(%rax)
movl   $0x0,-0x2c(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    126f <shortestPalindrome+0x12f>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x51(%rbp)
jle    120b <shortestPalindrome+0xcb>
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    121b <shortestPalindrome+0xdb>
jmp    1233 <shortestPalindrome+0xf3>
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
jmp    11e5 <shortestPalindrome+0xa5>
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1253 <shortestPalindrome+0x113>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%edx
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ca <shortestPalindrome+0x8a>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jl     131b <shortestPalindrome+0x1db>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    %eax,-0x34(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x2c(%rbp)
mov    %al,-0x52(%rbp)
jle    12c0 <shortestPalindrome+0x180>
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
setne  %al
mov    %al,-0x52(%rbp)
mov    -0x52(%rbp),%al
test   $0x1,%al
jne    12d0 <shortestPalindrome+0x190>
jmp    12e8 <shortestPalindrome+0x1a8>
mov    -0x50(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
jmp    129a <shortestPalindrome+0x15a>
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1308 <shortestPalindrome+0x1c8>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    130d <shortestPalindrome+0x1cd>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    127f <shortestPalindrome+0x13f>
mov    -0x14(%rbp),%eax
mov    -0x30(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
add    -0x14(%rbp),%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     13a4 <shortestPalindrome+0x264>
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jle    1397 <shortestPalindrome+0x257>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,(%rax)
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
jmp    135c <shortestPalindrome+0x21c>
mov    -0x48(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <strcpy@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rsp
mov    -0x8(%rbp),%rax
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<shortestPalindrome>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
test   %rdi,%rdi
je     1204 <shortestPalindrome+0xc4>
mov    %rdi,%r12
cmpb   $0x0,(%rdi)
je     1204 <shortestPalindrome+0xc4>
mov    %r12,%rdi
call   1040 <strlen@plt>
mov    %rsp,-0x38(%rbp)
mov    %eax,%esi
sar    %esi
mov    %rsp,%rdx
lea    0xf(,%rsi,4),%rdi
and    $0xfffffffffffffff0,%rdi
mov    %rdx,%rcx
sub    %rdi,%rcx
mov    %rcx,%rsp
neg    %rdi
movl   $0x0,(%rdx,%rdi,1)
cmp    $0x4,%eax
jl     121e <shortestPalindrome+0xde>
cmp    $0x3,%esi
mov    $0x2,%r8d
cmovge %esi,%r8d
xor    %esi,%esi
mov    $0x1,%edi
jmp    11da <shortestPalindrome+0x9a>
nopw   0x0(%rax,%rax,1)
movslq %esi,%rsi
xor    %edx,%edx
cmp    (%r12,%rsi,1),%bl
sete   %dl
add    %edx,%esi
mov    %esi,(%rcx,%rdi,4)
add    $0x1,%rdi
cmp    %r8,%rdi
je     121e <shortestPalindrome+0xde>
mov    (%r12,%rdi,1),%bl
test   %esi,%esi
jle    11c0 <shortestPalindrome+0x80>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,%edx
cmp    (%r12,%rdx,1),%bl
je     11c0 <shortestPalindrome+0x80>
add    $0xffffffff,%esi
mov    (%rcx,%rsi,4),%esi
test   %esi,%esi
jg     11f0 <shortestPalindrome+0xb0>
jmp    11c0 <shortestPalindrome+0x80>
lea    0xdf5(%rip),%rdi
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <strdup@plt>
lea    -0x1(%rax),%edx
test   %eax,%eax
mov    %edx,-0x2c(%rbp)
jle    1284 <shortestPalindrome+0x144>
mov    %eax,%r15d
add    $0xffffffffffffffff,%r15
xor    %ebx,%ebx
jmp    125b <shortestPalindrome+0x11b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %ebx,%rbx
xor    %edi,%edi
cmp    (%r12,%rbx,1),%dl
sete   %dil
add    %edi,%ebx
lea    -0x1(%rsi),%r15
movslq %ebx,%rdx
cmp    %rdx,%rsi
jle    1289 <shortestPalindrome+0x149>
mov    %r15,%rsi
mov    (%r12,%r15,1),%dl
test   %ebx,%ebx
jle    1240 <shortestPalindrome+0x100>
cs nopw 0x0(%rax,%rax,1)
mov    %ebx,%edi
cmp    (%r12,%rdi,1),%dl
je     1240 <shortestPalindrome+0x100>
add    $0xffffffff,%ebx
mov    (%rcx,%rbx,4),%ebx
test   %ebx,%ebx
jg     1270 <shortestPalindrome+0x130>
jmp    1240 <shortestPalindrome+0x100>
xor    %ebx,%ebx
mov    %edx,%r15d
lea    (%rbx,%r15,1),%r13d
add    %eax,%eax
sub    %r13d,%eax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%r14
test   %rax,%rax
je     13dc <shortestPalindrome+0x29c>
mov    %r14,%rdi
mov    -0x2c(%rbp),%eax
cmp    %r13d,%eax
jle    13d4 <shortestPalindrome+0x294>
cltq
movslq %r13d,%rcx
mov    %rax,%r9
sub    %rcx,%r9
cmp    $0x20,%r9
jae    12cd <shortestPalindrome+0x18d>
mov    %r14,%rdi
jmp    13c0 <shortestPalindrome+0x280>
lea    (%rax,%r12,1),%rdx
add    $0x1,%rdx
cmp    %r14,%rdx
jbe    12fc <shortestPalindrome+0x1bc>
lea    (%r14,%r9,1),%rdx
movslq %ebx,%rsi
movslq %r15d,%rdi
add    %rsi,%rdi
lea    (%r12,%rdi,1),%rsi
add    $0x1,%rsi
cmp    %rdx,%rsi
jae    12fc <shortestPalindrome+0x1bc>
mov    %r14,%rdi
jmp    13c0 <shortestPalindrome+0x280>
mov    %r9,%r8
and    $0xffffffffffffffe0,%r8
lea    (%r14,%r8,1),%rdi
mov    %r14,%rbx
add    $0x10,%rbx
mov    %r8,%r10
neg    %r10
lea    (%rax,%r12,1),%rdx
add    $0xfffffffffffffff1,%rdx
sub    %r8,%rax
xor    %esi,%esi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%rdx,%rsi,1),%xmm1
movdqu (%rdx,%rsi,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(%rbx)
movdqu %xmm1,(%rbx)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rsi
cmp    %rsi,%r10
jne    1330 <shortestPalindrome+0x1f0>
cmp    %r8,%r9
je     13d4 <shortestPalindrome+0x294>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r12,%rax,1),%edx
mov    %dl,(%rdi)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rax
cmp    %rcx,%rax
jg     13c0 <shortestPalindrome+0x280>
mov    %r12,%rsi
call   1030 <strcpy@plt>
mov    -0x38(%rbp),%rsp
mov    %r14,%rax
lea    -0x28(%rbp),%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 i8*
%7 = alloca i64
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i8*
store i8* %0, i8** %3
%14 = load i8*, i8** %3
%15 = icmp ne i8* %14, null
br i1 %15, label %16, label %20
16: ; preds = %1
%17 = load i8*, i8** %3
%18 = load i8, i8* %17
%19 = icmp ne i8 %18, 0
br i1 %19, label %22, label %20
20: ; preds = %16, %1
%21 = call i8* @strdup(i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str, i64 0, i64 0))
store i8* %21, i8** %2
br label %177
22: ; preds = %16
%23 = load i8*, i8** %3
%24 = call i32 @strlen(i8* %23)
store i32 %24, i32* %4
%25 = load i32, i32* %4
%26 = ashr i32 %25, 1
store i32 %26, i32* %5
%27 = load i32, i32* %5
%28 = zext i32 %27 to i64
%29 = call i8* @llvm.stacksave()
store i8* %29, i8** %6
%30 = alloca i32, i64 %28
store i64 %28, i64* %7
%31 = getelementptr inbounds i32, i32* %30, i64 0
store i32 0, i32* %31
store i32 0, i32* %8
store i32 1, i32* %9
br label %32
32: ; preds = %80, %22
%33 = load i32, i32* %9
%34 = load i32, i32* %5
%35 = icmp slt i32 %33, %34
br i1 %35, label %36, label %83
36: ; preds = %32
%37 = load i8*, i8** %3
%38 = load i32, i32* %9
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i8, i8* %37, i64 %39
%41 = load i8, i8* %40
%42 = sext i8 %41 to i32
store i32 %42, i32* %10
br label %43
43: ; preds = %57, %36
%44 = load i32, i32* %8
%45 = icmp sgt i32 %44, 0
br i1 %45, label %46, label %55
46: ; preds = %43
%47 = load i32, i32* %10
%48 = load i8*, i8** %3
%49 = load i32, i32* %8
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %48, i64 %50
%52 = load i8, i8* %51
%53 = sext i8 %52 to i32
%54 = icmp ne i32 %47, %53
br label %55
55: ; preds = %46, %43
%56 = phi i1 [ false, %43 ], [ %54, %46 ]
br i1 %56, label %57, label %63
57: ; preds = %55
%58 = load i32, i32* %8
%59 = sub nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %30, i64 %60
%62 = load i32, i32* %61
store i32 %62, i32* %8
br label %43
63: ; preds = %55
%64 = load i32, i32* %10
%65 = load i8*, i8** %3
%66 = load i32, i32* %8
%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 %75
72: ; preds = %63
%73 = load i32, i32* %8
%74 = add nsw i32 %73, 1
store i32 %74, i32* %8
br label %75
75: ; preds = %72, %63
%76 = load i32, i32* %8
%77 = load i32, i32* %9
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i32, i32* %30, i64 %78
store i32 %76, i32* %79
br label %80
80: ; preds = %75
%81 = load i32, i32* %9
%82 = add nsw i32 %81, 1
store i32 %82, i32* %9
br label %32
83: ; preds = %32
%84 = load i32, i32* %4
%85 = sub nsw i32 %84, 1
store i32 %85, i32* %9
store i32 0, i32* %8
br label %86
86: ; preds = %130, %83
%87 = load i32, i32* %9
%88 = load i32, i32* %8
%89 = icmp sge i32 %87, %88
br i1 %89, label %90, label %133
90: ; preds = %86
%91 = load i8*, i8** %3
%92 = load i32, i32* %9
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i8, i8* %91, i64 %93
%95 = load i8, i8* %94
%96 = sext i8 %95 to i32
store i32 %96, i32* %10
br label %97
97: ; preds = %111, %90
%98 = load i32, i32* %8
%99 = icmp sgt i32 %98, 0
br i1 %99, label %100, label %109
100: ; preds = %97
%101 = load i32, i32* %10
%102 = load i8*, i8** %3
%103 = load i32, i32* %8
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %102, i64 %104
%106 = load i8, i8* %105
%107 = sext i8 %106 to i32
%108 = icmp ne i32 %101, %107
br label %109
109: ; preds = %100, %97
%110 = phi i1 [ false, %97 ], [ %108, %100 ]
br i1 %110, label %111, label %117
111: ; preds = %109
%112 = load i32, i32* %8
%113 = sub nsw i32 %112, 1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds i32, i32* %30, i64 %114
%116 = load i32, i32* %115
store i32 %116, i32* %8
br label %97
117: ; preds = %109
%118 = load i32, i32* %10
%119 = load i8*, i8** %3
%120 = load i32, i32* %8
%121 = sext i32 %120 to i64
%122 = getelementptr inbounds i8, i8* %119, i64 %121
%123 = load i8, i8* %122
%124 = sext i8 %123 to i32
%125 = icmp eq i32 %118, %124
br i1 %125, label %126, label %129
126: ; preds = %117
%127 = load i32, i32* %8
%128 = add nsw i32 %127, 1
store i32 %128, i32* %8
br label %129
129: ; preds = %126, %117
br label %130
130: ; preds = %129
%131 = load i32, i32* %9
%132 = add nsw i32 %131, -1
store i32 %132, i32* %9
br label %86
133: ; preds = %86
%134 = load i32, i32* %4
%135 = load i32, i32* %9
%136 = load i32, i32* %8
%137 = add nsw i32 %135, %136
%138 = sub nsw i32 %134, %137
store i32 %138, i32* %11
%139 = load i32, i32* %11
%140 = load i32, i32* %4
%141 = add nsw i32 %139, %140
%142 = sext i32 %141 to i64
%143 = mul i64 %142, 1
%144 = trunc i64 %143 to i32
%145 = call i64 @malloc(i32 %144)
%146 = inttoptr i64 %145 to i8*
store i8* %146, i8** %12
%147 = load i8*, i8** %12
%148 = icmp ne i8* %147, null
br i1 %148, label %149, label %174
149: ; preds = %133
%150 = load i8*, i8** %12
store i8* %150, i8** %13
%151 = load i32, i32* %4
%152 = sub nsw i32 %151, 1
store i32 %152, i32* %9
br label %153
153: ; preds = %167, %149
%154 = load i32, i32* %9
%155 = load i32, i32* %4
%156 = load i32, i32* %11
%157 = sub nsw i32 %155, %156
%158 = icmp sgt i32 %154, %157
br i1 %158, label %159, label %170
159: ; preds = %153
%160 = load i8*, i8** %3
%161 = load i32, i32* %9
%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 = getelementptr inbounds i8, i8* %165, i32 1
store i8* %166, i8** %13
store i8 %164, i8* %165
br label %167
167: ; preds = %159
%168 = load i32, i32* %9
%169 = add nsw i32 %168, -1
store i32 %169, i32* %9
br label %153
170: ; preds = %153
%171 = load i8*, i8** %13
%172 = load i8*, i8** %3
%173 = call i32 @strcpy(i8* %171, i8* %172)
br label %174
174: ; preds = %170, %133
%175 = load i8*, i8** %12
store i8* %175, i8** %2
%176 = load i8*, i8** %6
br label %177
177: ; preds = %174, %20
%178 = load i8*, i8** %2
ret i8* %178
}

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