#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__ calloc(size_t, int);
int /*<<< orphan*/ free(int *);
int *ksBM_prep(const unsigned char *pat, int m) {
  int i;
  int *suff;
  int *prep;
  int *bmGs;
  int *bmBc;
  prep = (int *)calloc((size_t)(m + 256), sizeof(int));
  bmGs = prep;
  bmBc = prep + m;
  {
    for (i = 0; i < 256; ++i)
      bmBc[i] = m;
    for (i = 0; i < m - 1; ++i)
      bmBc[pat[i]] = m - i - 1;
  }
  suff = (int *)calloc((size_t)m, sizeof(int));
  {
    int f = 0;
    int g;
    suff[m - 1] = m;
    g = m - 1;
    for (i = m - 2; i >= 0; --i) {
      if ((i > g) && (suff[i + m - 1 - f] < i - g))
        suff[i] = suff[i + m - 1 - f];
      else {
        if (i < g)
          g = i;
        f = i;
        while ((g >= 0) && (pat[g] == pat[g + m - 1 - f]))
          --g;
        suff[i] = f - g;
      }
    }
  }
  {
    int j = 0;
    for (i = 0; i < m; ++i)
      bmGs[i] = m;
    for (i = m - 1; i >= 0; --i)
      if (suff[i] == i + 1)
        for (; j < m - 1 - i; ++j)
          if (bmGs[j] == m)
            bmGs[j] = m - 1 - i;
    for (i = 0; i <= m - 2; ++i)
      bmGs[m - 1 - suff[i]] = m - 1 - i;
  }
  free(suff);
  return prep;
}


