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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, char *);
int main() {
  char str[80], strrev[80];
  int i, l;
  int isPalindrome = 1;
  printf("Enter a string: ");
  scanf("%s", str);
  for (l = 0; str[l] != '\0'; l++)
    ;
  for (i = 0, l--; l > -1; l--, i++)
    strrev[i] = str[l];
  strrev[i] = '\0';
  printf("Reversed string: %s\n", strrev);
  for (l = 0; l < i; l++) {
    if (str[l] != strrev[l])
      isPalindrome = 0;
  }
  if (isPalindrome)
    printf("It's a palindrome\n");
  else
    printf("Not a palindrome\n");
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0xbc(%rbp)
lea    0xebd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    -0x60(%rbp),%rsi
lea    0xebc(%rip),%rdi
call   1040 <scanf@plt>
movl   $0x0,-0xb8(%rbp)
movslq -0xb8(%rbp),%rax
movsbl -0x60(%rbp,%rax,1),%eax
cmp    $0x0,%eax
je     1192 <main+0x72>
jmp    117e <main+0x5e>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1164 <main+0x44>
movl   $0x0,-0xb4(%rbp)
mov    -0xb8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb8(%rbp)
cmpl   $0xffffffff,-0xb8(%rbp)
jle    11f4 <main+0xd4>
movslq -0xb8(%rbp),%rax
mov    -0x60(%rbp,%rax,1),%cl
movslq -0xb4(%rbp),%rax
mov    %cl,-0xb0(%rbp,%rax,1)
mov    -0xb8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    11ab <main+0x8b>
movslq -0xb4(%rbp),%rax
movb   $0x0,-0xb0(%rbp,%rax,1)
lea    -0xb0(%rbp),%rsi
lea    0xe03(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x0,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0xb4(%rbp),%eax
jge    127a <main+0x15a>
movslq -0xb8(%rbp),%rax
movsbl -0x60(%rbp,%rax,1),%eax
movslq -0xb8(%rbp),%rcx
movsbl -0xb0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     1261 <main+0x141>
movl   $0x0,-0xbc(%rbp)
jmp    1266 <main+0x146>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    1222 <main+0x102>
cmpl   $0x0,-0xbc(%rbp)
je     129a <main+0x17a>
lea    0xd9b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
jmp    12a8 <main+0x188>
lea    0xd9b(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0xa0,%rsp
lea    0xeca(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xecd(%rip),%rdi
lea    0x50(%rsp),%rsi
call   1050 <scanf@plt>
mov    $0xfffffffffffffffe,%rbx
mov    $0xffffffff,%ebp
nopw   0x0(%rax,%rax,1)
add    $0x1,%ebp
cmpb   $0x0,0x52(%rsp,%rbx,1)
lea    0x1(%rbx),%rbx
jne    1170 <main+0x40>
cmp    $0xffffffff,%ebx
je     1288 <main+0x158>
lea    0x1(%rbx),%rax
mov    %eax,%eax
test   %ebp,%ebp
mov    $0x1,%r12d
cmovle %ebp,%r12d
neg    %r12d
lea    (%r12,%rbx,1),%r15
add    $0x2,%r15
add    %rbx,%r12
mov    %r15d,%r14d
cmp    $0x8,%r15d
jae    12a9 <main+0x179>
xor    %ecx,%ecx
mov    %rcx,%r8
not    %r8
add    %r14,%r8
test   $0x3,%r14b
je     11f8 <main+0xc8>
lea    0x1(%rbx),%esi
test   %esi,%esi
mov    $0x1,%edi
cmovle %esi,%edi
lea    0x2(%rbx),%rsi
sub    %dil,%sil
movzbl %sil,%esi
and    $0x3,%esi
add    $0xffffffffffffffff,%rax
mov    %eax,%edi
movzbl 0x50(%rsp,%rdi,1),%edx
mov    %dl,(%rsp,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    11e0 <main+0xb0>
cmp    $0x3,%r8
jb     125e <main+0x12e>
mov    $0xfffffffe,%r8d
test   %ebp,%ebp
mov    $0x1,%edi
cmovle %ebp,%edi
mov    %ebx,%esi
sub    %edi,%esi
add    $0x2,%esi
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rax,%r8,1),%rdi
lea    0x1(%rdi),%edx
movzbl 0x50(%rsp,%rdx,1),%edx
mov    %dl,(%rsp,%rcx,1)
mov    %edi,%edx
movzbl 0x50(%rsp,%rdx,1),%edx
mov    %dl,0x1(%rsp,%rcx,1)
add    $0xffffffff,%edi
movzbl 0x50(%rsp,%rdi,1),%edx
mov    %dl,0x2(%rsp,%rcx,1)
add    $0xfffffffffffffffc,%rax
mov    %eax,%edx
movzbl 0x50(%rsp,%rdx,1),%edx
mov    %dl,0x3(%rsp,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    1220 <main+0xf0>
mov    %r15d,%eax
movb   $0x0,(%rsp,%rax,1)
lea    0xdb8(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
cmp    $0xfffffffe,%r12d
jne    12d2 <main+0x1a2>
lea    0xdc7(%rip),%rdi
jmp    1458 <main+0x328>
movb   $0x0,(%rsp)
lea    0xd91(%rip),%rdi
mov    %rsp,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xda6(%rip),%rdi
jmp    1458 <main+0x328>
lea    -0x1(%r14),%rdx
xor    %ecx,%ecx
cmp    %edx,%ebx
jb     11b6 <main+0x86>
shr    $0x20,%rdx
jne    11b6 <main+0x86>
cmp    $0x20,%r15d
jae    146f <main+0x33f>
xor    %ecx,%ecx
jmp    1539 <main+0x409>
mov    $0x1,%r8d
xor    %esi,%esi
cmp    $0x8,%r15d
jae    12ec <main+0x1bc>
xor    %ecx,%ecx
mov    $0x1,%edx
jmp    1424 <main+0x2f4>
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rdx,%rdx
je     15af <main+0x47f>
test   %ebp,%ebp
mov    $0x1,%edi
cmovle %ebp,%edi
mov    %ebx,%edx
sub    %edi,%edx
add    $0x2,%edx
and    $0xfffffff8,%edx
add    $0xfffffffffffffff8,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffe,%rdx
movdqa 0xcca(%rip),%xmm0
xor    %edi,%edi
movdqa %xmm0,%xmm1
nopl   0x0(%rax)
movdqa 0x50(%rsp,%rdi,1),%xmm2
movd   0x54(%rsp,%rdi,1),%xmm3
movd   0x4(%rsp,%rdi,1),%xmm4
pcmpeqb %xmm3,%xmm4
pcmpeqb (%rsp,%rdi,1),%xmm2
movq   0x58(%rsp,%rdi,1),%xmm3
movd   0x5c(%rsp,%rdi,1),%xmm5
movq   0x8(%rsp,%rdi,1),%xmm6
pcmpeqb %xmm3,%xmm6
pand   %xmm2,%xmm6
punpcklbw %xmm6,%xmm2
punpcklwd %xmm2,%xmm2
movd   0xc(%rsp,%rdi,1),%xmm3
pcmpeqb %xmm5,%xmm3
pand   %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
psrad  $0x18,%xmm2
pand   %xmm2,%xmm0
psrad  $0x18,%xmm3
pand   %xmm3,%xmm1
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1340 <main+0x210>
test   $0x1,%al
je     13f4 <main+0x2c4>
movq   0x50(%rsp,%rdi,1),%xmm2
movd   0x54(%rsp,%rdi,1),%xmm3
movq   (%rsp,%rdi,1),%xmm4
pcmpeqb %xmm2,%xmm4
movd   0x4(%rsp,%rdi,1),%xmm2
pcmpeqb %xmm3,%xmm2
punpcklbw %xmm4,%xmm3
punpcklwd %xmm3,%xmm3
psrad  $0x18,%xmm3
pand   %xmm3,%xmm0
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
psrad  $0x18,%xmm2
pand   %xmm2,%xmm1
movdqa 0xc04(%rip),%xmm2
movdqa %xmm0,%xmm3
pcmpeqd %xmm2,%xmm3
pand   %xmm3,%xmm1
pandn  %xmm0,%xmm3
por    %xmm1,%xmm3
pcmpeqd %xmm2,%xmm3
movmskps %xmm3,%eax
xor    %edx,%edx
cmp    $0xf,%eax
sete   %dl
cmp    %r14,%rcx
je     1444 <main+0x314>
test   %ebp,%ebp
cmovle %ebp,%r8d
sub    %r8d,%ebx
add    $0x2,%ebx
movzbl 0x50(%rsp,%rcx,1),%eax
cmp    (%rsp,%rcx,1),%al
cmovne %esi,%edx
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    1430 <main+0x300>
test   %edx,%edx
lea    0xbec(%rip),%rax
lea    0xbf6(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0xa0,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14d,%ecx
and    $0xffffffe0,%ecx
test   %ebp,%ebp
mov    $0x1,%esi
cmovle %ebp,%esi
mov    %ebx,%r8d
sub    %esi,%r8d
add    $0x2,%r8d
and    $0xffffffe0,%r8d
xor    %esi,%esi
pxor   %xmm0,%xmm0
mov    %rbx,%rdi
cs nopw 0x0(%rax,%rax,1)
mov    %edi,%edx
movdqu 0x31(%rsp,%rdx,1),%xmm1
movdqu 0x41(%rsp,%rdx,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
movdqa %xmm2,(%rsp,%rsi,1)
movdqa %xmm1,0x10(%rsp,%rsi,1)
add    $0x20,%rsi
add    $0xffffffffffffffe0,%rdi
cmp    %rsi,%r8
jne    14a0 <main+0x370>
cmp    %r14,%rcx
je     125e <main+0x12e>
test   $0x18,%r14b
je     15ca <main+0x49a>
mov    %rcx,%rdx
mov    %r14d,%ecx
and    $0xfffffff8,%ecx
sub    %rcx,%rax
mov    %rbx,%rsi
sub    %rdx,%rsi
test   %ebp,%ebp
mov    $0x1,%r8d
cmovle %ebp,%r8d
mov    %ebx,%r9d
sub    %r8d,%r9d
add    $0x2,%r9d
and    $0xfffffff8,%r9d
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
mov    %esi,%edi
movq   0x49(%rsp,%rdi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsp,%rdx,1)
add    $0x8,%rdx
add    $0xfffffffffffffff8,%rsi
cmp    %rdx,%r9
jne    1570 <main+0x440>
cmp    %r14,%rcx
jne    11b6 <main+0x86>
jmp    125e <main+0x12e>
movdqa 0xa49(%rip),%xmm0
xor    %edi,%edi
movdqa %xmm0,%xmm1
test   $0x1,%al
jne    13b3 <main+0x283>
jmp    13f4 <main+0x2c4>
sub    %rcx,%rax
jmp    11b6 <main+0x86>

LLVM IR (-O0):
@.str = [17 x i8] c"Enter a string: \00"
@.str.1 = [3 x i8] c"%s\00"
@.str.2 = [21 x i8] c"Reversed string: %s\0A\00"
@.str.3 = [19 x i8] c"It's a palindrome\0A\00"
@.str.4 = [18 x i8] c"Not a palindrome\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [80 x i8]
%3 = alloca [80 x i8]
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
store i32 0, i32* %1
store i32 1, i32* %6
%7 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str, i64 0, i64 0))
%8 = getelementptr inbounds [80 x i8], [80 x i8]* %2, i64 0, i64 0
%9 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8* %8)
store i32 0, i32* %5
br label %10
10: ; preds = %18, %0
%11 = load i32, i32* %5
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds [80 x i8], [80 x i8]* %2, i64 0, i64 %12
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
%16 = icmp ne i32 %15, 0
br i1 %16, label %17, label %21
17: ; preds = %10
br label %18
18: ; preds = %17
%19 = load i32, i32* %5
%20 = add nsw i32 %19, 1
store i32 %20, i32* %5
br label %10
21: ; preds = %10
store i32 0, i32* %4
%22 = load i32, i32* %5
%23 = add nsw i32 %22, -1
store i32 %23, i32* %5
br label %24
24: ; preds = %35, %21
%25 = load i32, i32* %5
%26 = icmp sgt i32 %25, -1
br i1 %26, label %27, label %40
27: ; preds = %24
%28 = load i32, i32* %5
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [80 x i8], [80 x i8]* %2, i64 0, i64 %29
%31 = load i8, i8* %30
%32 = load i32, i32* %4
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 %33
store i8 %31, i8* %34
br label %35
35: ; preds = %27
%36 = load i32, i32* %5
%37 = add nsw i32 %36, -1
store i32 %37, i32* %5
%38 = load i32, i32* %4
%39 = add nsw i32 %38, 1
store i32 %39, i32* %4
br label %24
40: ; preds = %24
%41 = load i32, i32* %4
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 %42
store i8 0, i8* %43
%44 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 0
%45 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.2, i64 0, i64 0), i8* %44)
store i32 0, i32* %5
br label %46
46: ; preds = %64, %40
%47 = load i32, i32* %5
%48 = load i32, i32* %4
%49 = icmp slt i32 %47, %48
br i1 %49, label %50, label %67
50: ; preds = %46
%51 = load i32, i32* %5
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds [80 x i8], [80 x i8]* %2, i64 0, i64 %52
%54 = load i8, i8* %53
%55 = sext i8 %54 to i32
%56 = load i32, i32* %5
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds [80 x i8], [80 x i8]* %3, i64 0, i64 %57
%59 = load i8, i8* %58
%60 = sext i8 %59 to i32
%61 = icmp ne i32 %55, %60
br i1 %61, label %62, label %63
62: ; preds = %50
store i32 0, i32* %6
br label %63
63: ; preds = %62, %50
br label %64
64: ; preds = %63
%65 = load i32, i32* %5
%66 = add nsw i32 %65, 1
store i32 %66, i32* %5
br label %46
67: ; preds = %46
%68 = load i32, i32* %6
%69 = icmp ne i32 %68, 0
br i1 %69, label %70, label %72
70: ; preds = %67
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.3, i64 0, i64 0))
br label %74
72: ; preds = %67
%73 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.4, i64 0, i64 0))
br label %74
74: ; preds = %72, %70
%75 = load i32, i32* %1
ret i32 %75
}

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