#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 scalar_t__ needle_len;
typedef size_t j;
typedef int /*<<< orphan*/ haystack;

/* Variables and functions */
size_t SIZE_MAX;
size_t critical_factorization(unsigned char const *, size_t, size_t *);
scalar_t__ isupper(unsigned char const);
int /*<<< orphan*/ memchr(int /*<<< orphan*/, char, size_t);
scalar_t__ strncasecmp(char const *, char const *, size_t);
unsigned char const tolower(unsigned char const);
char *two_way_short_needle(const unsigned char *haystack, size_t haystack_len,
                           const unsigned char *needle, size_t needle_len) {
  size_t i;
  size_t j;
  size_t period;
  size_t suffix;
  suffix = critical_factorization(needle, needle_len, &period);
  if (strncasecmp((const char *)(needle), (const char *)(needle + period),
                  suffix) == 0) {
    size_t memory = 0;
    j = 0;
    while ((!memchr((haystack) + (haystack_len), '\0',
                    (j) + (needle_len) - (haystack_len)) &&
            ((haystack_len) = (j) + (needle_len)))) {
      i = ((suffix < memory) ? (memory) : (suffix));
      while (i < needle_len &&
             ((isupper(needle[i]) ? tolower(needle[i]) : (needle[i])) ==
              (isupper(haystack[i + j]) ? tolower(haystack[i + j])
                                        : (haystack[i + j]))))
        ++i;
      if (needle_len <= i) {
        i = suffix - 1;
        while (memory < i + 1 &&
               ((isupper(needle[i]) ? tolower(needle[i]) : (needle[i])) ==
                (isupper(haystack[i + j]) ? tolower(haystack[i + j])
                                          : (haystack[i + j]))))
          --i;
        if (i + 1 < memory + 1)
          return (char *)(haystack + j);
        j += period;
        memory = needle_len - period;
      } else {
        j += i - suffix + 1;
        memory = 0;
      }
    }
  } else {
    period =
        ((suffix < needle_len - suffix) ? (needle_len - suffix) : (suffix)) + 1;
    j = 0;
    while ((!memchr((haystack) + (haystack_len), '\0',
                    (j) + (needle_len) - (haystack_len)) &&
            ((haystack_len) = (j) + (needle_len)))) {
      i = suffix;
      while (i < needle_len &&
             ((isupper(needle[i]) ? tolower(needle[i]) : (needle[i])) ==
              (isupper(haystack[i + j]) ? tolower(haystack[i + j])
                                        : (haystack[i + j]))))
        ++i;
      if (needle_len <= i) {
        i = suffix - 1;
        while (i != SIZE_MAX &&
               ((isupper(needle[i]) ? tolower(needle[i]) : (needle[i])) ==
                (isupper(haystack[i + j]) ? tolower(haystack[i + j])
                                          : (haystack[i + j]))))
          --i;
        if (i == SIZE_MAX)
          return (char *)(haystack + j);
        j += period;
      } else
        j += i - suffix + 1;
    }
  }
  return NULL;
}


