#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 */
scalar_t__ strncmp(char *, char *, int);
void makeBMTable2(char *pattern, int patLen, int *bmTable) {
  int sIdx1;
  int sIdx0;
  int nextIdx[100000];
  int nextIdxSize;
  int sLen;
  int curIdx1;
  int i, j;
  for (i = 0; i < patLen; i++)
    bmTable[i] = -1;
  sIdx1 = patLen;
  if (sIdx1 == 0)
    return;
  for (nextIdxSize = 0, sIdx0 = sIdx1 - 1; sIdx0 > 0; --sIdx0) {
    if (pattern[sIdx0 - 1] == pattern[sIdx1 - 1]) {
      nextIdx[nextIdxSize++] = sIdx0 - 1;
    } else if (bmTable[sIdx1 - 1] == -1) {
      bmTable[sIdx1 - 1] = patLen - sIdx0;
    }
  }
  if (bmTable[sIdx1 - 1] == -1)
    bmTable[sIdx1 - 1] = patLen;
  sLen = 2;
  for (--sIdx1; sIdx1 > 0; --sIdx1) {
    for (i = 0; i < nextIdxSize;) {
      sIdx0 = nextIdx[i];
      if (sIdx0 == 0 || pattern[sIdx0 - 1] != pattern[sIdx1 - 1]) {
        for (j = i + 1; j < nextIdxSize; j++)
          nextIdx[j - 1] = nextIdx[j];
        --nextIdxSize;
        if (bmTable[sIdx1 - 1] == -1)
          bmTable[sIdx1 - 1] = patLen - (sIdx0 + sLen - 1);
      } else {
        --nextIdx[i];
        ++i;
      }
    }
    if (nextIdxSize == 0)
      break;
    ++sLen;
  }
  sIdx1 = patLen;
  curIdx1 = -1;
  while (sIdx1 > 1) {
    --sIdx1;
    if (bmTable[sIdx1 - 1] != -1)
      continue;
    sLen = patLen - sIdx1;
    i = 0;
    while (sLen > 0) {
      if (strncmp(pattern, pattern + sIdx1 + i, sLen) == 0)
        break;
      ++i;
      --sLen;
    }
    if (curIdx1 == patLen - sLen)
      break;
    bmTable[sIdx1 - 1] = curIdx1 = patLen - sLen;
  }
  while (sIdx1 > 0) {
    if (bmTable[sIdx1 - 1] == -1)
      bmTable[sIdx1 - 1] = curIdx1;
    --sIdx1;
  }
}


