#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ assert(int);
size_t strlen(char *);
size_t strings_search(char *s, char *sub, size_t start) {
  assert(s != NULL && sub != NULL);
  size_t s_len = strlen(s);
  size_t len = strlen(sub);
  size_t last = len - 1;
  size_t idx;
  size_t table[256] = {0};
  for (idx = 0; idx < 256; idx++)
    table[idx] = len;
  for (idx = 0; idx < len; idx++)
    table[(int)sub[idx]] = last - idx;
  size_t i, j, k, t, skip;
  for (i = start; i < s_len; i += skip) {
    skip = 0;
    for (j = 0; j < len; j++) {
      k = last - j;
      if (sub[k] != s[i + k]) {
        t = table[(int)s[i + k]];
        skip = t > j ? t - j : 1;
        break;
      }
    }
    if (skip == 0)
      return i;
  }
  return s_len;
}


x86 assembly (clang, -O0):
<strings_search>:
push   %rbp
mov    %rsp,%rbp
sub    $0x880,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
xor    %eax,%eax
cmpq   $0x0,-0x10(%rbp)
mov    %al,-0x869(%rbp)
je     1168 <strings_search+0x38>
cmpq   $0x0,-0x18(%rbp)
setne  %al
mov    %al,-0x869(%rbp)
mov    -0x869(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x38(%rbp)
lea    -0x840(%rbp),%rdi
xor    %esi,%esi
mov    $0x800,%edx
call   1040 <memset@plt>
movq   $0x0,-0x40(%rbp)
cmpq   $0x100,-0x40(%rbp)
jae    11e8 <strings_search+0xb8>
mov    -0x30(%rbp),%rcx
mov    -0x40(%rbp),%rax
mov    %rcx,-0x840(%rbp,%rax,8)
ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11b9 <strings_search+0x89>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    122d <strings_search+0xfd>
mov    -0x38(%rbp),%rcx
sub    -0x40(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rdx
movsbl (%rax,%rdx,1),%eax
cltq
mov    %rcx,-0x840(%rbp,%rax,8)
ff
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11f0 <strings_search+0xc0>
mov    -0x20(%rbp),%rax
mov    %rax,-0x848(%rbp)
mov    -0x848(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1381 <strings_search+0x251>
movq   $0x0,-0x868(%rbp)
movq   $0x0,-0x850(%rbp)
mov    -0x850(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    1344 <strings_search+0x214>
mov    -0x38(%rbp),%rax
sub    -0x850(%rbp),%rax
mov    %rax,-0x858(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x858(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x848(%rbp),%rdx
add    -0x858(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1328 <strings_search+0x1f8>
mov    -0x10(%rbp),%rax
mov    -0x848(%rbp),%rcx
add    -0x858(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cltq
mov    -0x840(%rbp,%rax,8),%rax
ff
mov    %rax,-0x860(%rbp)
mov    -0x860(%rbp),%rax
cmp    -0x850(%rbp),%rax
jbe    1304 <strings_search+0x1d4>
mov    -0x860(%rbp),%rax
sub    -0x850(%rbp),%rax
mov    %rax,-0x878(%rbp)
jmp    1315 <strings_search+0x1e5>
mov    $0x1,%eax
mov    %rax,-0x878(%rbp)
jmp    1315 <strings_search+0x1e5>
mov    -0x878(%rbp),%rax
mov    %rax,-0x868(%rbp)
jmp    1344 <strings_search+0x214>
jmp    132d <strings_search+0x1fd>
mov    -0x850(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x850(%rbp)
jmp    125f <strings_search+0x12f>
cmpq   $0x0,-0x868(%rbp)
jne    1362 <strings_search+0x232>
mov    -0x848(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1389 <strings_search+0x259>
jmp    1367 <strings_search+0x237>
mov    -0x868(%rbp),%rax
add    -0x848(%rbp),%rax
mov    %rax,-0x848(%rbp)
jmp    1238 <strings_search+0x108>
mov    -0x28(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x880,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<strings_search>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x808,%rsp
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r15
test   %rdi,%rdi
setne  %al
test   %rsi,%rsi
setne  %cl
and    %al,%cl
movzbl %cl,%edi
call   1050 <assert@plt>
mov    %r15,%rdi
call   1030 <strlen@plt>
mov    %rax,%r12
mov    %rbx,%rdi
call   1030 <strlen@plt>
mov    %rax,%r13
mov    %rsp,%rdi
xor    %ebp,%ebp
mov    $0x800,%edx
xor    %esi,%esi
call   1040 <memset@plt>
movq   %r13,%xmm0
pshufd $0x44,%xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqa %xmm0,(%rsp,%rbp,8)
movdqa %xmm0,0x10(%rsp,%rbp,8)
movdqa %xmm0,0x20(%rsp,%rbp,8)
movdqa %xmm0,0x30(%rsp,%rbp,8)
movdqa %xmm0,0x40(%rsp,%rbp,8)
movdqa %xmm0,0x50(%rsp,%rbp,8)
movdqa %xmm0,0x60(%rsp,%rbp,8)
movdqa %xmm0,0x70(%rsp,%rbp,8)
movdqa %xmm0,0x80(%rsp,%rbp,8)
movdqa %xmm0,0x90(%rsp,%rbp,8)
movdqa %xmm0,0xa0(%rsp,%rbp,8)
movdqa %xmm0,0xb0(%rsp,%rbp,8)
movdqa %xmm0,0xc0(%rsp,%rbp,8)
movdqa %xmm0,0xd0(%rsp,%rbp,8)
movdqa %xmm0,0xe0(%rsp,%rbp,8)
movdqa %xmm0,0xf0(%rsp,%rbp,8)
add    $0x20,%rbp
cmp    $0x100,%rbp
jne    11a0 <strings_search+0x70>
lea    -0x1(%r13),%r8
test   %r13,%r13
je     12d6 <strings_search+0x1a6>
mov    %r13d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
jae    1245 <strings_search+0x115>
xor    %edx,%edx
jmp    12a0 <strings_search+0x170>
mov    %r13,%rsi
and    $0xfffffffffffffffc,%rsi
lea    -0x2(%r13),%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%rdi),%rbp
movsbq (%rbx,%rdx,1),%rax
mov    %rbp,(%rsp,%rax,8)
movsbq 0x1(%rbx,%rdx,1),%rax
mov    %rdi,(%rsp,%rax,8)
lea    -0x1(%rdi),%rax
movsbq 0x2(%rbx,%rdx,1),%rbp
mov    %rax,(%rsp,%rbp,8)
lea    -0x2(%rdi),%rax
movsbq 0x3(%rbx,%rdx,1),%rbp
mov    %rax,(%rsp,%rbp,8)
add    $0x4,%rdx
add    $0xfffffffffffffffc,%rdi
cmp    %rdx,%rsi
jne    1260 <strings_search+0x130>
test   %rcx,%rcx
je     12d6 <strings_search+0x1a6>
lea    (%rbx,%rdx,1),%rsi
not    %rdx
add    %r13,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbq (%rsi,%rdi,1),%rbp
mov    %rdx,(%rsp,%rbp,8)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rdx
cmp    %rdi,%rcx
jne    12c0 <strings_search+0x190>
cmp    %r14,%r12
jbe    1349 <strings_search+0x219>
mov    %r13,%rcx
neg    %rcx
add    %r8,%rbx
add    %r8,%r15
mov    %r14,%rax
test   %r13,%r13
je     135e <strings_search+0x22e>
lea    (%r15,%rax,1),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movsbq (%rsi,%rdx,1),%rdi
cmp    %dil,(%rbx,%rdx,1)
jne    1320 <strings_search+0x1f0>
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rcx
jne    1300 <strings_search+0x1d0>
jmp    1346 <strings_search+0x216>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsp,%rdi,8),%rsi
mov    %rdx,%rbp
neg    %rbp
mov    $0x1,%edi
cmp    %rbp,%rsi
jbe    133c <strings_search+0x20c>
add    %rdx,%rsi
mov    %rsi,%rdi
je     1346 <strings_search+0x216>
add    %rdi,%rax
cmp    %r12,%rax
jb     12ea <strings_search+0x1ba>
jmp    1349 <strings_search+0x219>
mov    %rax,%r12
mov    %r12,%rax
add    $0x808,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14,%r12
jmp    1349 <strings_search+0x219>

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

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