#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 */
typedef size_t uint8_t;
typedef int uint32_t;

/* Variables and functions */
scalar_t__ max(int, int);
void boyer_moore_search(uint8_t text[], uint32_t text_len, uint8_t str[],
                        uint32_t str_len, uint32_t *hit_num_p,
                        uint32_t hit_index[]) {
  uint32_t skip[256];
  uint32_t i = 0;
  uint32_t j = 0;
  for (i = 0; i < 255; i++)
    skip[i] = str_len;
  for (i = 0; i < str_len - 1; i++)
    skip[str[i]] = str_len - i - 1;
  *hit_num_p = 0;
  for (i = str_len - 1; i < text_len; i += max(skip[text[i]], str_len - j)) {
    for (j = str_len - 1; text[i] == str[j]; i--, j--) {
      if (j == 0) {
        hit_index[*hit_num_p] = i;
        *hit_num_p = *hit_num_p + 1;
        break;
      }
    }
  }
}


x86 assembly (clang, -O0):
<boyer_moore_search>:
push   %rbp
mov    %rsp,%rbp
sub    $0x440,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x434(%rbp)
movl   $0x0,-0x438(%rbp)
movl   $0x0,-0x434(%rbp)
cmpl   $0xff,-0x434(%rbp)
jge    1184 <boyer_moore_search+0x74>
mov    -0x1c(%rbp),%ecx
movslq -0x434(%rbp),%rax
mov    %ecx,-0x430(%rbp,%rax,4)
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    114f <boyer_moore_search+0x3f>
movl   $0x0,-0x434(%rbp)
mov    -0x434(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11d8 <boyer_moore_search+0xc8>
mov    -0x1c(%rbp),%ecx
sub    -0x434(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%rax
movslq -0x434(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,-0x430(%rbp,%rax,4)
mov    -0x434(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x434(%rbp)
jmp    118e <boyer_moore_search+0x7e>
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x434(%rbp)
mov    -0x434(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12cb <boyer_moore_search+0x1bb>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x438(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x434(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movslq -0x438(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jne    128a <boyer_moore_search+0x17a>
cmpl   $0x0,-0x438(%rbp)
jne    1262 <boyer_moore_search+0x152>
mov    -0x434(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq (%rcx),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    (%rax),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
jmp    128a <boyer_moore_search+0x17a>
jmp    1267 <boyer_moore_search+0x157>
mov    -0x434(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x434(%rbp)
mov    -0x438(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x438(%rbp)
jmp    1209 <boyer_moore_search+0xf9>
jmp    128f <boyer_moore_search+0x17f>
mov    -0x8(%rbp),%rax
movslq -0x434(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x430(%rbp,%rax,4),%edi
mov    -0x1c(%rbp),%esi
sub    -0x438(%rbp),%esi
call   1030 <max@plt>
mov    %rax,%rcx
movslq -0x434(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x434(%rbp)
jmp    11ee <boyer_moore_search+0xde>
add    $0x440,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<boyer_moore_search>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x438,%rsp
mov    %r9,%rbx
mov    %r8,%rbp
mov    %rdx,0x18(%rsp)
mov    %esi,0x14(%rsp)
mov    %rdi,0x20(%rsp)
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
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)
mov    %ecx,0x410(%rsp)
mov    %ecx,0x414(%rsp)
mov    %ecx,0x418(%rsp)
mov    %ecx,0x41c(%rsp)
mov    %ecx,0x420(%rsp)
mov    %ecx,0x424(%rsp)
mov    %ecx,0x428(%rsp)
lea    -0x1(%rcx),%r12d
mov    %rcx,0x8(%rsp)
cmp    $0x2,%ecx
jl     1464 <boyer_moore_search+0x354>
mov    %r12d,%r10d
lea    -0x1(%r10),%rax
mov    %r10d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    13c4 <boyer_moore_search+0x2b4>
xor    %ecx,%ecx
test   %r8,%r8
jne    1438 <boyer_moore_search+0x328>
jmp    1464 <boyer_moore_search+0x354>
mov    %rbp,%r14
mov    %rbx,%r11
mov    0x8(%rsp),%rax
lea    -0x3(%rax),%r9d
mov    0x18(%rsp),%rcx
lea    0x18(%rcx),%rdi
lea    -0x2(%rax),%ebp
add    $0xfffffffc,%eax
mov    %r10d,%edx
and    $0xfffffffc,%edx
neg    %rdx
xor    %ecx,%ecx
nopl   (%rax)
lea    (%r10,%rcx,1),%esi
mov    -0x18(%rdi),%rbx
mov    %esi,0x30(%rsp,%rbx,4)
lea    (%rcx,%rbp,1),%esi
mov    -0x10(%rdi),%rbx
mov    %esi,0x30(%rsp,%rbx,4)
lea    (%r9,%rcx,1),%esi
mov    -0x8(%rdi),%rbx
mov    %esi,0x30(%rsp,%rbx,4)
lea    (%rax,%rcx,1),%esi
mov    (%rdi),%rbx
mov    %esi,0x30(%rsp,%rbx,4)
add    $0xfffffffffffffffc,%rcx
add    $0x20,%rdi
cmp    %rcx,%rdx
jne    13f0 <boyer_moore_search+0x2e0>
neg    %rcx
mov    %r11,%rbx
mov    %r14,%rbp
test   %r8,%r8
je     1464 <boyer_moore_search+0x354>
mov    0x18(%rsp),%rax
lea    (%rax,%rcx,8),%rax
not    %ecx
add    0x8(%rsp),%ecx
xor    %edx,%edx
nopl   0x0(%rax)
mov    (%rax,%rdx,8),%rsi
mov    %ecx,0x30(%rsp,%rsi,4)
add    $0x1,%rdx
add    $0xffffffff,%ecx
cmp    %rdx,%r8
jne    1450 <boyer_moore_search+0x340>
movl   $0x0,0x0(%rbp)
mov    0x14(%rsp),%eax
cmp    %eax,0x8(%rsp)
jle    1487 <boyer_moore_search+0x377>
add    $0x438,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movslq %r12d,%r15
mov    0x8(%rsp),%rax
add    $0xfffffffe,%eax
mov    %rax,0x28(%rsp)
mov    0x18(%rsp),%rax
lea    (%rax,%r15,8),%r13
mov    %r12d,%r14d
jmp    14d1 <boyer_moore_search+0x3c1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12d,%edx
mov    0x30(%rsp,%rax,4),%edi
mov    0x8(%rsp),%rax
mov    %eax,%esi
sub    %edx,%esi
call   1030 <max@plt>
add    %r14d,%eax
mov    %eax,%r14d
cmp    0x14(%rsp),%eax
jge    1475 <boyer_moore_search+0x365>
movslq %r14d,%rcx
mov    0x20(%rsp),%rax
mov    (%rax,%rcx,8),%rax
mov    0x18(%rsp),%rdx
cmp    (%rdx,%r15,8),%rax
jne    14b0 <boyer_moore_search+0x3a0>
test   %r12d,%r12d
je     1518 <boyer_moore_search+0x408>
mov    0x20(%rsp),%rax
lea    (%rax,%rcx,8),%rdx
mov    $0xfffffffffffffff8,%rsi
xor    %ecx,%ecx
nop
mov    (%rdx,%rsi,1),%rax
cmp    0x0(%r13,%rsi,1),%rax
jne    152b <boyer_moore_search+0x41b>
add    $0x1,%rcx
add    $0xfffffffffffffff8,%rsi
cmp    %rcx,%r15
jne    1500 <boyer_moore_search+0x3f0>
sub    %r12d,%r14d
movslq 0x0(%rbp),%rcx
mov    %r14d,(%rbx,%rcx,4)
addl   $0x1,0x0(%rbp)
xor    %edx,%edx
jmp    14b3 <boyer_moore_search+0x3a3>
mov    0x28(%rsp),%rdx
sub    %ecx,%edx
not    %ecx
add    %r14d,%ecx
mov    %ecx,%r14d
jmp    14b3 <boyer_moore_search+0x3a3>

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

LLVM IR (-O2):
define void @boyer_moore_search(i64* nocapture %0, i32 %1, i64* nocapture %2, i32 %3, i32* nocapture %4, i32* nocapture writeonly %5) {
%7 = alloca [256 x i32]
%8 = bitcast [256 x i32]* %7 to i8*
%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]* %7 to <4 x i32>*
store <4 x i32> %10, <4 x i32>* %13
%14 = getelementptr inbounds [256 x i32], [256 x i32]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, 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]* %7, i64 0, i64 248
store i32 %3, i32* %136
%137 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 249
store i32 %3, i32* %137
%138 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 250
store i32 %3, i32* %138
%139 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 251
store i32 %3, i32* %139
%140 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 252
store i32 %3, i32* %140
%141 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 253
store i32 %3, i32* %141
%142 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 254
store i32 %3, i32* %142
%143 = add i32 %3, -1
%144 = icmp sgt i32 %3, 1
br i1 %144, label %145, label %200
145: ; preds = %6
%146 = zext i32 %143 to i64
%147 = add nsw i64 %146, -1
%148 = and i64 %146, 3
%149 = icmp ult i64 %147, 3
br i1 %149, label %185, label %150
150: ; preds = %145
%151 = and i64 %146, 4294967292
br label %152
152: ; preds = %152, %150
%153 = phi i64 [ 0, %150 ], [ %182, %152 ]
%154 = phi i64 [ 0, %150 ], [ %183, %152 ]
%155 = trunc i64 %153 to i32
%156 = xor i32 %155, -1
%157 = add i32 %156, %3
%158 = getelementptr inbounds i64, i64* %2, i64 %153
%159 = load i64, i64* %158
%160 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %159
store i32 %157, i32* %160
%161 = or i64 %153, 1
%162 = trunc i64 %161 to i32
%163 = xor i32 %162, -1
%164 = add i32 %163, %3
%165 = getelementptr inbounds i64, i64* %2, i64 %161
%166 = load i64, i64* %165
%167 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %166
store i32 %164, i32* %167
%168 = or i64 %153, 2
%169 = trunc i64 %168 to i32
%170 = xor i32 %169, -1
%171 = add i32 %170, %3
%172 = getelementptr inbounds i64, i64* %2, i64 %168
%173 = load i64, i64* %172
%174 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %173
store i32 %171, i32* %174
%175 = or i64 %153, 3
%176 = trunc i64 %175 to i32
%177 = xor i32 %176, -1
%178 = add i32 %177, %3
%179 = getelementptr inbounds i64, i64* %2, i64 %175
%180 = load i64, i64* %179
%181 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %180
store i32 %178, i32* %181
%182 = add nuw nsw i64 %153, 4
%183 = add i64 %154, 4
%184 = icmp eq i64 %183, %151
br i1 %184, label %185, label %152
185: ; preds = %152, %145
%186 = phi i64 [ 0, %145 ], [ %182, %152 ]
%187 = icmp eq i64 %148, 0
br i1 %187, label %200, label %188
188: ; preds = %185, %188
%189 = phi i64 [ %197, %188 ], [ %186, %185 ]
%190 = phi i64 [ %198, %188 ], [ 0, %185 ]
%191 = trunc i64 %189 to i32
%192 = xor i32 %191, -1
%193 = add i32 %192, %3
%194 = getelementptr inbounds i64, i64* %2, i64 %189
%195 = load i64, i64* %194
%196 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %195
store i32 %193, i32* %196
%197 = add nuw nsw i64 %189, 1
%198 = add i64 %190, 1
%199 = icmp eq i64 %198, %148
br i1 %199, label %200, label %188
200: ; preds = %185, %188, %6
store i32 0, i32* %4
%201 = icmp sgt i32 %3, %1
br i1 %201, label %248, label %202
202: ; preds = %200
%203 = sext i32 %143 to i64
%204 = getelementptr inbounds i64, i64* %2, i64 %203
%205 = icmp eq i32 %143, 0
br label %206
206: ; preds = %202, %237
%207 = phi i32 [ %143, %202 ], [ %246, %237 ]
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i64, i64* %0, i64 %208
%210 = load i64, i64* %209
%211 = load i64, i64* %204
%212 = icmp eq i64 %210, %211
br i1 %212, label %213, label %237
213: ; preds = %206
%214 = sub i32 %207, %143
br i1 %205, label %217, label %224
215: ; preds = %224
%216 = icmp eq i64 %228, 0
br i1 %216, label %217, label %224
217: ; preds = %215, %213
%218 = phi i64 [ %210, %213 ], [ %230, %215 ]
%219 = load i32, i32* %4
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %5, i64 %220
store i32 %214, i32* %221
%222 = load i32, i32* %4
%223 = add nsw i32 %222, 1
store i32 %223, i32* %4
br label %237
224: ; preds = %213, %215
%225 = phi i64 [ %228, %215 ], [ %203, %213 ]
%226 = phi i64 [ %227, %215 ], [ %208, %213 ]
%227 = add nsw i64 %226, -1
%228 = add nsw i64 %225, -1
%229 = getelementptr inbounds i64, i64* %0, i64 %227
%230 = load i64, i64* %229
%231 = getelementptr inbounds i64, i64* %2, i64 %228
%232 = load i64, i64* %231
%233 = icmp eq i64 %230, %232
br i1 %233, label %215, label %234
234: ; preds = %224
%235 = trunc i64 %227 to i32
%236 = trunc i64 %228 to i32
br label %237
237: ; preds = %234, %206, %217
%238 = phi i32 [ %214, %217 ], [ %207, %206 ], [ %235, %234 ]
%239 = phi i32 [ 0, %217 ], [ %143, %206 ], [ %236, %234 ]
%240 = phi i64 [ %218, %217 ], [ %210, %206 ], [ %230, %234 ]
%241 = getelementptr inbounds [256 x i32], [256 x i32]* %7, i64 0, i64 %240
%242 = load i32, i32* %241
%243 = sub nsw i32 %3, %239
%244 = tail call i64 @max(i32 %242, i32 %243)
%245 = trunc i64 %244 to i32
%246 = add i32 %238, %245
%247 = icmp slt i32 %246, %1
br i1 %247, label %206, label %248
248: ; preds = %237, %200
ret void
}