#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 */
char *BoyerMoore(unsigned char *data, unsigned int dataLength,
                 unsigned char *string, unsigned int strLength) {
  unsigned int skipTable[256], i;
  unsigned char *search;
  register unsigned char lastChar;
  if (strLength == 0)
    return NULL;
  for (i = 0; i < 256; i++)
    skipTable[i] = strLength;
  search = string;
  i = --strLength;
  do {
    skipTable[*search++] = i;
  } while (i--);
  lastChar = *--search;
  search = data + strLength;
  dataLength -= strLength + (strLength - 1);
  while ((int)dataLength > 0) {
    unsigned int skip;
    skip = skipTable[*search];
    search += skip;
    dataLength -= skip;
    skip = skipTable[*search];
    search += skip;
    dataLength -= skip;
    skip = skipTable[*search];
    if (*search != lastChar) {
      search += skip;
      dataLength -= skip;
      continue;
    }
    i = strLength;
    do {
      if (i-- == 0)
        return search;
    } while (*--search == string[i]);
    search += (strLength - i + 1);
    dataLength--;
  }
  return NULL;
}


x86 assembly (clang, -O0):
<BoyerMoore>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3d0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
cmpl   $0x0,-0x24(%rbp)
jne    1130 <BoyerMoore+0x30>
movq   $0x0,-0x8(%rbp)
jmp    1387 <BoyerMoore+0x287>
movl   $0x0,-0x434(%rbp)
cmpl   $0x100,-0x434(%rbp)
jae    116e <BoyerMoore+0x6e>
mov    -0x24(%rbp),%ecx
mov    -0x434(%rbp),%eax
mov    %ecx,-0x430(%rbp,%rax,4)
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    113a <BoyerMoore+0x3a>
mov    -0x20(%rbp),%rax
mov    %rax,-0x440(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
mov    %eax,-0x434(%rbp)
mov    -0x434(%rbp),%ecx
mov    -0x440(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x440(%rbp)
movzbl (%rax),%eax
mov    %ecx,-0x430(%rbp,%rax,4)
mov    -0x434(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x434(%rbp)
cmp    $0x0,%eax
jne    1188 <BoyerMoore+0x88>
mov    -0x440(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x440(%rbp)
mov    -0x1(%rax),%al
mov    %al,-0x441(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x440(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
add    %eax,%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jle    137f <BoyerMoore+0x27f>
mov    -0x440(%rbp),%rax
movzbl (%rax),%eax
mov    -0x430(%rbp,%rax,4),%eax
mov    %eax,-0x448(%rbp)
mov    -0x448(%rbp),%ecx
mov    -0x440(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x440(%rbp)
mov    -0x448(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x440(%rbp),%rax
movzbl (%rax),%eax
mov    -0x430(%rbp,%rax,4),%eax
mov    %eax,-0x448(%rbp)
mov    -0x448(%rbp),%ecx
mov    -0x440(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x440(%rbp)
mov    -0x448(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x440(%rbp),%rax
movzbl (%rax),%eax
mov    -0x430(%rbp,%rax,4),%eax
mov    %eax,-0x448(%rbp)
mov    -0x440(%rbp),%rax
movzbl (%rax),%eax
movzbl -0x441(%rbp),%ecx
cmp    %ecx,%eax
je     12eb <BoyerMoore+0x1eb>
mov    -0x448(%rbp),%ecx
mov    -0x440(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x440(%rbp)
mov    -0x448(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
jmp    1209 <BoyerMoore+0x109>
mov    -0x24(%rbp),%eax
mov    %eax,-0x434(%rbp)
mov    -0x434(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x434(%rbp)
cmp    $0x0,%eax
jne    131e <BoyerMoore+0x21e>
mov    -0x440(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1387 <BoyerMoore+0x287>
jmp    1323 <BoyerMoore+0x223>
mov    -0x440(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x440(%rbp)
movzbl -0x1(%rax),%eax
mov    -0x20(%rbp),%rcx
mov    -0x434(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     12f4 <BoyerMoore+0x1f4>
mov    -0x24(%rbp),%ecx
sub    -0x434(%rbp),%ecx
add    $0x1,%ecx
mov    -0x440(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x440(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
jmp    1209 <BoyerMoore+0x109>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x3d0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BoyerMoore>:
push   %rbx
sub    $0x380,%rsp
test   %ecx,%ecx
je     1435 <BoyerMoore+0x335>
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),%r9d
mov    %ecx,%r11d
and    $0x3,%r11d
je     1448 <BoyerMoore+0x348>
mov    %r9d,%eax
mov    %rdx,%r10
nop
movzbl (%r10),%r8d
add    $0x1,%r10
mov    %eax,-0x80(%rsp,%r8,4)
add    $0xffffffff,%eax
add    $0xffffffff,%r11d
jne    1340 <BoyerMoore+0x240>
cmp    $0x3,%r9d
jb     1399 <BoyerMoore+0x299>
nopl   0x0(%rax)
movzbl (%r10),%ebx
mov    %eax,-0x80(%rsp,%rbx,4)
lea    -0x1(%rax),%r8d
movzbl 0x1(%r10),%ebx
mov    %r8d,-0x80(%rsp,%rbx,4)
movzbl 0x2(%r10),%r8d
lea    -0x2(%rax),%ebx
mov    %ebx,-0x80(%rsp,%r8,4)
movzbl 0x3(%r10),%r8d
add    $0xfffffffd,%eax
mov    %eax,-0x80(%rsp,%r8,4)
add    $0x4,%r10
sub    $0x1,%eax
jae    1360 <BoyerMoore+0x260>
add    %ecx,%ecx
sub    %ecx,%esi
add    $0x3,%esi
test   %esi,%esi
jle    1435 <BoyerMoore+0x335>
mov    %r9d,%r10d
add    %r10,%rdi
lea    (%r10,%rdx,1),%r9
add    $0xffffffffffffffff,%r9
neg    %r10
xor    %eax,%eax
movzbl (%rdi),%ecx
mov    -0x80(%rsp,%rcx,4),%ecx
lea    (%rdi,%rcx,1),%r11
movzbl (%rdi,%rcx,1),%edx
mov    -0x80(%rsp,%rdx,4),%edx
sub    %edx,%esi
sub    %ecx,%esi
movzbl (%rdx,%r11,1),%ebx
cmp    %r8b,%bl
jne    1420 <BoyerMoore+0x320>
add    %rdx,%rcx
add    %rcx,%rdi
mov    $0x1,%ecx
xor    %edx,%edx
nopl   0x0(%rax)
cmp    %rdx,%r10
je     1439 <BoyerMoore+0x339>
movzbl -0x1(%rdi,%rdx,1),%ebx
lea    -0x1(%rdx),%r11
add    $0x1,%ecx
cmp    (%r9,%rdx,1),%bl
mov    %r11,%rdx
je     13f0 <BoyerMoore+0x2f0>
mov    %ecx,%ecx
add    %rcx,%rdi
add    %r11,%rdi
add    $0xffffffff,%esi
jmp    142f <BoyerMoore+0x32f>
nopw   0x0(%rax,%rax,1)
add    %rdx,%r11
mov    -0x80(%rsp,%rbx,4),%ecx
add    %rcx,%r11
sub    %ecx,%esi
mov    %r11,%rdi
test   %esi,%esi
jg     13bb <BoyerMoore+0x2bb>
jmp    143f <BoyerMoore+0x33f>
xor    %eax,%eax
jmp    143f <BoyerMoore+0x33f>
add    %rdx,%rdi
mov    %rdi,%rax
add    $0x380,%rsp
pop    %rbx
ret
mov    %r9d,%eax
mov    %rdx,%r10
cmp    $0x3,%r9d
jae    1360 <BoyerMoore+0x260>
jmp    1399 <BoyerMoore+0x299>

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

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