x86 assembly (clang, -O0):
<ksBM_prep>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
add    $0x100,%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x10(%rbp)
cmpl   $0x100,-0x10(%rbp)
jge    1193 <ksBM_prep+0x73>
mov    -0xc(%rbp),%edx
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    116a <ksBM_prep+0x4a>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    11d5 <ksBM_prep+0xb5>
mov    -0xc(%rbp),%edx
sub    -0x10(%rbp),%edx
sub    $0x1,%edx
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x10(%rbp),%rsi
movzbl (%rcx,%rsi,1),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    119a <ksBM_prep+0x7a>
movslq -0xc(%rbp),%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0xc(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     1307 <ksBM_prep+0x1e7>
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    1273 <ksBM_prep+0x153>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
sub    -0x38(%rbp),%ecx
cmp    %ecx,%eax
jge    1273 <ksBM_prep+0x153>
mov    -0x18(%rbp),%rax
mov    -0x10(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x34(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12f4 <ksBM_prep+0x1d4>
mov    -0x10(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1285 <ksBM_prep+0x165>
mov    -0x10(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x34(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x38(%rbp)
mov    %al,-0x3d(%rbp)
jl     12c5 <ksBM_prep+0x1a5>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
mov    -0x38(%rbp),%edx
add    -0xc(%rbp),%edx
sub    $0x1,%edx
sub    -0x34(%rbp),%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
sete   %al
mov    %al,-0x3d(%rbp)
mov    -0x3d(%rbp),%al
test   $0x1,%al
jne    12d5 <ksBM_prep+0x1b5>
jmp    12e3 <ksBM_prep+0x1c3>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    128b <ksBM_prep+0x16b>
mov    -0x34(%rbp),%edx
sub    -0x38(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12f9 <ksBM_prep+0x1d9>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1213 <ksBM_prep+0xf3>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    133d <ksBM_prep+0x21d>
mov    -0xc(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    1315 <ksBM_prep+0x1f5>
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
cmpl   $0x0,-0x10(%rbp)
jl     13d5 <ksBM_prep+0x2b5>
mov    -0x18(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jne    13c2 <ksBM_prep+0x2a2>
jmp    136e <ksBM_prep+0x24e>
mov    -0x3c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    13bd <ksBM_prep+0x29d>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0xc(%rbp),%eax
jne    13aa <ksBM_prep+0x28a>
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
sub    -0x10(%rbp),%edx
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    13af <ksBM_prep+0x28f>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    136e <ksBM_prep+0x24e>
jmp    13c2 <ksBM_prep+0x2a2>
jmp    13c7 <ksBM_prep+0x2a7>
mov    -0x10(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x10(%rbp)
jmp    1346 <ksBM_prep+0x226>
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     141f <ksBM_prep+0x2ff>
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
sub    -0x10(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%rsi
movslq -0x10(%rbp),%rdi
sub    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    13dc <ksBM_prep+0x2bc>
mov    -0x18(%rbp),%rdi
call   1030 <free@plt>
mov    -0x20(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ksBM_prep>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %esi,%r14d
mov    %rdi,%r15
lea    0x100(%r14),%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%r13
movslq %r14d,%r12
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqu %xmm0,(%rax,%r12,4)
movdqu %xmm0,0x10(%rax,%r12,4)
movdqu %xmm0,0x20(%rax,%r12,4)
movdqu %xmm0,0x30(%rax,%r12,4)
movdqu %xmm0,0x40(%rax,%r12,4)
movdqu %xmm0,0x50(%rax,%r12,4)
movdqu %xmm0,0x60(%rax,%r12,4)
movdqu %xmm0,0x70(%rax,%r12,4)
movdqu %xmm0,0x80(%rax,%r12,4)
movdqu %xmm0,0x90(%rax,%r12,4)
movdqu %xmm0,0xa0(%rax,%r12,4)
movdqu %xmm0,0xb0(%rax,%r12,4)
movdqu %xmm0,0xc0(%rax,%r12,4)
movdqu %xmm0,0xd0(%rax,%r12,4)
movdqu %xmm0,0xe0(%rax,%r12,4)
movdqu %xmm0,0xf0(%rax,%r12,4)
movdqu %xmm0,0x100(%rax,%r12,4)
movdqu %xmm0,0x110(%rax,%r12,4)
movdqu %xmm0,0x120(%rax,%r12,4)
movdqu %xmm0,0x130(%rax,%r12,4)
movdqu %xmm0,0x140(%rax,%r12,4)
movdqu %xmm0,0x150(%rax,%r12,4)
movdqu %xmm0,0x160(%rax,%r12,4)
movdqu %xmm0,0x170(%rax,%r12,4)
movdqu %xmm0,0x180(%rax,%r12,4)
movdqu %xmm0,0x190(%rax,%r12,4)
movdqu %xmm0,0x1a0(%rax,%r12,4)
movdqu %xmm0,0x1b0(%rax,%r12,4)
movdqu %xmm0,0x1c0(%rax,%r12,4)
movdqu %xmm0,0x1d0(%rax,%r12,4)
movdqu %xmm0,0x1e0(%rax,%r12,4)
movdqu %xmm0,0x1f0(%rax,%r12,4)
movdqu %xmm0,0x200(%rax,%r12,4)
movdqu %xmm0,0x210(%rax,%r12,4)
movdqu %xmm0,0x220(%rax,%r12,4)
movdqu %xmm0,0x230(%rax,%r12,4)
movdqu %xmm0,0x240(%rax,%r12,4)
movdqu %xmm0,0x250(%rax,%r12,4)
movdqu %xmm0,0x260(%rax,%r12,4)
movdqu %xmm0,0x270(%rax,%r12,4)
movdqu %xmm0,0x280(%rax,%r12,4)
movdqu %xmm0,0x290(%rax,%r12,4)
movdqu %xmm0,0x2a0(%rax,%r12,4)
movdqu %xmm0,0x2b0(%rax,%r12,4)
movdqu %xmm0,0x2c0(%rax,%r12,4)
movdqu %xmm0,0x2d0(%rax,%r12,4)
movdqu %xmm0,0x2e0(%rax,%r12,4)
movdqu %xmm0,0x2f0(%rax,%r12,4)
movdqu %xmm0,0x300(%rax,%r12,4)
movdqu %xmm0,0x310(%rax,%r12,4)
movdqu %xmm0,0x320(%rax,%r12,4)
movdqu %xmm0,0x330(%rax,%r12,4)
movdqu %xmm0,0x340(%rax,%r12,4)
movdqu %xmm0,0x350(%rax,%r12,4)
movdqu %xmm0,0x360(%rax,%r12,4)
movdqu %xmm0,0x370(%rax,%r12,4)
movdqu %xmm0,0x380(%rax,%r12,4)
movdqu %xmm0,0x390(%rax,%r12,4)
movdqu %xmm0,0x3a0(%rax,%r12,4)
movdqu %xmm0,0x3b0(%rax,%r12,4)
movdqu %xmm0,0x3c0(%rax,%r12,4)
movdqu %xmm0,0x3d0(%rax,%r12,4)
movdqu %xmm0,0x3e0(%rax,%r12,4)
movdqu %xmm0,0x3f0(%rax,%r12,4)
lea    -0x1(%r12),%ebx
cmp    $0x1,%r12d
movdqa %xmm0,0x10(%rsp)
jle    1403 <ksBM_prep+0x2e3>
lea    0x0(,%r12,4),%rax
add    %r13,%rax
mov    %ebx,0xc(%rsp)
mov    %ebx,%r11d
lea    -0x1(%r11),%rcx
mov    %r11d,%r8d
and    $0x3,%r8d
cmp    $0x3,%rcx
jae    1428 <ksBM_prep+0x308>
xor    %edx,%edx
test   %r8,%r8
jne    1490 <ksBM_prep+0x370>
jmp    14b3 <ksBM_prep+0x393>
mov    %r12,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
movdqa 0x10(%rsp),%xmm1
mov    %rax,%rdi
movslq %ebx,%rax
mov    %r12d,(%rdi,%rax,4)
mov    %ebx,%r12d
jmp    1575 <ksBM_prep+0x455>
lea    -0x3(%r14),%r9d
lea    0x3(%r15),%rbp
lea    -0x2(%r14),%r10d
lea    -0x4(%r14),%ecx
mov    %r11d,%esi
and    $0xfffffffc,%esi
neg    %rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r11,%rdx,1),%ebx
movzbl -0x3(%rbp),%edi
mov    %ebx,(%rax,%rdi,4)
lea    (%r10,%rdx,1),%edi
movzbl -0x2(%rbp),%ebx
mov    %edi,(%rax,%rbx,4)
lea    (%r9,%rdx,1),%edi
movzbl -0x1(%rbp),%ebx
mov    %edi,(%rax,%rbx,4)
lea    (%rcx,%rdx,1),%edi
movzbl 0x0(%rbp),%ebx
mov    %edi,(%rax,%rbx,4)
add    $0xfffffffffffffffc,%rdx
add    $0x4,%rbp
cmp    %rdx,%rsi
jne    1450 <ksBM_prep+0x330>
neg    %rdx
test   %r8,%r8
je     14b3 <ksBM_prep+0x393>
lea    (%r15,%rdx,1),%rcx
not    %edx
add    %r14d,%edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rsi,1),%edi
mov    %edx,(%rax,%rdi,4)
add    $0x1,%rsi
add    $0xffffffff,%edx
cmp    %rsi,%r8
jne    14a0 <ksBM_prep+0x380>
mov    %r12,%rdi
mov    $0x4,%esi
call   1040 <calloc@plt>
mov    %rax,%rdi
mov    0xc(%rsp),%r12d
movslq %r12d,%rax
mov    %r14d,(%rdi,%rax,4)
cmp    $0x2,%r14d
movdqa 0x10(%rsp),%xmm1
jl     1575 <ksBM_prep+0x455>
lea    -0x2(%r14),%eax
xor    %r8d,%r8d
mov    $0x1,%ecx
mov    %r12d,%edx
jmp    150b <ksBM_prep+0x3eb>
mov    %eax,%ebx
sub    %ebp,%ebx
mov    %eax,%r8d
mov    %ebp,%edx
mov    %ebx,(%rdi,%rax,4)
lea    -0x1(%rax),%rsi
add    $0x1,%ecx
test   %rax,%rax
mov    %rsi,%rax
jle    1575 <ksBM_prep+0x455>
movslq %edx,%rbp
cmp    %rbp,%rax
jle    152b <ksBM_prep+0x40b>
mov    %r8d,%esi
not    %esi
add    %eax,%esi
add    %r14d,%esi
movslq %esi,%rsi
mov    (%rdi,%rsi,4),%ebx
mov    %eax,%esi
sub    %edx,%esi
cmp    %esi,%ebx
jl     14f9 <ksBM_prep+0x3d9>
cmp    %rbp,%rax
mov    %edx,%ebp
cmovl  %eax,%ebp
test   %ebp,%ebp
js     14f0 <ksBM_prep+0x3d0>
cmp    %eax,%edx
cmovge %eax,%edx
movslq %edx,%rsi
add    $0x1,%rsi
mov    %edx,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x1(%r15,%rsi,1),%edx
lea    (%rcx,%rbp,1),%ebx
movslq %ebx,%rbx
cmp    (%r15,%rbx,1),%dl
jne    14f0 <ksBM_prep+0x3d0>
add    $0xffffffff,%ebp
add    $0xffffffffffffffff,%rsi
jg     1550 <ksBM_prep+0x430>
mov    $0xffffffff,%ebp
jmp    14f0 <ksBM_prep+0x3d0>
test   %r14d,%r14d
jle    1858 <ksBM_prep+0x738>
mov    %r14d,%r9d
cmp    $0x8,%r14d
jae    158e <ksBM_prep+0x46e>
xor    %ecx,%ecx
jmp    1690 <ksBM_prep+0x570>
mov    %r9d,%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    15b5 <ksBM_prep+0x495>
xor    %esi,%esi
jmp    1656 <ksBM_prep+0x536>
and    $0xfffffffffffffff8,%rdx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu %xmm1,0x0(%r13,%rsi,4)
movdqu %xmm1,0x10(%r13,%rsi,4)
movdqu %xmm1,0x20(%r13,%rsi,4)
movdqu %xmm1,0x30(%r13,%rsi,4)
movdqu %xmm1,0x40(%r13,%rsi,4)
movdqu %xmm1,0x50(%r13,%rsi,4)
movdqu %xmm1,0x60(%r13,%rsi,4)
movdqu %xmm1,0x70(%r13,%rsi,4)
movdqu %xmm1,0x80(%r13,%rsi,4)
movdqu %xmm1,0x90(%r13,%rsi,4)
movdqu %xmm1,0xa0(%r13,%rsi,4)
movdqu %xmm1,0xb0(%r13,%rsi,4)
movdqu %xmm1,0xc0(%r13,%rsi,4)
movdqu %xmm1,0xd0(%r13,%rsi,4)
movdqu %xmm1,0xe0(%r13,%rsi,4)
movdqu %xmm1,0xf0(%r13,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rdx
jne    15c0 <ksBM_prep+0x4a0>
test   %rax,%rax
je     1684 <ksBM_prep+0x564>
lea    0x10(,%rsi,4),%rdx
add    %r13,%rdx
shl    $0x5,%rax
xor    %esi,%esi
nopl   0x0(%rax)
movdqu %xmm1,-0x10(%rdx,%rsi,1)
movdqu %xmm1,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rax
jne    1670 <ksBM_prep+0x550>
cmp    %r9,%rcx
je     169e <ksBM_prep+0x57e>
nopl   0x0(%rax)
mov    %r14d,0x0(%r13,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r9
jne    1690 <ksBM_prep+0x570>
test   %r14d,%r14d
jle    1858 <ksBM_prep+0x738>
mov    %r12d,%r8d
xor    %edx,%edx
mov    %r8,%r15
xor    %eax,%eax
jmp    16d3 <ksBM_prep+0x5b3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edx,%eax
add    $0xffffffffffffffff,%r15
add    $0x1,%rdx
cmp    %r9,%rdx
je     17eb <ksBM_prep+0x6cb>
mov    (%rdi,%r15,4),%ecx
lea    0x1(%r15),%rbp
cmp    %rcx,%rbp
jne    16c2 <ksBM_prep+0x5a2>
mov    %r8,%rcx
sub    %r15,%rcx
movslq %eax,%rbx
cmp    %rbx,%rcx
jle    16c2 <ksBM_prep+0x5a2>
mov    %rdx,%r10
sub    %rbx,%r10
cmp    $0x8,%r10
jae    1702 <ksBM_prep+0x5e2>
mov    %rbx,%rbp
jmp    17dd <ksBM_prep+0x6bd>
mov    %r10,%r11
and    $0xfffffffffffffff8,%r11
lea    (%r11,%rbx,1),%rbp
lea    0x0(,%rbx,4),%rbx
add    %r13,%rbx
xor    %eax,%eax
jmp    172d <ksBM_prep+0x60d>
nopl   0x0(%rax)
add    $0x8,%rax
cmp    %rax,%r11
je     17be <ksBM_prep+0x69e>
movdqu (%rbx,%rax,4),%xmm0
pcmpeqd %xmm1,%xmm0
movd   %xmm0,%esi
test   $0x1,%sil
je     1743 <ksBM_prep+0x623>
mov    %ecx,(%rbx,%rax,4)
pextrw $0x2,%xmm0,%esi
test   $0x1,%sil
je     1752 <ksBM_prep+0x632>
mov    %ecx,0x4(%rbx,%rax,4)
pextrw $0x4,%xmm0,%esi
test   $0x1,%sil
je     1761 <ksBM_prep+0x641>
mov    %ecx,0x8(%rbx,%rax,4)
pextrw $0x6,%xmm0,%esi
test   $0x1,%sil
je     1770 <ksBM_prep+0x650>
mov    %ecx,0xc(%rbx,%rax,4)
movdqu 0x10(%rbx,%rax,4),%xmm0
pcmpeqd %xmm1,%xmm0
movd   %xmm0,%esi
test   $0x1,%sil
je     1788 <ksBM_prep+0x668>
mov    %ecx,0x10(%rbx,%rax,4)
pextrw $0x2,%xmm0,%esi
test   $0x1,%sil
je     1797 <ksBM_prep+0x677>
mov    %ecx,0x14(%rbx,%rax,4)
pextrw $0x4,%xmm0,%esi
test   $0x1,%sil
je     17a6 <ksBM_prep+0x686>
mov    %ecx,0x18(%rbx,%rax,4)
pextrw $0x6,%xmm0,%esi
test   $0x1,%sil
je     1720 <ksBM_prep+0x600>
mov    %ecx,0x1c(%rbx,%rax,4)
jmp    1720 <ksBM_prep+0x600>
cmp    %r11,%r10
jne    17dd <ksBM_prep+0x6bd>
jmp    16c0 <ksBM_prep+0x5a0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %rbp,%rdx
je     16c0 <ksBM_prep+0x5a0>
cmp    %r14d,0x0(%r13,%rbp,4)
jne    17d0 <ksBM_prep+0x6b0>
mov    %ecx,0x0(%r13,%rbp,4)
jmp    17d0 <ksBM_prep+0x6b0>
cmp    $0x2,%r14d
jl     1858 <ksBM_prep+0x738>
cmp    $0x1,%r12d
jne    17fb <ksBM_prep+0x6db>
xor    %eax,%eax
jmp    1840 <ksBM_prep+0x720>
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
add    $0xfffffffe,%r14d
xor    %eax,%eax
movslq %r12d,%rbx
nopw   0x0(%rax,%rax,1)
lea    0x1(%r14),%esi
movslq (%rdi,%rax,4),%rbp
mov    %rbx,%rdx
sub    %rbp,%rdx
mov    %esi,0x0(%r13,%rdx,4)
movslq 0x4(%rdi,%rax,4),%rdx
mov    %rbx,%rsi
sub    %rdx,%rsi
mov    %r14d,0x0(%r13,%rsi,4)
add    $0x2,%rax
add    $0xfffffffe,%r14d
cmp    %rax,%rcx
jne    1810 <ksBM_prep+0x6f0>
test   $0x1,%r8b
je     1858 <ksBM_prep+0x738>
movslq (%rdi,%rax,4),%rcx
movslq %r12d,%rdx
sub    %eax,%r12d
sub    %rcx,%rdx
mov    %r12d,0x0(%r13,%rdx,4)
call   1030 <free@plt>
mov    %r13,%rax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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