#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 strlen(char *);
int main(void) {
  char palabra[80];
  int x;
  printf("\n\nEscribe una palabra: ");
  scanf("%[^\n]", palabra);
  x = strlen(palabra);
  printf("%d\n", x);
  char copia[80];
  int a = 0;
  for (int i = x - 1; i >= 0; i--) {
    copia[a] = palabra[i];
    a++;
  }
  printf("%s\n", copia);
  a = 0;
  for (int i = 0; i < x; i++) {
    if (copia[i] == palabra[i])
      a++;
  }
  if (a == x)
    printf("%s\n", "es palindromo");
  else
    printf("%s\n", "no es palindromo");
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xeb7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x60(%rbp),%rsi
lea    0xebd(%rip),%rdi
call   1050 <scanf@plt>
lea    -0x60(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%esi
lea    0xea8(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc4(%rbp)
mov    -0x64(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xc8(%rbp)
cmpl   $0x0,-0xc8(%rbp)
jl     11dc <main+0xac>
movslq -0xc8(%rbp),%rax
mov    -0x60(%rbp,%rax,1),%cl
movslq -0xc4(%rbp),%rax
mov    %cl,-0xc0(%rbp,%rax,1)
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
mov    -0xc8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc8(%rbp)
jmp    1193 <main+0x63>
lea    -0xc0(%rbp),%rsi
lea    0xe38(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0xc4(%rbp)
movl   $0x0,-0xcc(%rbp)
mov    -0xcc(%rbp),%eax
cmp    -0x64(%rbp),%eax
jge    125f <main+0x12f>
movslq -0xcc(%rbp),%rax
movsbl -0xc0(%rbp,%rax,1),%eax
ff
movslq -0xcc(%rbp),%rcx
movsbl -0x60(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
jne    1246 <main+0x116>
mov    -0xc4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc4(%rbp)
jmp    124b <main+0x11b>
mov    -0xcc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1205 <main+0xd5>
mov    -0xc4(%rbp),%eax
cmp    -0x64(%rbp),%eax
jne    1288 <main+0x158>
lea    0xdad(%rip),%rdi
lea    0xdad(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    129d <main+0x16d>
lea    0xd93(%rip),%rdi
lea    0xd90(%rip),%rsi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0xa8,%rsp
lea    0xebc(%rip),%rdi
xor    %ebp,%ebp
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xec4(%rip),%rdi
lea    0x50(%rsp),%rbx
mov    %rbx,%rsi
call   1060 <scanf@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    %eax,%r14d
lea    0xeab(%rip),%rdi
mov    %eax,%esi
xor    %eax,%eax
call   1050 <printf@plt>
test   %r14d,%r14d
jle    124a <main+0x10a>
mov    %r14d,%r15d
cmp    $0x8,%r14d
jae    1257 <main+0x117>
xor    %eax,%eax
mov    %r15,%rcx
mov    %rax,%rdx
not    %rdx
add    %r15,%rdx
mov    %r15,%rsi
and    $0x3,%rsi
je     11d8 <main+0x98>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rcx
mov    %ecx,%edi
movzbl 0x50(%rsp,%rdi,1),%ebx
mov    %bl,(%rsp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    11c0 <main+0x80>
cmp    $0x3,%rdx
jb     122e <main+0xee>
mov    $0xfffffffe,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rcx,%rdx,1),%rsi
lea    0x1(%rsi),%edi
movzbl 0x50(%rsp,%rdi,1),%ebx
mov    %bl,(%rsp,%rax,1)
mov    %esi,%edi
movzbl 0x50(%rsp,%rdi,1),%ebx
mov    %bl,0x1(%rsp,%rax,1)
add    $0xffffffff,%esi
movzbl 0x50(%rsp,%rsi,1),%ebx
mov    %bl,0x2(%rsp,%rax,1)
add    $0xfffffffffffffffc,%rcx
mov    %ecx,%esi
movzbl 0x50(%rsp,%rsi,1),%ebx
mov    %bl,0x3(%rsp,%rax,1)
add    $0x4,%rax
cmp    %rax,%r15
jne    11f0 <main+0xb0>
mov    %rsp,%rdi
call   1030 <puts@plt>
test   %r14d,%r14d
jle    128a <main+0x14a>
cmp    $0x8,%r14d
jae    1291 <main+0x151>
xor    %eax,%eax
xor    %ebp,%ebp
jmp    13d0 <main+0x290>
mov    %rsp,%rdi
call   1030 <puts@plt>
jmp    13e8 <main+0x2a8>
lea    -0x1(%r15),%rdx
lea    -0x1(%r14),%ecx
xor    %eax,%eax
cmp    %edx,%ecx
jb     11a4 <main+0x64>
mov    %rdx,%rcx
shr    $0x20,%rcx
mov    %r15,%rcx
jne    11a7 <main+0x67>
cmp    $0x20,%r14d
jae    1412 <main+0x2d2>
xor    %eax,%eax
jmp    14b9 <main+0x379>
xor    %ebp,%ebp
jmp    13e8 <main+0x2a8>
mov    %r15d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rdx
mov    %rdx,%rcx
shr    $0x3,%rcx
add    $0x1,%rcx
test   %rdx,%rdx
je     151f <main+0x3df>
mov    %rcx,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm0,%xmm0
xor    %edx,%edx
movdqa 0xd3c(%rip),%xmm2
pxor   %xmm1,%xmm1
nopl   0x0(%rax,%rax,1)
movdqa (%rsp,%rdx,1),%xmm4
movd   0x4(%rsp,%rdx,1),%xmm5
movd   0x54(%rsp,%rdx,1),%xmm3
pcmpeqb %xmm5,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pcmpeqb 0x50(%rsp,%rdx,1),%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm2,%xmm4
paddd  %xmm0,%xmm4
pand   %xmm2,%xmm3
paddd  %xmm1,%xmm3
movq   0x8(%rsp,%rdx,1),%xmm1
movd   0xc(%rsp,%rdx,1),%xmm5
movq   0x58(%rsp,%rdx,1),%xmm0
pcmpeqb %xmm1,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
movd   0x5c(%rsp,%rdx,1),%xmm1
pcmpeqb %xmm5,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm2,%xmm0
paddd  %xmm4,%xmm0
pand   %xmm2,%xmm1
paddd  %xmm3,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rsi
jne    12d0 <main+0x190>
test   $0x1,%cl
je     13a5 <main+0x265>
movq   (%rsp,%rdx,1),%xmm2
movd   0x4(%rsp,%rdx,1),%xmm3
movq   0x50(%rsp,%rdx,1),%xmm4
pcmpeqb %xmm2,%xmm4
movd   0x54(%rsp,%rdx,1),%xmm2
pcmpeqb %xmm3,%xmm2
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
movdqa 0xc73(%rip),%xmm3
pand   %xmm3,%xmm4
paddd  %xmm4,%xmm0
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
cmp    %r15,%rax
je     13e8 <main+0x2a8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rsp,%rax,1),%ecx
xor    %edx,%edx
cmp    0x50(%rsp,%rax,1),%cl
sete   %dl
add    %edx,%ebp
add    $0x1,%rax
cmp    %rax,%r15
jne    13d0 <main+0x290>
cmp    %r14d,%ebp
lea    0xc43(%rip),%rax
lea    0xc39(%rip),%rdi
cmove  %rax,%rdi
call   1030 <puts@plt>
xor    %eax,%eax
add    $0xa8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15d,%eax
and    $0xffffffe0,%eax
xor    %ecx,%ecx
pxor   %xmm0,%xmm0
xchg   %ax,%ax
mov    %edx,%esi
movdqu 0x31(%rsp,%rsi,1),%xmm1
movdqu 0x41(%rsp,%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
movdqa %xmm2,(%rsp,%rcx,1)
movdqa %xmm1,0x10(%rsp,%rcx,1)
add    $0x20,%rcx
add    $0xffffffffffffffe0,%rdx
cmp    %rcx,%rax
jne    1420 <main+0x2e0>
cmp    %r15,%rax
je     122e <main+0xee>
test   $0x18,%r15b
je     1537 <main+0x3f7>
mov    %rax,%rdx
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %r15d,%ecx
and    $0x7,%ecx
mov    %rdx,%rsi
not    %rsi
add    %r15,%rsi
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
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,%rax
jne    14e0 <main+0x3a0>
cmp    %r15,%rax
jne    11a7 <main+0x67>
jmp    122e <main+0xee>
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
test   $0x1,%cl
jne    135e <main+0x21e>
jmp    13a5 <main+0x265>
mov    %r15d,%ecx
and    $0x1f,%ecx
jmp    11a7 <main+0x67>

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

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