#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 */
void *memchr(void const *, unsigned char, size_t);
scalar_t__ memcmp(void const *, void const *, int);
void *wordlen_memmem(const void *haystack, size_t haystacklen,
                     const void *needle, size_t needlelen) {
  const void *needle_ptr;
  const void *haystack_ptr;
  int sums_diff;
  int compare_len;
  unsigned long last_needle_chars = 0;
  unsigned long last_haystack_chars = 0;
  switch (needlelen) {
  case (0):
    return (void *)haystack;
    break;
  case (1):
    return memchr(haystack, *((unsigned char *)needle), haystacklen);
    break;
  }
  haystack_ptr = memchr(haystack, *((unsigned char *)needle), haystacklen);
  if (!haystack_ptr) {
    return NULL;
  }
  haystacklen -= (haystack_ptr - haystack);
  if (haystacklen < needlelen) {
    return NULL;
  }
  haystack = haystack_ptr;
  if (needlelen > sizeof(long) + 1) {
    needle_ptr = needle;
    sums_diff = 0;
    needle += needlelen - sizeof(long);
    while (needle_ptr != needle) {
      sums_diff -= *((unsigned char *)needle_ptr++);
      sums_diff += *((unsigned char *)haystack_ptr++);
    }
    needle += sizeof(long);
    while (needle_ptr != needle) {
      last_needle_chars <<= 8;
      last_needle_chars ^= *(unsigned char *)needle_ptr;
      last_haystack_chars <<= 8;
      last_haystack_chars ^= *(unsigned char *)haystack_ptr;
      sums_diff -= *((unsigned char *)needle_ptr++);
      sums_diff += *((unsigned char *)haystack_ptr++);
    }
    needle -= needlelen;
    compare_len = needlelen - (sizeof(long) + 1);
    if (sums_diff == 0 && last_haystack_chars == last_needle_chars &&
        memcmp(haystack, needle, compare_len) == 0) {
      return (void *)haystack;
    }
    needle_ptr = haystack + haystacklen;
    while (haystack_ptr != needle_ptr) {
      last_haystack_chars <<= 8;
      last_haystack_chars ^= *(unsigned char *)haystack_ptr;
      sums_diff -= *((unsigned char *)haystack++);
      sums_diff += *((unsigned char *)haystack_ptr++);
      if (sums_diff == 0 && last_haystack_chars == last_needle_chars &&
          memcmp(haystack, needle, compare_len) == 0) {
        return (void *)haystack;
      }
    }
  } else if (needlelen < sizeof(long)) {
    needle_ptr = needle;
    needle += needlelen;
    sums_diff = 0;
    while (needle_ptr != needle) {
      sums_diff -= *((unsigned char *)needle_ptr++);
      sums_diff += *((unsigned char *)haystack_ptr++);
    }
    needle -= needlelen;
    compare_len = needlelen - 1;
    if (sums_diff == 0 && memcmp(haystack, needle, compare_len) == 0) {
      return (void *)haystack;
    }
    needle_ptr = haystack + haystacklen;
    while (haystack_ptr != needle_ptr) {
      sums_diff -= *((unsigned char *)haystack++);
      sums_diff += *((unsigned char *)haystack_ptr++);
      if (sums_diff == 0 && memcmp(haystack, needle, compare_len) == 0) {
        return (void *)haystack;
      }
    }
  } else if (needlelen == sizeof(long)) {
    needle_ptr = needle;
    needle += needlelen;
    while (needle_ptr != needle) {
      last_needle_chars <<= 8;
      last_needle_chars ^= *(unsigned char *)needle_ptr++;
      last_haystack_chars <<= 8;
      last_haystack_chars ^= *(unsigned char *)haystack_ptr++;
    }
    needle -= needlelen;
    if (last_haystack_chars == last_needle_chars) {
      return (void *)haystack;
    }
    needle_ptr = haystack + haystacklen;
    while (haystack_ptr != needle_ptr) {
      last_haystack_chars <<= 8;
      last_haystack_chars ^= *(unsigned char *)haystack_ptr++;
      if (last_haystack_chars == last_needle_chars) {
        return (void *)(haystack_ptr - needlelen);
      }
    }
  } else {
    needle_ptr = needle + 1;
    ++haystack_ptr;
    needle += needlelen;
    while (needle_ptr != needle) {
      last_needle_chars <<= 8;
      last_needle_chars ^= *(unsigned char *)needle_ptr++;
      last_haystack_chars <<= 8;
      last_haystack_chars ^= *(unsigned char *)haystack_ptr++;
    }
    needle -= needlelen;
    if (last_haystack_chars == last_needle_chars &&
        *(unsigned char *)haystack == *(unsigned char *)needle) {
      return (void *)haystack;
    }
    needle_ptr = haystack + haystacklen;
    while (haystack_ptr != needle_ptr) {
      last_haystack_chars <<= 8;
      last_haystack_chars ^= *(unsigned char *)haystack_ptr++;
      ++haystack;
      if (last_haystack_chars == last_needle_chars &&
          *(unsigned char *)haystack == *(unsigned char *)needle) {
        return (void *)haystack;
      }
    }
  }
  return NULL;
}


