#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ free(int *);
scalar_t__ malloc(int);
scalar_t__ max(int, int);
int BM_match(char *pSrc, int nSrcSize, char *pSubSrc, int nSubSrcSize) {
  int bcSkip[256];
  int i;
  for (i = 0; i < 256; i++) {
    bcSkip[i] = nSubSrcSize;
  }
  for (i = 0; i < nSubSrcSize - 1; i++) {
    bcSkip[pSubSrc[i]] = nSubSrcSize - i - 1;
  }
  int *suffix = (int *)malloc(nSubSrcSize * sizeof(int));
  suffix[nSubSrcSize - 1] = nSubSrcSize;
  for (i = nSubSrcSize - 2; i >= 0; i--) {
    int k = i;
    while (k >= 0 && pSubSrc[k] == pSubSrc[nSubSrcSize - 1 - i + k]) {
      k--;
    }
    suffix[i] = i - k;
  }
  int *gsSkip = (int *)malloc(nSubSrcSize * sizeof(int));
  for (i = 0; i < nSubSrcSize; i++) {
    gsSkip[i] = nSubSrcSize;
  }
  for (i = nSubSrcSize - 1; i >= 0; i--) {
    if (suffix[i] == i + 1) {
      int j;
      for (j = 0; j < nSubSrcSize - 1 - i; ++j) {
        if (gsSkip[j] == nSubSrcSize)
          gsSkip[j] = nSubSrcSize - 1 - i;
      }
    }
  }
  for (i = 0; i <= nSubSrcSize - 2; ++i) {
    gsSkip[nSubSrcSize - 1 - suffix[i]] = nSubSrcSize - 1 - i;
  }
  int nPos = 0;
  while (nPos <= nSrcSize - nSubSrcSize) {
    int j = nSubSrcSize - 1;
    while (j >= 0 && pSubSrc[j] == pSrc[j + nPos]) {
      j--;
    }
    if (j < 0)
      break;
    else {
      nPos += max(gsSkip[j], bcSkip[pSrc[j + nPos]] - (nSubSrcSize - 1 - j));
    }
  }
  free(gsSkip);
  return (nPos > nSrcSize - nSubSrcSize) ? -1 : nPos;
}