x86 assembly (clang, -O0):
<makeBMTable2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x61ac0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x61ab0(%rbp)
mov    -0x61ab0(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1165 <makeBMTable2+0x55>
mov    -0x18(%rbp),%rax
movslq -0x61ab0(%rbp),%rcx
movl   $0xffffffff,(%rax,%rcx,4)
mov    -0x61ab0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x61ab0(%rbp)
jmp    1130 <makeBMTable2+0x20>
mov    -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jne    117a <makeBMTable2+0x6a>
jmp    1511 <makeBMTable2+0x401>
movl   $0x0,-0x61aa4(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
jle    122b <makeBMTable2+0x11b>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    11e6 <makeBMTable2+0xd6>
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x61aa4(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x61aa4(%rbp)
cltq
mov    %ecx,-0x61aa0(%rbp,%rax,4)
jmp    1218 <makeBMTable2+0x108>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    1213 <makeBMTable2+0x103>
mov    -0xc(%rbp),%edx
sub    -0x20(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1218 <makeBMTable2+0x108>
jmp    121d <makeBMTable2+0x10d>
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
jmp    118d <makeBMTable2+0x7d>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    1255 <makeBMTable2+0x145>
mov    -0xc(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x2,-0x61aa8(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jle    13cf <makeBMTable2+0x2bf>
movl   $0x0,-0x61ab0(%rbp)
mov    -0x61ab0(%rbp),%eax
cmp    -0x61aa4(%rbp),%eax
jge    13a0 <makeBMTable2+0x290>
movslq -0x61ab0(%rbp),%rax
mov    -0x61aa0(%rbp,%rax,4),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x20(%rbp)
je     12d3 <makeBMTable2+0x1c3>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
je     1374 <makeBMTable2+0x264>
mov    -0x61ab0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x61ab4(%rbp)
mov    -0x61ab4(%rbp),%eax
cmp    -0x61aa4(%rbp),%eax
jge    1328 <makeBMTable2+0x218>
movslq -0x61ab4(%rbp),%rax
mov    -0x61aa0(%rbp,%rax,4),%ecx
mov    -0x61ab4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %ecx,-0x61aa0(%rbp,%rax,4)
mov    -0x61ab4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x61ab4(%rbp)
jmp    12e2 <makeBMTable2+0x1d2>
mov    -0x61aa4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x61aa4(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    136f <makeBMTable2+0x25f>
mov    -0xc(%rbp),%edx
mov    -0x20(%rbp),%eax
add    -0x61aa8(%rbp),%eax
sub    $0x1,%eax
sub    %eax,%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    139b <makeBMTable2+0x28b>
movslq -0x61ab0(%rbp),%rax
mov    -0x61aa0(%rbp,%rax,4),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x61aa0(%rbp,%rax,4)
mov    -0x61ab0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x61ab0(%rbp)
jmp    127c <makeBMTable2+0x16c>
cmpl   $0x0,-0x61aa4(%rbp)
jne    13b2 <makeBMTable2+0x2a2>
jmp    13cf <makeBMTable2+0x2bf>
mov    -0x61aa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x61aa8(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1268 <makeBMTable2+0x158>
mov    -0xc(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0xffffffff,-0x61aac(%rbp)
ff ff ff
cmpl   $0x1,-0x1c(%rbp)
jle    14c7 <makeBMTable2+0x3b7>
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
je     140e <makeBMTable2+0x2fe>
jmp    13df <makeBMTable2+0x2cf>
mov    -0xc(%rbp),%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x61aa8(%rbp)
movl   $0x0,-0x61ab0(%rbp)
cmpl   $0x0,-0x61aa8(%rbp)
jle    1487 <makeBMTable2+0x377>
mov    -0x8(%rbp),%rdi
mov    -0x8(%rbp),%rsi
movslq -0x1c(%rbp),%rax
add    %rax,%rsi
movslq -0x61ab0(%rbp),%rax
add    %rax,%rsi
mov    -0x61aa8(%rbp),%edx
call   1030 <strncmp@plt>
cmp    $0x0,%rax
jne    1464 <makeBMTable2+0x354>
jmp    1487 <makeBMTable2+0x377>
mov    -0x61ab0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x61ab0(%rbp)
mov    -0x61aa8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x61aa8(%rbp)
jmp    1424 <makeBMTable2+0x314>
mov    -0x61aac(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x61aa8(%rbp),%ecx
cmp    %ecx,%eax
jne    14a3 <makeBMTable2+0x393>
jmp    14c7 <makeBMTable2+0x3b7>
mov    -0xc(%rbp),%edx
sub    -0x61aa8(%rbp),%edx
mov    %edx,-0x61aac(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13df <makeBMTable2+0x2cf>
jmp    14cc <makeBMTable2+0x3bc>
cmpl   $0x0,-0x1c(%rbp)
jle    1511 <makeBMTable2+0x401>
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0xffffffff,(%rax,%rcx,4)
jne    1503 <makeBMTable2+0x3f3>
mov    -0x61aac(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    14cc <makeBMTable2+0x3bc>
add    $0x61ac0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<makeBMTable2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x61ac8,%rsp
mov    %rdx,%r8
mov    %esi,%r12d
mov    %rdi,%r15
mov    %esi,%eax
test   %esi,%esi
mov    %rdx,0x10(%rsp)
mov    %rax,0x18(%rsp)
jle    11c6 <makeBMTable2+0xa6>
lea    0x0(,%rax,4),%rdx
mov    %r8,%rdi
mov    $0xff,%esi
call   1040 <memset@plt>
cmp    $0x1,%r12d
setne  %cl
je     15cb <makeBMTable2+0x4ab>
lea    -0x1(%r12),%eax
mov    %eax,%edx
lea    0x1(%rdx),%rsi
lea    -0x2(%r12),%edi
xor    %r11d,%r11d
mov    $0x1,%ebp
mov    0x10(%rsp),%r8
jmp    11ab <makeBMTable2+0x8b>
nopl   0x0(%rax,%rax,1)
movslq %r11d,%rbx
add    $0x1,%r11d
mov    %edi,0x40(%rsp,%rbx,4)
add    $0x1,%ebp
add    $0xffffffffffffffff,%rsi
add    $0xffffffff,%edi
cmp    $0x1,%rsi
jbe    11d9 <makeBMTable2+0xb9>
lea    -0x2(%rsi),%ebx
movzbl (%r15,%rbx,1),%ebx
cmp    (%r15,%rdx,1),%bl
je     1190 <makeBMTable2+0x70>
cmpl   $0xffffffff,(%r8,%rdx,4)
jne    119b <makeBMTable2+0x7b>
mov    %ebp,(%r8,%rdx,4)
jmp    119b <makeBMTable2+0x7b>
je     160e <makeBMTable2+0x4ee>
lea    -0x1(%r12),%eax
movslq %eax,%rdx
xor    %ecx,%ecx
xor    %r11d,%r11d
cmpl   $0xffffffff,(%r8,%rdx,4)
je     15e2 <makeBMTable2+0x4c2>
mov    $0xfffffffe,%r10d
test   %cl,%cl
mov    %r12,0x28(%rsp)
mov    %r15,0x38(%rsp)
je     14f6 <makeBMTable2+0x3d6>
lea    0x1(%r12),%eax
mov    %eax,0x4(%rsp)
mov    $0x2,%eax
mov    %rax,0x8(%rsp)
movabs $0x400000000,%rbx
mov    0x18(%rsp),%rax
mov    %rax,0x30(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
test   %r11d,%r11d
jle    14d0 <makeBMTable2+0x3b0>
mov    0x30(%rsp),%rax
lea    (%rax,%r10,1),%esi
xor    %r12d,%r12d
mov    %rsi,0x20(%rsp)
jmp    1268 <makeBMTable2+0x148>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%r9
mov    %r9d,0x40(%rsp,%rdx,4)
add    $0x1,%edx
mov    %edx,%r12d
cmp    %r11d,%r12d
jge    14d0 <makeBMTable2+0x3b0>
movslq %r12d,%rdx
movslq 0x40(%rsp,%rdx,4),%r9
test   %r9,%r9
je     1280 <makeBMTable2+0x160>
mov    -0x1(%r15,%r9,1),%cl
cmp    (%r15,%rsi,1),%cl
je     1250 <makeBMTable2+0x130>
lea    0x1(%r12),%esi
cmp    %r11d,%esi
jge    1490 <makeBMTable2+0x370>
mov    %r8,%rbp
movslq %esi,%r13
lea    -0x2(%r11),%esi
mov    %esi,%r8d
sub    %r12d,%r8d
cmp    $0x7,%r8d
jb     12e8 <makeBMTable2+0x1c8>
cmp    %r12d,%esi
jl     12e8 <makeBMTable2+0x1c8>
lea    (%rsp,%rdx,4),%rcx
add    $0x40,%rcx
mov    %r11d,%esi
sub    %r12d,%esi
add    $0xfffffffe,%esi
lea    (%rsi,%r13,1),%rdi
lea    0x44(%rsp),%rax
lea    (%rax,%rdi,4),%rdi
cmp    %rdi,%rcx
jae    13bc <makeBMTable2+0x29c>
add    %rsi,%rdx
lea    (%rax,%rdx,4),%rcx
lea    (%rsp,%r13,4),%rdx
add    $0x40,%rdx
cmp    %rcx,%rdx
jae    13bc <makeBMTable2+0x29c>
mov    %r12d,%r14d
mov    %rbp,%r8
mov    %r11d,%edi
sub    %r13d,%edi
mov    %r13d,%ebp
not    %ebp
add    %r11d,%ebp
and    $0x3,%edi
je     1334 <makeBMTable2+0x214>
neg    %edi
xor    %edx,%edx
mov    %r13,%rsi
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp,%rsi,4),%ecx
movslq %r14d,%rax
mov    %ecx,0x40(%rsp,%rax,4)
mov    %esi,%r14d
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
cmp    %edx,%edi
jne    1310 <makeBMTable2+0x1f0>
not    %edx
add    %r13d,%edx
mov    %edx,%r14d
jmp    1337 <makeBMTable2+0x217>
mov    %r13,%rsi
movabs $0x1fffffff8,%rdx
cmp    $0x3,%ebp
jb     1490 <makeBMTable2+0x370>
mov    %r11d,%ebp
mov    %rsi,%rdi
shl    $0x20,%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x40(%rsp,%rsi,4),%eax
movslq %r14d,%rcx
mov    %eax,0x40(%rsp,%rcx,4)
mov    0x44(%rsp,%rsi,4),%eax
mov    %rdi,%rcx
sar    $0x1e,%rcx
mov    %eax,0x40(%rsp,%rcx,1)
mov    0x48(%rsp,%rsi,4),%eax
lea    (%r10,%rdi,1),%rcx
add    $0x2,%rcx
sar    $0x1e,%rcx
mov    %eax,0x40(%rsp,%rcx,1)
mov    0x4c(%rsp,%rsi,4),%eax
lea    (%rdx,%rdi,1),%rcx
add    $0x8,%rcx
sar    $0x1e,%rcx
mov    %eax,0x40(%rsp,%rcx,1)
mov    %esi,%r14d
lea    0x4(%rsi),%rax
add    $0x3,%r14d
add    %rbx,%rdi
mov    %rax,%rsi
cmp    %eax,%ebp
jne    1360 <makeBMTable2+0x240>
jmp    1490 <makeBMTable2+0x370>
add    $0x1,%r8
mov    %r8,%r14
movabs $0x1fffffff8,%rax
and    %rax,%r14
lea    -0x8(%r14),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     14c4 <makeBMTable2+0x3a4>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
lea    0x44(%rsp),%rax
lea    (%rax,%r13,4),%r10
add    $0x2c,%r10
lea    0x8(%r12),%edi
mov    %r12d,%r15d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
lea    (%r15,%rbp,1),%ecx
movups -0x30(%r10,%rbp,4),%xmm0
movups -0x20(%r10,%rbp,4),%xmm1
movslq %ecx,%rcx
movups %xmm0,0x40(%rsp,%rcx,4)
movups %xmm1,0x50(%rsp,%rcx,4)
lea    (%rdi,%rbp,1),%ecx
movups -0x10(%r10,%rbp,4),%xmm0
movups (%r10,%rbp,4),%xmm1
movslq %ecx,%rcx
movups %xmm0,0x40(%rsp,%rcx,4)
movups %xmm1,0x50(%rsp,%rcx,4)
add    $0x10,%rbp
add    $0xfffffffffffffffe,%rsi
jne    1410 <makeBMTable2+0x2f0>
test   $0x1,%dl
je     1477 <makeBMTable2+0x357>
mov    %rbp,%rcx
add    %r13,%rcx
add    %r12d,%ebp
movups 0x40(%rsp,%rcx,4),%xmm0
movups 0x50(%rsp,%rcx,4),%xmm1
movslq %ebp,%rcx
movups %xmm0,0x40(%rsp,%rcx,4)
movups %xmm1,0x50(%rsp,%rcx,4)
cmp    %r14,%r8
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%r15
mov    $0xfffffffe,%r10d
jne    14b9 <makeBMTable2+0x399>
nopl   0x0(%rax)
add    $0xffffffff,%r11d
mov    0x20(%rsp),%rsi
cmpl   $0xffffffff,(%r8,%rsi,4)
jne    125f <makeBMTable2+0x13f>
add    0x8(%rsp),%r9d
mov    0x4(%rsp),%eax
sub    %r9d,%eax
mov    %eax,(%r8,%rsi,4)
jmp    125f <makeBMTable2+0x13f>
add    %r14,%r13
add    %r12d,%r14d
jmp    12ee <makeBMTable2+0x1ce>
xor    %ebp,%ebp
test   $0x1,%dl
jne    1457 <makeBMTable2+0x337>
jmp    1477 <makeBMTable2+0x357>
nopl   (%rax)
test   %r11d,%r11d
mov    0x28(%rsp),%r12
je     14f6 <makeBMTable2+0x3d6>
addq   $0xffffffffffffffff,0x30(%rsp)
mov    0x8(%rsp),%rcx
lea    0x1(%rcx),%eax
cmp    %r12d,%ecx
mov    %rax,0x8(%rsp)
jne    1230 <makeBMTable2+0x110>
lea    0x1(%r15),%rbp
lea    0x1(%r12),%esi
mov    $0xffffffff,%edi
mov    %r12d,%r14d
mov    0x18(%rsp),%r9
mov    %r14d,%ecx
lea    -0x1(%r14),%r13d
add    %rbp,%r13
mov    %esi,%edx
sub    %r14d,%edx
nopl   0x0(%rax,%rax,1)
cmp    $0x2,%ecx
jl     15ee <makeBMTable2+0x4ce>
mov    %edx,%eax
lea    -0x1(%rcx),%r14
mov    %ecx,%r15d
add    %r10d,%r15d
add    $0xffffffffffffffff,%r13
lea    0x1(%rax),%edx
cmpl   $0xffffffff,(%r8,%r15,4)
mov    %r14,%rcx
jne    1520 <makeBMTable2+0x400>
mov    %r9,%rbx
sub    %r14,%rbx
test   %ebx,%ebx
jle    15b7 <makeBMTable2+0x497>
mov    %esi,0x4(%rsp)
mov    %rbp,0x8(%rsp)
mov    %edi,0x20(%rsp)
mov    %eax,%r12d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r13,%rsi
add    %rbp,%rsi
mov    0x38(%rsp),%rdi
mov    %ebx,%edx
call   1030 <strncmp@plt>
test   %rax,%rax
je     1595 <makeBMTable2+0x475>
add    $0x1,%rbp
add    $0xffffffff,%ebx
cmp    %rbp,%r12
jne    1570 <makeBMTable2+0x450>
xor    %ebx,%ebx
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%r12
mov    0x18(%rsp),%r9
mov    $0xfffffffe,%r10d
mov    0x20(%rsp),%edi
mov    0x8(%rsp),%rbp
mov    0x4(%rsp),%esi
mov    %r12d,%eax
sub    %ebx,%eax
cmp    %eax,%edi
je     15eb <makeBMTable2+0x4cb>
mov    %eax,(%r8,%r15,4)
mov    %eax,%edi
jmp    150c <makeBMTable2+0x3ec>
xor    %ecx,%ecx
xor    %edx,%edx
xor    %r11d,%r11d
mov    0x10(%rsp),%r8
cmpl   $0xffffffff,(%r8,%rdx,4)
jne    11e4 <makeBMTable2+0xc4>
mov    %r12d,(%r8,%rdx,4)
jmp    11e4 <makeBMTable2+0xc4>
mov    %r14,%rcx
test   %ecx,%ecx
jle    160e <makeBMTable2+0x4ee>
mov    %ecx,%edx
mov    %rdx,%rax
test   $0x1,%cl
je     1609 <makeBMTable2+0x4e9>
lea    -0x1(%rdx),%rax
mov    %eax,%ecx
cmpl   $0xffffffff,(%r8,%rcx,4)
je     1620 <makeBMTable2+0x500>
cmp    $0x1,%edx
jne    1629 <makeBMTable2+0x509>
add    $0x61ac8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %edi,(%r8,%rcx,4)
cmp    $0x1,%edx
je     160e <makeBMTable2+0x4ee>
add    $0xfffffffffffffffe,%rax
jmp    1641 <makeBMTable2+0x521>
nop
lea    -0x2(%rax),%rcx
add    $0x1,%rax
cmp    $0x1,%rax
mov    %rcx,%rax
jbe    160e <makeBMTable2+0x4ee>
lea    0x1(%rax),%ecx
cmpl   $0xffffffff,(%r8,%rcx,4)
jne    164f <makeBMTable2+0x52f>
mov    %edi,(%r8,%rcx,4)
mov    %eax,%ecx
cmpl   $0xffffffff,(%r8,%rcx,4)
jne    1630 <makeBMTable2+0x510>
mov    %edi,(%r8,%rcx,4)
jmp    1630 <makeBMTable2+0x510>

LLVM IR (-O0):
define void @makeBMTable2(i8* %0, i32 %1, i32* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca [100000 x i32]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32* %2, i32** %6
store i32 0, i32* %13
br label %15
15: ; preds = %24, %3
%16 = load i32, i32* %13
%17 = load i32, i32* %5
%18 = icmp slt i32 %16, %17
br i1 %18, label %19, label %27
19: ; preds = %15
%20 = load i32*, i32** %6
%21 = load i32, i32* %13
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %20, i64 %22
store i32 -1, i32* %23
br label %24
24: ; preds = %19
%25 = load i32, i32* %13
%26 = add nsw i32 %25, 1
store i32 %26, i32* %13
br label %15
27: ; preds = %15
%28 = load i32, i32* %5
store i32 %28, i32* %7
%29 = load i32, i32* %7
%30 = icmp eq i32 %29, 0
br i1 %30, label %31, label %32
31: ; preds = %27
br label %272
32: ; preds = %27
store i32 0, i32* %10
%33 = load i32, i32* %7
%34 = sub nsw i32 %33, 1
store i32 %34, i32* %8
br label %35
35: ; preds = %80, %32
%36 = load i32, i32* %8
%37 = icmp sgt i32 %36, 0
br i1 %37, label %38, label %83
38: ; preds = %35
%39 = load i8*, i8** %4
%40 = load i32, i32* %8
%41 = sub nsw i32 %40, 1
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %39, i64 %42
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = load i8*, i8** %4
%47 = load i32, i32* %7
%48 = sub nsw i32 %47, 1
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %46, i64 %49
%51 = load i8, i8* %50
%52 = sext i8 %51 to i32
%53 = icmp eq i32 %45, %52
br i1 %53, label %54, label %61
54: ; preds = %38
%55 = load i32, i32* %8
%56 = sub nsw i32 %55, 1
%57 = load i32, i32* %10
%58 = add nsw i32 %57, 1
store i32 %58, i32* %10
%59 = sext i32 %57 to i64
%60 = getelementptr inbounds [100000 x i32], [100000 x i32]* %9, i64 0, i64 %59
store i32 %56, i32* %60
br label %79
61: ; preds = %38
%62 = load i32*, i32** %6
%63 = load i32, i32* %7
%64 = sub nsw i32 %63, 1
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i32, i32* %62, i64 %65
%67 = load i32, i32* %66
%68 = icmp eq i32 %67, -1
br i1 %68, label %69, label %78
69: ; preds = %61
%70 = load i32, i32* %5
%71 = load i32, i32* %8
%72 = sub nsw i32 %70, %71
%73 = load i32*, i32** %6
%74 = load i32, i32* %7
%75 = sub nsw i32 %74, 1
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i32, i32* %73, i64 %76
store i32 %72, i32* %77
br label %78
78: ; preds = %69, %61
br label %79
79: ; preds = %78, %54
br label %80
80: ; preds = %79
%81 = load i32, i32* %8
%82 = add nsw i32 %81, -1
store i32 %82, i32* %8
br label %35
83: ; preds = %35
%84 = load i32*, i32** %6
%85 = load i32, i32* %7
%86 = sub nsw i32 %85, 1
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i32, i32* %84, i64 %87
%89 = load i32, i32* %88
%90 = icmp eq i32 %89, -1
br i1 %90, label %91, label %98
91: ; preds = %83
%92 = load i32, i32* %5
%93 = load i32*, i32** %6
%94 = load i32, i32* %7
%95 = sub nsw i32 %94, 1
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32, i32* %93, i64 %96
store i32 %92, i32* %97
br label %98
98: ; preds = %91, %83
store i32 2, i32* %11
%99 = load i32, i32* %7
%100 = add nsw i32 %99, -1
store i32 %100, i32* %7
br label %101
101: ; preds = %190, %98
%102 = load i32, i32* %7
%103 = icmp sgt i32 %102, 0
br i1 %103, label %104, label %193
104: ; preds = %101
store i32 0, i32* %13
br label %105
105: ; preds = %182, %104
%106 = load i32, i32* %13
%107 = load i32, i32* %10
%108 = icmp slt i32 %106, %107
br i1 %108, label %109, label %183
109: ; preds = %105
%110 = load i32, i32* %13
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [100000 x i32], [100000 x i32]* %9, i64 0, i64 %111
%113 = load i32, i32* %112
store i32 %113, i32* %8
%114 = load i32, i32* %8
%115 = icmp eq i32 %114, 0
br i1 %115, label %132, label %116
116: ; preds = %109
%117 = load i8*, i8** %4
%118 = load i32, i32* %8
%119 = sub nsw i32 %118, 1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i8, i8* %117, i64 %120
%122 = load i8, i8* %121
%123 = sext i8 %122 to i32
%124 = load i8*, i8** %4
%125 = load i32, i32* %7
%126 = sub nsw i32 %125, 1
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i8, i8* %124, i64 %127
%129 = load i8, i8* %128
%130 = sext i8 %129 to i32
%131 = icmp ne i32 %123, %130
br i1 %131, label %132, label %174
132: ; preds = %116, %109
%133 = load i32, i32* %13
%134 = add nsw i32 %133, 1
store i32 %134, i32* %14
br label %135
135: ; preds = %148, %132
%136 = load i32, i32* %14
%137 = load i32, i32* %10
%138 = icmp slt i32 %136, %137
br i1 %138, label %139, label %151
139: ; preds = %135
%140 = load i32, i32* %14
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds [100000 x i32], [100000 x i32]* %9, i64 0, i64 %141
%143 = load i32, i32* %142
%144 = load i32, i32* %14
%145 = sub nsw i32 %144, 1
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds [100000 x i32], [100000 x i32]* %9, i64 0, i64 %146
store i32 %143, i32* %147
br label %148
148: ; preds = %139
%149 = load i32, i32* %14
%150 = add nsw i32 %149, 1
store i32 %150, i32* %14
br label %135
151: ; preds = %135
%152 = load i32, i32* %10
%153 = add nsw i32 %152, -1
store i32 %153, i32* %10
%154 = load i32*, i32** %6
%155 = load i32, i32* %7
%156 = sub nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %154, i64 %157
%159 = load i32, i32* %158
%160 = icmp eq i32 %159, -1
br i1 %160, label %161, label %173
161: ; preds = %151
%162 = load i32, i32* %5
%163 = load i32, i32* %8
%164 = load i32, i32* %11
%165 = add nsw i32 %163, %164
%166 = sub nsw i32 %165, 1
%167 = sub nsw i32 %162, %166
%168 = load i32*, i32** %6
%169 = load i32, i32* %7
%170 = sub nsw i32 %169, 1
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i32, i32* %168, i64 %171
store i32 %167, i32* %172
br label %173
173: ; preds = %161, %151
br label %182
174: ; preds = %116
%175 = load i32, i32* %13
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds [100000 x i32], [100000 x i32]* %9, i64 0, i64 %176
%178 = load i32, i32* %177
%179 = add nsw i32 %178, -1
store i32 %179, i32* %177
%180 = load i32, i32* %13
%181 = add nsw i32 %180, 1
store i32 %181, i32* %13
br label %182
182: ; preds = %174, %173
br label %105
183: ; preds = %105
%184 = load i32, i32* %10
%185 = icmp eq i32 %184, 0
br i1 %185, label %186, label %187
186: ; preds = %183
br label %193
187: ; preds = %183
%188 = load i32, i32* %11
%189 = add nsw i32 %188, 1
store i32 %189, i32* %11
br label %190
190: ; preds = %187
%191 = load i32, i32* %7
%192 = add nsw i32 %191, -1
store i32 %192, i32* %7
br label %101
193: ; preds = %186, %101
%194 = load i32, i32* %5
store i32 %194, i32* %7
store i32 -1, i32* %12
br label %195
195: ; preds = %241, %208, %193
%196 = load i32, i32* %7
%197 = icmp sgt i32 %196, 1
br i1 %197, label %198, label %250
198: ; preds = %195
%199 = load i32, i32* %7
%200 = add nsw i32 %199, -1
store i32 %200, i32* %7
%201 = load i32*, i32** %6
%202 = load i32, i32* %7
%203 = sub nsw i32 %202, 1
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i32, i32* %201, i64 %204
%206 = load i32, i32* %205
%207 = icmp ne i32 %206, -1
br i1 %207, label %208, label %209
208: ; preds = %198
br label %195
209: ; preds = %198
%210 = load i32, i32* %5
%211 = load i32, i32* %7
%212 = sub nsw i32 %210, %211
store i32 %212, i32* %11
store i32 0, i32* %13
br label %213
213: ; preds = %229, %209
%214 = load i32, i32* %11
%215 = icmp sgt i32 %214, 0
br i1 %215, label %216, label %234
216: ; preds = %213
%217 = load i8*, i8** %4
%218 = load i8*, i8** %4
%219 = load i32, i32* %7
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds i8, i8* %218, i64 %220
%222 = load i32, i32* %13
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8, i8* %221, i64 %223
%225 = load i32, i32* %11
%226 = call i64 @strncmp(i8* %217, i8* %224, i32 %225)
%227 = icmp eq i64 %226, 0
br i1 %227, label %228, label %229
228: ; preds = %216
br label %234
229: ; preds = %216
%230 = load i32, i32* %13
%231 = add nsw i32 %230, 1
store i32 %231, i32* %13
%232 = load i32, i32* %11
%233 = add nsw i32 %232, -1
store i32 %233, i32* %11
br label %213
234: ; preds = %228, %213
%235 = load i32, i32* %12
%236 = load i32, i32* %5
%237 = load i32, i32* %11
%238 = sub nsw i32 %236, %237
%239 = icmp eq i32 %235, %238
br i1 %239, label %240, label %241
240: ; preds = %234
br label %250
241: ; preds = %234
%242 = load i32, i32* %5
%243 = load i32, i32* %11
%244 = sub nsw i32 %242, %243
store i32 %244, i32* %12
%245 = load i32*, i32** %6
%246 = load i32, i32* %7
%247 = sub nsw i32 %246, 1
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds i32, i32* %245, i64 %248
store i32 %244, i32* %249
br label %195
250: ; preds = %240, %195
br label %251
251: ; preds = %269, %250
%252 = load i32, i32* %7
%253 = icmp sgt i32 %252, 0
br i1 %253, label %254, label %272
254: ; preds = %251
%255 = load i32*, i32** %6
%256 = load i32, i32* %7
%257 = sub nsw i32 %256, 1
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i32, i32* %255, i64 %258
%260 = load i32, i32* %259
%261 = icmp eq i32 %260, -1
br i1 %261, label %262, label %269
262: ; preds = %254
%263 = load i32, i32* %12
%264 = load i32*, i32** %6
%265 = load i32, i32* %7
%266 = sub nsw i32 %265, 1
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %264, i64 %267
store i32 %263, i32* %268
br label %269
269: ; preds = %262, %254
%270 = load i32, i32* %7
%271 = add nsw i32 %270, -1
store i32 %271, i32* %7
br label %251
272: ; preds = %31, %251
ret void
}

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