#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__ memcmp(char *, char *, int);
long HORSPOOL(char *y, char *x, long n, int m) {
  long i;
  int a, j, bm_bc[256];
  unsigned char ch, lastch;
  for (a = 0; a < 256; a++)
    bm_bc[a] = m;
  for (j = 0; j < m - 1; j++)
    bm_bc[(unsigned char)x[j]] = m - j - 1;
  lastch = x[m - 1];
  i = 0;
  while (i <= n - m) {
    ch = y[i + m - 1];
    if (ch == lastch)
      if (memcmp(&y[i], x, m - 1) == 0)
        return (i);
    i += bm_bc[ch];
  }
  return (-1);
}


x86 assembly (clang, -O0):
<HORSPOOL>:
push   %rbp
mov    %rsp,%rbp
sub    $0x450,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x100,-0x34(%rbp)
jge    115a <HORSPOOL+0x4a>
mov    -0x24(%rbp),%ecx
movslq -0x34(%rbp),%rax
mov    %ecx,-0x440(%rbp,%rax,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1131 <HORSPOOL+0x21>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    119c <HORSPOOL+0x8c>
mov    -0x24(%rbp),%ecx
sub    -0x38(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rdx
movzbl (%rax,%rdx,1),%eax
mov    %ecx,-0x440(%rbp,%rax,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1161 <HORSPOOL+0x51>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x442(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
sub    %rdx,%rcx
cmp    %rcx,%rax
jg     1253 <HORSPOOL+0x143>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    %rdx,%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x441(%rbp)
movzbl -0x441(%rbp),%eax
movzbl -0x442(%rbp),%ecx
cmp    %ecx,%eax
jne    1237 <HORSPOOL+0x127>
mov    -0x10(%rbp),%rdi
add    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x24(%rbp),%edx
sub    $0x1,%edx
call   1030 <memcmp@plt>
cmp    $0x0,%rax
jne    1232 <HORSPOOL+0x122>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    125b <HORSPOOL+0x14b>
jmp    1237 <HORSPOOL+0x127>
movzbl -0x441(%rbp),%eax
movslq -0x440(%rbp,%rax,4),%rax
ff
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    11ba <HORSPOOL+0xaa>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
mov    -0x8(%rbp),%rax
add    $0x450,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<HORSPOOL>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x418,%rsp
mov    %rdx,%r15
mov    %rsi,0x8(%rsp)
mov    %rdi,%r12
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,0x10(%rsp)
movdqa %xmm0,0x20(%rsp)
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x60(%rsp)
movdqa %xmm0,0x70(%rsp)
movdqa %xmm0,0x80(%rsp)
movdqa %xmm0,0x90(%rsp)
movdqa %xmm0,0xa0(%rsp)
movdqa %xmm0,0xb0(%rsp)
movdqa %xmm0,0xc0(%rsp)
movdqa %xmm0,0xd0(%rsp)
movdqa %xmm0,0xe0(%rsp)
movdqa %xmm0,0xf0(%rsp)
movdqa %xmm0,0x100(%rsp)
movdqa %xmm0,0x110(%rsp)
movdqa %xmm0,0x120(%rsp)
movdqa %xmm0,0x130(%rsp)
movdqa %xmm0,0x140(%rsp)
movdqa %xmm0,0x150(%rsp)
movdqa %xmm0,0x160(%rsp)
movdqa %xmm0,0x170(%rsp)
movdqa %xmm0,0x180(%rsp)
movdqa %xmm0,0x190(%rsp)
movdqa %xmm0,0x1a0(%rsp)
movdqa %xmm0,0x1b0(%rsp)
movdqa %xmm0,0x1c0(%rsp)
movdqa %xmm0,0x1d0(%rsp)
movdqa %xmm0,0x1e0(%rsp)
movdqa %xmm0,0x1f0(%rsp)
movdqa %xmm0,0x200(%rsp)
movdqa %xmm0,0x210(%rsp)
movdqa %xmm0,0x220(%rsp)
movdqa %xmm0,0x230(%rsp)
movdqa %xmm0,0x240(%rsp)
movdqa %xmm0,0x250(%rsp)
movdqa %xmm0,0x260(%rsp)
movdqa %xmm0,0x270(%rsp)
movdqa %xmm0,0x280(%rsp)
movdqa %xmm0,0x290(%rsp)
movdqa %xmm0,0x2a0(%rsp)
movdqa %xmm0,0x2b0(%rsp)
movdqa %xmm0,0x2c0(%rsp)
movdqa %xmm0,0x2d0(%rsp)
movdqa %xmm0,0x2e0(%rsp)
movdqa %xmm0,0x2f0(%rsp)
movdqa %xmm0,0x300(%rsp)
movdqa %xmm0,0x310(%rsp)
movdqa %xmm0,0x320(%rsp)
movdqa %xmm0,0x330(%rsp)
movdqa %xmm0,0x340(%rsp)
movdqa %xmm0,0x350(%rsp)
movdqa %xmm0,0x360(%rsp)
movdqa %xmm0,0x370(%rsp)
movdqa %xmm0,0x380(%rsp)
movdqa %xmm0,0x390(%rsp)
movdqa %xmm0,0x3a0(%rsp)
movdqa %xmm0,0x3b0(%rsp)
movdqa %xmm0,0x3c0(%rsp)
movdqa %xmm0,0x3d0(%rsp)
movdqa %xmm0,0x3e0(%rsp)
movdqa %xmm0,0x3f0(%rsp)
movdqa %xmm0,0x400(%rsp)
lea    -0x1(%rcx),%eax
mov    %eax,0x4(%rsp)
cmp    $0x2,%ecx
jl     1434 <HORSPOOL+0x324>
mov    0x4(%rsp),%r11d
lea    -0x1(%r11),%rax
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    1392 <HORSPOOL+0x282>
xor    %edx,%edx
test   %r8,%r8
jne    1404 <HORSPOOL+0x2f4>
jmp    1434 <HORSPOOL+0x324>
lea    -0x3(%rcx),%r9d
mov    0x8(%rsp),%rax
lea    0x3(%rax),%rbp
lea    -0x2(%rcx),%r10d
lea    -0x4(%rcx),%eax
mov    %r11d,%esi
and    $0xfffffffc,%esi
neg    %rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r11,%rdx,1),%ebx
movzbl -0x3(%rbp),%edi
mov    %ebx,0x10(%rsp,%rdi,4)
lea    (%r10,%rdx,1),%edi
movzbl -0x2(%rbp),%ebx
mov    %edi,0x10(%rsp,%rbx,4)
lea    (%r9,%rdx,1),%edi
movzbl -0x1(%rbp),%ebx
mov    %edi,0x10(%rsp,%rbx,4)
lea    (%rax,%rdx,1),%edi
movzbl 0x0(%rbp),%ebx
mov    %edi,0x10(%rsp,%rbx,4)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rbp
cmp    %rdx,%rsi
jne    13c0 <HORSPOOL+0x2b0>
neg    %rdx
test   %r8,%r8
je     1434 <HORSPOOL+0x324>
mov    0x8(%rsp),%rax
add    %rdx,%rax
not    %edx
add    %ecx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rax,%rsi,1),%edi
mov    %edx,0x10(%rsp,%rdi,4)
add    $0x1,%rsi
add    $0xffffffff,%edx
cmp    %rsi,%r8
jne    1420 <HORSPOOL+0x310>
movslq %ecx,%rbp
sub    %rbp,%r15
mov    $0xffffffffffffffff,%rax
js     149e <HORSPOOL+0x38e>
movslq 0x4(%rsp),%rax
mov    0x8(%rsp),%rcx
mov    (%rcx,%rax,1),%bl
add    $0xffffffffffffffff,%rbp
xor    %r14d,%r14d
jmp    146d <HORSPOOL+0x35d>
nopl   0x0(%rax)
movslq 0x10(%rsp,%r13,4),%rax
add    %rax,%r14
cmp    %r15,%r14
jg     1497 <HORSPOOL+0x387>
lea    (%r14,%rbp,1),%rax
movzbl (%r12,%rax,1),%r13d
cmp    %bl,%r13b
jne    1460 <HORSPOOL+0x350>
lea    (%r12,%r14,1),%rdi
mov    0x8(%rsp),%rsi
mov    0x4(%rsp),%edx
call   1030 <memcmp@plt>
test   %rax,%rax
jne    1460 <HORSPOOL+0x350>
mov    %r14,%rax
jmp    149e <HORSPOOL+0x38e>
mov    $0xffffffffffffffff,%rax
add    $0x418,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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