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


x86 assembly (clang, -O0):
<Boyer_Moore_Horspool_Kaze>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3e0,%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    114a <Boyer_Moore_Horspool_Kaze+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    1121 <Boyer_Moore_Horspool_Kaze+0x21>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    118c <Boyer_Moore_Horspool_Kaze+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    1151 <Boyer_Moore_Horspool_Kaze+0x51>
mov    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x442(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%al
mov    %al,-0x443(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
cltq
mov    %rax,-0x458(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
sub    %rdx,%rcx
cmp    %rcx,%rax
jg     12f1 <Boyer_Moore_Horspool_Kaze+0x1f1>
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    12d5 <Boyer_Moore_Horspool_Kaze+0x1d5>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
movzbl -0x443(%rbp),%ecx
cmp    %ecx,%eax
jne    12d5 <Boyer_Moore_Horspool_Kaze+0x1d5>
mov    -0x458(%rbp),%rax
mov    %rax,-0x450(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x450(%rbp)
mov    %al,-0x459(%rbp)
je     128b <Boyer_Moore_Horspool_Kaze+0x18b>
mov    -0x18(%rbp),%rax
mov    -0x458(%rbp),%rcx
sub    -0x450(%rbp),%rcx
movsbl 0x1(%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
add    -0x30(%rbp),%rcx
mov    -0x458(%rbp),%rdx
sub    -0x450(%rbp),%rdx
movsbl 0x1(%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x459(%rbp)
mov    -0x459(%rbp),%al
test   $0x1,%al
jne    129e <Boyer_Moore_Horspool_Kaze+0x19e>
jmp    12b5 <Boyer_Moore_Horspool_Kaze+0x1b5>
mov    -0x450(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x450(%rbp)
jmp    1238 <Boyer_Moore_Horspool_Kaze+0x138>
cmpq   $0x0,-0x450(%rbp)
jne    12d0 <Boyer_Moore_Horspool_Kaze+0x1d0>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    12f9 <Boyer_Moore_Horspool_Kaze+0x1f9>
jmp    12d5 <Boyer_Moore_Horspool_Kaze+0x1d5>
movzbl -0x441(%rbp),%eax
movslq -0x440(%rbp,%rax,4),%rax
ff
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    11c5 <Boyer_Moore_Horspool_Kaze+0xc5>
movq   $0xffffffffffffffff,-0x8(%rbp)
ff
mov    -0x8(%rbp),%rax
add    $0x3e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Boyer_Moore_Horspool_Kaze>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x388,%rsp
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,-0x80(%rsp)
movdqa %xmm0,-0x70(%rsp)
movdqa %xmm0,-0x60(%rsp)
movdqa %xmm0,-0x50(%rsp)
movdqa %xmm0,-0x40(%rsp)
movdqa %xmm0,-0x30(%rsp)
movdqa %xmm0,-0x20(%rsp)
movdqa %xmm0,-0x10(%rsp)
movdqa %xmm0,(%rsp)
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)
lea    -0x1(%rcx),%r8d
cmp    $0x2,%ecx
jl     13f5 <Boyer_Moore_Horspool_Kaze+0x2f5>
mov    %r8d,%r10d
lea    -0x1(%r10),%rax
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x3,%rax
jae    1356 <Boyer_Moore_Horspool_Kaze+0x256>
xor    %eax,%eax
test   %r9,%r9
jne    13c8 <Boyer_Moore_Horspool_Kaze+0x2c8>
jmp    13f5 <Boyer_Moore_Horspool_Kaze+0x2f5>
lea    -0x3(%rcx),%r11d
lea    0x3(%rsi),%rbx
lea    -0x2(%rcx),%r14d
lea    -0x4(%rcx),%r15d
mov    %r10d,%r12d
and    $0xfffffffc,%r12d
neg    %r12
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r10,%rax,1),%r13d
movzbl -0x3(%rbx),%ebp
mov    %r13d,-0x80(%rsp,%rbp,4)
lea    (%r14,%rax,1),%r13d
movzbl -0x2(%rbx),%ebp
mov    %r13d,-0x80(%rsp,%rbp,4)
lea    (%r11,%rax,1),%r13d
movzbl -0x1(%rbx),%ebp
mov    %r13d,-0x80(%rsp,%rbp,4)
lea    (%r15,%rax,1),%r13d
movzbl (%rbx),%ebp
mov    %r13d,-0x80(%rsp,%rbp,4)
add    $0xfffffffffffffffc,%rax
add    $0x4,%rbx
cmp    %rax,%r12
jne    1380 <Boyer_Moore_Horspool_Kaze+0x280>
neg    %rax
test   %r9,%r9
je     13f5 <Boyer_Moore_Horspool_Kaze+0x2f5>
lea    (%rsi,%rax,1),%r10
not    %eax
add    %ecx,%eax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r10,%rbx,1),%ebp
mov    %eax,-0x80(%rsp,%rbp,4)
add    $0x1,%rbx
add    $0xffffffff,%eax
cmp    %rbx,%r9
jne    13e0 <Boyer_Moore_Horspool_Kaze+0x2e0>
movslq %ecx,%r9
sub    %r9,%rdx
mov    $0xffffffffffffffff,%rax
js     1468 <Boyer_Moore_Horspool_Kaze+0x368>
movslq %r8d,%rbp
mov    (%rsi,%rbp,1),%r10b
add    $0xfffffffe,%ecx
movslq %ecx,%r14
movzbl (%rsi),%r8d
add    $0xffffffffffffffff,%r9
xor    %ebp,%ebp
jmp    142d <Boyer_Moore_Horspool_Kaze+0x32d>
nopl   (%rax)
movslq -0x80(%rsp,%r11,4),%rcx
add    %rcx,%rbp
cmp    %rdx,%rbp
jg     1468 <Boyer_Moore_Horspool_Kaze+0x368>
lea    (%r9,%rbp,1),%rcx
movzbl (%rdi,%rcx,1),%r11d
cmp    %r10b,%r11b
jne    1420 <Boyer_Moore_Horspool_Kaze+0x320>
movsbl (%rdi,%rbp,1),%ecx
cmp    %r8d,%ecx
jne    1420 <Boyer_Moore_Horspool_Kaze+0x320>
test   %r14d,%r14d
je     1465 <Boyer_Moore_Horspool_Kaze+0x365>
lea    (%rdi,%rbp,1),%r15
xor    %ecx,%ecx
nop
movzbl 0x1(%rsi,%rcx,1),%ebx
cmp    0x1(%r15,%rcx,1),%bl
jne    1420 <Boyer_Moore_Horspool_Kaze+0x320>
add    $0x1,%rcx
cmp    %rcx,%r14
jne    1450 <Boyer_Moore_Horspool_Kaze+0x350>
mov    %rbp,%rax
add    $0x388,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i64 @Boyer_Moore_Horspool_Kaze(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
%16 = alloca i8
%17 = alloca i64
%18 = alloca i64
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 %19
19: ; preds = %27, %4
%20 = load i32, i32* %11
%21 = icmp slt i32 %20, 256
br i1 %21, label %22, label %30
22: ; preds = %19
%23 = load i32, i32* %9
%24 = load i32, i32* %11
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [256 x i32], [256 x i32]* %13, i64 0, i64 %25
store i32 %23, i32* %26
br label %27
27: ; preds = %22
%28 = load i32, i32* %11
%29 = add nsw i32 %28, 1
store i32 %29, i32* %11
br label %19
30: ; preds = %19
store i32 0, i32* %12
br label %31
31: ; preds = %48, %30
%32 = load i32, i32* %12
%33 = load i32, i32* %9
%34 = sub nsw i32 %33, 1
%35 = icmp slt i32 %32, %34
br i1 %35, label %36, label %51
36: ; preds = %31
%37 = load i32, i32* %9
%38 = load i32, i32* %12
%39 = sub nsw i32 %37, %38
%40 = sub nsw i32 %39, 1
%41 = load i8*, i8** %7
%42 = load i32, i32* %12
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %41, i64 %43
%45 = load i8, i8* %44
%46 = zext i8 %45 to i64
%47 = getelementptr inbounds [256 x i32], [256 x i32]* %13, i64 0, i64 %46
store i32 %40, i32* %47
br label %48
48: ; preds = %36
%49 = load i32, i32* %12
%50 = add nsw i32 %49, 1
store i32 %50, i32* %12
br label %31
51: ; preds = %31
%52 = load i8*, i8** %7
%53 = load i32, i32* %9
%54 = sub nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %52, i64 %55
%57 = load i8, i8* %56
store i8 %57, i8* %15
%58 = load i8*, i8** %7
%59 = getelementptr inbounds i8, i8* %58, i64 0
%60 = load i8, i8* %59
store i8 %60, i8* %16
store i64 0, i64* %10
%61 = load i32, i32* %9
%62 = sub nsw i32 %61, 2
%63 = sext i32 %62 to i64
store i64 %63, i64* %18
br label %64
64: ; preds = %130, %51
%65 = load i64, i64* %10
%66 = load i64, i64* %8
%67 = load i32, i32* %9
%68 = sext i32 %67 to i64
%69 = sub nsw i64 %66, %68
%70 = icmp sle i64 %65, %69
br i1 %70, label %71, label %138
71: ; preds = %64
%72 = load i8*, i8** %6
%73 = load i64, i64* %10
%74 = load i32, i32* %9
%75 = sext i32 %74 to i64
%76 = add nsw i64 %73, %75
%77 = sub nsw i64 %76, 1
%78 = getelementptr inbounds i8, i8* %72, i64 %77
%79 = load i8, i8* %78
store i8 %79, i8* %14
%80 = load i8, i8* %14
%81 = zext i8 %80 to i32
%82 = load i8, i8* %15
%83 = zext i8 %82 to i32
%84 = icmp eq i32 %81, %83
br i1 %84, label %85, label %130
85: ; preds = %71
%86 = load i8*, i8** %6
%87 = load i64, i64* %10
%88 = getelementptr inbounds i8, i8* %86, i64 %87
%89 = load i8, i8* %88
%90 = sext i8 %89 to i32
%91 = load i8, i8* %16
%92 = zext i8 %91 to i32
%93 = icmp eq i32 %90, %92
br i1 %93, label %94, label %130
94: ; preds = %85
%95 = load i64, i64* %18
store i64 %95, i64* %17
br label %96
96: ; preds = %121, %94
%97 = load i64, i64* %17
%98 = icmp ne i64 %97, 0
br i1 %98, label %99, label %119
99: ; preds = %96
%100 = load i8*, i8** %7
%101 = getelementptr inbounds i8, i8* %100, i64 1
%102 = load i64, i64* %18
%103 = load i64, i64* %17
%104 = sub i64 %102, %103
%105 = getelementptr inbounds i8, i8* %101, i64 %104
%106 = load i8, i8* %105
%107 = sext i8 %106 to i32
%108 = load i8*, i8** %6
%109 = load i64, i64* %10
%110 = getelementptr inbounds i8, i8* %108, i64 %109
%111 = getelementptr inbounds i8, i8* %110, i64 1
%112 = load i64, i64* %18
%113 = load i64, i64* %17
%114 = sub i64 %112, %113
%115 = getelementptr inbounds i8, i8* %111, i64 %114
%116 = load i8, i8* %115
%117 = sext i8 %116 to i32
%118 = icmp eq i32 %107, %117
br label %119
119: ; preds = %99, %96
%120 = phi i1 [ false, %96 ], [ %118, %99 ]
br i1 %120, label %121, label %124
121: ; preds = %119
%122 = load i64, i64* %17
%123 = add i64 %122, -1
store i64 %123, i64* %17
br label %96
124: ; preds = %119
%125 = load i64, i64* %17
%126 = icmp eq i64 %125, 0
br i1 %126, label %127, label %129
127: ; preds = %124
%128 = load i64, i64* %10
store i64 %128, i64* %5
br label %139
129: ; preds = %124
br label %130
130: ; preds = %129, %85, %71
%131 = load i8, i8* %14
%132 = zext i8 %131 to i64
%133 = getelementptr inbounds [256 x i32], [256 x i32]* %13, i64 0, i64 %132
%134 = load i32, i32* %133
%135 = sext i32 %134 to i64
%136 = load i64, i64* %10
%137 = add nsw i64 %136, %135
store i64 %137, i64* %10
br label %64
138: ; preds = %64
store i64 -1, i64* %5
br label %139
139: ; preds = %138, %127
%140 = load i64, i64* %5
ret i64 %140
}

LLVM IR (-O2):
define i64 @Boyer_Moore_Horspool_Kaze(i8* nocapture %0, i8* nocapture %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 = add nsw i32 %3, -2
%205 = sext i32 %204 to i64
%206 = sext i32 %3 to i64
%207 = sub nsw i64 %2, %206
%208 = icmp slt i64 %207, 0
br i1 %208, label %247, label %209
209: ; preds = %200
%210 = load i8, i8* %1
%211 = add nsw i64 %206, -1
%212 = zext i8 %210 to i32
%213 = icmp eq i32 %204, 0
%214 = getelementptr inbounds i8, i8* %1, i64 1
br label %215
215: ; preds = %209, %240
%216 = phi i64 [ 0, %209 ], [ %245, %240 ]
%217 = add i64 %211, %216
%218 = getelementptr inbounds i8, i8* %0, i64 %217
%219 = load i8, i8* %218
%220 = icmp eq i8 %219, %203
br i1 %220, label %221, label %240
221: ; preds = %215
%222 = getelementptr inbounds i8, i8* %0, i64 %216
%223 = load i8, i8* %222
%224 = sext i8 %223 to i32
%225 = icmp eq i32 %224, %212
br i1 %225, label %226, label %240
226: ; preds = %221
br i1 %213, label %247, label %227
227: ; preds = %226
%228 = getelementptr inbounds i8, i8* %222, i64 1
br label %231
229: ; preds = %231
%230 = icmp eq i64 %239, 0
br i1 %230, label %247, label %231
231: ; preds = %227, %229
%232 = phi i64 [ %205, %227 ], [ %239, %229 ]
%233 = sub i64 %205, %232
%234 = getelementptr inbounds i8, i8* %214, i64 %233
%235 = load i8, i8* %234
%236 = getelementptr inbounds i8, i8* %228, i64 %233
%237 = load i8, i8* %236
%238 = icmp eq i8 %235, %237
%239 = add i64 %232, -1
br i1 %238, label %229, label %240
240: ; preds = %231, %221, %215
%241 = zext i8 %219 to i64
%242 = getelementptr inbounds [256 x i32], [256 x i32]* %5, i64 0, i64 %241
%243 = load i32, i32* %242
%244 = sext i32 %243 to i64
%245 = add nsw i64 %216, %244
%246 = icmp sgt i64 %245, %207
br i1 %246, label %247, label %215
247: ; preds = %240, %226, %229, %200
%248 = phi i64 [ -1, %200 ], [ %216, %229 ], [ %216, %226 ], [ -1, %240 ]
ret i64 %248
}