#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 */
typedef size_t uint8_t;

/* Variables and functions */
size_t *memchr(size_t const *, int /*<<< orphan*/, size_t);
scalar_t__ memcmp(size_t const *, size_t const *, size_t);
char *twoway_strstr(const uint8_t *h, const uint8_t *n) {
  const uint8_t *z;
  size_t l, ip, jp, k, p, ms, p0, mem, mem0;
  size_t byteset[32 / sizeof(size_t)] = {0};
  size_t shift[256];
  for (l = 0; n[l] && h[l]; l++) {
    ((byteset)[(size_t)(n[l]) / (8 * sizeof *(byteset))] |=
     (size_t)1 << ((size_t)(n[l]) % (8 * sizeof *(byteset)))),
        shift[n[l]] = l + 1;
  }
  if (n[l]) {
    return 0;
  }
  ip = -1;
  jp = 0;
  k = p = 1;
  while (jp + k < l) {
    if (n[ip + k] == n[jp + k]) {
      if (k == p) {
        jp += p;
        k = 1;
      } else {
        k++;
      }
    } else if (n[ip + k] > n[jp + k]) {
      jp += k;
      k = 1;
      p = jp - ip;
    } else {
      ip = jp++;
      k = p = 1;
    }
  }
  ms = ip;
  p0 = p;
  ip = -1;
  jp = 0;
  k = p = 1;
  while (jp + k < l) {
    if (n[ip + k] == n[jp + k]) {
      if (k == p) {
        jp += p;
        k = 1;
      } else {
        k++;
      }
    } else if (n[ip + k] < n[jp + k]) {
      jp += k;
      k = 1;
      p = jp - ip;
    } else {
      ip = jp++;
      k = p = 1;
    }
  }
  if (ip + 1 > ms + 1) {
    ms = ip;
  } else {
    p = p0;
  }
  if (memcmp(n, n + p, ms + 1)) {
    mem0 = 0;
    p = ((ms) > (l - ms - 1) ? (ms) : (l - ms - 1)) + 1;
  } else {
    mem0 = l - p;
  }
  mem = 0;
  z = h;
  for (;;) {
    if ((size_t)(z - h) < l) {
      size_t grow = l | 63;
      const uint8_t *z2 = memchr(z, 0, grow);
      if (z2) {
        z = z2;
        if ((size_t)(z - h) < l) {
          return 0;
        }
      } else {
        z += grow;
      }
    }
    if (((byteset)[(size_t)(h[l - 1]) / (8 * sizeof *(byteset))] &
         (size_t)1 << ((size_t)(h[l - 1]) % (8 * sizeof *(byteset))))) {
      k = l - shift[h[l - 1]];
      if (k) {
        if (k < mem) {
          k = mem;
        }
        h += k;
        mem = 0;
        continue;
      }
    } else {
      h += l;
      mem = 0;
      continue;
    }
    for (k = ((ms + 1) > (mem) ? (ms + 1) : (mem)); n[k] && n[k] == h[k]; k++)
      ;
    if (n[k]) {
      h += k - ms;
      mem = 0;
      continue;
    }
    for (k = ms + 1; k > mem && n[k - 1] == h[k - 1]; k--)
      ;
    if (k <= mem) {
      return (char *)h;
    }
    h += p;
    mem = mem0;
  }
}


