#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 read_string(char *);
int /*<<< orphan*/ scanf(char *, ...);
int main() {
  char s1[200], s2[200], c;
  int i, j, n, l1, l2;
  l1 = read_string(s1);
  scanf("%c", &c);
  scanf("%d", &n);
  l2 = read_string(s2);
  int x = 0;
  for (i = 0; i < l1; i++) {
    if (s1[i] == c) {
      x = x + 1;
    }
  }
  int t = 0;
  if (x < n)
    t = t + 1;
  int h = 0;
  for (i = 0; i < l1; i++) {
    int g = 0;
    for (j = 0; j < l2; j++) {
      if (s1[i + j] == s2[j])
        g = g + 1;
    }
    if (g == l2) {
      h = 1;
      break;
    }
  }
  if (h == 1)
    t = t + 1;
  if (t == 1)
    printf("YES");
  else
    printf("NO");
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1d0,%rsp
movl   $0x0,-0x4(%rbp)
lea    -0xd0(%rbp),%rdi
call   1050 <read_string@plt>
mov    %eax,-0x1b4(%rbp)
lea    0xea5(%rip),%rdi
lea    -0x1a1(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
lea    0xe93(%rip),%rdi
lea    -0x1b0(%rbp),%rsi
mov    $0x0,%al
call   1040 <scanf@plt>
lea    -0x1a0(%rbp),%rdi
call   1050 <read_string@plt>
mov    %eax,-0x1b8(%rbp)
movl   $0x0,-0x1bc(%rbp)
movl   $0x0,-0x1a8(%rbp)
mov    -0x1a8(%rbp),%eax
cmp    -0x1b4(%rbp),%eax
jge    11fc <main+0xcc>
movslq -0x1a8(%rbp),%rax
movsbl -0xd0(%rbp,%rax,1),%eax
ff
movsbl -0x1a1(%rbp),%ecx
cmp    %ecx,%eax
jne    11e3 <main+0xb3>
mov    -0x1bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1bc(%rbp)
jmp    11e8 <main+0xb8>
mov    -0x1a8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a8(%rbp)
jmp    11a4 <main+0x74>
movl   $0x0,-0x1c0(%rbp)
mov    -0x1bc(%rbp),%eax
cmp    -0x1b0(%rbp),%eax
jge    1227 <main+0xf7>
mov    -0x1c0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c0(%rbp)
movl   $0x0,-0x1c4(%rbp)
movl   $0x0,-0x1a8(%rbp)
mov    -0x1a8(%rbp),%eax
cmp    -0x1b4(%rbp),%eax
jge    1302 <main+0x1d2>
movl   $0x0,-0x1c8(%rbp)
movl   $0x0,-0x1ac(%rbp)
mov    -0x1ac(%rbp),%eax
cmp    -0x1b8(%rbp),%eax
jge    12c8 <main+0x198>
mov    -0x1a8(%rbp),%eax
add    -0x1ac(%rbp),%eax
cltq
movsbl -0xd0(%rbp,%rax,1),%eax
ff
movslq -0x1ac(%rbp),%rcx
movsbl -0x1a0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
jne    12af <main+0x17f>
mov    -0x1c8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c8(%rbp)
jmp    12b4 <main+0x184>
mov    -0x1ac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1ac(%rbp)
jmp    1261 <main+0x131>
mov    -0x1c8(%rbp),%eax
cmp    -0x1b8(%rbp),%eax
jne    12e9 <main+0x1b9>
movl   $0x1,-0x1c4(%rbp)
jmp    1302 <main+0x1d2>
jmp    12ee <main+0x1be>
mov    -0x1a8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1a8(%rbp)
jmp    123b <main+0x10b>
cmpl   $0x1,-0x1c4(%rbp)
jne    131e <main+0x1ee>
mov    -0x1c0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c0(%rbp)
cmpl   $0x1,-0x1c0(%rbp)
jne    133c <main+0x20c>
lea    0xcd4(%rip),%rdi
call   1030 <printf@plt>
jmp    1348 <main+0x218>
lea    0xcc7(%rip),%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1b8,%rsp
lea    0x20(%rsp),%r15
mov    %r15,%rdi
call   1050 <read_string@plt>
mov    %eax,%r14d
lea    0xeb8(%rip),%rdi
xor    %r12d,%r12d
lea    0x3(%rsp),%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0xea5(%rip),%rdi
lea    0x4(%rsp),%rsi
xor    %eax,%eax
call   1040 <scanf@plt>
lea    0xf0(%rsp),%rdi
call   1050 <read_string@plt>
test   %r14d,%r14d
jle    11a0 <main+0x70>
mov    0x3(%rsp),%cl
mov    %r14d,%r10d
cmp    $0x8,%r14d
jae    11af <main+0x7f>
xor    %edx,%edx
jmp    12e0 <main+0x1b0>
xor    %ecx,%ecx
cmpl   $0x0,0x4(%rsp)
setg   %cl
jmp    150d <main+0x3dd>
mov    %r10d,%edx
and    $0xfffffff8,%edx
movzbl %cl,%esi
movd   %esi,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     153b <main+0x40b>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm1,%xmm1
xor    %edi,%edi
movdqa 0xe0e(%rip),%xmm3
pxor   %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
movd   0x24(%rsp,%rdi,1),%xmm4
movdqa 0x20(%rsp,%rdi,1),%xmm5
pcmpeqb %xmm0,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm5
paddd  %xmm1,%xmm5
pcmpeqb %xmm0,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm3,%xmm4
paddd  %xmm2,%xmm4
movq   0x28(%rsp,%rdi,1),%xmm1
movd   0x2c(%rsp,%rdi,1),%xmm2
pcmpeqb %xmm0,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm3,%xmm1
paddd  %xmm5,%xmm1
pcmpeqb %xmm0,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm4,%xmm2
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1200 <main+0xd0>
test   $0x1,%bpl
je     12b4 <main+0x184>
movq   0x20(%rsp,%rdi,1),%xmm3
movd   0x24(%rsp,%rdi,1),%xmm4
pcmpeqb %xmm0,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movdqa 0xd68(%rip),%xmm5
pand   %xmm5,%xmm3
paddd  %xmm3,%xmm1
pcmpeqb %xmm0,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm5,%xmm4
paddd  %xmm4,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm0
paddd  %xmm1,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%r12d
cmp    %r10,%rdx
je     12f6 <main+0x1c6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %esi,%esi
cmp    %cl,0x20(%rsp,%rdx,1)
sete   %sil
add    %esi,%r12d
add    $0x1,%rdx
cmp    %rdx,%r10
jne    12e0 <main+0x1b0>
mov    0x4(%rsp),%edx
xor    %ecx,%ecx
cmp    %edx,%r12d
setl   %cl
test   %r14d,%r14d
jle    150d <main+0x3dd>
mov    %edx,0x8(%rsp)
mov    %ecx,0xc(%rsp)
mov    %eax,%edi
mov    %edi,%r9d
and    $0xfffffff8,%r9d
lea    -0x8(%r9),%r11
mov    %r11,0x18(%rsp)
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%rcx
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x10(%rsp)
lea    0x2c(%rsp),%rsi
mov    $0x1,%r13b
xor    %r8d,%r8d
movdqa 0xcb4(%rip),%xmm0
nopl   0x0(%rax)
mov    $0x0,%edx
test   %eax,%eax
jle    14bd <main+0x38d>
cmp    $0x8,%eax
jae    1370 <main+0x240>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    14a0 <main+0x370>
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,0x18(%rsp)
je     14df <main+0x3af>
pxor   %xmm1,%xmm1
mov    0x10(%rsp),%r14
xor    %edx,%edx
pxor   %xmm2,%xmm2
nopl   0x0(%rax,%rax,1)
movd   -0xc(%rsi,%rdx,1),%xmm4
movd   -0x8(%rsi,%rdx,1),%xmm5
movd   0xf4(%rsp,%rdx,1),%xmm3
pcmpeqb %xmm5,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pcmpeqb 0xf0(%rsp,%rdx,1),%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
pand   %xmm0,%xmm4
paddd  %xmm1,%xmm4
pand   %xmm0,%xmm3
paddd  %xmm2,%xmm3
movd   -0x4(%rsi,%rdx,1),%xmm2
movd   (%rsi,%rdx,1),%xmm5
movq   0xf8(%rsp,%rdx,1),%xmm1
pcmpeqb %xmm2,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
movd   0xfc(%rsp,%rdx,1),%xmm2
pcmpeqb %xmm5,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm0,%xmm1
paddd  %xmm4,%xmm1
pand   %xmm0,%xmm2
paddd  %xmm3,%xmm2
add    $0x10,%rdx
add    $0xfffffffffffffffe,%r14
jne    1390 <main+0x260>
test   $0x1,%r11b
je     1475 <main+0x345>
lea    (%rdx,%r8,1),%rcx
movd   0x20(%rsp,%rcx,1),%xmm3
movd   0x24(%rsp,%rcx,1),%xmm4
movq   0xf0(%rsp,%rdx,1),%xmm5
pcmpeqb %xmm3,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
movd   0xf4(%rsp,%rdx,1),%xmm3
pcmpeqb %xmm4,%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm0,%xmm5
paddd  %xmm5,%xmm1
pand   %xmm0,%xmm3
paddd  %xmm3,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movd   %xmm1,%edx
mov    %r9,%rcx
cmp    %rdi,%r9
je     14bd <main+0x38d>
nopw   0x0(%rax,%rax,1)
movzbl (%r15,%rcx,1),%ebx
xor    %ebp,%ebp
cmp    0xf0(%rsp,%rcx,1),%bl
sete   %bpl
add    %ebp,%edx
add    $0x1,%rcx
cmp    %rcx,%rdi
jne    14a0 <main+0x370>
cmp    %eax,%edx
je     14f5 <main+0x3c5>
add    $0x1,%r8
cmp    %r10,%r8
setb   %r13b
add    $0x1,%rsi
add    $0x1,%r15
cmp    %r10,%r8
jne    1350 <main+0x220>
jmp    14f5 <main+0x3c5>
pxor   %xmm1,%xmm1
xor    %edx,%edx
pxor   %xmm2,%xmm2
test   $0x1,%r11b
jne    142b <main+0x2fb>
jmp    1475 <main+0x345>
xor    %eax,%eax
cmp    0x8(%rsp),%r12d
setl   %al
add    $0x1,%eax
test   $0x1,%r13b
mov    0xc(%rsp),%ecx
cmovne %eax,%ecx
cmp    $0x1,%ecx
lea    0xaff(%rip),%rax
lea    0xafc(%rip),%rdi
cmove  %rax,%rdi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x1b8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
pxor   %xmm1,%xmm1
xor    %edi,%edi
pxor   %xmm2,%xmm2
test   $0x1,%bpl
jne    1278 <main+0x148>
jmp    12b4 <main+0x184>

LLVM IR (-O0):
@.str = [3 x i8] c"%c\00"
@.str.1 = [3 x i8] c"%d\00"
@.str.2 = [4 x i8] c"YES\00"
@.str.3 = [3 x i8] c"NO\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca [200 x i8]
%3 = alloca [200 x i8]
%4 = alloca i8
%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 i32
store i32 0, i32* %1
%14 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 0
%15 = call i32 @read_string(i8* %14)
store i32 %15, i32* %8
%16 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %4)
%17 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i32* %7)
%18 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 0
%19 = call i32 @read_string(i8* %18)
store i32 %19, i32* %9
store i32 0, i32* %10
store i32 0, i32* %5
br label %20
20: ; preds = %37, %0
%21 = load i32, i32* %5
%22 = load i32, i32* %8
%23 = icmp slt i32 %21, %22
br i1 %23, label %24, label %40
24: ; preds = %20
%25 = load i32, i32* %5
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %26
%28 = load i8, i8* %27
%29 = sext i8 %28 to i32
%30 = load i8, i8* %4
%31 = sext i8 %30 to i32
%32 = icmp eq i32 %29, %31
br i1 %32, label %33, label %36
33: ; preds = %24
%34 = load i32, i32* %10
%35 = add nsw i32 %34, 1
store i32 %35, i32* %10
br label %36
36: ; preds = %33, %24
br label %37
37: ; preds = %36
%38 = load i32, i32* %5
%39 = add nsw i32 %38, 1
store i32 %39, i32* %5
br label %20
40: ; preds = %20
store i32 0, i32* %11
%41 = load i32, i32* %10
%42 = load i32, i32* %7
%43 = icmp slt i32 %41, %42
br i1 %43, label %44, label %47
44: ; preds = %40
%45 = load i32, i32* %11
%46 = add nsw i32 %45, 1
store i32 %46, i32* %11
br label %47
47: ; preds = %44, %40
store i32 0, i32* %12
store i32 0, i32* %5
br label %48
48: ; preds = %84, %47
%49 = load i32, i32* %5
%50 = load i32, i32* %8
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %87
52: ; preds = %48
store i32 0, i32* %13
store i32 0, i32* %6
br label %53
53: ; preds = %75, %52
%54 = load i32, i32* %6
%55 = load i32, i32* %9
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %78
57: ; preds = %53
%58 = load i32, i32* %5
%59 = load i32, i32* %6
%60 = add nsw i32 %58, %59
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %61
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = load i32, i32* %6
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [200 x i8], [200 x i8]* %3, i64 0, i64 %66
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
%70 = icmp eq i32 %64, %69
br i1 %70, label %71, label %74
71: ; preds = %57
%72 = load i32, i32* %13
%73 = add nsw i32 %72, 1
store i32 %73, i32* %13
br label %74
74: ; preds = %71, %57
br label %75
75: ; preds = %74
%76 = load i32, i32* %6
%77 = add nsw i32 %76, 1
store i32 %77, i32* %6
br label %53
78: ; preds = %53
%79 = load i32, i32* %13
%80 = load i32, i32* %9
%81 = icmp eq i32 %79, %80
br i1 %81, label %82, label %83
82: ; preds = %78
store i32 1, i32* %12
br label %87
83: ; preds = %78
br label %84
84: ; preds = %83
%85 = load i32, i32* %5
%86 = add nsw i32 %85, 1
store i32 %86, i32* %5
br label %48
87: ; preds = %82, %48
%88 = load i32, i32* %12
%89 = icmp eq i32 %88, 1
br i1 %89, label %90, label %93
90: ; preds = %87
%91 = load i32, i32* %11
%92 = add nsw i32 %91, 1
store i32 %92, i32* %11
br label %93
93: ; preds = %90, %87
%94 = load i32, i32* %11
%95 = icmp eq i32 %94, 1
br i1 %95, label %96, label %98
96: ; preds = %93
%97 = call i32 @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0))
br label %100
98: ; preds = %93
%99 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0))
br label %100
100: ; preds = %98, %96
ret i32 0
}

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