x86 assembly (clang, -O0):
<wordlen_memmem>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x58(%rbp)
test   %rax,%rax
je     1171 <wordlen_memmem+0x51>
jmp    115e <wordlen_memmem+0x3e>
mov    -0x58(%rbp),%rax
sub    $0x1,%rax
je     117e <wordlen_memmem+0x5e>
jmp    119d <wordlen_memmem+0x7d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rax
mov    (%rax),%al
mov    -0x18(%rbp),%rdx
movzbl %al,%esi
call   1030 <memchr@plt>
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rax
mov    (%rax),%al
mov    -0x18(%rbp),%rdx
movzbl %al,%esi
call   1030 <memchr@plt>
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
jne    11cf <wordlen_memmem+0xaf>
movq   $0x0,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
mov    -0x38(%rbp),%rcx
mov    -0x10(%rbp),%rax
sub    %rax,%rcx
mov    -0x18(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1200 <wordlen_memmem+0xe0>
movq   $0x0,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
mov    -0x38(%rbp),%rax
mov    %rax,-0x10(%rbp)
cmpq   $0x9,-0x28(%rbp)
jbe    140c <wordlen_memmem+0x2ec>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
sub    $0x8,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
je     1277 <wordlen_memmem+0x157>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1232 <wordlen_memmem+0x112>
mov    -0x20(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
je     12fe <wordlen_memmem+0x1de>
mov    -0x48(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
movzbl (%rax),%eax
xor    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1283 <wordlen_memmem+0x163>
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
sub    $0x9,%rax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jne    135c <wordlen_memmem+0x23c>
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    135c <wordlen_memmem+0x23c>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x40(%rbp),%edx
call   1040 <memcmp@plt>
cmp    $0x0,%rax
jne    135c <wordlen_memmem+0x23c>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     1407 <wordlen_memmem+0x2e7>
mov    -0x50(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jne    1402 <wordlen_memmem+0x2e2>
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    1402 <wordlen_memmem+0x2e2>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x40(%rbp),%edx
call   1040 <memcmp@plt>
cmp    $0x0,%rax
jne    1402 <wordlen_memmem+0x2e2>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
jmp    1368 <wordlen_memmem+0x248>
jmp    17c2 <wordlen_memmem+0x6a2>
cmpq   $0x8,-0x28(%rbp)
jae    154e <wordlen_memmem+0x42e>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
je     1477 <wordlen_memmem+0x357>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1432 <wordlen_memmem+0x312>
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
sub    $0x1,%rax
mov    %eax,-0x40(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jne    14c7 <wordlen_memmem+0x3a7>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x40(%rbp),%edx
call   1040 <memcmp@plt>
cmp    $0x0,%rax
jne    14c7 <wordlen_memmem+0x3a7>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     1549 <wordlen_memmem+0x429>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%ecx
mov    -0x3c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jne    1544 <wordlen_memmem+0x424>
mov    -0x10(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x40(%rbp),%edx
call   1040 <memcmp@plt>
cmp    $0x0,%rax
jne    1544 <wordlen_memmem+0x424>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
jmp    14d3 <wordlen_memmem+0x3b3>
jmp    17bd <wordlen_memmem+0x69d>
cmpq   $0x8,-0x28(%rbp)
jne    1669 <wordlen_memmem+0x549>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
je     15cc <wordlen_memmem+0x4ac>
mov    -0x48(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
xor    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    156d <wordlen_memmem+0x44d>
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    15fb <wordlen_memmem+0x4db>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     1664 <wordlen_memmem+0x544>
mov    -0x50(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    165f <wordlen_memmem+0x53f>
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
sub    -0x28(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
jmp    1607 <wordlen_memmem+0x4e7>
jmp    17b8 <wordlen_memmem+0x698>
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x20(%rbp),%rax
je     16ec <wordlen_memmem+0x5cc>
mov    -0x48(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
movzbl (%rax),%eax
xor    -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    168d <wordlen_memmem+0x56d>
mov    -0x28(%rbp),%rdx
mov    -0x20(%rbp),%rax
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    1731 <wordlen_memmem+0x611>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
jne    1731 <wordlen_memmem+0x611>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     17b3 <wordlen_memmem+0x693>
mov    -0x50(%rbp),%rax
shl    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
movzbl (%rax),%eax
xor    -0x50(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    17ae <wordlen_memmem+0x68e>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
jne    17ae <wordlen_memmem+0x68e>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17ca <wordlen_memmem+0x6aa>
jmp    173d <wordlen_memmem+0x61d>
jmp    17b8 <wordlen_memmem+0x698>
jmp    17bd <wordlen_memmem+0x69d>
jmp    17c2 <wordlen_memmem+0x6a2>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<wordlen_memmem>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r13
test   %rcx,%rcx
je     1162 <wordlen_memmem+0x42>
mov    %rcx,%r12
mov    %rdx,%r14
mov    %rsi,%rbx
cmp    $0x1,%rcx
jne    1167 <wordlen_memmem+0x47>
movzbl (%r14),%esi
mov    %r13,%rdi
mov    %rbx,%rdx
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <memchr@plt>
mov    %r13,%r9
jmp    118f <wordlen_memmem+0x6f>
movzbl (%r14),%esi
mov    %r13,%rdi
mov    %rbx,%rdx
call   1030 <memchr@plt>
test   %rax,%rax
je     118c <wordlen_memmem+0x6c>
mov    %rax,%r9
mov    %r13,%r10
sub    %rax,%r10
add    %rbx,%r10
cmp    %r12,%r10
jae    11a1 <wordlen_memmem+0x81>
xor    %r9d,%r9d
mov    %r9,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0xa,%r12
jb     12b9 <wordlen_memmem+0x199>
mov    %r12,%r13
add    $0xfffffffffffffff8,%r13
je     143e <wordlen_memmem+0x31e>
lea    (%r14,%r12,1),%rax
add    $0xfffffffffffffff8,%rax
xor    %ebp,%ebp
mov    %r9,%rdx
mov    %r14,%rcx
cmp    $0x8,%r13
jb     1600 <wordlen_memmem+0x4e0>
mov    %r13,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     156f <wordlen_memmem+0x44f>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm2,%xmm2
xor    %edx,%edx
pxor   %xmm0,%xmm0
pxor   %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movd   (%r14,%rdx,1),%xmm6
movd   0x4(%r14,%rdx,1),%xmm5
punpcklbw %xmm2,%xmm6
punpcklwd %xmm2,%xmm6
punpcklbw %xmm2,%xmm5
punpcklwd %xmm2,%xmm5
movd   (%r9,%rdx,1),%xmm4
movd   0x4(%r9,%rdx,1),%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
paddd  %xmm0,%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
paddd  %xmm1,%xmm3
movd   0x8(%r14,%rdx,1),%xmm0
movd   0xc(%r14,%rdx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm6,%xmm0
psubd  %xmm0,%xmm4
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm5,%xmm1
psubd  %xmm1,%xmm3
movd   0x8(%r9,%rdx,1),%xmm0
movd   0xc(%r9,%rdx,1),%xmm1
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
paddd  %xmm4,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
paddd  %xmm3,%xmm1
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1210 <wordlen_memmem+0xf0>
jmp    1579 <wordlen_memmem+0x459>
cmp    $0x7,%r12
ja     1352 <wordlen_memmem+0x232>
test   %r12,%r12
je     1560 <wordlen_memmem+0x440>
xor    %ebp,%ebp
mov    %r9,%rax
mov    %r14,%rcx
cmp    $0x8,%r12
jb     178b <wordlen_memmem+0x66b>
mov    %r12,%rax
and    $0xfffffffffffffff8,%rax
movd   (%r14),%xmm0
movd   0x4(%r14),%xmm1
pxor   %xmm2,%xmm2
punpcklbw %xmm2,%xmm0
punpcklwd %xmm2,%xmm0
punpcklbw %xmm2,%xmm1
punpcklwd %xmm2,%xmm1
movd   (%r9),%xmm3
movd   0x4(%r9),%xmm4
punpcklbw %xmm2,%xmm3
punpcklwd %xmm2,%xmm3
psubd  %xmm0,%xmm3
punpcklbw %xmm2,%xmm4
punpcklwd %xmm2,%xmm4
psubd  %xmm1,%xmm4
paddd  %xmm3,%xmm4
pshufd $0xee,%xmm4,%xmm0
paddd  %xmm4,%xmm0
pshufd $0x55,%xmm0,%xmm1
paddd  %xmm0,%xmm1
movd   %xmm1,%ebp
cmp    %r12,%rax
jne    1784 <wordlen_memmem+0x664>
mov    %r14,%r15
jmp    17b7 <wordlen_memmem+0x697>
cmp    $0x8,%r12
jne    144b <wordlen_memmem+0x32b>
movzbl (%r14),%eax
movzbl (%r9),%ecx
movzbl 0x1(%r14),%edx
movzbl 0x1(%r9),%esi
shl    $0x10,%eax
shl    $0x8,%edx
or     %eax,%edx
movzbl 0x2(%r14),%eax
or     %edx,%eax
shl    $0x10,%ecx
shl    $0x8,%esi
or     %ecx,%esi
movzbl 0x2(%r9),%ecx
or     %esi,%ecx
movzbl 0x3(%r14),%edx
movzbl 0x3(%r9),%esi
shl    $0x10,%rax
shl    $0x8,%rdx
or     %rax,%rdx
movzbl 0x4(%r14),%eax
or     %rdx,%rax
shl    $0x10,%rcx
shl    $0x8,%rsi
or     %rcx,%rsi
movzbl 0x4(%r9),%ecx
or     %rsi,%rcx
movzbl 0x5(%r14),%edx
movzbl 0x5(%r9),%esi
shl    $0x10,%rax
shl    $0x8,%rdx
or     %rax,%rdx
movzbl 0x6(%r14),%edi
or     %rdx,%rdi
shl    $0x10,%rcx
shl    $0x8,%rsi
or     %rcx,%rsi
movzbl 0x6(%r9),%edx
or     %rsi,%rdx
shl    $0x8,%rdi
movzbl 0x7(%r14),%eax
or     %rdi,%rax
shl    $0x8,%rdx
movzbl 0x7(%r9),%ecx
or     %rdx,%rcx
cmp    %rax,%rcx
je     118f <wordlen_memmem+0x6f>
add    %r13,%rbx
sub    %r9,%rbx
add    $0xfffffffffffffff8,%rbx
test   %rbx,%rbx
je     118c <wordlen_memmem+0x6c>
shl    $0x8,%rcx
movzbl 0x8(%r9),%edx
or     %rdx,%rcx
add    $0x1,%r9
add    $0xffffffffffffffff,%rbx
cmp    %rax,%rcx
jne    1417 <wordlen_memmem+0x2f7>
jmp    118f <wordlen_memmem+0x6f>
xor    %ebp,%ebp
mov    %r14,%rax
mov    %r9,%r13
jmp    161a <wordlen_memmem+0x4fa>
movzbl 0x1(%r14),%eax
movzbl 0x1(%r9),%ecx
movzbl 0x2(%r14),%edx
movzbl 0x2(%r9),%esi
shl    $0x10,%eax
shl    $0x8,%edx
or     %eax,%edx
movzbl 0x3(%r14),%eax
or     %edx,%eax
shl    $0x10,%ecx
shl    $0x8,%esi
or     %ecx,%esi
movzbl 0x3(%r9),%ecx
or     %esi,%ecx
movzbl 0x4(%r14),%edx
movzbl 0x4(%r9),%esi
shl    $0x10,%rax
shl    $0x8,%rdx
or     %rax,%rdx
movzbl 0x5(%r14),%eax
or     %rdx,%rax
shl    $0x10,%rcx
shl    $0x8,%rsi
or     %rcx,%rsi
movzbl 0x5(%r9),%ecx
or     %rsi,%rcx
movzbl 0x6(%r14),%edx
movzbl 0x6(%r9),%esi
shl    $0x10,%rax
shl    $0x8,%rdx
or     %rax,%rdx
movzbl 0x7(%r14),%edi
or     %rdx,%rdi
shl    $0x10,%rcx
shl    $0x8,%rsi
or     %rcx,%rsi
movzbl 0x7(%r9),%edx
or     %rsi,%rdx
shl    $0x8,%rdi
mov    %r14,%r8
movzbl 0x8(%r14),%ebp
or     %rdi,%rbp
shl    $0x8,%rdx
movzbl 0x8(%r9),%ecx
or     %rdx,%rcx
cmp    %rbp,%rcx
jne    1509 <wordlen_memmem+0x3e9>
mov    (%r9),%dl
cmp    (%r8),%dl
je     118f <wordlen_memmem+0x6f>
lea    0x9(%r9),%rdx
add    %r9,%r10
cmp    %r10,%rdx
je     118c <wordlen_memmem+0x6c>
add    %r13,%rbx
sub    %r9,%rbx
mov    %r9,%rdx
add    $0x1,%rdx
add    $0xfffffffffffffff7,%rbx
xor    %r9d,%r9d
jmp    153d <wordlen_memmem+0x41d>
add    $0x1,%rdx
add    $0xffffffffffffffff,%rbx
je     118f <wordlen_memmem+0x6f>
mov    %rcx,%rsi
shl    $0x8,%rsi
movzbl 0x8(%rdx),%ecx
or     %rsi,%rcx
cmp    %rbp,%rcx
jne    152f <wordlen_memmem+0x40f>
movzbl (%rdx),%eax
cmp    (%r8),%al
jne    152f <wordlen_memmem+0x40f>
mov    %rdx,%r9
jmp    118f <wordlen_memmem+0x6f>
mov    %r14,%r15
add    $0xffffffff,%r12d
mov    %r9,%r14
jmp    17c3 <wordlen_memmem+0x6a3>
pxor   %xmm0,%xmm0
xor    %edx,%edx
pxor   %xmm1,%xmm1
test   $0x1,%sil
je     15cd <wordlen_memmem+0x4ad>
movd   (%r14,%rdx,1),%xmm2
movd   0x4(%r14,%rdx,1),%xmm3
pxor   %xmm4,%xmm4
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
psubd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
psubd  %xmm3,%xmm1
movd   (%r9,%rdx,1),%xmm2
movd   0x4(%r9,%rdx,1),%xmm3
punpcklbw %xmm4,%xmm2
punpcklwd %xmm4,%xmm2
paddd  %xmm2,%xmm0
punpcklbw %xmm4,%xmm3
punpcklwd %xmm4,%xmm3
paddd  %xmm3,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ebp
cmp    %rcx,%r13
je     1617 <wordlen_memmem+0x4f7>
lea    (%r9,%rcx,1),%rdx
add    %r14,%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rcx),%esi
add    $0x1,%rcx
sub    %esi,%ebp
movzbl (%rdx),%esi
add    $0x1,%rdx
add    %esi,%ebp
cmp    %rax,%rcx
jne    1600 <wordlen_memmem+0x4e0>
add    %r9,%r13
lea    (%r14,%r12,1),%rdx
cmp    %rdx,%rax
mov    %r14,0x10(%rsp)
je     163d <wordlen_memmem+0x51d>
mov    %rdx,%r8
sub    %rax,%r8
lea    0x1(%rax),%rsi
cmp    %rsi,%rdx
jne    1648 <wordlen_memmem+0x528>
xor    %edx,%edx
xor    %esi,%esi
jmp    16b6 <wordlen_memmem+0x596>
xor    %r14d,%r14d
xor    %r15d,%r15d
jmp    16d8 <wordlen_memmem+0x5b8>
mov    %r8,%rdx
and    $0xfffffffffffffffe,%rdx
xor    %r15d,%r15d
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rax),%ebx
movzbl 0x0(%r13),%edi
shl    $0x10,%r14
mov    %rbx,%rsi
shl    $0x8,%rsi
or     %r14,%rsi
movzbl 0x1(%rax),%ecx
lea    (%rcx,%rsi,1),%r14
shl    $0x10,%r15
add    %edi,%ebp
shl    $0x8,%rdi
or     %r15,%rdi
movzbl 0x1(%r13),%esi
lea    (%rsi,%rdi,1),%r15
add    $0x2,%rax
add    %ecx,%ebx
sub    %ebx,%ebp
add    $0x2,%r13
add    %esi,%ebp
add    $0xfffffffffffffffe,%rdx
jne    1660 <wordlen_memmem+0x540>
mov    %r14,%rsi
shl    $0x8,%rsi
mov    %r15,%rdx
shl    $0x8,%rdx
test   $0x1,%r8b
je     16d8 <wordlen_memmem+0x5b8>
movzbl (%rax),%eax
or     %rax,%rsi
movzbl 0x0(%r13),%ecx
or     %rcx,%rdx
sub    %eax,%ebp
add    $0x1,%r13
add    %ecx,%ebp
mov    %rsi,%r14
mov    %rdx,%r15
add    $0xfffffff7,%r12d
test   %ebp,%ebp
mov    %r12,0x8(%rsp)
jne    1714 <wordlen_memmem+0x5f4>
cmp    %r14,%r15
jne    1714 <wordlen_memmem+0x5f4>
mov    %r9,%rdi
mov    0x10(%rsp),%rsi
mov    %r12d,%edx
mov    %r9,%r12
mov    %r10,%rbx
call   1040 <memcmp@plt>
mov    %rbx,%r10
mov    %r12,%r9
mov    0x8(%rsp),%r12
test   %rax,%rax
je     118f <wordlen_memmem+0x6f>
add    %r9,%r10
cmp    %r10,%r13
je     118c <wordlen_memmem+0x6c>
mov    %r9,%rbx
add    $0x1,%rbx
xor    %r9d,%r9d
jmp    1741 <wordlen_memmem+0x621>
nopl   0x0(%rax)
add    $0x1,%r13
add    $0x1,%rbx
cmp    %r10,%r13
je     118f <wordlen_memmem+0x6f>
shl    $0x8,%r15
movzbl 0x0(%r13),%eax
add    %rax,%r15
movzbl -0x1(%rbx),%ecx
sub    %ecx,%ebp
add    %eax,%ebp
jne    1730 <wordlen_memmem+0x610>
cmp    %r14,%r15
jne    1730 <wordlen_memmem+0x610>
mov    %rbx,%rdi
mov    0x10(%rsp),%rsi
mov    %r12d,%edx
mov    %r10,%r12
call   1040 <memcmp@plt>
mov    %r12,%r10
mov    0x8(%rsp),%r12
xor    %r9d,%r9d
test   %rax,%rax
jne    1730 <wordlen_memmem+0x610>
jmp    1843 <wordlen_memmem+0x723>
lea    (%r14,%rax,1),%rcx
add    %r9,%rax
mov    %r14,%r15
lea    (%r14,%r12,1),%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rcx),%esi
add    $0x1,%rcx
sub    %esi,%ebp
movzbl (%rax),%esi
add    $0x1,%rax
add    %esi,%ebp
cmp    %rdx,%rcx
jne    17a0 <wordlen_memmem+0x680>
lea    (%r9,%r12,1),%r14
add    $0xffffffff,%r12d
test   %ebp,%ebp
jne    17e8 <wordlen_memmem+0x6c8>
mov    %r9,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
mov    %r9,%rbx
mov    %r10,%rbp
call   1040 <memcmp@plt>
mov    %rbp,%r10
mov    %rbx,%r9
xor    %ebp,%ebp
test   %rax,%rax
je     118f <wordlen_memmem+0x6f>
add    %r9,%r10
cmp    %r10,%r14
je     118c <wordlen_memmem+0x6c>
mov    %r9,%rbx
add    $0x1,%rbx
xor    %r9d,%r9d
jmp    1811 <wordlen_memmem+0x6f1>
add    $0x1,%r14
add    $0x1,%rbx
cmp    %r10,%r14
je     118f <wordlen_memmem+0x6f>
movzbl -0x1(%rbx),%eax
mov    %ebp,%ecx
sub    %eax,%ecx
movzbl (%r14),%ebp
add    %ecx,%ebp
jne    1800 <wordlen_memmem+0x6e0>
mov    %rbx,%rdi
mov    %r15,%rsi
mov    %r12d,%edx
mov    %r12,%r13
mov    %r10,%r12
call   1040 <memcmp@plt>
mov    %r12,%r10
mov    %r13,%r12
xor    %r9d,%r9d
test   %rax,%rax
jne    1800 <wordlen_memmem+0x6e0>
mov    %rbx,%r9
jmp    118f <wordlen_memmem+0x6f>

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

LLVM IR (-O2):
define i8* @wordlen_memmem(i8* %0, i64 %1, i8* %2, i64 %3) {
%5 = ptrtoint i8* %2 to i64
switch i64 %3, label %9 [
i64 0, label %541
i64 1, label %6
]
6: ; preds = %4
%7 = load i8, i8* %2
%8 = tail call i8* @memchr(i8* %0, i8 zeroext %7, i64 %1)
br label %541
9: ; preds = %4
%10 = load i8, i8* %2
%11 = tail call i8* @memchr(i8* %0, i8 zeroext %10, i64 %1)
%12 = icmp eq i8* %11, null
br i1 %12, label %541, label %13
13: ; preds = %9
%14 = ptrtoint i8* %11 to i64
%15 = ptrtoint i8* %0 to i64
%16 = sub i64 %15, %14
%17 = add i64 %16, %1
%18 = icmp ult i64 %17, %3
br i1 %18, label %541, label %19
19: ; preds = %13
%20 = icmp ugt i64 %3, 9
br i1 %20, label %21, label %259
21: ; preds = %19
%22 = add i64 %3, -8
%23 = getelementptr i8, i8* %2, i64 %22
%24 = icmp eq i8* %23, %2
br i1 %24, label %141, label %25
25: ; preds = %21
%26 = icmp ult i64 %22, 8
br i1 %26, label %121, label %27
27: ; preds = %25
%28 = and i64 %22, -8
%29 = getelementptr i8, i8* %11, i64 %28
%30 = getelementptr i8, i8* %2, i64 %28
%31 = add i64 %28, -8
%32 = lshr exact i64 %31, 3
%33 = add nuw nsw i64 %32, 1
%34 = and i64 %33, 1
%35 = icmp eq i64 %31, 0
br i1 %35, label %87, label %36
36: ; preds = %27
%37 = and i64 %33, 4611686018427387902
br label %38
38: ; preds = %38, %36
%39 = phi i64 [ 0, %36 ], [ %84, %38 ]
%40 = phi <4 x i32> [ zeroinitializer, %36 ], [ %82, %38 ]
%41 = phi <4 x i32> [ zeroinitializer, %36 ], [ %83, %38 ]
%42 = phi i64 [ 0, %36 ], [ %85, %38 ]
%43 = getelementptr i8, i8* %11, i64 %39
%44 = getelementptr i8, i8* %2, i64 %39
%45 = bitcast i8* %44 to <4 x i8>*
%46 = load <4 x i8>, <4 x i8>* %45
%47 = getelementptr i8, i8* %44, i64 4
%48 = bitcast i8* %47 to <4 x i8>*
%49 = load <4 x i8>, <4 x i8>* %48
%50 = zext <4 x i8> %46 to <4 x i32>
%51 = zext <4 x i8> %49 to <4 x i32>
%52 = bitcast i8* %43 to <4 x i8>*
%53 = load <4 x i8>, <4 x i8>* %52
%54 = getelementptr i8, i8* %43, i64 4
%55 = bitcast i8* %54 to <4 x i8>*
%56 = load <4 x i8>, <4 x i8>* %55
%57 = zext <4 x i8> %53 to <4 x i32>
%58 = zext <4 x i8> %56 to <4 x i32>
%59 = or i64 %39, 8
%60 = getelementptr i8, i8* %11, i64 %59
%61 = getelementptr i8, i8* %2, i64 %59
%62 = bitcast i8* %61 to <4 x i8>*
%63 = load <4 x i8>, <4 x i8>* %62
%64 = getelementptr i8, i8* %61, i64 4
%65 = bitcast i8* %64 to <4 x i8>*
%66 = load <4 x i8>, <4 x i8>* %65
%67 = zext <4 x i8> %63 to <4 x i32>
%68 = zext <4 x i8> %66 to <4 x i32>
%69 = add <4 x i32> %40, %57
%70 = add nuw nsw <4 x i32> %50, %67
%71 = sub <4 x i32> %69, %70
%72 = add <4 x i32> %41, %58
%73 = add nuw nsw <4 x i32> %51, %68
%74 = sub <4 x i32> %72, %73
%75 = bitcast i8* %60 to <4 x i8>*
%76 = load <4 x i8>, <4 x i8>* %75
%77 = getelementptr i8, i8* %60, i64 4
%78 = bitcast i8* %77 to <4 x i8>*
%79 = load <4 x i8>, <4 x i8>* %78
%80 = zext <4 x i8> %76 to <4 x i32>
%81 = zext <4 x i8> %79 to <4 x i32>
%82 = add <4 x i32> %71, %80
%83 = add <4 x i32> %74, %81
%84 = add nuw i64 %39, 16
%85 = add i64 %42, 2
%86 = icmp eq i64 %85, %37
br i1 %86, label %87, label %38
87: ; preds = %38, %27
%88 = phi <4 x i32> [ undef, %27 ], [ %82, %38 ]
%89 = phi <4 x i32> [ undef, %27 ], [ %83, %38 ]
%90 = phi i64 [ 0, %27 ], [ %84, %38 ]
%91 = phi <4 x i32> [ zeroinitializer, %27 ], [ %82, %38 ]
%92 = phi <4 x i32> [ zeroinitializer, %27 ], [ %83, %38 ]
%93 = icmp eq i64 %34, 0
br i1 %93, label %115, label %94
94: ; preds = %87
%95 = getelementptr i8, i8* %11, i64 %90
%96 = getelementptr i8, i8* %2, i64 %90
%97 = bitcast i8* %96 to <4 x i8>*
%98 = load <4 x i8>, <4 x i8>* %97
%99 = getelementptr i8, i8* %96, i64 4
%100 = bitcast i8* %99 to <4 x i8>*
%101 = load <4 x i8>, <4 x i8>* %100
%102 = zext <4 x i8> %98 to <4 x i32>
%103 = zext <4 x i8> %101 to <4 x i32>
%104 = sub <4 x i32> %91, %102
%105 = sub <4 x i32> %92, %103
%106 = bitcast i8* %95 to <4 x i8>*
%107 = load <4 x i8>, <4 x i8>* %106
%108 = getelementptr i8, i8* %95, i64 4
%109 = bitcast i8* %108 to <4 x i8>*
%110 = load <4 x i8>, <4 x i8>* %109
%111 = zext <4 x i8> %107 to <4 x i32>
%112 = zext <4 x i8> %110 to <4 x i32>
%113 = add <4 x i32> %104, %111
%114 = add <4 x i32> %105, %112
br label %115
115: ; preds = %87, %94
%116 = phi <4 x i32> [ %88, %87 ], [ %113, %94 ]
%117 = phi <4 x i32> [ %89, %87 ], [ %114, %94 ]
%118 = add <4 x i32> %117, %116
%119 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %118)
%120 = icmp eq i64 %22, %28
br i1 %120, label %138, label %121
121: ; preds = %25, %115
%122 = phi i32 [ 0, %25 ], [ %119, %115 ]
%123 = phi i8* [ %11, %25 ], [ %29, %115 ]
%124 = phi i8* [ %2, %25 ], [ %30, %115 ]
br label %125
125: ; preds = %121, %125
%126 = phi i32 [ %136, %125 ], [ %122, %121 ]
%127 = phi i8* [ %133, %125 ], [ %123, %121 ]
%128 = phi i8* [ %129, %125 ], [ %124, %121 ]
%129 = getelementptr inbounds i8, i8* %128, i64 1
%130 = load i8, i8* %128
%131 = zext i8 %130 to i32
%132 = sub i32 %126, %131
%133 = getelementptr inbounds i8, i8* %127, i64 1
%134 = load i8, i8* %127
%135 = zext i8 %134 to i32
%136 = add nsw i32 %132, %135
%137 = icmp eq i8* %129, %23
br i1 %137, label %138, label %125
138: ; preds = %125, %115
%139 = phi i32 [ %119, %115 ], [ %136, %125 ]
%140 = getelementptr i8, i8* %11, i64 %22
br label %141
141: ; preds = %138, %21
%142 = phi i8* [ %2, %21 ], [ %23, %138 ]
%143 = phi i8* [ %11, %21 ], [ %140, %138 ]
%144 = phi i32 [ 0, %21 ], [ %139, %138 ]
%145 = ptrtoint i8* %142 to i64
%146 = getelementptr i8, i8* %2, i64 %3
%147 = icmp eq i8* %142, %146
br i1 %147, label %219, label %148
148: ; preds = %141
%149 = add i64 %5, %3
%150 = sub i64 %149, %145
%151 = add i64 %145, 1
%152 = and i64 %150, 1
%153 = icmp eq i64 %149, %151
br i1 %153, label %196, label %154
154: ; preds = %148
%155 = and i64 %150, -2
br label %156
156: ; preds = %156, %154
%157 = phi i64 [ 0, %154 ], [ %182, %156 ]
%158 = phi i64 [ 0, %154 ], [ %176, %156 ]
%159 = phi i32 [ %144, %154 ], [ %190, %156 ]
%160 = phi i8* [ %143, %154 ], [ %188, %156 ]
%161 = phi i8* [ %142, %154 ], [ %183, %156 ]
%162 = phi i64 [ 0, %154 ], [ %191, %156 ]
%163 = load i8, i8* %161
%164 = zext i8 %163 to i64
%165 = load i8, i8* %160
%166 = zext i8 %165 to i64
%167 = getelementptr inbounds i8, i8* %161, i64 1
%168 = zext i8 %163 to i32
%169 = getelementptr inbounds i8, i8* %160, i64 1
%170 = zext i8 %165 to i32
%171 = shl i64 %158, 16
%172 = shl nuw nsw i64 %164, 8
%173 = or i64 %171, %172
%174 = load i8, i8* %167
%175 = zext i8 %174 to i64
%176 = or i64 %173, %175
%177 = shl i64 %157, 16
%178 = shl nuw nsw i64 %166, 8
%179 = or i64 %177, %178
%180 = load i8, i8* %169
%181 = zext i8 %180 to i64
%182 = or i64 %179, %181
%183 = getelementptr inbounds i8, i8* %161, i64 2
%184 = zext i8 %174 to i32
%185 = add i32 %159, %170
%186 = add nuw nsw i32 %168, %184
%187 = sub i32 %185, %186
%188 = getelementptr inbounds i8, i8* %160, i64 2
%189 = zext i8 %180 to i32
%190 = add nsw i32 %187, %189
%191 = add i64 %162, 2
%192 = icmp eq i64 %191, %155
br i1 %192, label %193, label %156
193: ; preds = %156
%194 = shl i64 %176, 8
%195 = shl i64 %182, 8
br label %196
196: ; preds = %193, %148
%197 = phi i64 [ undef, %148 ], [ %176, %193 ]
%198 = phi i64 [ undef, %148 ], [ %182, %193 ]
%199 = phi i8* [ undef, %148 ], [ %188, %193 ]
%200 = phi i32 [ undef, %148 ], [ %190, %193 ]
%201 = phi i64 [ 0, %148 ], [ %195, %193 ]
%202 = phi i64 [ 0, %148 ], [ %194, %193 ]
%203 = phi i32 [ %144, %148 ], [ %190, %193 ]
%204 = phi i8* [ %143, %148 ], [ %188, %193 ]
%205 = phi i8* [ %142, %148 ], [ %183, %193 ]
%206 = icmp eq i64 %152, 0
br i1 %206, label %219, label %207
207: ; preds = %196
%208 = load i8, i8* %205
%209 = zext i8 %208 to i64
%210 = or i64 %202, %209
%211 = load i8, i8* %204
%212 = zext i8 %211 to i64
%213 = or i64 %201, %212
%214 = zext i8 %208 to i32
%215 = sub i32 %203, %214
%216 = getelementptr inbounds i8, i8* %204, i64 1
%217 = zext i8 %211 to i32
%218 = add nsw i32 %215, %217
br label %219
219: ; preds = %207, %196, %141
%220 = phi i8* [ %143, %141 ], [ %199, %196 ], [ %216, %207 ]
%221 = phi i32 [ %144, %141 ], [ %200, %196 ], [ %218, %207 ]
%222 = phi i64 [ 0, %141 ], [ %197, %196 ], [ %210, %207 ]
%223 = phi i64 [ 0, %141 ], [ %198, %196 ], [ %213, %207 ]
%224 = trunc i64 %3 to i32
%225 = add i32 %224, -9
%226 = icmp eq i32 %221, 0
%227 = icmp eq i64 %223, %222
%228 = select i1 %226, i1 %227, i1 false
br i1 %228, label %229, label %232
229: ; preds = %219
%230 = tail call i64 @memcmp(i8* %11, i8* %2, i32 %225)
%231 = icmp eq i64 %230, 0
br i1 %231, label %541, label %232
232: ; preds = %229, %219
%233 = getelementptr i8, i8* %11, i64 %17
%234 = icmp eq i8* %220, %233
br i1 %234, label %541, label %235
235: ; preds = %232, %257
%236 = phi i64 [ %243, %257 ], [ %223, %232 ]
%237 = phi i32 [ %250, %257 ], [ %221, %232 ]
%238 = phi i8* [ %248, %257 ], [ %220, %232 ]
%239 = phi i8* [ %244, %257 ], [ %11, %232 ]
%240 = shl i64 %236, 8
%241 = load i8, i8* %238
%242 = zext i8 %241 to i64
%243 = or i64 %240, %242
%244 = getelementptr inbounds i8, i8* %239, i64 1
%245 = load i8, i8* %239
%246 = zext i8 %245 to i32
%247 = sub nsw i32 %237, %246
%248 = getelementptr inbounds i8, i8* %238, i64 1
%249 = zext i8 %241 to i32
%250 = add nsw i32 %247, %249
%251 = icmp eq i32 %250, 0
%252 = icmp eq i64 %243, %222
%253 = select i1 %251, i1 %252, i1 false
br i1 %253, label %254, label %257
254: ; preds = %235
%255 = tail call i64 @memcmp(i8* %244, i8* %2, i32 %225)
%256 = icmp eq i64 %255, 0
br i1 %256, label %541, label %257
257: ; preds = %254, %235
%258 = icmp eq i8* %248, %233
br i1 %258, label %541, label %235
259: ; preds = %19
%260 = icmp ult i64 %3, 8
br i1 %260, label %261, label %344
261: ; preds = %259
%262 = getelementptr i8, i8* %2, i64 %3
%263 = icmp eq i8* %262, %2
br i1 %263, label %293, label %264
264: ; preds = %261
%265 = icmp ult i64 %3, 8
br i1 %265, label %289, label %266
266: ; preds = %264
%267 = and i64 %3, -8
%268 = getelementptr i8, i8* %2, i64 %267
%269 = getelementptr i8, i8* %11, i64 %267
%270 = bitcast i8* %2 to <4 x i8>*
%271 = load <4 x i8>, <4 x i8>* %270
%272 = getelementptr i8, i8* %2, i64 4
%273 = bitcast i8* %272 to <4 x i8>*
%274 = load <4 x i8>, <4 x i8>* %273
%275 = zext <4 x i8> %271 to <4 x i32>
%276 = zext <4 x i8> %274 to <4 x i32>
%277 = bitcast i8* %11 to <4 x i8>*
%278 = load <4 x i8>, <4 x i8>* %277
%279 = getelementptr i8, i8* %11, i64 4
%280 = bitcast i8* %279 to <4 x i8>*
%281 = load <4 x i8>, <4 x i8>* %280
%282 = zext <4 x i8> %278 to <4 x i32>
%283 = zext <4 x i8> %281 to <4 x i32>
%284 = sub nsw <4 x i32> %282, %275
%285 = sub nsw <4 x i32> %283, %276
%286 = add nsw <4 x i32> %285, %284
%287 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %286)
%288 = icmp eq i64 %267, %3
br i1 %288, label %309, label %289
289: ; preds = %264, %266
%290 = phi i32 [ 0, %264 ], [ %287, %266 ]
%291 = phi i8* [ %11, %264 ], [ %269, %266 ]
%292 = phi i8* [ %2, %264 ], [ %268, %266 ]
br label %296
293: ; preds = %261
%294 = trunc i64 %3 to i32
%295 = add nsw i32 %294, -1
br label %315
296: ; preds = %289, %296
%297 = phi i32 [ %307, %296 ], [ %290, %289 ]
%298 = phi i8* [ %304, %296 ], [ %291, %289 ]
%299 = phi i8* [ %300, %296 ], [ %292, %289 ]
%300 = getelementptr inbounds i8, i8* %299, i64 1
%301 = load i8, i8* %299
%302 = zext i8 %301 to i32
%303 = sub i32 %297, %302
%304 = getelementptr inbounds i8, i8* %298, i64 1
%305 = load i8, i8* %298
%306 = zext i8 %305 to i32
%307 = add nsw i32 %303, %306
%308 = icmp eq i8* %300, %262
br i1 %308, label %309, label %296
309: ; preds = %296, %266
%310 = phi i32 [ %287, %266 ], [ %307, %296 ]
%311 = getelementptr i8, i8* %11, i64 %3
%312 = trunc i64 %3 to i32
%313 = add i32 %312, -1
%314 = icmp eq i32 %310, 0
br i1 %314, label %315, label %320
315: ; preds = %293, %309
%316 = phi i32 [ %295, %293 ], [ %313, %309 ]
%317 = phi i8* [ %11, %293 ], [ %311, %309 ]
%318 = tail call i64 @memcmp(i8* %11, i8* %2, i32 %316)
%319 = icmp eq i64 %318, 0
br i1 %319, label %541, label %320
320: ; preds = %315, %309
%321 = phi i32 [ %316, %315 ], [ %313, %309 ]
%322 = phi i32 [ 0, %315 ], [ %310, %309 ]
%323 = phi i8* [ %317, %315 ], [ %311, %309 ]
%324 = getelementptr i8, i8* %11, i64 %17
%325 = icmp eq i8* %323, %324
br i1 %325, label %541, label %326
326: ; preds = %320, %342
%327 = phi i32 [ %337, %342 ], [ %322, %320 ]
%328 = phi i8* [ %334, %342 ], [ %323, %320 ]
%329 = phi i8* [ %330, %342 ], [ %11, %320 ]
%330 = getelementptr inbounds i8, i8* %329, i64 1
%331 = load i8, i8* %329
%332 = zext i8 %331 to i32
%333 = sub nsw i32 %327, %332
%334 = getelementptr inbounds i8, i8* %328, i64 1
%335 = load i8, i8* %328
%336 = zext i8 %335 to i32
%337 = add nsw i32 %333, %336
%338 = icmp eq i32 %337, 0
br i1 %338, label %339, label %342
339: ; preds = %326
%340 = tail call i64 @memcmp(i8* %330, i8* %2, i32 %321)
%341 = icmp eq i64 %340, 0
br i1 %341, label %541, label %342
342: ; preds = %339, %326
%343 = icmp eq i8* %334, %324
br i1 %343, label %541, label %326
344: ; preds = %259
%345 = icmp eq i64 %3, 8
br i1 %345, label %346, label %438
346: ; preds = %344
%347 = getelementptr inbounds i8, i8* %2, i64 1
%348 = load i8, i8* %2
%349 = zext i8 %348 to i64
%350 = getelementptr inbounds i8, i8* %11, i64 1
%351 = load i8, i8* %11
%352 = zext i8 %351 to i64
%353 = getelementptr inbounds i8, i8* %2, i64 2
%354 = load i8, i8* %347
%355 = zext i8 %354 to i64
%356 = getelementptr inbounds i8, i8* %11, i64 2
%357 = load i8, i8* %350
%358 = zext i8 %357 to i64
%359 = shl nuw nsw i64 %349, 16
%360 = shl nuw nsw i64 %355, 8
%361 = or i64 %359, %360
%362 = getelementptr inbounds i8, i8* %2, i64 3
%363 = load i8, i8* %353
%364 = zext i8 %363 to i64
%365 = or i64 %361, %364
%366 = shl nuw nsw i64 %352, 16
%367 = shl nuw nsw i64 %358, 8
%368 = or i64 %366, %367
%369 = getelementptr inbounds i8, i8* %11, i64 3
%370 = load i8, i8* %356
%371 = zext i8 %370 to i64
%372 = or i64 %368, %371
%373 = getelementptr inbounds i8, i8* %2, i64 4
%374 = load i8, i8* %362
%375 = zext i8 %374 to i64
%376 = getelementptr inbounds i8, i8* %11, i64 4
%377 = load i8, i8* %369
%378 = zext i8 %377 to i64
%379 = shl nuw nsw i64 %365, 16
%380 = shl nuw nsw i64 %375, 8
%381 = or i64 %379, %380
%382 = getelementptr inbounds i8, i8* %2, i64 5
%383 = load i8, i8* %373
%384 = zext i8 %383 to i64
%385 = or i64 %381, %384
%386 = shl nuw nsw i64 %372, 16
%387 = shl nuw nsw i64 %378, 8
%388 = or i64 %386, %387
%389 = getelementptr inbounds i8, i8* %11, i64 5
%390 = load i8, i8* %376
%391 = zext i8 %390 to i64
%392 = or i64 %388, %391
%393 = getelementptr inbounds i8, i8* %2, i64 6
%394 = load i8, i8* %382
%395 = zext i8 %394 to i64
%396 = getelementptr inbounds i8, i8* %11, i64 6
%397 = load i8, i8* %389
%398 = zext i8 %397 to i64
%399 = shl i64 %385, 16
%400 = shl nuw nsw i64 %395, 8
%401 = or i64 %399, %400
%402 = getelementptr inbounds i8, i8* %2, i64 7
%403 = load i8, i8* %393
%404 = zext i8 %403 to i64
%405 = or i64 %401, %404
%406 = shl i64 %392, 16
%407 = shl nuw nsw i64 %398, 8
%408 = or i64 %406, %407
%409 = getelementptr inbounds i8, i8* %11, i64 7
%410 = load i8, i8* %396
%411 = zext i8 %410 to i64
%412 = or i64 %408, %411
%413 = shl i64 %405, 8
%414 = load i8, i8* %402
%415 = zext i8 %414 to i64
%416 = or i64 %413, %415
%417 = shl i64 %412, 8
%418 = load i8, i8* %409
%419 = zext i8 %418 to i64
%420 = or i64 %417, %419
%421 = icmp eq i64 %420, %416
br i1 %421, label %541, label %422
422: ; preds = %346
%423 = getelementptr i8, i8* %11, i64 8
%424 = getelementptr i8, i8* %11, i64 %17
br label %425
425: ; preds = %429, %422
%426 = phi i8* [ %423, %422 ], [ %431, %429 ]
%427 = phi i64 [ %420, %422 ], [ %434, %429 ]
%428 = icmp eq i8* %426, %424
br i1 %428, label %541, label %429
429: ; preds = %425
%430 = shl i64 %427, 8
%431 = getelementptr inbounds i8, i8* %426, i64 1
%432 = load i8, i8* %426
%433 = zext i8 %432 to i64
%434 = or i64 %430, %433
%435 = icmp eq i64 %434, %416
br i1 %435, label %436, label %425
436: ; preds = %429
%437 = getelementptr i8, i8* %426, i64 -7
br label %541
438: ; preds = %344
%439 = getelementptr inbounds i8, i8* %11, i64 1
%440 = getelementptr inbounds i8, i8* %2, i64 1
%441 = load i8, i8* %440
%442 = zext i8 %441 to i64
%443 = load i8, i8* %439
%444 = zext i8 %443 to i64
%445 = getelementptr inbounds i8, i8* %11, i64 2
%446 = getelementptr inbounds i8, i8* %2, i64 2
%447 = load i8, i8* %446
%448 = zext i8 %447 to i64
%449 = load i8, i8* %445
%450 = zext i8 %449 to i64
%451 = getelementptr inbounds i8, i8* %11, i64 3
%452 = getelementptr inbounds i8, i8* %2, i64 3
%453 = shl nuw nsw i64 %442, 16
%454 = shl nuw nsw i64 %448, 8
%455 = or i64 %453, %454
%456 = load i8, i8* %452
%457 = zext i8 %456 to i64
%458 = or i64 %455, %457
%459 = shl nuw nsw i64 %444, 16
%460 = shl nuw nsw i64 %450, 8
%461 = or i64 %459, %460
%462 = load i8, i8* %451
%463 = zext i8 %462 to i64
%464 = or i64 %461, %463
%465 = getelementptr inbounds i8, i8* %11, i64 4
%466 = getelementptr inbounds i8, i8* %2, i64 4
%467 = load i8, i8* %466
%468 = zext i8 %467 to i64
%469 = load i8, i8* %465
%470 = zext i8 %469 to i64
%471 = getelementptr inbounds i8, i8* %11, i64 5
%472 = getelementptr inbounds i8, i8* %2, i64 5
%473 = shl nuw nsw i64 %458, 16
%474 = shl nuw nsw i64 %468, 8
%475 = or i64 %473, %474
%476 = load i8, i8* %472
%477 = zext i8 %476 to i64
%478 = or i64 %475, %477
%479 = shl nuw nsw i64 %464, 16
%480 = shl nuw nsw i64 %470, 8
%481 = or i64 %479, %480
%482 = load i8, i8* %471
%483 = zext i8 %482 to i64
%484 = or i64 %481, %483
%485 = getelementptr inbounds i8, i8* %11, i64 6
%486 = getelementptr inbounds i8, i8* %2, i64 6
%487 = load i8, i8* %486
%488 = zext i8 %487 to i64
%489 = load i8, i8* %485
%490 = zext i8 %489 to i64
%491 = getelementptr inbounds i8, i8* %11, i64 7
%492 = getelementptr inbounds i8, i8* %2, i64 7
%493 = shl i64 %478, 16
%494 = shl nuw nsw i64 %488, 8
%495 = or i64 %493, %494
%496 = load i8, i8* %492
%497 = zext i8 %496 to i64
%498 = or i64 %495, %497
%499 = shl i64 %484, 16
%500 = shl nuw nsw i64 %490, 8
%501 = or i64 %499, %500
%502 = load i8, i8* %491
%503 = zext i8 %502 to i64
%504 = or i64 %501, %503
%505 = getelementptr inbounds i8, i8* %11, i64 8
%506 = getelementptr inbounds i8, i8* %2, i64 8
%507 = shl i64 %498, 8
%508 = load i8, i8* %506
%509 = zext i8 %508 to i64
%510 = or i64 %507, %509
%511 = shl i64 %504, 8
%512 = load i8, i8* %505
%513 = zext i8 %512 to i64
%514 = or i64 %511, %513
%515 = getelementptr i8, i8* %11, i64 9
%516 = icmp eq i64 %514, %510
br i1 %516, label %517, label %521
517: ; preds = %438
%518 = load i8, i8* %11
%519 = load i8, i8* %2
%520 = icmp eq i8 %518, %519
br i1 %520, label %541, label %521
521: ; preds = %517, %438
%522 = getelementptr i8, i8* %11, i64 %17
%523 = icmp eq i8* %515, %522
br i1 %523, label %541, label %524
524: ; preds = %521, %539
%525 = phi i64 [ %532, %539 ], [ %514, %521 ]
%526 = phi i8* [ %529, %539 ], [ %515, %521 ]
%527 = phi i8* [ %533, %539 ], [ %11, %521 ]
%528 = shl i64 %525, 8
%529 = getelementptr inbounds i8, i8* %526, i64 1
%530 = load i8, i8* %526
%531 = zext i8 %530 to i64
%532 = or i64 %528, %531
%533 = getelementptr inbounds i8, i8* %527, i64 1
%534 = icmp eq i64 %532, %510
br i1 %534, label %535, label %539
535: ; preds = %524
%536 = load i8, i8* %533
%537 = load i8, i8* %2
%538 = icmp eq i8 %536, %537
br i1 %538, label %541, label %539
539: ; preds = %535, %524
%540 = icmp eq i8* %529, %522
br i1 %540, label %541, label %524
541: ; preds = %535, %539, %425, %339, %342, %254, %257, %521, %320, %232, %517, %346, %315, %229, %13, %9, %4, %436, %6
%542 = phi i8* [ %437, %436 ], [ %8, %6 ], [ %0, %4 ], [ null, %9 ], [ null, %13 ], [ %11, %229 ], [ %11, %315 ], [ %11, %346 ], [ %11, %517 ], [ null, %232 ], [ null, %320 ], [ null, %521 ], [ %244, %254 ], [ null, %257 ], [ %330, %339 ], [ null, %342 ], [ null, %425 ], [ %533, %535 ], [ null, %539 ]
ret i8* %542
}