#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 isSubstring(char *, char *);
scalar_t__ malloc(int);
int strlen(char *);
int isRotation(char *s1, char *s2) {
  if (strlen(s1) == strlen(s2)) {
    char *s1s1 = (char *)malloc(2 * strlen(s1) * sizeof(char));
    int i = 0;
    while (i++ < 2) {
      int len = strlen(s1);
      int j;
      for (j = 0; j < len; j++) {
        *(s1s1 + j + (i - 1) * len) = *(s1 + j);
      }
    }
    return isSubstring(s1s1, s2);
  }
  return 0;
}


x86 assembly (clang, -O0):
<isRotation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
cmp    %ecx,%eax
jne    1207 <isRotation+0xd7>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
shl    $0x1,%eax
cltq
shl    $0x0,%rax
mov    %eax,%edi
call   1040 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %eax,%ecx
add    $0x1,%ecx
mov    %ecx,-0x24(%rbp)
cmp    $0x2,%eax
jge    11f2 <isRotation+0xc2>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jge    11ed <isRotation+0xbd>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
imul   -0x28(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11ad <isRotation+0x7d>
jmp    1186 <isRotation+0x56>
mov    -0x20(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1050 <isSubstring@plt>
mov    %eax,-0x4(%rbp)
jmp    120e <isRotation+0xde>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<isRotation>:
push   %rbp
push   %r15
push   %r14
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %eax,%ebp
mov    %r14,%rdi
call   1030 <strlen@plt>
cmp    %eax,%ebp
jne    12c0 <isRotation+0x190>
mov    %rbx,%rdi
call   1030 <strlen@plt>
lea    (%rax,%rax,1),%edi
call   1040 <malloc@plt>
mov    %rax,%r15
mov    %rbx,%rdi
call   1030 <strlen@plt>
test   %eax,%eax
jle    11ff <isRotation+0xcf>
mov    %eax,%r8d
cmp    $0x8,%eax
jb     1199 <isRotation+0x69>
lea    (%rbx,%r8,1),%rdx
cmp    %r15,%rdx
jbe    12cd <isRotation+0x19d>
lea    (%r15,%r8,1),%rdx
cmp    %rbx,%rdx
jbe    12cd <isRotation+0x19d>
xor    %eax,%eax
mov    %rax,%rdx
not    %rdx
add    %r8,%rdx
mov    %r8,%rsi
and    $0x3,%rsi
je     11c2 <isRotation+0x92>
nopl   (%rax)
movzbl (%rbx,%rax,1),%ecx
mov    %cl,(%r15,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    11b0 <isRotation+0x80>
cmp    $0x3,%rdx
jb     11ff <isRotation+0xcf>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rax,1),%ecx
mov    %cl,(%r15,%rax,1)
movzbl 0x1(%rbx,%rax,1),%ecx
mov    %cl,0x1(%r15,%rax,1)
movzbl 0x2(%rbx,%rax,1),%ecx
mov    %cl,0x2(%r15,%rax,1)
movzbl 0x3(%rbx,%rax,1),%ecx
mov    %cl,0x3(%r15,%rax,1)
add    $0x4,%rax
cmp    %rax,%r8
jne    11d0 <isRotation+0xa0>
mov    %rbx,%rdi
call   1030 <strlen@plt>
test   %eax,%eax
jle    12ab <isRotation+0x17b>
mov    %eax,%r9d
lea    (%r15,%r9,1),%rdx
cmp    $0x8,%eax
jb     1235 <isRotation+0x105>
lea    (%rbx,%r9,1),%rsi
cmp    %rsi,%rdx
jae    12d9 <isRotation+0x1a9>
lea    (%r15,%r9,2),%rsi
cmp    %rbx,%rsi
jbe    12d9 <isRotation+0x1a9>
xor    %eax,%eax
mov    %rax,%rsi
not    %rsi
add    %r9,%rsi
mov    %r9,%rdi
and    $0x3,%rdi
je     1261 <isRotation+0x131>
nopl   0x0(%rax)
movzbl (%rbx,%rax,1),%ecx
mov    %cl,(%rdx,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdi
jne    1250 <isRotation+0x120>
cmp    $0x3,%rsi
jb     12ab <isRotation+0x17b>
lea    (%rax,%r9,1),%rcx
sub    %rax,%r9
lea    (%r15,%rcx,1),%rdx
add    $0x3,%rdx
add    %rbx,%rax
add    $0x3,%rax
xor    %esi,%esi
nop
movzbl -0x3(%rax,%rsi,1),%ecx
mov    %cl,-0x3(%rdx,%rsi,1)
movzbl -0x2(%rax,%rsi,1),%ecx
mov    %cl,-0x2(%rdx,%rsi,1)
movzbl -0x1(%rax,%rsi,1),%ecx
mov    %cl,-0x1(%rdx,%rsi,1)
movzbl (%rax,%rsi,1),%ecx
mov    %cl,(%rdx,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1280 <isRotation+0x150>
mov    %r15,%rdi
mov    %r14,%rsi
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
jmp    1050 <isSubstring@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x20,%eax
jae    12e5 <isRotation+0x1b5>
xor    %eax,%eax
jmp    13ee <isRotation+0x2be>
cmp    $0x20,%eax
jae    130c <isRotation+0x1dc>
xor    %eax,%eax
jmp    14de <isRotation+0x3ae>
mov    %r8d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rdi
jae    1339 <isRotation+0x209>
xor    %edi,%edi
jmp    13a0 <isRotation+0x270>
mov    %r9d,%eax
and    $0xffffffe0,%eax
lea    -0x20(%rax),%rsi
mov    %rsi,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rsi
jae    141f <isRotation+0x2ef>
xor    %ebp,%ebp
jmp    1488 <isRotation+0x358>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nop
movups (%rbx,%rdi,1),%xmm0
movups 0x10(%rbx,%rdi,1),%xmm1
movups %xmm0,(%r15,%rdi,1)
movups %xmm1,0x10(%r15,%rdi,1)
movups 0x20(%rbx,%rdi,1),%xmm0
movups 0x30(%rbx,%rdi,1),%xmm1
movups %xmm0,0x20(%r15,%rdi,1)
movups %xmm1,0x30(%r15,%rdi,1)
movups 0x40(%rbx,%rdi,1),%xmm0
movups 0x50(%rbx,%rdi,1),%xmm1
movups %xmm0,0x40(%r15,%rdi,1)
movups %xmm1,0x50(%r15,%rdi,1)
movups 0x60(%rbx,%rdi,1),%xmm0
movups 0x70(%rbx,%rdi,1),%xmm1
movups %xmm0,0x60(%r15,%rdi,1)
movups %xmm1,0x70(%r15,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1340 <isRotation+0x210>
test   %rdx,%rdx
je     13db <isRotation+0x2ab>
lea    (%r15,%rdi,1),%rsi
add    $0x10,%rsi
add    %rbx,%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    13c0 <isRotation+0x290>
cmp    %r8,%rax
je     11ff <isRotation+0xcf>
test   $0x18,%r8b
je     119b <isRotation+0x6b>
mov    %rax,%rdx
mov    %r8d,%eax
and    $0xfffffff8,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rdx,1),%rsi
mov    %rsi,(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rax
jne    1400 <isRotation+0x2d0>
cmp    %r8,%rax
je     11ff <isRotation+0xcf>
jmp    119b <isRotation+0x6b>
and    $0xfffffffffffffffc,%rdi
lea    (%r9,%r15,1),%rsi
add    $0x70,%rsi
xor    %ebp,%ebp
nopl   (%rax)
movups (%rbx,%rbp,1),%xmm0
movups 0x10(%rbx,%rbp,1),%xmm1
movups %xmm0,-0x70(%rsi,%rbp,1)
movups %xmm1,-0x60(%rsi,%rbp,1)
movups 0x20(%rbx,%rbp,1),%xmm0
movups 0x30(%rbx,%rbp,1),%xmm1
movups %xmm0,-0x50(%rsi,%rbp,1)
movups %xmm1,-0x40(%rsi,%rbp,1)
movups 0x40(%rbx,%rbp,1),%xmm0
movups 0x50(%rbx,%rbp,1),%xmm1
movups %xmm0,-0x30(%rsi,%rbp,1)
movups %xmm1,-0x20(%rsi,%rbp,1)
movups 0x60(%rbx,%rbp,1),%xmm0
movups 0x70(%rbx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1430 <isRotation+0x300>
test   %r8,%r8
je     14cb <isRotation+0x39b>
lea    (%r9,%rbp,1),%rsi
add    %r15,%rsi
add    $0x10,%rsi
lea    (%rbx,%rbp,1),%rdi
add    $0x10,%rdi
shl    $0x5,%r8
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    14b0 <isRotation+0x380>
cmp    %r9,%rax
je     12ab <isRotation+0x17b>
test   $0x18,%r9b
je     1237 <isRotation+0x107>
mov    %rax,%rsi
mov    %r9d,%eax
and    $0xfffffff8,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rbx,%rsi,1),%rdi
mov    %rdi,(%rdx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rax
jne    14f0 <isRotation+0x3c0>
cmp    %r9,%rax
je     12ab <isRotation+0x17b>
jmp    1237 <isRotation+0x107>

LLVM IR (-O0):
define i32 @isRotation(i8* %0, i8* %1) {
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
%10 = load i8*, i8** %4
%11 = call i32 @strlen(i8* %10)
%12 = load i8*, i8** %5
%13 = call i32 @strlen(i8* %12)
%14 = icmp eq i32 %11, %13
br i1 %14, label %15, label %59
15: ; preds = %2
%16 = load i8*, i8** %4
%17 = call i32 @strlen(i8* %16)
%18 = mul nsw i32 2, %17
%19 = sext i32 %18 to i64
%20 = mul i64 %19, 1
%21 = trunc i64 %20 to i32
%22 = call i64 @malloc(i32 %21)
%23 = inttoptr i64 %22 to i8*
store i8* %23, i8** %6
store i32 0, i32* %7
br label %24
24: ; preds = %54, %15
%25 = load i32, i32* %7
%26 = add nsw i32 %25, 1
store i32 %26, i32* %7
%27 = icmp slt i32 %25, 2
br i1 %27, label %28, label %55
28: ; preds = %24
%29 = load i8*, i8** %4
%30 = call i32 @strlen(i8* %29)
store i32 %30, i32* %8
store i32 0, i32* %9
br label %31
31: ; preds = %51, %28
%32 = load i32, i32* %9
%33 = load i32, i32* %8
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %54
35: ; preds = %31
%36 = load i8*, i8** %4
%37 = load i32, i32* %9
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i8, i8* %36, i64 %38
%40 = load i8, i8* %39
%41 = load i8*, i8** %6
%42 = load i32, i32* %9
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %41, i64 %43
%45 = load i32, i32* %7
%46 = sub nsw i32 %45, 1
%47 = load i32, i32* %8
%48 = mul nsw i32 %46, %47
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %44, i64 %49
store i8 %40, i8* %50
br label %51
51: ; preds = %35
%52 = load i32, i32* %9
%53 = add nsw i32 %52, 1
store i32 %53, i32* %9
br label %31
54: ; preds = %31
br label %24
55: ; preds = %24
%56 = load i8*, i8** %6
%57 = load i8*, i8** %5
%58 = call i32 @isSubstring(i8* %56, i8* %57)
store i32 %58, i32* %3
br label %60
59: ; preds = %2
store i32 0, i32* %3
br label %60
60: ; preds = %59, %55
%61 = load i32, i32* %3
ret i32 %61
}

LLVM IR (-O2):
define i32 @isRotation(i8* %0, i8* %1) {
%3 = tail call i32 @strlen(i8* %0)
%4 = tail call i32 @strlen(i8* %1)
%5 = icmp eq i32 %3, %4
br i1 %5, label %6, label %309
6: ; preds = %2
%7 = tail call i32 @strlen(i8* %0)
%8 = shl nsw i32 %7, 1
%9 = tail call i64 @malloc(i32 %8)
%10 = inttoptr i64 %9 to i8*
%11 = tail call i32 @strlen(i8* %0)
%12 = icmp sgt i32 %11, 0
br i1 %12, label %165, label %13
13: ; preds = %287, %290, %253, %270, %6
%14 = tail call i32 @strlen(i8* %0)
%15 = icmp sgt i32 %14, 0
br i1 %15, label %16, label %163
16: ; preds = %13
%17 = zext i32 %14 to i64
%18 = zext i32 %14 to i64
%19 = getelementptr inbounds i8, i8* %10, i64 %17
%20 = icmp ult i32 %14, 8
br i1 %20, label %126, label %21
21: ; preds = %16
%22 = shl nuw nsw i64 %18, 1
%23 = getelementptr i8, i8* %10, i64 %22
%24 = getelementptr i8, i8* %0, i64 %18
%25 = icmp ult i8* %19, %24
%26 = icmp ugt i8* %23, %0
%27 = and i1 %25, %26
br i1 %27, label %126, label %28
28: ; preds = %21
%29 = icmp ult i32 %14, 32
br i1 %29, label %112, label %30
30: ; preds = %28
%31 = and i64 %18, 4294967264
%32 = add nsw i64 %31, -32
%33 = lshr exact i64 %32, 5
%34 = add nuw nsw i64 %33, 1
%35 = and i64 %34, 3
%36 = icmp ult i64 %32, 96
br i1 %36, label %88, label %37
37: ; preds = %30
%38 = and i64 %34, 1152921504606846972
br label %39
39: ; preds = %39, %37
%40 = phi i64 [ 0, %37 ], [ %85, %39 ]
%41 = phi i64 [ 0, %37 ], [ %86, %39 ]
%42 = getelementptr inbounds i8, i8* %0, i64 %40
%43 = bitcast i8* %42 to <16 x i8>*
%44 = load <16 x i8>, <16 x i8>* %43
%45 = getelementptr inbounds i8, i8* %42, i64 16
%46 = bitcast i8* %45 to <16 x i8>*
%47 = load <16 x i8>, <16 x i8>* %46
%48 = getelementptr inbounds i8, i8* %19, i64 %40
%49 = bitcast i8* %48 to <16 x i8>*
store <16 x i8> %44, <16 x i8>* %49
%50 = getelementptr inbounds i8, i8* %48, i64 16
%51 = bitcast i8* %50 to <16 x i8>*
store <16 x i8> %47, <16 x i8>* %51
%52 = or i64 %40, 32
%53 = getelementptr inbounds i8, i8* %0, i64 %52
%54 = bitcast i8* %53 to <16 x i8>*
%55 = load <16 x i8>, <16 x i8>* %54
%56 = getelementptr inbounds i8, i8* %53, i64 16
%57 = bitcast i8* %56 to <16 x i8>*
%58 = load <16 x i8>, <16 x i8>* %57
%59 = getelementptr inbounds i8, i8* %19, i64 %52
%60 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %55, <16 x i8>* %60
%61 = getelementptr inbounds i8, i8* %59, i64 16
%62 = bitcast i8* %61 to <16 x i8>*
store <16 x i8> %58, <16 x i8>* %62
%63 = or i64 %40, 64
%64 = getelementptr inbounds i8, i8* %0, i64 %63
%65 = bitcast i8* %64 to <16 x i8>*
%66 = load <16 x i8>, <16 x i8>* %65
%67 = getelementptr inbounds i8, i8* %64, i64 16
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = getelementptr inbounds i8, i8* %19, i64 %63
%71 = bitcast i8* %70 to <16 x i8>*
store <16 x i8> %66, <16 x i8>* %71
%72 = getelementptr inbounds i8, i8* %70, i64 16
%73 = bitcast i8* %72 to <16 x i8>*
store <16 x i8> %69, <16 x i8>* %73
%74 = or i64 %40, 96
%75 = getelementptr inbounds i8, i8* %0, i64 %74
%76 = bitcast i8* %75 to <16 x i8>*
%77 = load <16 x i8>, <16 x i8>* %76
%78 = getelementptr inbounds i8, i8* %75, i64 16
%79 = bitcast i8* %78 to <16 x i8>*
%80 = load <16 x i8>, <16 x i8>* %79
%81 = getelementptr inbounds i8, i8* %19, i64 %74
%82 = bitcast i8* %81 to <16 x i8>*
store <16 x i8> %77, <16 x i8>* %82
%83 = getelementptr inbounds i8, i8* %81, i64 16
%84 = bitcast i8* %83 to <16 x i8>*
store <16 x i8> %80, <16 x i8>* %84
%85 = add nuw i64 %40, 128
%86 = add i64 %41, 4
%87 = icmp eq i64 %86, %38
br i1 %87, label %88, label %39
88: ; preds = %39, %30
%89 = phi i64 [ 0, %30 ], [ %85, %39 ]
%90 = icmp eq i64 %35, 0
br i1 %90, label %107, label %91
91: ; preds = %88, %91
%92 = phi i64 [ %104, %91 ], [ %89, %88 ]
%93 = phi i64 [ %105, %91 ], [ 0, %88 ]
%94 = getelementptr inbounds i8, i8* %0, i64 %92
%95 = bitcast i8* %94 to <16 x i8>*
%96 = load <16 x i8>, <16 x i8>* %95
%97 = getelementptr inbounds i8, i8* %94, i64 16
%98 = bitcast i8* %97 to <16 x i8>*
%99 = load <16 x i8>, <16 x i8>* %98
%100 = getelementptr inbounds i8, i8* %19, i64 %92
%101 = bitcast i8* %100 to <16 x i8>*
store <16 x i8> %96, <16 x i8>* %101
%102 = getelementptr inbounds i8, i8* %100, i64 16
%103 = bitcast i8* %102 to <16 x i8>*
store <16 x i8> %99, <16 x i8>* %103
%104 = add nuw i64 %92, 32
%105 = add i64 %93, 1
%106 = icmp eq i64 %105, %35
br i1 %106, label %107, label %91
107: ; preds = %91, %88
%108 = icmp eq i64 %31, %18
br i1 %108, label %163, label %109
109: ; preds = %107
%110 = and i64 %18, 24
%111 = icmp eq i64 %110, 0
br i1 %111, label %126, label %112
112: ; preds = %28, %109
%113 = phi i64 [ %31, %109 ], [ 0, %28 ]
%114 = and i64 %18, 4294967288
br label %115
115: ; preds = %115, %112
%116 = phi i64 [ %113, %112 ], [ %122, %115 ]
%117 = getelementptr inbounds i8, i8* %0, i64 %116
%118 = bitcast i8* %117 to <8 x i8>*
%119 = load <8 x i8>, <8 x i8>* %118
%120 = getelementptr inbounds i8, i8* %19, i64 %116
%121 = bitcast i8* %120 to <8 x i8>*
store <8 x i8> %119, <8 x i8>* %121
%122 = add nuw i64 %116, 8
%123 = icmp eq i64 %122, %114
br i1 %123, label %124, label %115
124: ; preds = %115
%125 = icmp eq i64 %114, %18
br i1 %125, label %163, label %126
126: ; preds = %21, %16, %109, %124
%127 = phi i64 [ 0, %16 ], [ 0, %21 ], [ %31, %109 ], [ %114, %124 ]
%128 = xor i64 %127, -1
%129 = add nsw i64 %128, %18
%130 = and i64 %18, 3
%131 = icmp eq i64 %130, 0
br i1 %131, label %141, label %132
132: ; preds = %126, %132
%133 = phi i64 [ %138, %132 ], [ %127, %126 ]
%134 = phi i64 [ %139, %132 ], [ 0, %126 ]
%135 = getelementptr inbounds i8, i8* %0, i64 %133
%136 = load i8, i8* %135
%137 = getelementptr inbounds i8, i8* %19, i64 %133
store i8 %136, i8* %137
%138 = add nuw nsw i64 %133, 1
%139 = add i64 %134, 1
%140 = icmp eq i64 %139, %130
br i1 %140, label %141, label %132
141: ; preds = %132, %126
%142 = phi i64 [ %127, %126 ], [ %138, %132 ]
%143 = icmp ult i64 %129, 3
br i1 %143, label %163, label %144
144: ; preds = %141, %144
%145 = phi i64 [ %161, %144 ], [ %142, %141 ]
%146 = getelementptr inbounds i8, i8* %0, i64 %145
%147 = load i8, i8* %146
%148 = getelementptr inbounds i8, i8* %19, i64 %145
store i8 %147, i8* %148
%149 = add nuw nsw i64 %145, 1
%150 = getelementptr inbounds i8, i8* %0, i64 %149
%151 = load i8, i8* %150
%152 = getelementptr inbounds i8, i8* %19, i64 %149
store i8 %151, i8* %152
%153 = add nuw nsw i64 %145, 2
%154 = getelementptr inbounds i8, i8* %0, i64 %153
%155 = load i8, i8* %154
%156 = getelementptr inbounds i8, i8* %19, i64 %153
store i8 %155, i8* %156
%157 = add nuw nsw i64 %145, 3
%158 = getelementptr inbounds i8, i8* %0, i64 %157
%159 = load i8, i8* %158
%160 = getelementptr inbounds i8, i8* %19, i64 %157
store i8 %159, i8* %160
%161 = add nuw nsw i64 %145, 4
%162 = icmp eq i64 %161, %18
br i1 %162, label %163, label %144
163: ; preds = %141, %144, %107, %124, %13
%164 = tail call i32 @isSubstring(i8* %10, i8* %1)
br label %309
165: ; preds = %6
%166 = zext i32 %11 to i64
%167 = icmp ult i32 %11, 8
br i1 %167, label %272, label %168
168: ; preds = %165
%169 = getelementptr i8, i8* %10, i64 %166
%170 = getelementptr i8, i8* %0, i64 %166
%171 = icmp ugt i8* %170, %10
%172 = icmp ugt i8* %169, %0
%173 = and i1 %171, %172
br i1 %173, label %272, label %174
174: ; preds = %168
%175 = icmp ult i32 %11, 32
br i1 %175, label %258, label %176
176: ; preds = %174
%177 = and i64 %166, 4294967264
%178 = add nsw i64 %177, -32
%179 = lshr exact i64 %178, 5
%180 = add nuw nsw i64 %179, 1
%181 = and i64 %180, 3
%182 = icmp ult i64 %178, 96
br i1 %182, label %234, label %183
183: ; preds = %176
%184 = and i64 %180, 1152921504606846972
br label %185
185: ; preds = %185, %183
%186 = phi i64 [ 0, %183 ], [ %231, %185 ]
%187 = phi i64 [ 0, %183 ], [ %232, %185 ]
%188 = getelementptr inbounds i8, i8* %0, i64 %186
%189 = bitcast i8* %188 to <16 x i8>*
%190 = load <16 x i8>, <16 x i8>* %189
%191 = getelementptr inbounds i8, i8* %188, i64 16
%192 = bitcast i8* %191 to <16 x i8>*
%193 = load <16 x i8>, <16 x i8>* %192
%194 = getelementptr inbounds i8, i8* %10, i64 %186
%195 = bitcast i8* %194 to <16 x i8>*
store <16 x i8> %190, <16 x i8>* %195
%196 = getelementptr inbounds i8, i8* %194, i64 16
%197 = bitcast i8* %196 to <16 x i8>*
store <16 x i8> %193, <16 x i8>* %197
%198 = or i64 %186, 32
%199 = getelementptr inbounds i8, i8* %0, i64 %198
%200 = bitcast i8* %199 to <16 x i8>*
%201 = load <16 x i8>, <16 x i8>* %200
%202 = getelementptr inbounds i8, i8* %199, i64 16
%203 = bitcast i8* %202 to <16 x i8>*
%204 = load <16 x i8>, <16 x i8>* %203
%205 = getelementptr inbounds i8, i8* %10, i64 %198
%206 = bitcast i8* %205 to <16 x i8>*
store <16 x i8> %201, <16 x i8>* %206
%207 = getelementptr inbounds i8, i8* %205, i64 16
%208 = bitcast i8* %207 to <16 x i8>*
store <16 x i8> %204, <16 x i8>* %208
%209 = or i64 %186, 64
%210 = getelementptr inbounds i8, i8* %0, i64 %209
%211 = bitcast i8* %210 to <16 x i8>*
%212 = load <16 x i8>, <16 x i8>* %211
%213 = getelementptr inbounds i8, i8* %210, i64 16
%214 = bitcast i8* %213 to <16 x i8>*
%215 = load <16 x i8>, <16 x i8>* %214
%216 = getelementptr inbounds i8, i8* %10, i64 %209
%217 = bitcast i8* %216 to <16 x i8>*
store <16 x i8> %212, <16 x i8>* %217
%218 = getelementptr inbounds i8, i8* %216, i64 16
%219 = bitcast i8* %218 to <16 x i8>*
store <16 x i8> %215, <16 x i8>* %219
%220 = or i64 %186, 96
%221 = getelementptr inbounds i8, i8* %0, i64 %220
%222 = bitcast i8* %221 to <16 x i8>*
%223 = load <16 x i8>, <16 x i8>* %222
%224 = getelementptr inbounds i8, i8* %221, i64 16
%225 = bitcast i8* %224 to <16 x i8>*
%226 = load <16 x i8>, <16 x i8>* %225
%227 = getelementptr inbounds i8, i8* %10, i64 %220
%228 = bitcast i8* %227 to <16 x i8>*
store <16 x i8> %223, <16 x i8>* %228
%229 = getelementptr inbounds i8, i8* %227, i64 16
%230 = bitcast i8* %229 to <16 x i8>*
store <16 x i8> %226, <16 x i8>* %230
%231 = add nuw i64 %186, 128
%232 = add i64 %187, 4
%233 = icmp eq i64 %232, %184
br i1 %233, label %234, label %185
234: ; preds = %185, %176
%235 = phi i64 [ 0, %176 ], [ %231, %185 ]
%236 = icmp eq i64 %181, 0
br i1 %236, label %253, label %237
237: ; preds = %234, %237
%238 = phi i64 [ %250, %237 ], [ %235, %234 ]
%239 = phi i64 [ %251, %237 ], [ 0, %234 ]
%240 = getelementptr inbounds i8, i8* %0, i64 %238
%241 = bitcast i8* %240 to <16 x i8>*
%242 = load <16 x i8>, <16 x i8>* %241
%243 = getelementptr inbounds i8, i8* %240, i64 16
%244 = bitcast i8* %243 to <16 x i8>*
%245 = load <16 x i8>, <16 x i8>* %244
%246 = getelementptr inbounds i8, i8* %10, i64 %238
%247 = bitcast i8* %246 to <16 x i8>*
store <16 x i8> %242, <16 x i8>* %247
%248 = getelementptr inbounds i8, i8* %246, i64 16
%249 = bitcast i8* %248 to <16 x i8>*
store <16 x i8> %245, <16 x i8>* %249
%250 = add nuw i64 %238, 32
%251 = add i64 %239, 1
%252 = icmp eq i64 %251, %181
br i1 %252, label %253, label %237
253: ; preds = %237, %234
%254 = icmp eq i64 %177, %166
br i1 %254, label %13, label %255
255: ; preds = %253
%256 = and i64 %166, 24
%257 = icmp eq i64 %256, 0
br i1 %257, label %272, label %258
258: ; preds = %174, %255
%259 = phi i64 [ %177, %255 ], [ 0, %174 ]
%260 = and i64 %166, 4294967288
br label %261
261: ; preds = %261, %258
%262 = phi i64 [ %259, %258 ], [ %268, %261 ]
%263 = getelementptr inbounds i8, i8* %0, i64 %262
%264 = bitcast i8* %263 to <8 x i8>*
%265 = load <8 x i8>, <8 x i8>* %264
%266 = getelementptr inbounds i8, i8* %10, i64 %262
%267 = bitcast i8* %266 to <8 x i8>*
store <8 x i8> %265, <8 x i8>* %267
%268 = add nuw i64 %262, 8
%269 = icmp eq i64 %268, %260
br i1 %269, label %270, label %261
270: ; preds = %261
%271 = icmp eq i64 %260, %166
br i1 %271, label %13, label %272
272: ; preds = %168, %165, %255, %270
%273 = phi i64 [ 0, %165 ], [ 0, %168 ], [ %177, %255 ], [ %260, %270 ]
%274 = xor i64 %273, -1
%275 = add nsw i64 %274, %166
%276 = and i64 %166, 3
%277 = icmp eq i64 %276, 0
br i1 %277, label %287, label %278
278: ; preds = %272, %278
%279 = phi i64 [ %284, %278 ], [ %273, %272 ]
%280 = phi i64 [ %285, %278 ], [ 0, %272 ]
%281 = getelementptr inbounds i8, i8* %0, i64 %279
%282 = load i8, i8* %281
%283 = getelementptr inbounds i8, i8* %10, i64 %279
store i8 %282, i8* %283
%284 = add nuw nsw i64 %279, 1
%285 = add i64 %280, 1
%286 = icmp eq i64 %285, %276
br i1 %286, label %287, label %278
287: ; preds = %278, %272
%288 = phi i64 [ %273, %272 ], [ %284, %278 ]
%289 = icmp ult i64 %275, 3
br i1 %289, label %13, label %290
290: ; preds = %287, %290
%291 = phi i64 [ %307, %290 ], [ %288, %287 ]
%292 = getelementptr inbounds i8, i8* %0, i64 %291
%293 = load i8, i8* %292
%294 = getelementptr inbounds i8, i8* %10, i64 %291
store i8 %293, i8* %294
%295 = add nuw nsw i64 %291, 1
%296 = getelementptr inbounds i8, i8* %0, i64 %295
%297 = load i8, i8* %296
%298 = getelementptr inbounds i8, i8* %10, i64 %295
store i8 %297, i8* %298
%299 = add nuw nsw i64 %291, 2
%300 = getelementptr inbounds i8, i8* %0, i64 %299
%301 = load i8, i8* %300
%302 = getelementptr inbounds i8, i8* %10, i64 %299
store i8 %301, i8* %302
%303 = add nuw nsw i64 %291, 3
%304 = getelementptr inbounds i8, i8* %0, i64 %303
%305 = load i8, i8* %304
%306 = getelementptr inbounds i8, i8* %10, i64 %303
store i8 %305, i8* %306
%307 = add nuw nsw i64 %291, 4
%308 = icmp eq i64 %307, %166
br i1 %308, label %13, label %290
309: ; preds = %2, %163
%310 = phi i32 [ %164, %163 ], [ 0, %2 ]
ret i32 %310
}