#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() {
  char string[100], reverse_string[100] = {'\0'};
  int i, length = 0, flag = 1;
  printf("Enter a string \n");
  scanf("%[^\n]s", string);
  length = strlen(string);
  for (i = length - 1; i >= 0; i--) {
    reverse_string[length - i - 1] = string[i];
  }
  for (i = 0; i < length; i++) {
    if (reverse_string[i] != string[i]) {
      flag = 0;
    }
  }
  printf("%d\n", flag);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0xe0(%rbp),%rdi
xor    %esi,%esi
mov    $0x64,%edx
call   1050 <memset@plt>
movl   $0x0,-0xe8(%rbp)
movl   $0x1,-0xec(%rbp)
lea    0xe80(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x70(%rbp),%rsi
lea    0xe7f(%rip),%rdi
call   1060 <scanf@plt>
lea    -0x70(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xe8(%rbp)
mov    -0xe8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xe4(%rbp)
cmpl   $0x0,-0xe4(%rbp)
jl     11f9 <main+0xb9>
movslq -0xe4(%rbp),%rax
mov    -0x70(%rbp,%rax,1),%cl
mov    -0xe8(%rbp),%eax
sub    -0xe4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %cl,-0xe0(%rbp,%rax,1)
mov    -0xe4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xe4(%rbp)
jmp    11b5 <main+0x75>
movl   $0x0,-0xe4(%rbp)
mov    -0xe4(%rbp),%eax
cmp    -0xe8(%rbp),%eax
jge    125b <main+0x11b>
movslq -0xe4(%rbp),%rax
movsbl -0xe0(%rbp,%rax,1),%eax
ff
movslq -0xe4(%rbp),%rcx
movsbl -0x70(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     1242 <main+0x102>
movl   $0x0,-0xec(%rbp)
jmp    1247 <main+0x107>
mov    -0xe4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe4(%rbp)
jmp    1203 <main+0xc3>
mov    -0xec(%rbp),%esi
lea    0xdb0(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
xor    %eax,%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbx
sub    $0xe0,%rsp
pxor   %xmm0,%xmm0
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,0x10(%rsp)
movdqa %xmm0,(%rsp)
movl   $0x0,0x60(%rsp)
lea    0xe9d(%rip),%rdi
call   1030 <puts@plt>
lea    0xe86(%rip),%rdi
lea    0x70(%rsp),%rbx
mov    %rbx,%rsi
call   1060 <scanf@plt>
mov    %rbx,%rdi
call   1040 <strlen@plt>
mov    $0x1,%esi
test   %eax,%eax
jle    1454 <main+0x314>
mov    %eax,%r8d
mov    %r8,%rdi
cmp    $0x8,%eax
jb     12ca <main+0x18a>
cmp    $0x20,%eax
jae    11c7 <main+0x87>
xor    %edx,%edx
jmp    126c <main+0x12c>
mov    %r8d,%edx
and    $0xffffffe0,%edx
lea    (%r8,%rbx,1),%rdi
add    $0xfffffffffffffff0,%rdi
xor    %ebx,%ebx
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdi),%xmm1
movdqu (%rdi),%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,%rbx,1)
movdqa %xmm1,0x10(%rsp,%rbx,1)
add    $0x20,%rbx
add    $0xffffffffffffffe0,%rdi
cmp    %rbx,%rdx
jne    11e0 <main+0xa0>
cmp    %r8,%rdx
je     12f5 <main+0x1b5>
test   $0x18,%r8b
je     12c4 <main+0x184>
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
mov    %r8d,%edi
and    $0x7,%edi
mov    %r8,%rbx
sub    %rdx,%rbx
add    %rsp,%rbx
add    $0x68,%rbx
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
movq   (%rbx),%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,%rbx
cmp    %rdx,%rcx
jne    1290 <main+0x150>
cmp    %r8,%rcx
jne    12ca <main+0x18a>
jmp    12f5 <main+0x1b5>
mov    %r8d,%edi
and    $0x1f,%edi
mov    %r8,%rcx
sub    %rdi,%rcx
add    $0x1,%rdi
add    %rsp,%rcx
nopw   0x0(%rax,%rax,1)
movzbl 0x6e(%rsp,%rdi,1),%edx
mov    %dl,(%rcx)
add    $0xffffffffffffffff,%rdi
add    $0x1,%rcx
cmp    $0x1,%rdi
ja     12e0 <main+0x1a0>
test   %eax,%eax
jle    1454 <main+0x314>
xor    %edx,%edx
cmp    $0x8,%eax
jae    1310 <main+0x1d0>
mov    $0x1,%esi
xor    %eax,%eax
jmp    1440 <main+0x300>
mov    %r8d,%eax
and    $0xfffffff8,%eax
lea    -0x8(%rax),%rcx
mov    %rcx,%rbx
shr    $0x3,%rbx
add    $0x1,%rbx
test   %rcx,%rcx
je     146d <main+0x32d>
mov    %rbx,%rsi
and    $0xfffffffffffffffe,%rsi
movdqa 0xcc3(%rip),%xmm0
xor    %edi,%edi
movdqa %xmm0,%xmm1
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqa (%rsp,%rdi,1),%xmm2
movd   0x4(%rsp,%rdi,1),%xmm3
movd   0x74(%rsp,%rdi,1),%xmm4
pcmpeqb %xmm3,%xmm4
pcmpeqb 0x70(%rsp,%rdi,1),%xmm2
movq   0x8(%rsp,%rdi,1),%xmm3
movd   0xc(%rsp,%rdi,1),%xmm5
movq   0x78(%rsp,%rdi,1),%xmm6
pcmpeqb %xmm3,%xmm6
pand   %xmm2,%xmm6
punpcklbw %xmm6,%xmm2
punpcklwd %xmm2,%xmm2
movd   0x7c(%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,%rsi
jne    1350 <main+0x210>
test   $0x1,%bl
je     1405 <main+0x2c5>
movq   (%rsp,%rdi,1),%xmm2
movd   0x4(%rsp,%rdi,1),%xmm3
movq   0x70(%rsp,%rdi,1),%xmm4
pcmpeqb %xmm2,%xmm4
movd   0x74(%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 0xbf3(%rip),%xmm2
movdqa %xmm0,%xmm3
pcmpeqd %xmm2,%xmm3
pand   %xmm3,%xmm1
pandn  %xmm0,%xmm3
por    %xmm1,%xmm3
pcmpeqd %xmm2,%xmm3
movmskps %xmm3,%ecx
xor    %esi,%esi
cmp    $0xf,%ecx
sete   %sil
cmp    %r8,%rax
je     1454 <main+0x314>
cs nopw 0x0(%rax,%rax,1)
movzbl (%rsp,%rax,1),%ecx
cmp    0x70(%rsp,%rax,1),%cl
cmovne %edx,%esi
add    $0x1,%rax
cmp    %rax,%r8
jne    1440 <main+0x300>
lea    0xbbc(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0xe0,%rsp
pop    %rbx
ret
movdqa 0xb8b(%rip),%xmm0
xor    %edi,%edi
movdqa %xmm0,%xmm1
test   $0x1,%bl
jne    13c4 <main+0x284>
jmp    1405 <main+0x2c5>

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

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