#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*/ memcpy(char *, char *, int);
int find_and_replace(char *src, int src_length, char *find, int find_length,
                     char *replace, int replace_length) {
  int src_index;
  for (src_index = 0; src_index <= src_length - find_length; src_index++) {
    int find_index;
    int find_flag = 1;
    for (find_index = 0; find_index < find_length; find_index++) {
      if (src[find_index + src_index] != find[find_index]) {
        find_flag = 0;
        break;
      }
    }
    if (find_flag) {
      if (find_length >= replace_length) {
        memcpy(src + src_index, replace, replace_length);
        int find_index = src_index + replace_length;
        int replace_index = src_index + find_length;
        while (replace_index <= src_length) {
          src[find_index] = src[replace_index];
          find_index++;
          replace_index++;
        }
        return src_length - find_length + replace_length;
      } else {
        int replace_index = src_length + replace_length - find_length;
        int error = replace_length - find_length;
        int length = src_length - src_index - find_length + 1;
        while (length--) {
          src[replace_index] = src[replace_index - error];
          replace_index--;
        }
        memcpy(src + src_index, replace, replace_length);
        return src_length - find_length + replace_length;
      }
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<find_and_replace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    -0x24(%rbp),%ecx
cmp    %ecx,%eax
jg     12c9 <find_and_replace+0x1b9>
movl   $0x1,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    11a4 <find_and_replace+0x94>
mov    -0x10(%rbp),%rax
mov    -0x3c(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%rcx
movslq -0x3c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1191 <find_and_replace+0x81>
movl   $0x0,-0x40(%rbp)
jmp    11a4 <find_and_replace+0x94>
jmp    1196 <find_and_replace+0x86>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1154 <find_and_replace+0x44>
cmpl   $0x0,-0x40(%rbp)
je     12b6 <find_and_replace+0x1a6>
mov    -0x24(%rbp),%eax
cmp    -0x34(%rbp),%eax
jl     122d <find_and_replace+0x11d>
mov    -0x10(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1030 <memcpy@plt>
mov    -0x38(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     121c <find_and_replace+0x10c>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11e3 <find_and_replace+0xd3>
mov    -0x14(%rbp),%eax
sub    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    12d0 <find_and_replace+0x1c0>
mov    -0x14(%rbp),%eax
add    -0x34(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
sub    -0x24(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x38(%rbp),%eax
sub    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x54(%rbp)
cmp    $0x0,%eax
je     128e <find_and_replace+0x17e>
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
sub    -0x50(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x4c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x4c(%rbp)
jmp    1251 <find_and_replace+0x141>
mov    -0x10(%rbp),%rdi
movslq -0x38(%rbp),%rax
add    %rax,%rdi
mov    -0x30(%rbp),%rsi
mov    -0x34(%rbp),%edx
call   1030 <memcpy@plt>
mov    -0x14(%rbp),%eax
sub    -0x24(%rbp),%eax
add    -0x34(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    12d0 <find_and_replace+0x1c0>
jmp    12bb <find_and_replace+0x1ab>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1135 <find_and_replace+0x25>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_and_replace>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %esi,%r15d
sub    %ecx,%r15d
js     117d <find_and_replace+0x6d>
mov    %ecx,%ebx
mov    %esi,%r12d
mov    %rdi,%r14
lea    0x1(%r12),%r11d
mov    %r11d,%r10d
sub    %ecx,%r10d
mov    %ecx,%esi
xor    %r13d,%r13d
mov    %rdi,%rbp
xor    %edi,%edi
test   %ebx,%ebx
jle    1188 <find_and_replace+0x78>
xor    %eax,%eax
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rax,1),%ecx
cmp    (%rdx,%rax,1),%cl
jne    1170 <find_and_replace+0x60>
add    $0x1,%rax
cmp    %rax,%rsi
jne    1150 <find_and_replace+0x40>
jmp    1185 <find_and_replace+0x75>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rdi
add    $0x1,%rbp
cmp    %r10,%rdi
jne    1143 <find_and_replace+0x33>
xor    %r15d,%r15d
jmp    15be <find_and_replace+0x4ae>
mov    %edi,%r13d
mov    %ebx,%ecx
sub    %r9d,%ecx
jge    11cf <find_and_replace+0xbf>
add    %r9d,%r15d
lea    (%rbx,%r13,1),%eax
sub    %eax,%r11d
je     1329 <find_and_replace+0x219>
movslq %r15d,%rbp
mov    %r12d,%edx
sub    %eax,%edx
cmp    $0x7,%edx
jae    1254 <find_and_replace+0x144>
mov    %rbp,%rdx
test   $0x1,%r11b
jne    12d0 <find_and_replace+0x1c0>
mov    %r11d,%esi
cmp    $0x1,%r11d
jne    12eb <find_and_replace+0x1db>
jmp    1329 <find_and_replace+0x219>
mov    %r13d,%edi
add    %r14,%rdi
mov    %r8,%rsi
mov    %r9d,%edx
mov    %r9d,(%rsp)
call   1030 <memcpy@plt>
mov    (%rsp),%r9d
add    %r13d,%ebx
cmp    %r12d,%ebx
jg     15bb <find_and_replace+0x4ab>
add    %r9d,%r13d
movslq %ebx,%rax
movslq %r13d,%rcx
mov    %r12d,%r8d
sub    %ebx,%r8d
cmp    $0x7,%r8d
jb     152d <find_and_replace+0x41d>
lea    (%r14,%rcx,1),%r13
lea    (%r14,%rax,1),%r11
lea    (%rax,%r8,1),%rdx
add    %r14,%rdx
add    $0x1,%rdx
cmp    %rdx,%r13
jae    1239 <find_and_replace+0x129>
lea    (%rcx,%r8,1),%rdx
add    %r14,%rdx
add    $0x1,%rdx
cmp    %rdx,%r11
jb     152d <find_and_replace+0x41d>
movabs $0x1fffffff8,%rbx
cmp    $0x1f,%r8d
jae    1342 <find_and_replace+0x232>
xor    %edx,%edx
jmp    14a9 <find_and_replace+0x399>
mov    %r12d,%r10d
sub    %eax,%r10d
jl     11b0 <find_and_replace+0xa0>
lea    (%r14,%rbp,1),%rax
mov    %rax,%rsi
sub    %rdx,%rsi
cmp    %rax,%rsi
ja     11b0 <find_and_replace+0xa0>
movslq %r12d,%rsi
lea    (%r14,%rsi,1),%rax
mov    %rax,%rdi
sub    %rdx,%rdi
cmp    %rax,%rdi
ja     11b0 <find_and_replace+0xa0>
mov    %rbp,%rax
sub    %r10,%rax
add    %r14,%rax
lea    (%rsi,%r14,1),%rdi
add    $0x1,%rdi
cmp    %rdi,%rax
jae    12b6 <find_and_replace+0x1a6>
lea    (%r14,%rbp,1),%rax
add    $0x1,%rax
sub    %r10,%rsi
add    %r14,%rsi
cmp    %rax,%rsi
jb     11b0 <find_and_replace+0xa0>
movabs $0x1fffffff8,%rdi
cmp    $0xf,%edx
jae    13c9 <find_and_replace+0x2b9>
xor    %eax,%eax
jmp    15da <find_and_replace+0x4ca>
lea    -0x1(%r11),%esi
add    %edx,%ecx
movslq %ecx,%rax
mov    (%r14,%rax,1),%al
mov    %al,(%r14,%rdx,1)
add    $0xffffffffffffffff,%rdx
cmp    $0x1,%r11d
je     1329 <find_and_replace+0x219>
lea    (%r14,%rdx,1),%rax
add    %edx,%ebx
sub    %r9d,%ebx
mov    %esi,%esi
mov    $0xffffffffffffffff,%rdx
nopl   (%rax)
movslq %ebx,%rbx
movzbl (%r14,%rbx,1),%ecx
mov    %cl,0x1(%rax,%rdx,1)
lea    -0x1(%rbx),%ecx
movslq %ecx,%rcx
movzbl (%r14,%rcx,1),%ecx
mov    %cl,(%rax,%rdx,1)
add    $0xfffffffffffffffe,%rdx
add    $0xfffffffe,%ebx
lea    (%rsi,%rdx,1),%ecx
cmp    $0xffffffff,%ecx
jne    1300 <find_and_replace+0x1f0>
mov    %r13d,%eax
add    %rax,%r14
mov    %r14,%rdi
mov    %r8,%rsi
mov    %r9d,%edx
call   1030 <memcpy@plt>
jmp    15be <find_and_replace+0x4ae>
lea    0x1(%r8),%rsi
lea    -0x18(%rbx),%rdx
mov    %rsi,0x8(%rsp)
and    %rsi,%rdx
lea    -0x20(%rdx),%rsi
mov    %rsi,%r10
shr    $0x5,%r10
add    $0x1,%r10
test   %rsi,%rsi
je     1468 <find_and_replace+0x358>
mov    %r10,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rcx,%r14,1),%rsi
add    $0x30,%rsi
lea    (%rax,%r14,1),%r9
add    $0x30,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r9,%rdi,1),%xmm0
movups -0x20(%r9,%rdi,1),%xmm1
movups %xmm0,-0x30(%rsi,%rdi,1)
movups %xmm1,-0x20(%rsi,%rdi,1)
movups -0x10(%r9,%rdi,1),%xmm0
movups (%r9,%rdi,1),%xmm1
movups %xmm0,-0x10(%rsi,%rdi,1)
movups %xmm1,(%rsi,%rdi,1)
add    $0x40,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1390 <find_and_replace+0x280>
jmp    146a <find_and_replace+0x35a>
add    $0x1,%rdx
lea    -0x8(%rdi),%rax
and    %rdx,%rax
mov    %rax,(%rsp)
add    $0xfffffffffffffff0,%rax
mov    %rax,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
test   %rax,%rax
je     14dc <find_and_replace+0x3cc>
mov    %r10,0x20(%rsp)
mov    %r11,0x8(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rsi,%r11
and    $0xfffffffffffffffe,%r11
mov    %rbp,0x18(%rsp)
lea    (%r14,%rbp,1),%r10
add    $0xfffffffffffffff1,%r10
lea    -0x10(%r12),%esi
mov    %r12d,%ebp
xor    %edi,%edi
nopl   (%rax)
lea    (%rdi,%rbp,1),%eax
cltq
movups -0xf(%r14,%rax,1),%xmm0
movups %xmm0,(%r10,%rdi,1)
lea    (%rsi,%rdi,1),%eax
cltq
movups -0xf(%r14,%rax,1),%xmm0
movups %xmm0,-0x10(%r10,%rdi,1)
add    $0xffffffffffffffe0,%rdi
add    $0xfffffffffffffffe,%r11
jne    1420 <find_and_replace+0x310>
neg    %rdi
mov    0x8(%rsp),%r11
mov    0x20(%rsp),%r10
mov    0x18(%rsp),%rbp
mov    (%rsp),%rax
mov    0x10(%rsp),%rsi
jmp    14e2 <find_and_replace+0x3d2>
xor    %edi,%edi
test   $0x1,%r10b
je     148d <find_and_replace+0x37d>
lea    (%rdi,%rcx,1),%rsi
add    %rax,%rdi
movups (%r14,%rdi,1),%xmm0
movups 0x10(%r14,%rdi,1),%xmm1
movups %xmm0,(%r14,%rsi,1)
movups %xmm1,0x10(%r14,%rsi,1)
mov    0x8(%rsp),%rsi
cmp    %rdx,%rsi
mov    (%rsp),%r9d
je     15bb <find_and_replace+0x4ab>
test   $0x18,%sil
je     1527 <find_and_replace+0x417>
add    $0x1,%r8
and    %r8,%rbx
add    %rbx,%rcx
add    %rbx,%rax
cs nopw 0x0(%rax,%rax,1)
mov    (%r11,%rdx,1),%rsi
mov    %rsi,0x0(%r13,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%rbx
jne    14c0 <find_and_replace+0x3b0>
cmp    %rbx,%r8
jne    152d <find_and_replace+0x41d>
jmp    15bb <find_and_replace+0x4ab>
xor    %edi,%edi
mov    (%rsp),%rax
test   $0x1,%sil
je     1507 <find_and_replace+0x3f7>
mov    %rbp,%rax
sub    %rdi,%rax
mov    %ebp,%esi
sub    %edi,%esi
add    %ecx,%esi
movslq %esi,%rsi
movups -0xf(%r14,%rsi,1),%xmm0
movups %xmm0,-0xf(%r14,%rax,1)
mov    (%rsp),%rax
cmp    %rax,%rdx
je     1329 <find_and_replace+0x219>
test   $0x8,%dl
jne    15d0 <find_and_replace+0x4c0>
sub    %eax,%r11d
sub    %rax,%rbp
mov    %rbp,%rdx
jmp    11b3 <find_and_replace+0xa3>
add    %rdx,%rax
add    %rdx,%rcx
mov    %r12d,%edx
sub    %eax,%edx
lea    0x1(%rdx),%esi
and    $0x3,%esi
je     156b <find_and_replace+0x45b>
neg    %esi
xor    %edi,%edi
mov    %r14,%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%rbp,%rax,1),%ebx
mov    %bl,0x0(%rbp,%rcx,1)
add    $0xffffffffffffffff,%rdi
add    $0x1,%rbp
cmp    %edi,%esi
jne    1550 <find_and_replace+0x440>
sub    %rdi,%rcx
sub    %rdi,%rax
cmp    $0x3,%edx
jb     15bb <find_and_replace+0x4ab>
add    %r14,%rcx
add    $0x3,%rcx
sub    %eax,%r12d
add    $0x1,%r12d
add    %r14,%rax
add    $0x3,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl -0x3(%rax,%rdx,1),%ebx
mov    %bl,-0x3(%rcx,%rdx,1)
movzbl -0x2(%rax,%rdx,1),%ebx
mov    %bl,-0x2(%rcx,%rdx,1)
movzbl -0x1(%rax,%rdx,1),%ebx
mov    %bl,-0x1(%rcx,%rdx,1)
movzbl (%rax,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,1)
add    $0x4,%rdx
cmp    %edx,%r12d
jne    1590 <find_and_replace+0x480>
add    %r9d,%r15d
mov    %r15d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1fffffff8,%rdi
add    $0x1,%r10
and    %r10,%rdi
mov    %rbp,%rdx
sub    %rdi,%rdx
sub    %edi,%r11d
sub    %eax,%r12d
sub    %rax,%rbp
mov    %rdi,(%rsp)
sub    %rdi,%rax
lea    (%r14,%rbp,1),%rsi
add    $0xfffffffffffffff9,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rax,%rdi
lea    (%r12,%rbp,1),%eax
cltq
mov    -0x7(%r14,%rax,1),%rax
mov    %rax,(%rsi,%rbp,1)
mov    %rdi,%rax
add    $0xfffffffffffffff8,%rbp
cmp    %rbp,%rdi
jne    1610 <find_and_replace+0x500>
cmp    (%rsp),%r10
je     1329 <find_and_replace+0x219>
jmp    11b3 <find_and_replace+0xa3>

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

LLVM IR (-O2):
define i32 @find_and_replace(i8* %0, i32 %1, i8* nocapture %2, i32 %3, i8* %4, i32 %5) {
%7 = sub i32 %1, %3
%8 = icmp slt i32 %7, 0
br i1 %8, label %381, label %9
9: ; preds = %6
%10 = icmp sgt i32 %3, 0
%11 = add i32 %1, 1
%12 = sub i32 %11, %3
%13 = zext i32 %12 to i64
%14 = zext i32 %3 to i64
br label %15
15: ; preds = %9, %378
%16 = phi i64 [ 0, %9 ], [ %379, %378 ]
br i1 %10, label %19, label %30
17: ; preds = %19
%18 = icmp eq i64 %27, %14
br i1 %18, label %28, label %19
19: ; preds = %15, %17
%20 = phi i64 [ %27, %17 ], [ 0, %15 ]
%21 = add nuw nsw i64 %20, %16
%22 = getelementptr inbounds i8, i8* %0, i64 %21
%23 = load i8, i8* %22
%24 = getelementptr inbounds i8, i8* %2, i64 %20
%25 = load i8, i8* %24
%26 = icmp eq i8 %23, %25
%27 = add nuw nsw i64 %20, 1
br i1 %26, label %17, label %378
28: ; preds = %17
%29 = trunc i64 %16 to i32
br label %30
30: ; preds = %15, %28
%31 = phi i32 [ %29, %28 ], [ 0, %15 ]
%32 = icmp slt i32 %3, %5
br i1 %32, label %201, label %33
33: ; preds = %30
%34 = zext i32 %31 to i64
%35 = getelementptr inbounds i8, i8* %0, i64 %34
%36 = tail call i32 @memcpy(i8* %35, i8* %4, i32 %5)
%37 = add i32 %31, %3
%38 = icmp sgt i32 %37, %1
br i1 %38, label %199, label %39
39: ; preds = %33
%40 = add i32 %31, %5
%41 = sext i32 %37 to i64
%42 = sext i32 %40 to i64
%43 = add i32 %31, %3
%44 = sub i32 %1, %43
%45 = zext i32 %44 to i64
%46 = add nuw nsw i64 %45, 1
%47 = icmp ult i32 %44, 7
br i1 %47, label %150, label %48
48: ; preds = %39
%49 = getelementptr i8, i8* %0, i64 %42
%50 = add i32 %31, %3
%51 = sub i32 %1, %50
%52 = zext i32 %51 to i64
%53 = add nsw i64 %42, %52
%54 = add nsw i64 %53, 1
%55 = getelementptr i8, i8* %0, i64 %54
%56 = getelementptr i8, i8* %0, i64 %41
%57 = add nsw i64 %41, %52
%58 = add nsw i64 %57, 1
%59 = getelementptr i8, i8* %0, i64 %58
%60 = icmp ult i8* %49, %59
%61 = icmp ult i8* %56, %55
%62 = and i1 %60, %61
br i1 %62, label %150, label %63
63: ; preds = %48
%64 = icmp ult i32 %44, 31
br i1 %64, label %128, label %65
65: ; preds = %63
%66 = and i64 %46, 8589934560
%67 = add nsw i64 %66, -32
%68 = lshr exact i64 %67, 5
%69 = add nuw nsw i64 %68, 1
%70 = and i64 %69, 1
%71 = icmp eq i64 %67, 0
br i1 %71, label %105, label %72
72: ; preds = %65
%73 = and i64 %69, 1152921504606846974
br label %74
74: ; preds = %74, %72
%75 = phi i64 [ 0, %72 ], [ %102, %74 ]
%76 = phi i64 [ 0, %72 ], [ %103, %74 ]
%77 = add i64 %75, %42
%78 = add i64 %75, %41
%79 = getelementptr inbounds i8, i8* %0, i64 %78
%80 = bitcast i8* %79 to <16 x i8>*
%81 = load <16 x i8>, <16 x i8>* %80
%82 = getelementptr inbounds i8, i8* %79, i64 16
%83 = bitcast i8* %82 to <16 x i8>*
%84 = load <16 x i8>, <16 x i8>* %83
%85 = getelementptr inbounds i8, i8* %0, i64 %77
%86 = bitcast i8* %85 to <16 x i8>*
store <16 x i8> %81, <16 x i8>* %86
%87 = getelementptr inbounds i8, i8* %85, i64 16
%88 = bitcast i8* %87 to <16 x i8>*
store <16 x i8> %84, <16 x i8>* %88
%89 = or i64 %75, 32
%90 = add i64 %89, %42
%91 = add i64 %89, %41
%92 = getelementptr inbounds i8, i8* %0, i64 %91
%93 = bitcast i8* %92 to <16 x i8>*
%94 = load <16 x i8>, <16 x i8>* %93
%95 = getelementptr inbounds i8, i8* %92, i64 16
%96 = bitcast i8* %95 to <16 x i8>*
%97 = load <16 x i8>, <16 x i8>* %96
%98 = getelementptr inbounds i8, i8* %0, i64 %90
%99 = bitcast i8* %98 to <16 x i8>*
store <16 x i8> %94, <16 x i8>* %99
%100 = getelementptr inbounds i8, i8* %98, i64 16
%101 = bitcast i8* %100 to <16 x i8>*
store <16 x i8> %97, <16 x i8>* %101
%102 = add nuw i64 %75, 64
%103 = add i64 %76, 2
%104 = icmp eq i64 %103, %73
br i1 %104, label %105, label %74
105: ; preds = %74, %65
%106 = phi i64 [ 0, %65 ], [ %102, %74 ]
%107 = icmp eq i64 %70, 0
br i1 %107, label %121, label %108
108: ; preds = %105
%109 = add i64 %106, %42
%110 = add i64 %106, %41
%111 = getelementptr inbounds i8, i8* %0, i64 %110
%112 = bitcast i8* %111 to <16 x i8>*
%113 = load <16 x i8>, <16 x i8>* %112
%114 = getelementptr inbounds i8, i8* %111, i64 16
%115 = bitcast i8* %114 to <16 x i8>*
%116 = load <16 x i8>, <16 x i8>* %115
%117 = getelementptr inbounds i8, i8* %0, i64 %109
%118 = bitcast i8* %117 to <16 x i8>*
store <16 x i8> %113, <16 x i8>* %118
%119 = getelementptr inbounds i8, i8* %117, i64 16
%120 = bitcast i8* %119 to <16 x i8>*
store <16 x i8> %116, <16 x i8>* %120
br label %121
121: ; preds = %105, %108
%122 = icmp eq i64 %46, %66
br i1 %122, label %199, label %123
123: ; preds = %121
%124 = add nsw i64 %66, %41
%125 = add nsw i64 %66, %42
%126 = and i64 %46, 24
%127 = icmp eq i64 %126, 0
br i1 %127, label %150, label %128
128: ; preds = %63, %123
%129 = phi i64 [ %66, %123 ], [ 0, %63 ]
%130 = add i32 %31, %3
%131 = sub i32 %1, %130
%132 = zext i32 %131 to i64
%133 = add nuw nsw i64 %132, 1
%134 = and i64 %133, 8589934584
%135 = add nsw i64 %134, %42
%136 = add nsw i64 %134, %41
br label %137
137: ; preds = %137, %128
%138 = phi i64 [ %129, %128 ], [ %146, %137 ]
%139 = add i64 %138, %42
%140 = add i64 %138, %41
%141 = getelementptr inbounds i8, i8* %0, i64 %140
%142 = bitcast i8* %141 to <8 x i8>*
%143 = load <8 x i8>, <8 x i8>* %142
%144 = getelementptr inbounds i8, i8* %0, i64 %139
%145 = bitcast i8* %144 to <8 x i8>*
store <8 x i8> %143, <8 x i8>* %145
%146 = add nuw i64 %138, 8
%147 = icmp eq i64 %146, %134
br i1 %147, label %148, label %137
148: ; preds = %137
%149 = icmp eq i64 %133, %134
br i1 %149, label %199, label %150
150: ; preds = %48, %39, %123, %148
%151 = phi i64 [ %42, %39 ], [ %42, %48 ], [ %125, %123 ], [ %135, %148 ]
%152 = phi i64 [ %41, %39 ], [ %41, %48 ], [ %124, %123 ], [ %136, %148 ]
%153 = add i32 %1, 1
%154 = trunc i64 %152 to i32
%155 = sub i32 %153, %154
%156 = sub i32 %1, %154
%157 = and i32 %155, 3
%158 = icmp eq i32 %157, 0
br i1 %158, label %170, label %159
159: ; preds = %150, %159
%160 = phi i64 [ %166, %159 ], [ %151, %150 ]
%161 = phi i64 [ %167, %159 ], [ %152, %150 ]
%162 = phi i32 [ %168, %159 ], [ 0, %150 ]
%163 = getelementptr inbounds i8, i8* %0, i64 %161
%164 = load i8, i8* %163
%165 = getelementptr inbounds i8, i8* %0, i64 %160
store i8 %164, i8* %165
%166 = add nsw i64 %160, 1
%167 = add nsw i64 %161, 1
%168 = add i32 %162, 1
%169 = icmp eq i32 %168, %157
br i1 %169, label %170, label %159
170: ; preds = %159, %150
%171 = phi i64 [ %151, %150 ], [ %166, %159 ]
%172 = phi i64 [ %152, %150 ], [ %167, %159 ]
%173 = icmp ult i32 %156, 3
br i1 %173, label %199, label %174
174: ; preds = %170, %174
%175 = phi i64 [ %195, %174 ], [ %171, %170 ]
%176 = phi i64 [ %196, %174 ], [ %172, %170 ]
%177 = getelementptr inbounds i8, i8* %0, i64 %176
%178 = load i8, i8* %177
%179 = getelementptr inbounds i8, i8* %0, i64 %175
store i8 %178, i8* %179
%180 = add nsw i64 %175, 1
%181 = add nsw i64 %176, 1
%182 = getelementptr inbounds i8, i8* %0, i64 %181
%183 = load i8, i8* %182
%184 = getelementptr inbounds i8, i8* %0, i64 %180
store i8 %183, i8* %184
%185 = add nsw i64 %175, 2
%186 = add nsw i64 %176, 2
%187 = getelementptr inbounds i8, i8* %0, i64 %186
%188 = load i8, i8* %187
%189 = getelementptr inbounds i8, i8* %0, i64 %185
store i8 %188, i8* %189
%190 = add nsw i64 %175, 3
%191 = add nsw i64 %176, 3
%192 = getelementptr inbounds i8, i8* %0, i64 %191
%193 = load i8, i8* %192
%194 = getelementptr inbounds i8, i8* %0, i64 %190
store i8 %193, i8* %194
%195 = add nsw i64 %175, 4
%196 = add nsw i64 %176, 4
%197 = trunc i64 %196 to i32
%198 = icmp eq i32 %11, %197
br i1 %198, label %199, label %174
199: ; preds = %170, %174, %121, %148, %33
%200 = add nsw i32 %7, %5
br label %381
201: ; preds = %30
%202 = add i32 %7, %5
%203 = sub i32 %3, %5
%204 = add i32 %31, %3
%205 = sub i32 %11, %204
%206 = icmp eq i32 %205, 0
br i1 %206, label %374, label %207
207: ; preds = %201
%208 = sext i32 %202 to i64
%209 = sub i32 %1, %204
%210 = zext i32 %209 to i64
%211 = add nuw nsw i64 %210, 1
%212 = icmp ult i32 %209, 7
br i1 %212, label %337, label %213
213: ; preds = %207
%214 = sub i32 %1, %204
%215 = icmp sgt i32 %204, %1
%216 = getelementptr i8, i8* %0, i64 %208
%217 = zext i32 %214 to i64
%218 = sub nsw i64 0, %217
%219 = getelementptr i8, i8* %216, i64 %218
%220 = icmp ugt i8* %219, %216
%221 = sext i32 %1 to i64
%222 = getelementptr i8, i8* %0, i64 %221
%223 = zext i32 %214 to i64
%224 = sub nsw i64 0, %223
%225 = getelementptr i8, i8* %222, i64 %224
%226 = icmp ugt i8* %225, %222
%227 = or i1 %215, %220
%228 = or i1 %227, %226
br i1 %228, label %337, label %229
229: ; preds = %213
%230 = sub i32 %1, %204
%231 = zext i32 %230 to i64
%232 = sub nsw i64 %208, %231
%233 = getelementptr i8, i8* %0, i64 %232
%234 = add nsw i64 %208, 1
%235 = getelementptr i8, i8* %0, i64 %234
%236 = sext i32 %1 to i64
%237 = sub nsw i64 %236, %231
%238 = getelementptr i8, i8* %0, i64 %237
%239 = add nsw i64 %236, 1
%240 = getelementptr i8, i8* %0, i64 %239
%241 = icmp ult i8* %233, %240
%242 = icmp ult i8* %238, %235
%243 = and i1 %241, %242
br i1 %243, label %337, label %244
244: ; preds = %229
%245 = icmp ult i32 %209, 15
br i1 %245, label %310, label %246
246: ; preds = %244
%247 = and i64 %211, 8589934576
%248 = add nsw i64 %247, -16
%249 = lshr exact i64 %248, 4
%250 = add nuw nsw i64 %249, 1
%251 = and i64 %250, 1
%252 = icmp eq i64 %248, 0
br i1 %252, label %286, label %253
253: ; preds = %246
%254 = and i64 %250, 2305843009213693950
%255 = getelementptr inbounds i8, i8* %0, i64 -15
%256 = getelementptr inbounds i8, i8* %0, i64 -15
%257 = getelementptr inbounds i8, i8* %0, i64 -15
%258 = getelementptr inbounds i8, i8* %0, i64 -15
br label %259
259: ; preds = %259, %253
%260 = phi i64 [ 0, %253 ], [ %283, %259 ]
%261 = phi i64 [ 0, %253 ], [ %284, %259 ]
%262 = sub i64 %208, %260
%263 = trunc i64 %260 to i32
%264 = sub i32 %202, %263
%265 = add i32 %203, %264
%266 = sext i32 %265 to i64
%267 = getelementptr inbounds i8, i8* %255, i64 %266
%268 = bitcast i8* %267 to <16 x i8>*
%269 = load <16 x i8>, <16 x i8>* %268
%270 = getelementptr inbounds i8, i8* %256, i64 %262
%271 = bitcast i8* %270 to <16 x i8>*
store <16 x i8> %269, <16 x i8>* %271
%272 = or i64 %260, 16
%273 = sub i64 %208, %272
%274 = trunc i64 %272 to i32
%275 = sub i32 %202, %274
%276 = add i32 %203, %275
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds i8, i8* %257, i64 %277
%279 = bitcast i8* %278 to <16 x i8>*
%280 = load <16 x i8>, <16 x i8>* %279
%281 = getelementptr inbounds i8, i8* %258, i64 %273
%282 = bitcast i8* %281 to <16 x i8>*
store <16 x i8> %280, <16 x i8>* %282
%283 = add nuw i64 %260, 32
%284 = add i64 %261, 2
%285 = icmp eq i64 %284, %254
br i1 %285, label %286, label %259
286: ; preds = %259, %246
%287 = phi i64 [ 0, %246 ], [ %283, %259 ]
%288 = icmp eq i64 %251, 0
br i1 %288, label %302, label %289
289: ; preds = %286
%290 = sub i64 %208, %287
%291 = trunc i64 %287 to i32
%292 = sub i32 %202, %291
%293 = add i32 %203, %292
%294 = sext i32 %293 to i64
%295 = getelementptr inbounds i8, i8* %0, i64 -15
%296 = getelementptr inbounds i8, i8* %295, i64 %294
%297 = bitcast i8* %296 to <16 x i8>*
%298 = load <16 x i8>, <16 x i8>* %297
%299 = getelementptr inbounds i8, i8* %0, i64 -15
%300 = getelementptr inbounds i8, i8* %299, i64 %290
%301 = bitcast i8* %300 to <16 x i8>*
store <16 x i8> %298, <16 x i8>* %301
br label %302
302: ; preds = %286, %289
%303 = icmp eq i64 %211, %247
br i1 %303, label %374, label %304
304: ; preds = %302
%305 = trunc i64 %247 to i32
%306 = sub i32 %205, %305
%307 = sub nsw i64 %208, %247
%308 = and i64 %211, 8
%309 = icmp eq i64 %308, 0
br i1 %309, label %337, label %310
310: ; preds = %244, %304
%311 = phi i64 [ %247, %304 ], [ 0, %244 ]
%312 = sub i32 %1, %204
%313 = zext i32 %312 to i64
%314 = add nuw nsw i64 %313, 1
%315 = and i64 %314, 8589934584
%316 = sub nsw i64 %208, %315
%317 = trunc i64 %315 to i32
%318 = sub i32 %205, %317
%319 = getelementptr inbounds i8, i8* %0, i64 -7
%320 = getelementptr inbounds i8, i8* %0, i64 -7
br label %321
321: ; preds = %321, %310
%322 = phi i64 [ %311, %310 ], [ %333, %321 ]
%323 = sub i64 %208, %322
%324 = trunc i64 %322 to i32
%325 = sub i32 %202, %324
%326 = add i32 %203, %325
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds i8, i8* %319, i64 %327
%329 = bitcast i8* %328 to <8 x i8>*
%330 = load <8 x i8>, <8 x i8>* %329
%331 = getelementptr inbounds i8, i8* %320, i64 %323
%332 = bitcast i8* %331 to <8 x i8>*
store <8 x i8> %330, <8 x i8>* %332
%333 = add nuw i64 %322, 8
%334 = icmp eq i64 %333, %315
br i1 %334, label %335, label %321
335: ; preds = %321
%336 = icmp eq i64 %314, %315
br i1 %336, label %374, label %337
337: ; preds = %229, %213, %207, %304, %335
%338 = phi i64 [ %208, %207 ], [ %208, %229 ], [ %208, %213 ], [ %307, %304 ], [ %316, %335 ]
%339 = phi i32 [ %205, %207 ], [ %205, %229 ], [ %205, %213 ], [ %306, %304 ], [ %318, %335 ]
%340 = and i32 %339, 1
%341 = icmp eq i32 %340, 0
br i1 %341, label %351, label %342
342: ; preds = %337
%343 = add nsw i32 %339, -1
%344 = trunc i64 %338 to i32
%345 = add i32 %203, %344
%346 = sext i32 %345 to i64
%347 = getelementptr inbounds i8, i8* %0, i64 %346
%348 = load i8, i8* %347
%349 = getelementptr inbounds i8, i8* %0, i64 %338
store i8 %348, i8* %349
%350 = add nsw i64 %338, -1
br label %351
351: ; preds = %342, %337
%352 = phi i64 [ %338, %337 ], [ %350, %342 ]
%353 = phi i32 [ %339, %337 ], [ %343, %342 ]
%354 = icmp eq i32 %339, 1
br i1 %354, label %374, label %355
355: ; preds = %351, %355
%356 = phi i64 [ %372, %355 ], [ %352, %351 ]
%357 = phi i32 [ %365, %355 ], [ %353, %351 ]
%358 = trunc i64 %356 to i32
%359 = add i32 %203, %358
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i8, i8* %0, i64 %360
%362 = load i8, i8* %361
%363 = getelementptr inbounds i8, i8* %0, i64 %356
store i8 %362, i8* %363
%364 = add nsw i64 %356, -1
%365 = add nsw i32 %357, -2
%366 = trunc i64 %364 to i32
%367 = add i32 %203, %366
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds i8, i8* %0, i64 %368
%370 = load i8, i8* %369
%371 = getelementptr inbounds i8, i8* %0, i64 %364
store i8 %370, i8* %371
%372 = add nsw i64 %356, -2
%373 = icmp eq i32 %365, 0
br i1 %373, label %374, label %355
374: ; preds = %351, %355, %302, %335, %201
%375 = zext i32 %31 to i64
%376 = getelementptr inbounds i8, i8* %0, i64 %375
%377 = tail call i32 @memcpy(i8* %376, i8* %4, i32 %5)
br label %381
378: ; preds = %19
%379 = add nuw nsw i64 %16, 1
%380 = icmp eq i64 %379, %13
br i1 %380, label %381, label %15
381: ; preds = %378, %6, %199, %374
%382 = phi i32 [ %200, %199 ], [ %202, %374 ], [ 0, %6 ], [ 0, %378 ]
ret i32 %382
}