x86 assembly (clang, -O0):
<twoway_strstr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x8c0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
lea    -0x90(%rbp),%rdi
xor    %esi,%esi
mov    $0x20,%edx
call   1030 <memset@plt>
movq   $0x0,-0x28(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    %eax,%eax
cmpq   $0x0,(%rcx,%rdx,8)
mov    %al,-0x8a1(%rbp)
je     118f <twoway_strstr+0x5f>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
setne  %al
mov    %al,-0x8a1(%rbp)
mov    -0x8a1(%rbp),%al
test   $0x1,%al
jne    11a2 <twoway_strstr+0x72>
jmp    120a <twoway_strstr+0xda>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rcx
and    $0x3f,%rcx
mov    $0x1,%eax
shl    %cl,%rax
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
shr    $0x6,%rax
or     -0x90(%rbp,%rax,8),%rcx
ff
mov    %rcx,-0x90(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rcx
add    $0x1,%rcx
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %rcx,-0x890(%rbp,%rax,8)
ff
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    115e <twoway_strstr+0x2e>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     122a <twoway_strstr+0xfa>
movq   $0x0,-0x8(%rbp)
jmp    17fc <twoway_strstr+0x6cc>
movq   $0xffffffffffffffff,-0x30(%rbp)
ff
movq   $0x0,-0x38(%rbp)
movq   $0x1,-0x48(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    1332 <twoway_strstr+0x202>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%rdx
add    -0x40(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jne    12ba <twoway_strstr+0x18a>
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    12a9 <twoway_strstr+0x179>
mov    -0x48(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x1,-0x40(%rbp)
jmp    12b5 <twoway_strstr+0x185>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    132d <twoway_strstr+0x1fd>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%rdx
add    -0x40(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jbe    1305 <twoway_strstr+0x1d5>
mov    -0x40(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x38(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    1328 <twoway_strstr+0x1f8>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x30(%rbp)
movq   $0x1,-0x48(%rbp)
movq   $0x1,-0x40(%rbp)
jmp    132d <twoway_strstr+0x1fd>
jmp    124a <twoway_strstr+0x11a>
mov    -0x30(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
movq   $0xffffffffffffffff,-0x30(%rbp)
ff
movq   $0x0,-0x38(%rbp)
movq   $0x1,-0x48(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x38(%rbp),%rax
add    -0x40(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    144a <twoway_strstr+0x31a>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%rdx
add    -0x40(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jne    13d2 <twoway_strstr+0x2a2>
mov    -0x40(%rbp),%rax
cmp    -0x48(%rbp),%rax
jne    13c1 <twoway_strstr+0x291>
mov    -0x48(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x1,-0x40(%rbp)
jmp    13cd <twoway_strstr+0x29d>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1445 <twoway_strstr+0x315>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
mov    -0x38(%rbp),%rdx
add    -0x40(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
jae    141d <twoway_strstr+0x2ed>
mov    -0x40(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x1,-0x40(%rbp)
mov    -0x38(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    1440 <twoway_strstr+0x310>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rax,-0x30(%rbp)
movq   $0x1,-0x48(%rbp)
movq   $0x1,-0x40(%rbp)
jmp    1445 <twoway_strstr+0x315>
jmp    1362 <twoway_strstr+0x232>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    -0x50(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jbe    1470 <twoway_strstr+0x340>
mov    -0x30(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    1478 <twoway_strstr+0x348>
mov    -0x58(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x48(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
mov    -0x50(%rbp),%rdx
add    $0x1,%rdx
call   1050 <memcmp@plt>
cmp    $0x0,%rax
je     14fa <twoway_strstr+0x3ca>
movq   $0x0,-0x68(%rbp)
mov    -0x50(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    -0x50(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jbe    14d3 <twoway_strstr+0x3a3>
mov    -0x50(%rbp),%rax
mov    %rax,-0x8b0(%rbp)
jmp    14e6 <twoway_strstr+0x3b6>
mov    -0x28(%rbp),%rax
sub    -0x50(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x8b0(%rbp)
mov    -0x8b0(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1506 <twoway_strstr+0x3d6>
mov    -0x28(%rbp),%rax
sub    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x3,%rax
cmp    -0x28(%rbp),%rax
jae    15b3 <twoway_strstr+0x483>
mov    -0x28(%rbp),%rax
or     $0x3f,%rax
mov    %rax,-0x898(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x898(%rbp),%rdx
xor    %esi,%esi
call   1040 <memchr@plt>
mov    %rax,-0x8a0(%rbp)
cmpq   $0x0,-0x8a0(%rbp)
je     159b <twoway_strstr+0x46b>
mov    -0x8a0(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
sar    $0x3,%rax
cmp    -0x28(%rbp),%rax
jae    1596 <twoway_strstr+0x466>
movq   $0x0,-0x8(%rbp)
jmp    17fc <twoway_strstr+0x6cc>
jmp    15ae <twoway_strstr+0x47e>
mov    -0x898(%rbp),%rax
shl    $0x3,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    15b3 <twoway_strstr+0x483>
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x6,%rax
mov    -0x90(%rbp,%rax,8),%rax
ff
mov    -0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdx
sub    $0x1,%rdx
mov    (%rcx,%rdx,8),%rcx
and    $0x3f,%rcx
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rdx,%rcx
and    %rcx,%rax
cmp    $0x0,%rax
je     165e <twoway_strstr+0x52e>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x28(%rbp),%rdx
sub    $0x1,%rdx
mov    (%rcx,%rdx,8),%rcx
sub    -0x890(%rbp,%rcx,8),%rax
ff
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
je     1659 <twoway_strstr+0x529>
mov    -0x40(%rbp),%rax
cmp    -0x60(%rbp),%rax
jae    163c <twoway_strstr+0x50c>
mov    -0x60(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
shl    $0x3,%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
movq   $0x0,-0x60(%rbp)
jmp    1516 <twoway_strstr+0x3e6>
jmp    167b <twoway_strstr+0x54b>
mov    -0x28(%rbp),%rax
shl    $0x3,%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
movq   $0x0,-0x60(%rbp)
jmp    1516 <twoway_strstr+0x3e6>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
cmp    -0x60(%rbp),%rax
jbe    16a1 <twoway_strstr+0x571>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8b8(%rbp)
jmp    16ac <twoway_strstr+0x57c>
mov    -0x60(%rbp),%rax
mov    %rax,-0x8b8(%rbp)
mov    -0x8b8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x40(%rbp),%rdx
xor    %eax,%eax
cmpq   $0x0,(%rcx,%rdx,8)
mov    %al,-0x8b9(%rbp)
je     16f3 <twoway_strstr+0x5c3>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x40(%rbp),%rdx
cmp    (%rcx,%rdx,8),%rax
sete   %al
mov    %al,-0x8b9(%rbp)
mov    -0x8b9(%rbp),%al
test   $0x1,%al
jne    1706 <twoway_strstr+0x5d6>
jmp    171c <twoway_strstr+0x5ec>
jmp    170b <twoway_strstr+0x5db>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    16b7 <twoway_strstr+0x587>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
cmpq   $0x0,(%rax,%rcx,8)
je     1750 <twoway_strstr+0x620>
mov    -0x40(%rbp),%rax
sub    -0x50(%rbp),%rax
shl    $0x3,%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
movq   $0x0,-0x60(%rbp)
jmp    1516 <twoway_strstr+0x3e6>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp),%rcx
mov    %al,-0x8ba(%rbp)
jbe    179b <twoway_strstr+0x66b>
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
mov    -0x40(%rbp),%rdx
sub    $0x1,%rdx
cmp    (%rcx,%rdx,8),%rax
sete   %al
mov    %al,-0x8ba(%rbp)
mov    -0x8ba(%rbp),%al
test   $0x1,%al
jne    17ae <twoway_strstr+0x67e>
jmp    17c4 <twoway_strstr+0x694>
jmp    17b3 <twoway_strstr+0x683>
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x40(%rbp)
jmp    175c <twoway_strstr+0x62c>
mov    -0x40(%rbp),%rax
cmp    -0x60(%rbp),%rax
ja     17df <twoway_strstr+0x6af>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17fc <twoway_strstr+0x6cc>
mov    -0x48(%rbp),%rax
shl    $0x3,%rax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x68(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    1516 <twoway_strstr+0x3e6>
mov    -0x8(%rbp),%rax
add    $0x8c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<twoway_strstr>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x848,%rsp
mov    %rsi,%rbx
mov    %rdi,%r15
xorps  %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
mov    (%rsi),%rcx
mov    $0xffffffffffffffff,%r14
test   %rcx,%rcx
je     1226 <twoway_strstr+0x106>
xor    %eax,%eax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
cmpq   $0x0,(%r15,%rdi,8)
je     13a7 <twoway_strstr+0x287>
mov    $0x1,%edx
shl    %cl,%rdx
mov    %rcx,%rsi
shr    $0x6,%rsi
or     %rdx,0x20(%rsp,%rsi,8)
lea    0x1(%rdi),%r13
mov    %r13,0x40(%rsp,%rcx,8)
mov    0x8(%rbx,%rdi,8),%rcx
mov    %r13,%rdi
test   %rcx,%rcx
jne    1160 <twoway_strstr+0x40>
mov    $0x1,%r12d
cmp    $0x2,%r13
jb     122f <twoway_strstr+0x10f>
mov    $0xffffffffffffffff,%r14
mov    $0x1,%edx
xor    %eax,%eax
mov    $0x1,%r12d
mov    $0x1,%ecx
jmp    11df <twoway_strstr+0xbf>
mov    %rax,%r14
add    $0x1,%rax
mov    $0x1,%ecx
mov    $0x1,%r12d
lea    (%rcx,%rax,1),%rdx
cmp    %r13,%rdx
jae    13b9 <twoway_strstr+0x299>
lea    (%rcx,%r14,1),%rsi
mov    (%rbx,%rdx,8),%rdi
cmp    %rdi,(%rbx,%rsi,8)
jne    1200 <twoway_strstr+0xe0>
cmp    %r12,%rcx
jne    1220 <twoway_strstr+0x100>
add    %r12,%rax
mov    $0x1,%ecx
jmp    11d2 <twoway_strstr+0xb2>
nopl   0x0(%rax)
jbe    11c0 <twoway_strstr+0xa0>
mov    %rdx,%r12
sub    %r14,%r12
mov    $0x1,%ecx
mov    %rdx,%rax
jmp    11d2 <twoway_strstr+0xb2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rcx
jmp    11d2 <twoway_strstr+0xb2>
mov    $0x1,%r12d
xor    %r13d,%r13d
mov    $0xffffffffffffffff,%r8
mov    $0x1,%ecx
lea    0x1(%r8),%rax
lea    0x1(%r14),%rdx
cmp    %rdx,%rax
cmova  %rcx,%r12
cmova  %r8,%r14
lea    (%rbx,%r12,8),%rsi
lea    0x1(%r14),%rdx
mov    %rbx,%rdi
mov    %rdx,0x10(%rsp)
call   1040 <memcmp@plt>
test   %rax,%rax
je     1285 <twoway_strstr+0x165>
mov    %r14,%rax
not    %rax
add    %r13,%rax
cmp    %rax,%r14
cmova  %r14,%rax
add    $0x1,%rax
mov    %rax,0x8(%rsp)
xor    %eax,%eax
jmp    1290 <twoway_strstr+0x170>
mov    %r13,%rax
mov    %r12,0x8(%rsp)
sub    %r12,%rax
mov    %rax,(%rsp)
mov    %r13,%r12
or     $0x3f,%r12
neg    %r14
mov    %r14,0x18(%rsp)
xor    %ebp,%ebp
mov    %r15,%r14
jmp    12b9 <twoway_strstr+0x199>
nopw   0x0(%rax,%rax,1)
mov    %r13,%rax
xor    %ebp,%ebp
lea    (%r14,%rax,8),%r14
mov    %r15,%rax
sub    %r14,%rax
sar    $0x3,%rax
cmp    %r13,%rax
jae    1300 <twoway_strstr+0x1e0>
mov    %r15,%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1030 <memchr@plt>
test   %rax,%rax
je     12f1 <twoway_strstr+0x1d1>
mov    %rax,%rcx
sub    %r14,%rcx
sar    $0x3,%rcx
mov    %rax,%r15
cmp    %r13,%rcx
jae    1300 <twoway_strstr+0x1e0>
jmp    1457 <twoway_strstr+0x337>
lea    (%r15,%r12,8),%r15
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x8(%r14,%r13,8),%rcx
mov    %rcx,%rax
shr    $0x6,%rax
mov    0x20(%rsp,%rax,8),%rax
bt     %rcx,%rax
jae    12b0 <twoway_strstr+0x190>
mov    %r13,%rax
sub    0x40(%rsp,%rcx,8),%rax
je     1330 <twoway_strstr+0x210>
cmp    %rbp,%rax
cmovb  %rbp,%rax
jmp    12b3 <twoway_strstr+0x193>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rdx
cmp    %rbp,%rdx
mov    %rbp,%rax
cmova  %rdx,%rax
mov    (%rbx,%rax,8),%rcx
test   %rcx,%rcx
je     1370 <twoway_strstr+0x250>
nopl   0x0(%rax,%rax,1)
cmp    (%r14,%rax,8),%rcx
jne    139a <twoway_strstr+0x27a>
mov    0x8(%rbx,%rax,8),%rcx
add    $0x1,%rax
test   %rcx,%rcx
jne    1350 <twoway_strstr+0x230>
mov    0x10(%rsp),%rdx
nopl   0x0(%rax)
cmp    %rbp,%rdx
jbe    13a4 <twoway_strstr+0x284>
mov    -0x8(%rbx,%rdx,8),%rax
lea    -0x1(%rdx),%rcx
cmp    -0x8(%r14,%rdx,8),%rax
mov    %rcx,%rdx
je     1370 <twoway_strstr+0x250>
mov    0x8(%rsp),%rax
mov    (%rsp),%rbp
lea    (%r14,%rax,8),%r14
jmp    12b9 <twoway_strstr+0x199>
add    0x18(%rsp),%rax
jmp    12b3 <twoway_strstr+0x193>
mov    %r14,%rax
add    $0x848,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmp    $0x2,%r13
jb     1446 <twoway_strstr+0x326>
mov    $0xffffffffffffffff,%r8
mov    $0x1,%edi
xor    %edx,%edx
mov    $0x1,%ecx
mov    $0x1,%esi
jmp    13fe <twoway_strstr+0x2de>
nopl   (%rax)
mov    %rdx,%r8
add    $0x1,%rdx
mov    $0x1,%esi
mov    $0x1,%ecx
lea    (%rsi,%rdx,1),%rdi
cmp    %r13,%rdi
jae    123b <twoway_strstr+0x11b>
lea    (%rsi,%r8,1),%rbp
mov    (%rbx,%rdi,8),%rax
cmp    %rax,(%rbx,%rbp,8)
jne    1420 <twoway_strstr+0x300>
cmp    %rcx,%rsi
jne    1440 <twoway_strstr+0x320>
add    %rcx,%rdx
mov    $0x1,%esi
jmp    13f1 <twoway_strstr+0x2d1>
nopl   0x0(%rax,%rax,1)
jae    13e0 <twoway_strstr+0x2c0>
mov    %rdi,%rcx
sub    %r8,%rcx
mov    $0x1,%esi
mov    %rdi,%rdx
jmp    13f1 <twoway_strstr+0x2d1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
jmp    13f1 <twoway_strstr+0x2d1>
mov    $0x1,%ecx
mov    $0xffffffffffffffff,%r8
jmp    123b <twoway_strstr+0x11b>
xor    %eax,%eax
jmp    13a7 <twoway_strstr+0x287>

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

LLVM IR (-O2):
define i8* @twoway_strstr(i64* %0, i64* %1) {
%3 = alloca [4 x i64]
%4 = alloca [256 x i64]
%5 = bitcast [4 x i64]* %3 to i8*
%6 = bitcast [256 x i64]* %4 to i8*
%7 = load i64, i64* %1
%8 = icmp eq i64 %7, 0
br i1 %8, label %92, label %11
9: ; preds = %17
%10 = icmp ugt i64 %24, 1
br i1 %10, label %30, label %92
11: ; preds = %2, %17
%12 = phi i64 [ %27, %17 ], [ %7, %2 ]
%13 = phi i64 [ %24, %17 ], [ 0, %2 ]
%14 = getelementptr inbounds i64, i64* %0, i64 %13
%15 = load i64, i64* %14
%16 = icmp eq i64 %15, 0
br i1 %16, label %194, label %17
17: ; preds = %11
%18 = and i64 %12, 63
%19 = shl nuw i64 1, %18
%20 = lshr i64 %12, 6
%21 = getelementptr inbounds [4 x i64], [4 x i64]* %3, i64 0, i64 %20
%22 = load i64, i64* %21
%23 = or i64 %22, %19
store i64 %23, i64* %21
%24 = add i64 %13, 1
%25 = getelementptr inbounds [256 x i64], [256 x i64]* %4, i64 0, i64 %12
store i64 %24, i64* %25
%26 = getelementptr inbounds i64, i64* %1, i64 %24
%27 = load i64, i64* %26
%28 = icmp eq i64 %27, 0
br i1 %28, label %9, label %11
29: ; preds = %54
br i1 %10, label %61, label %92
30: ; preds = %9, %54
%31 = phi i64 [ %59, %54 ], [ 1, %9 ]
%32 = phi i64 [ %58, %54 ], [ 1, %9 ]
%33 = phi i64 [ %57, %54 ], [ 1, %9 ]
%34 = phi i64 [ %56, %54 ], [ 0, %9 ]
%35 = phi i64 [ %55, %54 ], [ -1, %9 ]
%36 = add i64 %33, %35
%37 = getelementptr inbounds i64, i64* %1, i64 %36
%38 = load i64, i64* %37
%39 = getelementptr inbounds i64, i64* %1, i64 %31
%40 = load i64, i64* %39
%41 = icmp eq i64 %38, %40
br i1 %41, label %42, label %48
42: ; preds = %30
%43 = icmp eq i64 %33, %32
br i1 %43, label %44, label %46
44: ; preds = %42
%45 = add i64 %32, %34
br label %54
46: ; preds = %42
%47 = add i64 %33, 1
br label %54
48: ; preds = %30
%49 = icmp ugt i64 %38, %40
br i1 %49, label %50, label %52
50: ; preds = %48
%51 = sub i64 %31, %35
br label %54
52: ; preds = %48
%53 = add i64 %34, 1
br label %54
54: ; preds = %50, %52, %44, %46
%55 = phi i64 [ %35, %44 ], [ %35, %46 ], [ %35, %50 ], [ %34, %52 ]
%56 = phi i64 [ %45, %44 ], [ %34, %46 ], [ %31, %50 ], [ %53, %52 ]
%57 = phi i64 [ 1, %44 ], [ %47, %46 ], [ 1, %50 ], [ 1, %52 ]
%58 = phi i64 [ %32, %44 ], [ %32, %46 ], [ %51, %50 ], [ 1, %52 ]
%59 = add i64 %57, %56
%60 = icmp ult i64 %59, %24
br i1 %60, label %30, label %29
61: ; preds = %29, %85
%62 = phi i64 [ %90, %85 ], [ 1, %29 ]
%63 = phi i64 [ %89, %85 ], [ 1, %29 ]
%64 = phi i64 [ %88, %85 ], [ 1, %29 ]
%65 = phi i64 [ %87, %85 ], [ 0, %29 ]
%66 = phi i64 [ %86, %85 ], [ -1, %29 ]
%67 = add i64 %64, %66
%68 = getelementptr inbounds i64, i64* %1, i64 %67
%69 = load i64, i64* %68
%70 = getelementptr inbounds i64, i64* %1, i64 %62
%71 = load i64, i64* %70
%72 = icmp eq i64 %69, %71
br i1 %72, label %73, label %79
73: ; preds = %61
%74 = icmp eq i64 %64, %63
br i1 %74, label %75, label %77
75: ; preds = %73
%76 = add i64 %63, %65
br label %85
77: ; preds = %73
%78 = add i64 %64, 1
br label %85
79: ; preds = %61
%80 = icmp ult i64 %69, %71
br i1 %80, label %81, label %83
81: ; preds = %79
%82 = sub i64 %62, %66
br label %85
83: ; preds = %79
%84 = add i64 %65, 1
br label %85
85: ; preds = %81, %83, %75, %77
%86 = phi i64 [ %66, %75 ], [ %66, %77 ], [ %66, %81 ], [ %65, %83 ]
%87 = phi i64 [ %76, %75 ], [ %65, %77 ], [ %62, %81 ], [ %84, %83 ]
%88 = phi i64 [ 1, %75 ], [ %78, %77 ], [ 1, %81 ], [ 1, %83 ]
%89 = phi i64 [ %63, %75 ], [ %63, %77 ], [ %82, %81 ], [ 1, %83 ]
%90 = add i64 %88, %87
%91 = icmp ult i64 %90, %24
br i1 %91, label %61, label %92
92: ; preds = %85, %2, %9, %29
%93 = phi i64 [ %58, %29 ], [ 1, %9 ], [ 1, %2 ], [ %58, %85 ]
%94 = phi i64 [ %55, %29 ], [ -1, %9 ], [ -1, %2 ], [ %55, %85 ]
%95 = phi i64 [ %24, %29 ], [ %24, %9 ], [ 0, %2 ], [ %24, %85 ]
%96 = phi i64 [ -1, %29 ], [ -1, %9 ], [ -1, %2 ], [ %86, %85 ]
%97 = phi i64 [ 1, %29 ], [ 1, %9 ], [ 1, %2 ], [ %89, %85 ]
%98 = add i64 %96, 1
%99 = add i64 %94, 1
%100 = icmp ugt i64 %98, %99
%101 = select i1 %100, i64 %97, i64 %93
%102 = select i1 %100, i64 %96, i64 %94
%103 = getelementptr inbounds i64, i64* %1, i64 %101
%104 = add i64 %102, 1
%105 = tail call i64 @memcmp(i64* %1, i64* %103, i64 %104)
%106 = icmp eq i64 %105, 0
br i1 %106, label %113, label %107
107: ; preds = %92
%108 = xor i64 %102, -1
%109 = add i64 %95, %108
%110 = icmp ugt i64 %102, %109
%111 = select i1 %110, i64 %102, i64 %109
%112 = add i64 %111, 1
br label %115
113: ; preds = %92
%114 = sub i64 %95, %101
br label %115
115: ; preds = %113, %107
%116 = phi i64 [ %112, %107 ], [ %101, %113 ]
%117 = phi i64 [ 0, %107 ], [ %114, %113 ]
%118 = or i64 %95, 63
%119 = add i64 %95, -1
br label %120
120: ; preds = %158, %115
%121 = phi i64* [ %0, %115 ], [ %140, %158 ]
%122 = phi i64 [ 0, %115 ], [ %160, %158 ]
%123 = phi i64* [ %0, %115 ], [ %161, %158 ]
%124 = ptrtoint i64* %121 to i64
%125 = ptrtoint i64* %123 to i64
%126 = sub i64 %124, %125
%127 = ashr exact i64 %126, 3
%128 = icmp ult i64 %127, %95
br i1 %128, label %129, label %139
129: ; preds = %120
%130 = tail call i64* @memchr(i64* dereferenceable(1) %121, i32 0, i64 %118)
%131 = icmp eq i64* %130, null
br i1 %131, label %137, label %132
132: ; preds = %129
%133 = ptrtoint i64* %130 to i64
%134 = sub i64 %133, %125
%135 = ashr exact i64 %134, 3
%136 = icmp ult i64 %135, %95
br i1 %136, label %194, label %139
137: ; preds = %129
%138 = getelementptr inbounds i64, i64* %121, i64 %118
br label %139
139: ; preds = %132, %137, %120
%140 = phi i64* [ %121, %120 ], [ %130, %132 ], [ %138, %137 ]
%141 = getelementptr inbounds i64, i64* %123, i64 %119
%142 = load i64, i64* %141
%143 = lshr i64 %142, 6
%144 = getelementptr inbounds [4 x i64], [4 x i64]* %3, i64 0, i64 %143
%145 = load i64, i64* %144
%146 = and i64 %142, 63
%147 = shl nuw i64 1, %146
%148 = and i64 %147, %145
%149 = icmp eq i64 %148, 0
br i1 %149, label %158, label %150
150: ; preds = %139
%151 = getelementptr inbounds [256 x i64], [256 x i64]* %4, i64 0, i64 %142
%152 = load i64, i64* %151
%153 = sub i64 %95, %152
%154 = icmp eq i64 %153, 0
br i1 %154, label %162, label %155
155: ; preds = %150
%156 = icmp ult i64 %153, %122
%157 = select i1 %156, i64 %122, i64 %153
br label %158
158: ; preds = %185, %139, %155, %180
%159 = phi i64 [ %157, %155 ], [ %181, %180 ], [ %95, %139 ], [ %116, %185 ]
%160 = phi i64 [ 0, %155 ], [ 0, %180 ], [ 0, %139 ], [ %117, %185 ]
%161 = getelementptr inbounds i64, i64* %123, i64 %159
br label %120
162: ; preds = %150
%163 = icmp ugt i64 %104, %122
%164 = select i1 %163, i64 %104, i64 %122
%165 = getelementptr inbounds i64, i64* %1, i64 %164
%166 = load i64, i64* %165
%167 = icmp eq i64 %166, 0
br i1 %167, label %168, label %169
168: ; preds = %175, %162
br label %182
169: ; preds = %162, %175
%170 = phi i64 [ %178, %175 ], [ %166, %162 ]
%171 = phi i64 [ %176, %175 ], [ %164, %162 ]
%172 = getelementptr inbounds i64, i64* %123, i64 %171
%173 = load i64, i64* %172
%174 = icmp eq i64 %170, %173
br i1 %174, label %175, label %180
175: ; preds = %169
%176 = add i64 %171, 1
%177 = getelementptr inbounds i64, i64* %1, i64 %176
%178 = load i64, i64* %177
%179 = icmp eq i64 %178, 0
br i1 %179, label %168, label %169
180: ; preds = %169
%181 = sub i64 %171, %102
br label %158
182: ; preds = %168, %185
%183 = phi i64 [ %186, %185 ], [ %104, %168 ]
%184 = icmp ugt i64 %183, %122
br i1 %184, label %185, label %192
185: ; preds = %182
%186 = add i64 %183, -1
%187 = getelementptr inbounds i64, i64* %1, i64 %186
%188 = load i64, i64* %187
%189 = getelementptr inbounds i64, i64* %123, i64 %186
%190 = load i64, i64* %189
%191 = icmp eq i64 %188, %190
br i1 %191, label %182, label %158
192: ; preds = %182
%193 = bitcast i64* %123 to i8*
br label %194
194: ; preds = %11, %132, %192
%195 = phi i8* [ %193, %192 ], [ null, %132 ], [ null, %11 ]
ret i8* %195
}