x86 assembly (clang, -O0):
<BM_match>:
push   %rbp
mov    %rsp,%rbp
sub    $0x460,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x424(%rbp)
cmpl   $0x100,-0x424(%rbp)
jge    1188 <BM_match+0x58>
mov    -0x1c(%rbp),%ecx
movslq -0x424(%rbp),%rax
mov    %ecx,-0x420(%rbp,%rax,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    1153 <BM_match+0x23>
movl   $0x0,-0x424(%rbp)
mov    -0x424(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11dd <BM_match+0xad>
mov    -0x1c(%rbp),%ecx
sub    -0x424(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%rax
movslq -0x424(%rbp),%rdx
movsbq (%rax,%rdx,1),%rax
mov    %ecx,-0x420(%rbp,%rax,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    1192 <BM_match+0x62>
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x430(%rbp)
mov    -0x1c(%rbp),%edx
mov    -0x430(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x424(%rbp)
cmpl   $0x0,-0x424(%rbp)
jl     12d2 <BM_match+0x1a2>
mov    -0x424(%rbp),%eax
mov    %eax,-0x434(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x434(%rbp)
mov    %al,-0x44d(%rbp)
jl     127a <BM_match+0x14a>
mov    -0x18(%rbp),%rax
movslq -0x434(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x18(%rbp),%rcx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
sub    -0x424(%rbp),%edx
add    -0x434(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x44d(%rbp)
mov    -0x44d(%rbp),%al
test   $0x1,%al
jne    128d <BM_match+0x15d>
jmp    12a1 <BM_match+0x171>
mov    -0x434(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x434(%rbp)
jmp    122e <BM_match+0xfe>
mov    -0x424(%rbp),%edx
sub    -0x434(%rbp),%edx
mov    -0x430(%rbp),%rax
movslq -0x424(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x424(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x424(%rbp)
jmp    1215 <BM_match+0xe5>
movslq -0x1c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x440(%rbp)
movl   $0x0,-0x424(%rbp)
mov    -0x424(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1329 <BM_match+0x1f9>
mov    -0x1c(%rbp),%edx
mov    -0x440(%rbp),%rax
movslq -0x424(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    12f2 <BM_match+0x1c2>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x424(%rbp)
cmpl   $0x0,-0x424(%rbp)
jl     13f6 <BM_match+0x2c6>
mov    -0x430(%rbp),%rax
movslq -0x424(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x424(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    13dd <BM_match+0x2ad>
movl   $0x0,-0x444(%rbp)
mov    -0x444(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x424(%rbp),%ecx
cmp    %ecx,%eax
jge    13d8 <BM_match+0x2a8>
mov    -0x440(%rbp),%rax
movslq -0x444(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jne    13bf <BM_match+0x28f>
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
sub    -0x424(%rbp),%edx
mov    -0x440(%rbp),%rax
movslq -0x444(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13c4 <BM_match+0x294>
mov    -0x444(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x444(%rbp)
jmp    136e <BM_match+0x23e>
jmp    13dd <BM_match+0x2ad>
jmp    13e2 <BM_match+0x2b2>
mov    -0x424(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x424(%rbp)
jmp    1335 <BM_match+0x205>
movl   $0x0,-0x424(%rbp)
mov    -0x424(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1458 <BM_match+0x328>
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
sub    -0x424(%rbp),%edx
mov    -0x440(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x430(%rbp),%rsi
movslq -0x424(%rbp),%rdi
sub    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x424(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x424(%rbp)
jmp    1400 <BM_match+0x2d0>
movl   $0x0,-0x448(%rbp)
mov    -0x448(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jg     155c <BM_match+0x42c>
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44c(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x44c(%rbp)
mov    %al,-0x44e(%rbp)
jl     14c8 <BM_match+0x398>
mov    -0x18(%rbp),%rax
movslq -0x44c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x44c(%rbp),%edx
add    -0x448(%rbp),%edx
movslq %edx,%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x44e(%rbp)
mov    -0x44e(%rbp),%al
test   $0x1,%al
jne    14db <BM_match+0x3ab>
jmp    14ef <BM_match+0x3bf>
mov    -0x44c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44c(%rbp)
jmp    1482 <BM_match+0x352>
cmpl   $0x0,-0x44c(%rbp)
jge    1501 <BM_match+0x3d1>
jmp    155c <BM_match+0x42c>
mov    -0x440(%rbp),%rax
movslq -0x44c(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x8(%rbp),%rax
mov    -0x44c(%rbp),%ecx
add    -0x448(%rbp),%ecx
movslq %ecx,%rcx
movsbq (%rax,%rcx,1),%rax
mov    -0x420(%rbp,%rax,4),%esi
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
sub    -0x44c(%rbp),%eax
sub    %eax,%esi
call   1040 <max@plt>
mov    %rax,%rcx
movslq -0x448(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x448(%rbp)
jmp    1462 <BM_match+0x332>
mov    -0x440(%rbp),%rdi
call   1030 <free@plt>
mov    -0x448(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
cmp    %ecx,%eax
jle    158c <BM_match+0x45c>
mov    $0xffffffff,%eax
mov    %eax,-0x454(%rbp)
jmp    1598 <BM_match+0x468>
mov    -0x448(%rbp),%eax
mov    %eax,-0x454(%rbp)
mov    -0x454(%rbp),%eax
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<BM_match>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x438,%rsp
mov    %ecx,%r12d
mov    %rdx,%r15
mov    %esi,0xc(%rsp)
mov    %rdi,0x18(%rsp)
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa %xmm0,0x30(%rsp)
movdqa %xmm0,0x40(%rsp)
movdqa %xmm0,0x50(%rsp)
movdqa %xmm0,0x60(%rsp)
movdqa %xmm0,0x70(%rsp)
movdqa %xmm0,0x80(%rsp)
movdqa %xmm0,0x90(%rsp)
movdqa %xmm0,0xa0(%rsp)
movdqa %xmm0,0xb0(%rsp)
movdqa %xmm0,0xc0(%rsp)
movdqa %xmm0,0xd0(%rsp)
movdqa %xmm0,0xe0(%rsp)
movdqa %xmm0,0xf0(%rsp)
movdqa %xmm0,0x100(%rsp)
movdqa %xmm0,0x110(%rsp)
movdqa %xmm0,0x120(%rsp)
movdqa %xmm0,0x130(%rsp)
movdqa %xmm0,0x140(%rsp)
movdqa %xmm0,0x150(%rsp)
movdqa %xmm0,0x160(%rsp)
movdqa %xmm0,0x170(%rsp)
movdqa %xmm0,0x180(%rsp)
movdqa %xmm0,0x190(%rsp)
movdqa %xmm0,0x1a0(%rsp)
movdqa %xmm0,0x1b0(%rsp)
movdqa %xmm0,0x1c0(%rsp)
movdqa %xmm0,0x1d0(%rsp)
movdqa %xmm0,0x1e0(%rsp)
movdqa %xmm0,0x1f0(%rsp)
movdqa %xmm0,0x200(%rsp)
movdqa %xmm0,0x210(%rsp)
movdqa %xmm0,0x220(%rsp)
movdqa %xmm0,0x230(%rsp)
movdqa %xmm0,0x240(%rsp)
movdqa %xmm0,0x250(%rsp)
movdqa %xmm0,0x260(%rsp)
movdqa %xmm0,0x270(%rsp)
movdqa %xmm0,0x280(%rsp)
movdqa %xmm0,0x290(%rsp)
movdqa %xmm0,0x2a0(%rsp)
movdqa %xmm0,0x2b0(%rsp)
movdqa %xmm0,0x2c0(%rsp)
movdqa %xmm0,0x2d0(%rsp)
movdqa %xmm0,0x2e0(%rsp)
movdqa %xmm0,0x2f0(%rsp)
movdqa %xmm0,0x300(%rsp)
movdqa %xmm0,0x310(%rsp)
movdqa %xmm0,0x320(%rsp)
movdqa %xmm0,0x330(%rsp)
movdqa %xmm0,0x340(%rsp)
movdqa %xmm0,0x350(%rsp)
movdqa %xmm0,0x360(%rsp)
movdqa %xmm0,0x370(%rsp)
movdqa %xmm0,0x380(%rsp)
movdqa %xmm0,0x390(%rsp)
movdqa %xmm0,0x3a0(%rsp)
movdqa %xmm0,0x3b0(%rsp)
movdqa %xmm0,0x3c0(%rsp)
movdqa %xmm0,0x3d0(%rsp)
movdqa %xmm0,0x3e0(%rsp)
movdqa %xmm0,0x3f0(%rsp)
movdqa %xmm0,0x400(%rsp)
movdqa %xmm0,0x410(%rsp)
movdqa %xmm0,0x420(%rsp)
lea    -0x1(%r12),%eax
mov    %rax,0x10(%rsp)
cmp    $0x2,%ecx
jl     1455 <BM_match+0x325>
mov    0x10(%rsp),%r10d
lea    -0x1(%r10),%rcx
mov    %r10d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rcx
jae    13bf <BM_match+0x28f>
xor    %ecx,%ecx
test   %r8,%r8
jne    1426 <BM_match+0x2f6>
jmp    1455 <BM_match+0x325>
lea    -0x3(%r12),%r9d
lea    0x3(%r15),%rdi
lea    -0x2(%r12),%ebp
lea    -0x4(%r12),%ebx
mov    %r10d,%edx
and    $0xfffffffc,%edx
neg    %rdx
xor    %ecx,%ecx
nopl   (%rax)
lea    (%r10,%rcx,1),%esi
movsbq -0x3(%rdi),%rax
mov    %esi,0x30(%rsp,%rax,4)
lea    (%rcx,%rbp,1),%eax
movsbq -0x2(%rdi),%rsi
mov    %eax,0x30(%rsp,%rsi,4)
lea    (%r9,%rcx,1),%eax
movsbq -0x1(%rdi),%rsi
mov    %eax,0x30(%rsp,%rsi,4)
lea    (%rbx,%rcx,1),%eax
movsbq (%rdi),%rsi
mov    %eax,0x30(%rsp,%rsi,4)
add    $0xfffffffffffffffc,%rcx
add    $0x4,%rdi
cmp    %rcx,%rdx
jne    13e0 <BM_match+0x2b0>
neg    %rcx
test   %r8,%r8
je     1455 <BM_match+0x325>
lea    (%r15,%rcx,1),%rax
not    %ecx
add    %r12d,%ecx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsbq (%rax,%rdx,1),%rsi
mov    %ecx,0x30(%rsp,%rsi,4)
add    $0x1,%rdx
add    $0xffffffff,%ecx
cmp    %rdx,%r8
jne    1440 <BM_match+0x310>
movdqa %xmm0,0x20(%rsp)
lea    0x0(,%r12,4),%ebp
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%r13
movslq 0x10(%rsp),%r14
mov    %r12d,(%rax,%r14,4)
cmp    $0x2,%r12d
jl     14df <BM_match+0x3af>
lea    -0x2(%r12),%ecx
mov    $0x1,%eax
jmp    14a8 <BM_match+0x378>
nopl   0x0(%rax,%rax,1)
mov    %ecx,%esi
sub    %edx,%esi
mov    %esi,0x0(%r13,%rcx,4)
lea    -0x1(%rcx),%rdx
add    $0x1,%eax
test   %rcx,%rcx
mov    %rdx,%rcx
jle    14df <BM_match+0x3af>
movslq %eax,%rsi
add    %r15,%rsi
mov    %rcx,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %edx,%edi
movzbl (%r15,%rdi,1),%ebx
cmp    (%rsi,%rdx,1),%bl
jne    1490 <BM_match+0x360>
lea    -0x1(%rdx),%rdi
test   %rdx,%rdx
mov    %rdi,%rdx
jg     14c0 <BM_match+0x390>
mov    $0xffffffff,%edx
jmp    1490 <BM_match+0x360>
mov    %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,%rbx
test   %r12d,%r12d
movdqa 0x20(%rsp),%xmm2
jle    1794 <BM_match+0x664>
mov    %r12d,%r10d
cmp    $0x8,%r12d
jae    1508 <BM_match+0x3d8>
xor    %ecx,%ecx
jmp    1600 <BM_match+0x4d0>
mov    %r10d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%eax
and    $0x7,%eax
cmp    $0x38,%rsi
jae    152f <BM_match+0x3ff>
xor    %esi,%esi
jmp    15c5 <BM_match+0x495>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movdqu %xmm2,(%rbx,%rsi,4)
movdqu %xmm2,0x10(%rbx,%rsi,4)
movdqu %xmm2,0x20(%rbx,%rsi,4)
movdqu %xmm2,0x30(%rbx,%rsi,4)
movdqu %xmm2,0x40(%rbx,%rsi,4)
movdqu %xmm2,0x50(%rbx,%rsi,4)
movdqu %xmm2,0x60(%rbx,%rsi,4)
movdqu %xmm2,0x70(%rbx,%rsi,4)
movdqu %xmm2,0x80(%rbx,%rsi,4)
movdqu %xmm2,0x90(%rbx,%rsi,4)
movdqu %xmm2,0xa0(%rbx,%rsi,4)
movdqu %xmm2,0xb0(%rbx,%rsi,4)
movdqu %xmm2,0xc0(%rbx,%rsi,4)
movdqu %xmm2,0xd0(%rbx,%rsi,4)
movdqu %xmm2,0xe0(%rbx,%rsi,4)
movdqu %xmm2,0xf0(%rbx,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rdx
jne    1540 <BM_match+0x410>
test   %rax,%rax
je     15f4 <BM_match+0x4c4>
lea    (%rbx,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rax
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu %xmm2,-0x10(%rdx,%rsi,1)
movdqu %xmm2,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rax
jne    15e0 <BM_match+0x4b0>
cmp    %r10,%rcx
je     160d <BM_match+0x4dd>
nopl   0x0(%rax)
mov    %r12d,(%rbx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r10
jne    1600 <BM_match+0x4d0>
test   %r12d,%r12d
jle    1794 <BM_match+0x664>
mov    0x10(%rsp),%r9d
xor    %esi,%esi
movabs $0x7ffffffffffffff8,%r8
ff ff 7f
mov    %r9,%rdi
jmp    1641 <BM_match+0x511>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rdi
add    $0x1,%rsi
cmp    %r10,%rsi
je     1728 <BM_match+0x5f8>
mov    0x0(%r13,%rdi,4),%eax
lea    0x1(%rdi),%rcx
cmp    %rax,%rcx
jne    1630 <BM_match+0x500>
mov    %r9,%rcx
sub    %rdi,%rcx
je     1630 <BM_match+0x500>
cmp    $0x8,%rsi
jae    1664 <BM_match+0x534>
xor    %edx,%edx
jmp    1719 <BM_match+0x5e9>
mov    %rsi,%r11
and    $0xfffffffffffffff8,%r11
mov    %rsi,%rdx
and    %r8,%rdx
xor    %ebp,%ebp
jmp    168d <BM_match+0x55d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x8,%rbp
cmp    %rbp,%r11
je     1710 <BM_match+0x5e0>
movdqu (%rbx,%rbp,4),%xmm1
movdqu 0x10(%rbx,%rbp,4),%xmm0
pcmpeqd %xmm2,%xmm1
movd   %xmm1,%eax
test   $0x1,%al
je     16a7 <BM_match+0x577>
mov    %ecx,(%rbx,%rbp,4)
pextrw $0x2,%xmm1,%eax
test   $0x1,%al
je     16b4 <BM_match+0x584>
mov    %ecx,0x4(%rbx,%rbp,4)
pextrw $0x4,%xmm1,%eax
test   $0x1,%al
je     16c1 <BM_match+0x591>
mov    %ecx,0x8(%rbx,%rbp,4)
pextrw $0x6,%xmm1,%eax
test   $0x1,%al
je     16ce <BM_match+0x59e>
mov    %ecx,0xc(%rbx,%rbp,4)
pcmpeqd %xmm2,%xmm0
movd   %xmm0,%eax
test   $0x1,%al
je     16de <BM_match+0x5ae>
mov    %ecx,0x10(%rbx,%rbp,4)
pextrw $0x2,%xmm0,%eax
test   $0x1,%al
je     16eb <BM_match+0x5bb>
mov    %ecx,0x14(%rbx,%rbp,4)
pextrw $0x4,%xmm0,%eax
test   $0x1,%al
je     16f8 <BM_match+0x5c8>
mov    %ecx,0x18(%rbx,%rbp,4)
pextrw $0x6,%xmm0,%eax
test   $0x1,%al
je     1680 <BM_match+0x550>
mov    %ecx,0x1c(%rbx,%rbp,4)
jmp    1680 <BM_match+0x550>
xchg   %ax,%ax
cmp    %rdx,%rsi
je     1630 <BM_match+0x500>
cmp    %r12d,(%rbx,%rdx,4)
jne    1722 <BM_match+0x5f2>
mov    %ecx,(%rbx,%rdx,4)
add    $0x1,%rdx
jmp    1710 <BM_match+0x5e0>
cmp    $0x2,%r12d
jl     1794 <BM_match+0x664>
cmpl   $0x1,0x10(%rsp)
jne    1739 <BM_match+0x609>
xor    %eax,%eax
jmp    177b <BM_match+0x64b>
mov    %r9d,%ecx
and    $0xfffffffe,%ecx
lea    -0x2(%r12),%edx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%rdx),%esi
movslq 0x0(%r13,%rax,4),%rdi
mov    %r14,%rbp
sub    %rdi,%rbp
mov    %esi,(%rbx,%rbp,4)
movslq 0x4(%r13,%rax,4),%rsi
mov    %r14,%rdi
sub    %rsi,%rdi
mov    %edx,(%rbx,%rdi,4)
add    $0x2,%rax
add    $0xfffffffe,%edx
cmp    %rax,%rcx
jne    1750 <BM_match+0x620>
test   $0x1,%r9b
je     1794 <BM_match+0x664>
mov    0x10(%rsp),%rcx
sub    %eax,%ecx
movslq 0x0(%r13,%rax,4),%rax
sub    %rax,%r14
mov    %ecx,(%rbx,%r14,4)
sub    %r12d,0xc(%rsp)
js     184a <BM_match+0x71a>
movslq %r12d,%rbp
add    %rbp,%r15
add    $0xffffffffffffffff,%r15
mov    0x18(%rsp),%rax
lea    (%rax,%rbp,1),%rdx
add    $0xffffffffffffffff,%rdx
xor    %r13d,%r13d
test   %r12d,%r12d
jle    184a <BM_match+0x71a>
movslq %r13d,%rax
add    %rdx,%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movzbl (%r15,%rsi,1),%ecx
cmp    (%rax,%rsi,1),%cl
jne    1800 <BM_match+0x6d0>
lea    (%rsi,%rbp,1),%rcx
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%rsi
add    $0x1,%rcx
cmp    $0x1,%rcx
jg     17d0 <BM_match+0x6a0>
jmp    1845 <BM_match+0x715>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r12,%rsi,1),%eax
add    $0xffffffff,%eax
mov    (%rbx,%rax,4),%edi
mov    0x10(%rsp),%rax
add    %r13d,%eax
add    %esi,%eax
cltq
mov    0x18(%rsp),%rcx
movsbq (%rcx,%rax,1),%rax
add    0x30(%rsp,%rax,4),%esi
mov    %rdx,%r14
call   1040 <max@plt>
mov    %r14,%rdx
mov    %rax,%r14
add    %r13d,%r14d
mov    %r14d,%r13d
cmp    0xc(%rsp),%r14d
jle    17b9 <BM_match+0x689>
jmp    184d <BM_match+0x71d>
mov    %r13d,%r14d
jmp    184d <BM_match+0x71d>
xor    %r14d,%r14d
mov    %rbx,%rdi
call   1030 <free@plt>
cmp    0xc(%rsp),%r14d
mov    $0xffffffff,%eax
cmovle %r14d,%eax
add    $0x438,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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