#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*/ buildIndex(char *, int *);
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
int strlen(char *);
int KMPSearch(char *subString, char *originalString) {
  int i, j, temp, stringLength, *stringIndex;
  int index = -1;
  stringLength = strlen(subString);
  stringIndex = (int *)malloc(stringLength * sizeof(int));
  memset(stringIndex, 0, stringLength * sizeof(int));
  buildIndex(subString, stringIndex);
  i = 0;
  while (originalString[i] != '\0') {
    temp = i;
    j = 0;
    while ((subString[j] == originalString[temp]) &&
           (originalString[temp] != '\0')) {
      j++;
      temp++;
    }
    if (subString[j] == '\0') {
      index = i;
      free(stringIndex);
      break;
    }
    if (originalString[temp] == '\0') {
      free(stringIndex);
      break;
    }
    if (j > 0)
      i += j - stringIndex[j - 1];
    else
      i += 1;
  }
  return index;
}


x86 assembly (clang, -O0):
<KMPSearch>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0xffffffff,-0x2c(%rbp)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %eax,-0x20(%rbp)
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1070 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rdi
movslq -0x20(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1050 <memset@plt>
mov    -0x8(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1060 <buildIndex@plt>
movl   $0x0,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
je     12b4 <KMPSearch+0x164>
mov    -0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rdx
movsbl (%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x2d(%rbp)
jne    120b <KMPSearch+0xbb>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    121b <KMPSearch+0xcb>
jmp    1232 <KMPSearch+0xe2>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11d1 <KMPSearch+0x81>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    125b <KMPSearch+0x10b>
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
jmp    12b4 <KMPSearch+0x164>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
jne    127e <KMPSearch+0x12e>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
jmp    12b4 <KMPSearch+0x164>
cmpl   $0x0,-0x18(%rbp)
jle    12a6 <KMPSearch+0x156>
mov    -0x18(%rbp),%eax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
sub    (%rcx,%rdx,4),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    12af <KMPSearch+0x15f>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11af <KMPSearch+0x5f>
mov    -0x2c(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<KMPSearch>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r14
mov    %rdi,%rbp
call   1040 <strlen@plt>
lea    0x0(,%rax,4),%r12d
mov    %r12d,%edi
call   1070 <malloc@plt>
mov    %rax,%r15
xor    %r13d,%r13d
mov    %rax,%rdi
xor    %esi,%esi
mov    %r12d,%edx
call   1050 <memset@plt>
mov    %rbp,%rdi
mov    %r15,%rsi
call   1060 <buildIndex@plt>
mov    (%r14),%cl
mov    $0xffffffff,%r12d
test   %cl,%cl
je     121f <KMPSearch+0xcf>
mov    0x0(%rbp),%r8b
lea    0x1(%r14),%rsi
jmp    11c5 <KMPSearch+0x75>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rdx),%eax
sub    (%r15,%rax,4),%edx
add    %edx,%r13d
movslq %r13d,%rax
mov    (%r14,%rax,1),%cl
test   %cl,%cl
je     121f <KMPSearch+0xcf>
xor    %edx,%edx
mov    %r8d,%eax
mov    $0x0,%edi
cmp    %cl,%r8b
jne    11fb <KMPSearch+0xab>
movslq %r13d,%rcx
add    %rsi,%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movzbl 0x1(%rbp,%rdx,1),%eax
movzbl (%rcx,%rdx,1),%ebx
add    $0x1,%rdx
test   %bl,%bl
sete   %dil
cmp    %bl,%al
jne    11fb <KMPSearch+0xab>
test   %bl,%bl
jne    11e0 <KMPSearch+0x90>
test   %al,%al
je     120f <KMPSearch+0xbf>
test   %dil,%dil
jne    120f <KMPSearch+0xbf>
test   %edx,%edx
jne    11b0 <KMPSearch+0x60>
mov    $0x1,%edx
jmp    11b7 <KMPSearch+0x67>
neg    %al
sbb    %r12d,%r12d
or     %r13d,%r12d
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12d,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @KMPSearch(i8* %0, i8* nocapture %1) {
%3 = tail call i32 @strlen(i8* %0)
%4 = shl i32 %3, 2
%5 = tail call i64 @malloc(i32 %4)
%6 = inttoptr i64 %5 to i32*
%7 = tail call i32 @memset(i32* %6, i32 0, i32 %4)
%8 = tail call i32 @buildIndex(i8* %0, i32* %6)
%9 = load i8, i8* %1
%10 = icmp eq i8 %9, 0
br i1 %10, label %57, label %11
11: ; preds = %2
%12 = load i8, i8* %0
br label %13
13: ; preds = %11, %47
%14 = phi i8 [ %9, %11 ], [ %52, %47 ]
%15 = phi i32 [ 0, %11 ], [ %49, %47 ]
%16 = icmp eq i8 %12, %14
br i1 %16, label %17, label %33
17: ; preds = %13
%18 = sext i32 %15 to i64
br label %19
19: ; preds = %17, %19
%20 = phi i64 [ %18, %17 ], [ %23, %19 ]
%21 = phi i64 [ 0, %17 ], [ %22, %19 ]
%22 = add nuw nsw i64 %21, 1
%23 = add i64 %20, 1
%24 = getelementptr inbounds i8, i8* %0, i64 %22
%25 = load i8, i8* %24
%26 = getelementptr inbounds i8, i8* %1, i64 %23
%27 = load i8, i8* %26
%28 = icmp ne i8 %25, %27
%29 = icmp eq i8 %27, 0
%30 = or i1 %28, %29
br i1 %30, label %31, label %19
31: ; preds = %19
%32 = trunc i64 %22 to i32
br label %33
33: ; preds = %31, %13
%34 = phi i32 [ 0, %13 ], [ %32, %31 ]
%35 = phi i8 [ %12, %13 ], [ %25, %31 ]
%36 = phi i1 [ false, %13 ], [ %29, %31 ]
%37 = icmp eq i8 %35, 0
%38 = select i1 %37, i1 true, i1 %36
br i1 %38, label %54, label %39
39: ; preds = %33
%40 = icmp eq i32 %34, 0
br i1 %40, label %47, label %41
41: ; preds = %39
%42 = add nsw i32 %34, -1
%43 = zext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %6, i64 %43
%45 = load i32, i32* %44
%46 = sub nsw i32 %34, %45
br label %47
47: ; preds = %39, %41
%48 = phi i32 [ %46, %41 ], [ 1, %39 ]
%49 = add nsw i32 %48, %15
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %1, i64 %50
%52 = load i8, i8* %51
%53 = icmp eq i8 %52, 0
br i1 %53, label %57, label %13
54: ; preds = %33
%55 = select i1 %37, i32 %15, i32 -1
%56 = tail call i32 @free(i32* %6)
br label %57
57: ; preds = %47, %54, %2
%58 = phi i32 [ -1, %2 ], [ %55, %54 ], [ -1, %47 ]
ret i32 %58
}