x86 assembly (clang, -O0):
<two_way_short_needle>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
lea    -0x40(%rbp),%rdx
call   1070 <critical_factorization@plt>
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x20(%rbp),%rsi
add    -0x40(%rbp),%rsi
mov    -0x48(%rbp),%rdx
call   1050 <strncasecmp@plt>
cmp    $0x0,%rax
jne    147b <two_way_short_needle+0x32b>
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %eax,%edi
mov    -0x38(%rbp),%rdx
add    -0x28(%rbp),%rdx
sub    -0x18(%rbp),%rdx
xor    %esi,%esi
call   1030 <memchr@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x51(%rbp)
jne    11f2 <two_way_short_needle+0xa2>
mov    -0x38(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
setne  %al
mov    %al,-0x51(%rbp)
mov    -0x51(%rbp),%al
test   $0x1,%al
jne    1202 <two_way_short_needle+0xb2>
jmp    1476 <two_way_short_needle+0x326>
mov    -0x48(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    121d <two_way_short_needle+0xcd>
mov    -0x50(%rbp),%rax
mov    %rax,-0x60(%rbp)
jmp    1225 <two_way_short_needle+0xd5>
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x61(%rbp)
jae    12ec <two_way_short_needle+0x19c>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isupper@plt>
cmp    $0x0,%rax
je     1277 <two_way_short_needle+0x127>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movzbl %al,%eax
mov    %eax,-0x68(%rbp)
jmp    1286 <two_way_short_needle+0x136>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isupper@plt>
cmp    $0x0,%rax
je     12cb <two_way_short_needle+0x17b>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movzbl %al,%eax
mov    %eax,-0x70(%rbp)
jmp    12de <two_way_short_needle+0x18e>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x70(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x70(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    12fc <two_way_short_needle+0x1ac>
jmp    130d <two_way_short_needle+0x1bd>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    122d <two_way_short_needle+0xdd>
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
ja     1455 <two_way_short_needle+0x305>
mov    -0x48(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x50(%rbp),%rcx
mov    -0x30(%rbp),%rdx
add    $0x1,%rdx
xor    %eax,%eax
cmp    %rdx,%rcx
mov    %al,-0x71(%rbp)
jae    13ed <two_way_short_needle+0x29d>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isupper@plt>
cmp    $0x0,%rax
je     1378 <two_way_short_needle+0x228>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movzbl %al,%eax
mov    %eax,-0x78(%rbp)
jmp    1387 <two_way_short_needle+0x237>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isupper@plt>
cmp    $0x0,%rax
je     13cc <two_way_short_needle+0x27c>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movzbl %al,%eax
mov    %eax,-0x80(%rbp)
jmp    13df <two_way_short_needle+0x28f>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x80(%rbp)
mov    -0x7c(%rbp),%eax
mov    -0x80(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
test   $0x1,%al
jne    13fd <two_way_short_needle+0x2ad>
jmp    140e <two_way_short_needle+0x2be>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    1327 <two_way_short_needle+0x1d7>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    -0x50(%rbp),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jae    1438 <two_way_short_needle+0x2e8>
mov    -0x10(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17a8 <two_way_short_needle+0x658>
mov    -0x40(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x40(%rbp),%rax
mov    %rax,-0x50(%rbp)
jmp    1471 <two_way_short_needle+0x321>
mov    -0x30(%rbp),%rax
sub    -0x48(%rbp),%rax
add    $0x1,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x50(%rbp)
jmp    11af <two_way_short_needle+0x5f>
jmp    17a0 <two_way_short_needle+0x650>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    -0x48(%rbp),%rcx
cmp    %rcx,%rax
jae    14a4 <two_way_short_needle+0x354>
mov    -0x28(%rbp),%rax
sub    -0x48(%rbp),%rax
mov    %rax,-0x88(%rbp)
jmp    14af <two_way_short_needle+0x35f>
mov    -0x48(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %eax,%edi
mov    -0x38(%rbp),%rdx
add    -0x28(%rbp),%rdx
sub    -0x18(%rbp),%rdx
xor    %esi,%esi
call   1030 <memchr@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x89(%rbp)
jne    150f <two_way_short_needle+0x3bf>
mov    -0x38(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x18(%rbp)
cmp    $0x0,%rax
setne  %al
mov    %al,-0x89(%rbp)
mov    -0x89(%rbp),%al
test   $0x1,%al
jne    1522 <two_way_short_needle+0x3d2>
jmp    179b <two_way_short_needle+0x64b>
mov    -0x48(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x28(%rbp),%rcx
mov    %al,-0x8a(%rbp)
jae    1607 <two_way_short_needle+0x4b7>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isupper@plt>
cmp    $0x0,%rax
je     157a <two_way_short_needle+0x42a>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movzbl %al,%eax
mov    %eax,-0x90(%rbp)
jmp    158c <two_way_short_needle+0x43c>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    %eax,-0x94(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isupper@plt>
cmp    $0x0,%rax
je     15da <two_way_short_needle+0x48a>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movzbl %al,%eax
mov    %eax,-0x98(%rbp)
jmp    15f0 <two_way_short_needle+0x4a0>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x98(%rbp)
mov    -0x94(%rbp),%eax
mov    -0x98(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x8a(%rbp)
mov    -0x8a(%rbp),%al
test   $0x1,%al
jne    161a <two_way_short_needle+0x4ca>
jmp    162b <two_way_short_needle+0x4db>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    152a <two_way_short_needle+0x3da>
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
ja     1782 <two_way_short_needle+0x632>
mov    -0x48(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rcx
xor    %eax,%eax
mov    0x2986(%rip),%rdx
cmp    (%rdx),%rcx
mov    %al,-0x99(%rbp)
je     1728 <two_way_short_needle+0x5d8>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isupper@plt>
cmp    $0x0,%rax
je     169b <two_way_short_needle+0x54b>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movzbl %al,%eax
mov    %eax,-0xa0(%rbp)
jmp    16ad <two_way_short_needle+0x55d>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1060 <isupper@plt>
cmp    $0x0,%rax
je     16fb <two_way_short_needle+0x5ab>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
call   1040 <tolower@plt>
movzbl %al,%eax
mov    %eax,-0xa8(%rbp)
jmp    1711 <two_way_short_needle+0x5c1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa4(%rbp),%eax
mov    -0xa8(%rbp),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x99(%rbp)
mov    -0x99(%rbp),%al
test   $0x1,%al
jne    173b <two_way_short_needle+0x5eb>
jmp    174c <two_way_short_needle+0x5fc>
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
jmp    1645 <two_way_short_needle+0x4f5>
mov    -0x30(%rbp),%rax
mov    0x2881(%rip),%rcx
cmp    (%rcx),%rax
jne    1771 <two_way_short_needle+0x621>
mov    -0x10(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    17a8 <two_way_short_needle+0x658>
mov    -0x40(%rbp),%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    1796 <two_way_short_needle+0x646>
mov    -0x30(%rbp),%rax
sub    -0x48(%rbp),%rax
add    $0x1,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    14c6 <two_way_short_needle+0x376>
jmp    17a0 <two_way_short_needle+0x650>
movq   $0x0,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<two_way_short_needle>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rcx,%rbp
mov    %rdx,%r14
mov    %rsi,%r13
mov    %rdi,%r15
lea    0x30(%rsp),%rdx
mov    %r14,%rdi
mov    %rcx,%rsi
call   1070 <critical_factorization@plt>
mov    %rax,%r12
mov    0x30(%rsp),%rsi
add    %r14,%rsi
mov    %r14,%rdi
mov    %rax,%rdx
call   1050 <strncasecmp@plt>
test   %rax,%rax
mov    %rbp,%rax
mov    %rbp,0x20(%rsp)
mov    %r12,0x48(%rsp)
je     1373 <two_way_short_needle+0x223>
mov    %rbp,%rax
sub    %r12,%rax
cmp    %rax,%r12
cmovae %r12,%rax
add    $0x1,%rax
mov    %rax,0x30(%rsp)
lea    (%r15,%r13,1),%edi
mov    %rbp,%rdx
sub    %r13,%rdx
xor    %esi,%esi
call   1030 <memchr@plt>
test   %eax,%eax
jne    1542 <two_way_short_needle+0x3f2>
xor    %eax,%eax
mov    %rax,0x8(%rsp)
test   %rbp,%rbp
je     1555 <two_way_short_needle+0x405>
mov    %r12,%rcx
mov    0x20(%rsp),%rax
sub    %rax,%rcx
mov    %rcx,0x10(%rsp)
lea    (%r15,%r12,1),%rcx
mov    %rcx,0x50(%rsp)
lea    (%r14,%r12,1),%rbp
lea    -0x1(%r12),%rcx
mov    %rcx,0x38(%rsp)
xor    %ecx,%ecx
mov    %rcx,0x8(%rsp)
mov    %rax,%rcx
xor    %eax,%eax
mov    %rax,0x18(%rsp)
mov    %rcx,0x40(%rsp)
cmp    0x20(%rsp),%r12
jae    129f <two_way_short_needle+0x14f>
mov    0x50(%rsp),%rax
mov    0x18(%rsp),%rcx
lea    (%rax,%rcx,1),%r13
mov    $0x1,%r12d
nopl   (%rax)
movzbl -0x1(%rbp,%r12,1),%edi
call   1060 <isupper@plt>
movzbl -0x1(%rbp,%r12,1),%ebx
test   %rax,%rax
je     1260 <two_way_short_needle+0x110>
movzbl %bl,%edi
call   1040 <tolower@plt>
mov    %eax,%ebx
movzbl -0x1(%r13,%r12,1),%edi
call   1060 <isupper@plt>
mov    %rax,%rcx
movzbl -0x1(%r13,%r12,1),%eax
test   %rcx,%rcx
je     1281 <two_way_short_needle+0x131>
movzbl %al,%edi
call   1040 <tolower@plt>
cmp    %al,%bl
jne    1329 <two_way_short_needle+0x1d9>
mov    0x10(%rsp),%rax
add    %r12,%rax
add    $0x1,%rax
add    $0x1,%r12
cmp    $0x1,%rax
jne    1240 <two_way_short_needle+0xf0>
mov    0x18(%rsp),%rax
lea    (%r15,%rax,1),%r12
mov    0x38(%rsp),%r13
jmp    12b8 <two_way_short_needle+0x168>
nop
add    $0xffffffffffffffff,%r13
cmp    %al,%bl
jne    1310 <two_way_short_needle+0x1c0>
mov    0x2d19(%rip),%rax
cmp    (%rax),%r13
je     153b <two_way_short_needle+0x3eb>
movzbl (%r14,%r13,1),%edi
call   1060 <isupper@plt>
movzbl (%r14,%r13,1),%ebx
test   %rax,%rax
je     12e6 <two_way_short_needle+0x196>
movzbl %bl,%edi
call   1040 <tolower@plt>
mov    %eax,%ebx
movzbl (%r12,%r13,1),%edi
call   1060 <isupper@plt>
mov    %rax,%rcx
movzbl (%r12,%r13,1),%eax
test   %rcx,%rcx
je     12b0 <two_way_short_needle+0x160>
movzbl %al,%edi
call   1040 <tolower@plt>
jmp    12b0 <two_way_short_needle+0x160>
nopw   0x0(%rax,%rax,1)
mov    0x2cc1(%rip),%rax
sub    (%rax),%r13
cmp    $0xffffffffffffffff,%r13
je     153b <two_way_short_needle+0x3eb>
mov    0x30(%rsp),%r12
mov    0x18(%rsp),%rdx
add    %r12,%rdx
mov    0x40(%rsp),%rsi
lea    (%r15,%rsi,1),%edi
mov    0x20(%rsp),%rax
mov    %rdx,0x18(%rsp)
lea    (%rdx,%rax,1),%rbx
mov    %rbx,%rdx
sub    %rsi,%rdx
xor    %esi,%esi
call   1030 <memchr@plt>
test   %eax,%eax
jne    1555 <two_way_short_needle+0x405>
mov    %rbx,%rcx
test   %rbx,%rbx
mov    0x48(%rsp),%r12
jne    121d <two_way_short_needle+0xcd>
jmp    1555 <two_way_short_needle+0x405>
lea    (%r15,%r13,1),%edi
mov    %rbp,%rdx
sub    %r13,%rdx
xor    %eax,%eax
mov    %rax,0x8(%rsp)
xor    %esi,%esi
call   1030 <memchr@plt>
test   %eax,%eax
jne    1555 <two_way_short_needle+0x405>
test   %rbp,%rbp
je     1555 <two_way_short_needle+0x405>
mov    $0x1,%eax
sub    %r12,%rax
mov    %rax,0x38(%rsp)
lea    -0x1(%r15),%rax
mov    %rax,0x40(%rsp)
xor    %eax,%eax
mov    %rax,0x8(%rsp)
mov    0x20(%rsp),%rcx
xor    %r13d,%r13d
xor    %eax,%eax
mov    %rax,0x10(%rsp)
mov    %r15,0x28(%rsp)
nopl   (%rax)
mov    %rcx,0x18(%rsp)
cmp    %r13,%r12
cmovb  %r13,%r12
mov    0x20(%rsp),%rbp
cmp    %rbp,%r12
jae    144e <two_way_short_needle+0x2fe>
mov    0x28(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%r15
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r14,%r12,1),%edi
call   1060 <isupper@plt>
movzbl (%r14,%r12,1),%ebx
test   %rax,%rax
je     141e <two_way_short_needle+0x2ce>
movzbl %bl,%edi
call   1040 <tolower@plt>
mov    %eax,%ebx
movzbl (%r15,%r12,1),%edi
call   1060 <isupper@plt>
mov    %rax,%rcx
movzbl (%r15,%r12,1),%eax
test   %rcx,%rcx
je     143d <two_way_short_needle+0x2ed>
movzbl %al,%edi
call   1040 <tolower@plt>
cmp    %al,%bl
jne    14f0 <two_way_short_needle+0x3a0>
add    $0x1,%r12
cmp    %r12,%rbp
jne    1400 <two_way_short_needle+0x2b0>
mov    0x40(%rsp),%rax
mov    0x10(%rsp),%rcx
lea    (%rax,%rcx,1),%r15
mov    0x48(%rsp),%rcx
jmp    1478 <two_way_short_needle+0x328>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x1(%rbp),%rcx
cmp    %al,%bl
jne    14d0 <two_way_short_needle+0x380>
mov    %rcx,%rbp
cmp    %rcx,%r13
jae    14d0 <two_way_short_needle+0x380>
movzbl -0x1(%r14,%rbp,1),%edi
call   1060 <isupper@plt>
movzbl -0x1(%r14,%rbp,1),%ebx
test   %rax,%rax
je     14a0 <two_way_short_needle+0x350>
movzbl %bl,%edi
call   1040 <tolower@plt>
mov    %eax,%ebx
movzbl (%r15,%rbp,1),%edi
call   1060 <isupper@plt>
mov    %rax,%rcx
movzbl (%r15,%rbp,1),%eax
test   %rcx,%rcx
je     1470 <two_way_short_needle+0x320>
movzbl %al,%edi
call   1040 <tolower@plt>
jmp    1470 <two_way_short_needle+0x320>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    %r13,%rbp
jb     1546 <two_way_short_needle+0x3f6>
mov    0x30(%rsp),%r12
mov    0x20(%rsp),%rbp
mov    %rbp,%r13
sub    %r12,%r13
jmp    14f8 <two_way_short_needle+0x3a8>
nopl   0x0(%rax,%rax,1)
add    0x38(%rsp),%r12
xor    %r13d,%r13d
mov    0x28(%rsp),%r15
mov    0x10(%rsp),%rcx
add    %r12,%rcx
mov    0x18(%rsp),%rsi
lea    (%r15,%rsi,1),%edi
mov    %rcx,0x10(%rsp)
lea    (%rcx,%rbp,1),%rbx
mov    %rbx,%rdx
sub    %rsi,%rdx
xor    %esi,%esi
call   1030 <memchr@plt>
test   %eax,%eax
jne    1555 <two_way_short_needle+0x405>
mov    %rbx,%rcx
test   %rbx,%rbx
mov    0x48(%rsp),%r12
jne    13d0 <two_way_short_needle+0x280>
jmp    1555 <two_way_short_needle+0x405>
mov    %r12,0x8(%rsp)
jmp    1555 <two_way_short_needle+0x405>
xor    %eax,%eax
jmp    1550 <two_way_short_needle+0x400>
mov    0x28(%rsp),%rax
add    0x10(%rsp),%rax
mov    %rax,0x8(%rsp)
mov    0x8(%rsp),%rax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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