#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__ cmp2(unsigned int, unsigned int, unsigned int, unsigned int);
scalar_t__ cmp3(unsigned int, unsigned int, unsigned int, unsigned int,
                unsigned int, unsigned int);
int /*<<< orphan*/ pass1(unsigned int *, unsigned int *, unsigned int *,
                         unsigned int, unsigned int);
void suffix_array(unsigned int *s, unsigned int *SA, unsigned int n,
                  unsigned int alphabet_size) {
  unsigned int n0 = (n + 2) / 3;
  unsigned int n1 = (n + 1) / 3;
  unsigned int n2 = (n + 0) / 3;
  unsigned int n02 = n0 + n2;
  unsigned int s12[n02 + 3];
  s12[n02] = 0;
  s12[n02 + 1] = 0;
  s12[n02 + 2] = 0;
  unsigned int SA12[n02 + 3];
  SA12[n02] = 0;
  SA12[n02 + 1] = 0;
  SA12[n02 + 2] = 0;
  unsigned int s0[n0];
  unsigned int SA0[n0];
  unsigned int limit = (n % 3 == 1) ? n + 1 : n;
  for (unsigned int i = 0, j = 0; i < limit; i++)
    if (i % 3 != 0)
      s12[j++] = i;
  pass1(s12, SA12, s + 2, n02, alphabet_size);
  pass1(SA12, s12, s + 1, n02, alphabet_size);
  pass1(s12, SA12, s, n02, alphabet_size);
  unsigned int name = 0, c0 = -1, c1 = -1, c2 = -1;
  for (unsigned int i = 0; i < n02; i++) {
    if (s[SA12[i]] != c0 || s[SA12[i] + 1] != c1 || s[SA12[i] + 2] != c2) {
      name++;
      c0 = s[SA12[i]];
      c1 = s[SA12[i] + 1];
      c2 = s[SA12[i] + 2];
    }
    unsigned int pos = SA12[i] / 3;
    if (SA12[i] % 3 == 2)
      pos += n0;
    s12[pos] = name;
  }
  if (name >= n02) {
    for (unsigned int i = 0; i < n02; i++)
      SA12[s12[i] - 1] = i;
  } else {
    suffix_array(s12, SA12, n02, name);
    for (unsigned int i = 0; i < n02; i++)
      s12[SA12[i]] = i + 1;
  }
  for (unsigned int i = 0, j = 0; i < n02; i++)
    if (SA12[i] < n0)
      s0[j++] = 3 * SA12[i];
  pass1(s0, SA0, s, n0, alphabet_size);
  for (unsigned int p = 0, t = n0 - n1, k = 0; k < n; k++) {
    unsigned int i = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
    unsigned int j = SA0[p];
    if (SA12[t] < n0 ? cmp2(s[i], s12[SA12[t] + n0], s[j], s12[j / 3])
                     : cmp3(s[i], s[i + 1], s12[SA12[t] - n0 + 1], s[j],
                            s[j + 1], s12[j / 3 + n0])) {
      SA[k] = i;
      t++;
      if (t == n02)
        for (k++; p < n0; p++, k++)
          SA[k] = SA0[p];
    } else {
      SA[k] = j;
      p++;
      if (p == n0)
        for (k++; t < n02; t++, k++)
          SA[k] = (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2);
    }
  }
}


x86 assembly (clang, -O0):
<suffix_array>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0x2,%eax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x21,%rax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
imul   %rcx,%rax
shr    $0x21,%rax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
imul   %rcx,%rax
shr    $0x21,%rax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x3,%eax
mov    %eax,%ecx
mov    %rsp,%rax
mov    %rax,-0x30(%rbp)
lea    0xf(,%rcx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0xb8(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x38(%rbp)
mov    -0x28(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x3,%eax
mov    %eax,%ecx
lea    0xf(,%rcx,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0xb0(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x40(%rbp)
mov    -0x28(%rbp),%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x28(%rbp),%ecx
add    $0x2,%ecx
movl   $0x0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xa8(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x48(%rbp)
mov    -0x1c(%rbp),%eax
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0xa0(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x3,%ecx
xor    %edx,%edx
div    %ecx
cmp    $0x1,%edx
jne    12a4 <suffix_array+0x164>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    12ad <suffix_array+0x16d>
mov    -0x14(%rbp),%eax
mov    %eax,-0xbc(%rbp)
mov    -0xbc(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x54(%rbp),%eax
jae    1312 <suffix_array+0x1d2>
mov    -0x58(%rbp),%eax
mov    $0x3,%ecx
xor    %edx,%edx
div    %ecx
cmp    $0x0,%edx
je     12ff <suffix_array+0x1bf>
mov    -0xb8(%rbp),%rax
mov    -0x58(%rbp),%edx
mov    -0x5c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x5c(%rbp)
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
jmp    1304 <suffix_array+0x1c4>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    12c4 <suffix_array+0x184>
mov    -0xb0(%rbp),%rsi
mov    -0xb8(%rbp),%rdi
mov    -0x8(%rbp),%rdx
add    $0x8,%rdx
mov    -0x28(%rbp),%ecx
mov    -0x18(%rbp),%r8d
call   1060 <pass1@plt>
mov    -0xb8(%rbp),%rsi
mov    -0xb0(%rbp),%rdi
mov    -0x8(%rbp),%rdx
add    $0x4,%rdx
mov    -0x28(%rbp),%ecx
mov    -0x18(%rbp),%r8d
call   1060 <pass1@plt>
mov    -0xb8(%rbp),%rdi
mov    -0xb0(%rbp),%rsi
mov    -0x8(%rbp),%rdx
mov    -0x28(%rbp),%ecx
mov    -0x18(%rbp),%r8d
call   1060 <pass1@plt>
movl   $0x0,-0x60(%rbp)
movl   $0xffffffff,-0x64(%rbp)
movl   $0xffffffff,-0x68(%rbp)
movl   $0xffffffff,-0x6c(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    14af <suffix_array+0x36f>
mov    -0xb0(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%edx
mov    (%rcx,%rdx,4),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x64(%rbp),%eax
jne    1404 <suffix_array+0x2c4>
mov    -0xb0(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%edx
mov    (%rcx,%rdx,4),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x68(%rbp),%eax
jne    1404 <suffix_array+0x2c4>
mov    -0xb0(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%edx
mov    (%rcx,%rdx,4),%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x6c(%rbp),%eax
je     144e <suffix_array+0x30e>
mov    -0xb0(%rbp),%rcx
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%edx
mov    (%rcx,%rdx,4),%edx
mov    (%rax,%rdx,4),%eax
mov    %eax,-0x64(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%edx
mov    (%rcx,%rdx,4),%edx
add    $0x1,%edx
mov    %edx,%edx
mov    (%rax,%rdx,4),%eax
mov    %eax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x70(%rbp),%edx
mov    (%rcx,%rdx,4),%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    -0xb0(%rbp),%rax
mov    -0x70(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    $0x3,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
mov    -0xb0(%rbp),%rax
mov    %ecx,-0x74(%rbp)
mov    -0x70(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    $0x3,%ecx
xor    %edx,%edx
div    %ecx
cmp    $0x2,%edx
jne    1491 <suffix_array+0x351>
mov    -0x1c(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0xb8(%rbp),%rax
mov    -0x60(%rbp),%edx
mov    -0x74(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1397 <suffix_array+0x257>
mov    -0x60(%rbp),%eax
cmp    -0x28(%rbp),%eax
jb     1500 <suffix_array+0x3c0>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    14fb <suffix_array+0x3bb>
mov    -0xb0(%rbp),%rax
mov    -0xb8(%rbp),%rcx
mov    -0x78(%rbp),%edx
mov    -0x78(%rbp),%esi
mov    (%rcx,%rsi,4),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14c2 <suffix_array+0x382>
jmp    155c <suffix_array+0x41c>
mov    -0xb0(%rbp),%rsi
mov    -0xb8(%rbp),%rdi
mov    -0x28(%rbp),%edx
mov    -0x60(%rbp),%ecx
call   1040 <suffix_array@plt>
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    1557 <suffix_array+0x417>
mov    -0xb8(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    -0x7c(%rbp),%edx
add    $0x1,%edx
mov    -0x7c(%rbp),%esi
mov    (%rcx,%rsi,4),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    1520 <suffix_array+0x3e0>
jmp    155c <suffix_array+0x41c>
movl   $0x0,-0x80(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0x80(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    15cd <suffix_array+0x48d>
mov    -0xb0(%rbp),%rax
mov    -0x80(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jae    15ba <suffix_array+0x47a>
mov    -0xa8(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    -0x80(%rbp),%edx
imul   $0x3,(%rcx,%rdx,4),%edx
mov    -0x84(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x84(%rbp)
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
jmp    15bf <suffix_array+0x47f>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    156d <suffix_array+0x42d>
mov    -0xa0(%rbp),%rsi
mov    -0xa8(%rbp),%rdi
mov    -0x8(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%r8d
call   1060 <pass1@plt>
movl   $0x0,-0x88(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x20(%rbp),%eax
mov    %eax,-0x8c(%rbp)
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    195c <suffix_array+0x81c>
mov    -0xb0(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jae    1652 <suffix_array+0x512>
mov    -0xb0(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   $0x3,(%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1671 <suffix_array+0x531>
mov    -0xb0(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
sub    -0x1c(%rbp),%eax
imul   $0x3,%eax,%eax
add    $0x2,%eax
mov    %eax,-0xc0(%rbp)
mov    -0xb0(%rbp),%rax
mov    -0xa0(%rbp),%rcx
mov    -0xc0(%rbp),%edx
mov    %edx,-0x94(%rbp)
mov    -0x88(%rbp),%edx
mov    (%rcx,%rdx,4),%ecx
mov    %ecx,-0x98(%rbp)
mov    -0x8c(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jae    1722 <suffix_array+0x5e2>
mov    -0xb8(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x94(%rbp),%esi
mov    (%rdx,%rsi,4),%edi
mov    -0x8c(%rbp),%edx
mov    (%rcx,%rdx,4),%ecx
add    -0x1c(%rbp),%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%esi
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc4(%rbp)
mov    -0x98(%rbp),%eax
mov    $0x3,%ecx
xor    %edx,%edx
div    %ecx
mov    -0xc4(%rbp),%edx
mov    %eax,%ecx
mov    -0xb8(%rbp),%rax
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%ecx
call   1050 <cmp2@plt>
cmp    $0x0,%rax
jne    17c4 <suffix_array+0x684>
jmp    185d <suffix_array+0x71d>
mov    -0xb8(%rbp),%rax
mov    -0xb0(%rbp),%rcx
mov    -0x8(%rbp),%rdx
mov    -0x94(%rbp),%esi
mov    (%rdx,%rsi,4),%edi
mov    -0x8(%rbp),%rdx
mov    -0x94(%rbp),%esi
add    $0x1,%esi
mov    %esi,%esi
mov    (%rdx,%rsi,4),%esi
mov    -0x8c(%rbp),%edx
mov    (%rcx,%rdx,4),%ecx
sub    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc8(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%ecx
mov    (%rax,%rcx,4),%ecx
mov    -0x8(%rbp),%rax
mov    -0x98(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
mov    (%rax,%rdx,4),%r8d
mov    -0x98(%rbp),%eax
mov    $0x3,%r9d
xor    %edx,%edx
div    %r9d
mov    -0xc8(%rbp),%edx
mov    %eax,%r9d
mov    -0xb8(%rbp),%rax
add    -0x1c(%rbp),%r9d
mov    %r9d,%r9d
mov    (%rax,%r9,4),%r9d
call   1030 <cmp3@plt>
cmp    $0x0,%rax
je     185d <suffix_array+0x71d>
mov    -0x94(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jne    1858 <suffix_array+0x718>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1853 <suffix_array+0x713>
mov    -0xa0(%rbp),%rax
mov    -0x88(%rbp),%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    1804 <suffix_array+0x6c4>
jmp    1858 <suffix_array+0x718>
jmp    1943 <suffix_array+0x803>
mov    -0x98(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jne    193e <suffix_array+0x7fe>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
mov    -0x8c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    1939 <suffix_array+0x7f9>
mov    -0xb0(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x1c(%rbp),%eax
jae    18e4 <suffix_array+0x7a4>
mov    -0xb0(%rbp),%rax
mov    -0x8c(%rbp),%ecx
imul   $0x3,(%rax,%rcx,4),%eax
add    $0x1,%eax
mov    %eax,-0xcc(%rbp)
jmp    1903 <suffix_array+0x7c3>
mov    -0xb0(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
sub    -0x1c(%rbp),%eax
imul   $0x3,%eax,%eax
add    $0x2,%eax
mov    %eax,-0xcc(%rbp)
mov    -0xcc(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x90(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    189d <suffix_array+0x75d>
jmp    193e <suffix_array+0x7fe>
jmp    1943 <suffix_array+0x803>
jmp    1948 <suffix_array+0x808>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    160b <suffix_array+0x4cb>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<suffix_array>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %ecx,%r10d
mov    %rsi,%r12
mov    %rdi,%r14
lea    0x2(%rdx),%r13d
mov    $0xaaaaaaab,%ecx
mov    %r13,-0x58(%rbp)
imul   %rcx,%r13
shr    $0x21,%r13
lea    0x1(%rdx),%r9d
mov    %edx,%eax
mov    %rax,-0x50(%rbp)
imul   %rcx,%rax
shr    $0x21,%rax
mov    %rax,-0x78(%rbp)
lea    (%rax,%r13,1),%ebx
lea    0x1b(,%rbx,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rdi
sub    %rax,%rdi
mov    %rdi,%rsp
movq   $0x0,(%rdi,%rbx,4)
movl   $0x0,0x8(%rdi,%rbx,4)
mov    %rsp,%rsi
sub    %rax,%rsi
mov    %rsi,%rsp
movq   $0x0,(%rsi,%rbx,4)
movl   $0x0,0x8(%rsi,%rbx,4)
lea    0xf(,%r13,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x38(%rbp)
mov    %rcx,%rsp
imul   $0xaaaaaaab,%edx,%eax
add    $0x55555555,%eax
cmp    $0x55555555,%eax
mov    %rdx,-0xa0(%rbp)
mov    %edx,%r8d
mov    %r9,-0x70(%rbp)
cmovb  %r9d,%r8d
test   %r8d,%r8d
mov    %rbx,-0x40(%rbp)
mov    %r10d,-0x2c(%rbp)
je     125d <suffix_array+0x11d>
xor    %eax,%eax
mov    $0x0,%r11d
cmp    $0x1,%r8d
jne    13a5 <suffix_array+0x265>
test   $0x1,%r8b
mov    -0x40(%rbp),%rbx
mov    -0x2c(%rbp),%r10d
je     125d <suffix_array+0x11d>
mov    %eax,%ecx
mov    $0xaaaaaaab,%edx
imul   %rcx,%rdx
shr    $0x21,%rdx
lea    (%rdx,%rdx,2),%ecx
mov    %eax,%edx
sub    %ecx,%edx
je     125d <suffix_array+0x11d>
mov    %r11d,%ecx
mov    %eax,(%rdi,%rcx,4)
lea    0x8(%r14),%rdx
mov    %ebx,%ecx
mov    %r10d,%r8d
mov    %rsi,-0x68(%rbp)
mov    %rdi,%r15
call   1060 <pass1@plt>
lea    0x4(%r14),%rdx
mov    -0x68(%rbp),%rdi
mov    %r15,%rsi
mov    %ebx,%ecx
mov    -0x2c(%rbp),%r8d
call   1060 <pass1@plt>
mov    %r15,-0x48(%rbp)
mov    %r15,%rdi
mov    -0x68(%rbp),%r15
mov    %r15,%rsi
mov    %r14,%rdx
mov    %ebx,%ecx
mov    -0x2c(%rbp),%r8d
call   1060 <pass1@plt>
mov    -0x2c(%rbp),%r8d
test   %ebx,%ebx
mov    -0x38(%rbp),%r9
je     15a5 <suffix_array+0x465>
xor    %eax,%eax
mov    $0xffffffff,%r9d
mov    $0xaaaaaaab,%r8d
mov    $0xffffffff,%r10d
mov    $0xffffffff,%r11d
xor    %ecx,%ecx
jmp    132c <suffix_array+0x1ec>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%ecx
mov    (%r14,%rdi,4),%r10d
lea    0x2(%rdx),%esi
mov    (%r14,%rsi,4),%r9d
mov    %ebx,%r11d
mov    %edx,%esi
imul   %r8,%rsi
shr    $0x21,%rsi
imul   $0xaaaaaaab,%edx,%edx
add    $0xaaaaaaaa,%edx
cmp    $0x55555555,%edx
mov    $0x0,%edx
cmovb  %r13d,%edx
add    %esi,%edx
mov    -0x48(%rbp),%rsi
mov    %ecx,(%rsi,%rdx,4)
add    $0x1,%rax
mov    -0x40(%rbp),%rbx
cmp    %rax,%rbx
je     134d <suffix_array+0x20d>
mov    (%r15,%rax,4),%edx
mov    (%r14,%rdx,4),%ebx
lea    0x1(%rdx),%edi
cmp    %r11d,%ebx
jne    12e0 <suffix_array+0x1a0>
cmp    %r10d,(%r14,%rdi,4)
jne    12e0 <suffix_array+0x1a0>
lea    0x2(%rdx),%esi
cmp    %r9d,(%r14,%rsi,4)
jne    12e0 <suffix_array+0x1a0>
jmp    12f1 <suffix_array+0x1b1>
cmp    %ebx,%ecx
jae    1421 <suffix_array+0x2e1>
mov    -0x48(%rbp),%rdi
mov    %r15,%rsi
mov    %ebx,%edx
call   1040 <suffix_array@plt>
mov    $0xaaaaaaab,%eax
mov    -0x50(%rbp),%rcx
imul   %rax,%rcx
shr    $0x21,%rcx
mov    -0x58(%rbp),%edx
imul   %rax,%rdx
shr    $0x21,%rdx
add    %ecx,%edx
add    $0xffffffffffffffff,%rdx
mov    %ebx,%r8d
and    $0x3,%r8d
cmp    $0x3,%rdx
jae    146d <suffix_array+0x32d>
xor    %ecx,%ecx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%r9
jmp    14b1 <suffix_array+0x371>
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
xor    %eax,%eax
mov    $0xffffffff,%r15d
mov    $0x1,%ebx
mov    $0xaaaaaaab,%r9d
xor    %r11d,%r11d
jmp    13e3 <suffix_array+0x2a3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x2,%eax
add    $0xfffffffe,%r15d
add    $0x2,%ebx
cmp    %eax,%r10d
je     1231 <suffix_array+0xf1>
mov    %ebx,%ecx
imul   %r9,%rcx
shr    $0x21,%rcx
lea    (%rcx,%rcx,2),%ecx
add    %r15d,%ecx
mov    %eax,%edx
imul   %r9,%rdx
shr    $0x21,%rdx
lea    (%rdx,%rdx,2),%edx
cmp    %eax,%edx
je     140e <suffix_array+0x2ce>
mov    %r11d,%edx
add    $0x1,%r11d
mov    %eax,(%rdi,%rdx,4)
test   %ecx,%ecx
je     13d0 <suffix_array+0x290>
lea    0x1(%rax),%ecx
mov    %r11d,%edx
add    $0x1,%r11d
mov    %ecx,(%rdi,%rdx,4)
jmp    13d0 <suffix_array+0x290>
test   %ebx,%ebx
mov    -0x38(%rbp),%r9
mov    -0x2c(%rbp),%r8d
je     15a5 <suffix_array+0x465>
mov    $0xaaaaaaab,%eax
mov    -0x50(%rbp),%rcx
imul   %rax,%rcx
shr    $0x21,%rcx
mov    -0x58(%rbp),%edx
imul   %rax,%rdx
shr    $0x21,%rdx
add    %ecx,%edx
add    $0xffffffffffffffff,%rdx
mov    %ebx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    14e4 <suffix_array+0x3a4>
xor    %ecx,%ecx
mov    -0x48(%rbp),%rbx
jmp    152d <suffix_array+0x3ed>
mov    %ebx,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
mov    -0x48(%rbp),%rax
mov    -0x38(%rbp),%r9
nopl   0x0(%rax)
mov    (%r15,%rcx,4),%esi
lea    0x1(%rcx),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x4(%r15,%rcx,4),%esi
lea    0x2(%rcx),%edi
mov    %edi,(%rax,%rsi,4)
mov    0x8(%r15,%rcx,4),%esi
lea    0x3(%rcx),%edi
mov    %edi,(%rax,%rsi,4)
mov    0xc(%r15,%rcx,4),%esi
add    $0x4,%rcx
mov    %ecx,(%rax,%rsi,4)
cmp    %rcx,%rdx
jne    1480 <suffix_array+0x340>
test   %r8,%r8
je     1554 <suffix_array+0x414>
lea    (%r15,%rcx,4),%rdx
add    $0x1,%ecx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rdx,%rsi,4),%edi
lea    (%rcx,%rsi,1),%ebx
mov    %ebx,(%rax,%rdi,4)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    14d0 <suffix_array+0x390>
jmp    1554 <suffix_array+0x414>
mov    %ebx,%edx
and    $0xfffffffc,%edx
xor    %ecx,%ecx
mov    -0x48(%rbp),%rbx
nop
mov    (%rbx,%rcx,4),%esi
add    $0xffffffff,%esi
mov    %ecx,(%r15,%rsi,4)
mov    0x4(%rbx,%rcx,4),%esi
add    $0xffffffff,%esi
lea    0x1(%rcx),%edi
mov    %edi,(%r15,%rsi,4)
mov    0x8(%rbx,%rcx,4),%esi
add    $0xffffffff,%esi
lea    0x2(%rcx),%edi
mov    %edi,(%r15,%rsi,4)
mov    0xc(%rbx,%rcx,4),%esi
add    $0xffffffff,%esi
lea    0x3(%rcx),%edi
mov    %edi,(%r15,%rsi,4)
add    $0x4,%rcx
cmp    %rdx,%rcx
jne    14f0 <suffix_array+0x3b0>
test   %rax,%rax
je     1554 <suffix_array+0x414>
shl    $0x2,%rax
cs nopw 0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%edx
add    $0xffffffff,%edx
mov    %ecx,(%r15,%rdx,4)
add    $0x1,%rcx
add    $0xfffffffffffffffc,%rax
jne    1540 <suffix_array+0x400>
mov    -0x40(%rbp),%rbx
test   %ebx,%ebx
mov    -0x2c(%rbp),%r8d
je     15a5 <suffix_array+0x465>
mov    $0xaaaaaaab,%eax
mov    -0x50(%rbp),%rcx
imul   %rax,%rcx
shr    $0x21,%rcx
mov    -0x58(%rbp),%edx
imul   %rax,%rdx
shr    $0x21,%rdx
add    %ecx,%edx
cmp    $0x1,%edx
jne    1b9e <suffix_array+0xa5e>
xor    %ecx,%ecx
xor    %eax,%eax
test   $0x1,%bl
je     15a5 <suffix_array+0x465>
mov    (%r15,%rcx,4),%ecx
cmp    %r13d,%ecx
jae    15a5 <suffix_array+0x465>
lea    (%rcx,%rcx,2),%ecx
mov    %eax,%eax
mov    -0x60(%rbp),%rdx
mov    %ecx,(%rdx,%rax,4)
mov    -0x60(%rbp),%rdi
mov    %r9,%rsi
mov    %r14,-0x98(%rbp)
mov    %r14,%rdx
mov    %r13d,%ecx
call   1060 <pass1@plt>
mov    -0x38(%rbp),%rbx
cmpl   $0x0,-0xa0(%rbp)
mov    -0x48(%rbp),%r11
je     1b8f <suffix_array+0xa4f>
mov    $0xaaaaaaab,%eax
mov    -0x70(%rbp),%rcx
imul   %rax,%rcx
shr    $0x21,%rcx
mov    %r13d,%edx
sub    %ecx,%edx
mov    $0x1,%eax
sub    %r13d,%eax
mov    %eax,-0x84(%rbp)
mov    $0xaaaaaaab,%eax
mov    -0x50(%rbp),%r15
imul   %rax,%r15
shr    $0x21,%r15
lea    (%r15,%r13,1),%eax
mov    %rax,-0xb8(%rbp)
mov    -0x78(%rbp),%rax
add    %r13d,%eax
mov    %rax,-0x78(%rbp)
movd   %r13d,%xmm0
pshufd $0x0,%xmm0,%xmm3
lea    0x30(%rbx),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x68(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0xa8(%rbp)
add    %r13,%r15
mov    %r15,-0x50(%rbp)
movdqa 0x9af(%rip),%xmm0
movdqa %xmm3,%xmm5
por    %xmm0,%xmm5
xor    %r14d,%r14d
xor    %esi,%esi
mov    %r13,-0x80(%rbp)
mov    %r12,-0x90(%rbp)
movdqa %xmm3,-0xe0(%rbp)
ff
movdqa %xmm5,-0xd0(%rbp)
ff
jmp    1699 <suffix_array+0x559>
nopl   0x0(%rax,%rax,1)
mov    -0x80(%rbp),%r13
mov    -0x38(%rbp),%rbx
add    $0x1,%r14d
cmp    -0xa0(%rbp),%r14d
jae    1b8f <suffix_array+0xa4f>
mov    %edx,-0x2c(%rbp)
mov    %edx,%ecx
mov    -0x68(%rbp),%rax
mov    %rcx,-0x70(%rbp)
mov    (%rax,%rcx,4),%eax
mov    %eax,%ecx
mov    %r14d,%edx
mov    %rdx,-0x58(%rbp)
mov    %esi,-0x60(%rbp)
mov    %esi,%r15d
sub    %r13d,%ecx
mov    %r13,%r9
jae    1850 <suffix_array+0x710>
lea    (%rax,%rax,2),%r12d
add    $0x1,%r12d
mov    (%rbx,%r15,4),%r13d
mov    -0x98(%rbp),%rcx
mov    (%rcx,%r12,4),%edi
add    %r9d,%eax
mov    (%r11,%rax,4),%esi
mov    (%rcx,%r13,4),%edx
mov    %r13,%rax
mov    $0xaaaaaaab,%ecx
imul   %rcx,%rax
shr    $0x21,%rax
mov    (%r11,%rax,4),%ecx
call   1050 <cmp2@plt>
test   %rax,%rax
je     18ab <suffix_array+0x76b>
mov    -0x90(%rbp),%rax
mov    -0x58(%rbp),%rcx
mov    %r12d,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
mov    -0x40(%rbp),%rcx
cmp    %ecx,%edx
mov    -0x48(%rbp),%r11
mov    -0x60(%rbp),%esi
jne    1680 <suffix_array+0x540>
mov    %rax,%r12
lea    0x1(%r14),%eax
mov    -0x80(%rbp),%r13
cmp    %r13d,%esi
jae    1839 <suffix_array+0x6f9>
mov    %r13,%r10
sub    %r15,%r10
cmp    $0x8,%r10
jb     1a1f <suffix_array+0x8df>
mov    %r15,%rdx
not    %rdx
add    %r13,%rdx
mov    $0xfffffffe,%esi
sub    %r14d,%esi
cmp    %edx,%esi
jb     1a1f <suffix_array+0x8df>
shr    $0x20,%rdx
jne    1a1f <suffix_array+0x8df>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1abb <suffix_array+0x97b>
mov    %r9,%rsi
and    $0xfffffffffffffffe,%rsi
mov    -0xb0(%rbp),%rcx
lea    (%rcx,%r15,4),%rdx
lea    0x9(%r14),%ebx
add    $0x1,%r14d
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%r14,%rdi,1),%ecx
movups -0x30(%rdx,%rdi,4),%xmm0
movups -0x20(%rdx,%rdi,4),%xmm1
movups %xmm0,(%r12,%rcx,4)
movups %xmm1,0x10(%r12,%rcx,4)
lea    (%rbx,%rdi,1),%ecx
movdqu -0x10(%rdx,%rdi,4),%xmm0
movdqu (%rdx,%rdi,4),%xmm1
movdqu %xmm0,(%r12,%rcx,4)
movdqu %xmm1,0x10(%r12,%rcx,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    17c0 <suffix_array+0x680>
test   $0x1,%r9b
je     1826 <suffix_array+0x6e6>
lea    (%rdi,%r15,1),%rcx
add    %eax,%edi
mov    -0x38(%rbp),%rdx
movdqu (%rdx,%rcx,4),%xmm0
movdqu 0x10(%rdx,%rcx,4),%xmm1
movdqu %xmm0,(%r12,%rdi,4)
movdqu %xmm1,0x10(%r12,%rdi,4)
add    %r8d,%eax
cmp    %r8,%r10
mov    -0x40(%rbp),%rcx
jne    1a1c <suffix_array+0x8dc>
mov    %r13d,%esi
mov    %ecx,%edx
mov    %eax,%r14d
jmp    1684 <suffix_array+0x544>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rcx,%rcx,2),%r12d
add    $0x2,%r12d
mov    (%rbx,%r15,4),%r13d
mov    -0x98(%rbp),%rbx
mov    (%rbx,%r12,4),%edi
lea    (%rcx,%rcx,2),%ecx
add    $0x3,%ecx
mov    (%rbx,%rcx,4),%esi
add    -0x84(%rbp),%eax
mov    (%r11,%rax,4),%edx
mov    (%rbx,%r13,4),%ecx
lea    0x1(%r13),%eax
mov    (%rbx,%rax,4),%r8d
mov    %r13,%rax
mov    $0xaaaaaaab,%ebx
imul   %rbx,%rax
shr    $0x21,%rax
add    %r9d,%eax
mov    (%r11,%rax,4),%r9d
call   1030 <cmp3@plt>
test   %rax,%rax
jne    1708 <suffix_array+0x5c8>
mov    -0x90(%rbp),%r12
mov    -0x58(%rbp),%rax
mov    %r13d,(%r12,%rax,4)
mov    -0x60(%rbp),%esi
add    $0x1,%esi
mov    -0x80(%rbp),%r13
cmp    %r13d,%esi
mov    -0x48(%rbp),%r11
movdqa -0xe0(%rbp),%xmm3
ff
movdqa 0x725(%rip),%xmm4
movdqa -0xd0(%rbp),%xmm5
ff
movdqa 0x725(%rip),%xmm6
mov    -0x2c(%rbp),%edx
jne    1684 <suffix_array+0x544>
lea    0x1(%r14),%r10d
cmp    -0x40(%rbp),%edx
jae    1a11 <suffix_array+0x8d1>
mov    -0x78(%rbp),%rcx
mov    -0x70(%rbp),%rbx
sub    %rbx,%rcx
cmp    $0x4,%rcx
mov    -0x68(%rbp),%r15
jb     1b3b <suffix_array+0x9fb>
mov    %rbx,%rdx
not    %rdx
add    -0xb8(%rbp),%rdx
mov    $0xfffffffe,%esi
sub    %r14d,%esi
cmp    %edx,%esi
jb     1b3b <suffix_array+0x9fb>
shr    $0x20,%rdx
jne    1b3b <suffix_array+0x9fb>
mov    %rcx,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rdx
mov    %rdx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1acc <suffix_array+0x98c>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
mov    -0xa8(%rbp),%rax
lea    (%rax,%rbx,4),%rdx
lea    0x5(%r14),%ebx
add    $0x1,%r14d
xor    %esi,%esi
nopl   0x0(%rax)
lea    (%r14,%rsi,1),%eax
movdqu -0x10(%rdx,%rsi,4),%xmm0
movdqa %xmm0,%xmm1
pxor   %xmm4,%xmm1
movdqa %xmm5,%xmm2
pcmpgtd %xmm1,%xmm2
movdqa %xmm2,%xmm1
pandn  %xmm6,%xmm1
psubd  %xmm2,%xmm1
pandn  %xmm3,%xmm2
psubd  %xmm2,%xmm0
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm0
paddd  %xmm0,%xmm1
movdqu %xmm1,(%r12,%rax,4)
lea    (%rbx,%rsi,1),%eax
movdqu (%rdx,%rsi,4),%xmm0
movdqa %xmm0,%xmm1
pxor   %xmm4,%xmm1
movdqa %xmm5,%xmm2
pcmpgtd %xmm1,%xmm2
movdqa %xmm2,%xmm1
pandn  %xmm6,%xmm1
psubd  %xmm2,%xmm1
pandn  %xmm3,%xmm2
psubd  %xmm2,%xmm0
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm0
paddd  %xmm0,%xmm1
movdqu %xmm1,(%r12,%rax,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1980 <suffix_array+0x840>
jmp    1ace <suffix_array+0x98e>
mov    %r13d,%esi
mov    %r10d,%r14d
jmp    1684 <suffix_array+0x544>
add    %r8,%r15
mov    -0x38(%rbp),%rbx
mov    %r13d,%edx
sub    %r15d,%edx
mov    %r15,%rcx
not    %rcx
add    %r13,%rcx
and    $0x3,%rdx
je     1a57 <suffix_array+0x917>
shl    $0x2,%rdx
nopl   0x0(%rax)
mov    (%rbx,%r15,4),%esi
mov    %eax,%edi
mov    %esi,(%r12,%rdi,4)
add    $0x1,%r15
add    $0x1,%eax
add    $0xfffffffffffffffc,%rdx
jne    1a40 <suffix_array+0x900>
mov    %r13d,%esi
mov    -0x40(%rbp),%rdx
mov    %eax,%r14d
cmp    $0x3,%rcx
jb     1688 <suffix_array+0x548>
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%r15,4),%ecx
mov    %eax,%edx
mov    %ecx,(%r12,%rdx,4)
lea    0x1(%rax),%ecx
mov    0x4(%rbx,%r15,4),%edx
mov    %edx,(%r12,%rcx,4)
lea    0x2(%rax),%ecx
mov    0x8(%rbx,%r15,4),%edx
mov    %edx,(%r12,%rcx,4)
lea    0x3(%rax),%ecx
mov    0xc(%rbx,%r15,4),%edx
mov    %edx,(%r12,%rcx,4)
add    $0x4,%r15
add    $0x4,%eax
cmp    %r15,%r13
jne    1a70 <suffix_array+0x930>
mov    %r13d,%esi
mov    -0x40(%rbp),%rcx
mov    %ecx,%edx
mov    %eax,%r14d
jmp    1688 <suffix_array+0x548>
xor    %edi,%edi
test   $0x1,%r9b
jne    1804 <suffix_array+0x6c4>
jmp    1826 <suffix_array+0x6e6>
xor    %esi,%esi
test   $0x1,%r9b
mov    -0x70(%rbp),%rbx
je     1b1f <suffix_array+0x9df>
lea    (%rsi,%rbx,1),%rax
add    %r10d,%esi
movdqu (%r15,%rax,4),%xmm0
movdqa %xmm0,%xmm1
pxor   %xmm4,%xmm1
movdqa %xmm5,%xmm2
pcmpgtd %xmm1,%xmm2
movdqa %xmm2,%xmm1
pandn  %xmm6,%xmm1
psubd  %xmm2,%xmm1
pandn  %xmm3,%xmm2
psubd  %xmm2,%xmm0
movdqa %xmm0,%xmm2
paddd  %xmm0,%xmm2
paddd  %xmm0,%xmm2
paddd  %xmm1,%xmm2
movdqu %xmm2,(%r12,%rsi,4)
add    %r8d,%r10d
cmp    %r8,%rcx
jne    1b38 <suffix_array+0x9f8>
mov    %r13d,%esi
mov    -0x40(%rbp),%rax
mov    %eax,%edx
mov    %r10d,%r14d
jmp    1684 <suffix_array+0x544>
add    %r8,%rbx
lea    (%r15,%rbx,4),%rcx
mov    -0x50(%rbp),%rdx
sub    %rbx,%rdx
mov    %r10d,%r14d
xor    %eax,%eax
xor    %r8d,%r8d
xchg   %ax,%ax
mov    (%rcx,%rax,4),%esi
cmp    %r13d,%esi
mov    %r13d,%edi
cmovb  %r8d,%edi
mov    %esi,%ebx
sub    %edi,%ebx
cmp    %r13d,%esi
lea    (%rbx,%rbx,2),%esi
sbb    $0x0,%esi
lea    (%r14,%rax,1),%edi
add    $0x2,%esi
mov    %esi,(%r12,%rdi,4)
add    $0x1,%rax
cmp    %rax,%rdx
jne    1b50 <suffix_array+0xa10>
add    %eax,%r14d
mov    %r13d,%esi
mov    -0x40(%rbp),%rax
mov    %eax,%edx
jmp    1684 <suffix_array+0x544>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %ebx,%r10d
and    $0xfffffffe,%r10d
xor    %ecx,%ecx
xor    %eax,%eax
mov    -0x60(%rbp),%rdx
jmp    1bbd <suffix_array+0xa7d>
nop
add    $0x2,%rcx
cmp    %rcx,%r10
je     158b <suffix_array+0x44b>
mov    (%r15,%rcx,4),%esi
cmp    %r13d,%esi
jae    1bd1 <suffix_array+0xa91>
lea    (%rsi,%rsi,2),%esi
mov    %eax,%edi
add    $0x1,%eax
mov    %esi,(%rdx,%rdi,4)
mov    0x4(%r15,%rcx,4),%esi
cmp    %r13d,%esi
jae    1bb0 <suffix_array+0xa70>
lea    (%rsi,%rsi,2),%esi
mov    %eax,%edi
add    $0x1,%eax
mov    %esi,(%rdx,%rdi,4)
jmp    1bb0 <suffix_array+0xa70>

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

LLVM IR (-O2):
define void @suffix_array(i32* %0, i32* nocapture writeonly %1, i32 %2, i32 %3) {
%5 = add i32 %2, 2
%6 = udiv i32 %5, 3
%7 = add i32 %2, 1
%8 = udiv i32 %7, 3
%9 = udiv i32 %2, 3
%10 = add nuw i32 %6, %9
%11 = add nuw i32 %10, 3
%12 = zext i32 %11 to i64
%13 = alloca i32, i64 %12
%14 = zext i32 %10 to i64
%15 = getelementptr inbounds i32, i32* %13, i64 %14
store i32 0, i32* %15
%16 = add nuw i32 %10, 1
%17 = zext i32 %16 to i64
%18 = getelementptr inbounds i32, i32* %13, i64 %17
store i32 0, i32* %18
%19 = add nuw i32 %10, 2
%20 = zext i32 %19 to i64
%21 = getelementptr inbounds i32, i32* %13, i64 %20
store i32 0, i32* %21
%22 = alloca i32, i64 %12
%23 = getelementptr inbounds i32, i32* %22, i64 %14
store i32 0, i32* %23
%24 = getelementptr inbounds i32, i32* %22, i64 %17
store i32 0, i32* %24
%25 = getelementptr inbounds i32, i32* %22, i64 %20
store i32 0, i32* %25
%26 = zext i32 %6 to i64
%27 = alloca i32, i64 %26
%28 = alloca i32, i64 %26
%29 = urem i32 %2, 3
%30 = udiv i32 %2, 3
%31 = icmp eq i32 %29, 1
%32 = select i1 %31, i32 %7, i32 %2
%33 = icmp eq i32 %32, 0
br i1 %33, label %49, label %34
34: ; preds = %4
%35 = and i32 %32, 1
%36 = icmp eq i32 %32, 1
br i1 %36, label %39, label %37
37: ; preds = %34
%38 = and i32 %32, -2
br label %56
39: ; preds = %75, %34
%40 = phi i32 [ 0, %34 ], [ %77, %75 ]
%41 = phi i32 [ 0, %34 ], [ %76, %75 ]
%42 = icmp eq i32 %35, 0
%43 = urem i32 %40, 3
%44 = icmp eq i32 %43, 0
%45 = select i1 %42, i1 true, i1 %44
br i1 %45, label %49, label %46
46: ; preds = %39
%47 = zext i32 %41 to i64
%48 = getelementptr inbounds i32, i32* %13, i64 %47
store i32 %40, i32* %48
br label %49
49: ; preds = %39, %46, %4
%50 = getelementptr inbounds i32, i32* %0, i64 2
%51 = call i32 @pass1(i32* %13, i32* %22, i32* %50, i32 %10, i32 %3)
%52 = getelementptr inbounds i32, i32* %0, i64 1
%53 = call i32 @pass1(i32* %22, i32* %13, i32* %52, i32 %10, i32 %3)
%54 = call i32 @pass1(i32* %13, i32* %22, i32* %0, i32 %10, i32 %3)
%55 = icmp eq i32 %10, 0
br i1 %55, label %261, label %93
56: ; preds = %75, %37
%57 = phi i32 [ 0, %37 ], [ %77, %75 ]
%58 = phi i32 [ 0, %37 ], [ %76, %75 ]
%59 = phi i32 [ 0, %37 ], [ %78, %75 ]
%60 = urem i32 %57, 3
%61 = icmp eq i32 %60, 0
br i1 %61, label %66, label %62
62: ; preds = %56
%63 = add i32 %58, 1
%64 = zext i32 %58 to i64
%65 = getelementptr inbounds i32, i32* %13, i64 %64
store i32 %57, i32* %65
br label %66
66: ; preds = %56, %62
%67 = phi i32 [ %63, %62 ], [ %58, %56 ]
%68 = or i32 %57, 1
%69 = urem i32 %68, 3
%70 = icmp eq i32 %69, 0
br i1 %70, label %75, label %71
71: ; preds = %66
%72 = add i32 %67, 1
%73 = zext i32 %67 to i64
%74 = getelementptr inbounds i32, i32* %13, i64 %73
store i32 %68, i32* %74
br label %75
75: ; preds = %71, %66
%76 = phi i32 [ %72, %71 ], [ %67, %66 ]
%77 = add nuw i32 %57, 2
%78 = add i32 %59, 2
%79 = icmp eq i32 %78, %38
br i1 %79, label %39, label %56
80: ; preds = %125
%81 = icmp ult i32 %126, %10
br i1 %81, label %172, label %82
82: ; preds = %80
br i1 %55, label %261, label %83
83: ; preds = %82
%84 = udiv i32 %2, 3
%85 = udiv i32 %5, 3
%86 = add nuw i32 %84, %85
%87 = zext i32 %86 to i64
%88 = add nsw i64 %87, -1
%89 = and i64 %14, 3
%90 = icmp ult i64 %88, 3
br i1 %90, label %225, label %91
91: ; preds = %83
%92 = and i64 %14, 4294967292
br label %139
93: ; preds = %49, %125
%94 = phi i64 [ %137, %125 ], [ 0, %49 ]
%95 = phi i32 [ %129, %125 ], [ -1, %49 ]
%96 = phi i32 [ %128, %125 ], [ -1, %49 ]
%97 = phi i32 [ %127, %125 ], [ -1, %49 ]
%98 = phi i32 [ %126, %125 ], [ 0, %49 ]
%99 = getelementptr inbounds i32, i32* %22, i64 %94
%100 = load i32, i32* %99
%101 = zext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %0, i64 %101
%103 = load i32, i32* %102
%104 = icmp eq i32 %103, %97
%105 = add i32 %100, 1
%106 = zext i32 %105 to i64
br i1 %104, label %107, label %117
107: ; preds = %93
%108 = getelementptr inbounds i32, i32* %0, i64 %106
%109 = load i32, i32* %108
%110 = icmp eq i32 %109, %96
br i1 %110, label %111, label %117
111: ; preds = %107
%112 = add i32 %100, 2
%113 = zext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %0, i64 %113
%115 = load i32, i32* %114
%116 = icmp eq i32 %115, %95
br i1 %116, label %125, label %117
117: ; preds = %93, %111, %107
%118 = add i32 %98, 1
%119 = getelementptr inbounds i32, i32* %0, i64 %106
%120 = load i32, i32* %119
%121 = add i32 %100, 2
%122 = zext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %0, i64 %122
%124 = load i32, i32* %123
br label %125
125: ; preds = %117, %111
%126 = phi i32 [ %118, %117 ], [ %98, %111 ]
%127 = phi i32 [ %103, %117 ], [ %97, %111 ]
%128 = phi i32 [ %120, %117 ], [ %96, %111 ]
%129 = phi i32 [ %124, %117 ], [ %95, %111 ]
%130 = udiv i32 %100, 3
%131 = urem i32 %100, 3
%132 = icmp eq i32 %131, 2
%133 = select i1 %132, i32 %6, i32 0
%134 = add nuw i32 %133, %130
%135 = zext i32 %134 to i64
%136 = getelementptr inbounds i32, i32* %13, i64 %135
store i32 %126, i32* %136
%137 = add nuw nsw i64 %94, 1
%138 = icmp eq i64 %137, %14
br i1 %138, label %80, label %93
139: ; preds = %139, %91
%140 = phi i64 [ 0, %91 ], [ %169, %139 ]
%141 = phi i64 [ 0, %91 ], [ %170, %139 ]
%142 = getelementptr inbounds i32, i32* %13, i64 %140
%143 = load i32, i32* %142
%144 = add i32 %143, -1
%145 = zext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %22, i64 %145
%147 = trunc i64 %140 to i32
store i32 %147, i32* %146
%148 = or i64 %140, 1
%149 = getelementptr inbounds i32, i32* %13, i64 %148
%150 = load i32, i32* %149
%151 = add i32 %150, -1
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds i32, i32* %22, i64 %152
%154 = trunc i64 %148 to i32
store i32 %154, i32* %153
%155 = or i64 %140, 2
%156 = getelementptr inbounds i32, i32* %13, i64 %155
%157 = load i32, i32* %156
%158 = add i32 %157, -1
%159 = zext i32 %158 to i64
%160 = getelementptr inbounds i32, i32* %22, i64 %159
%161 = trunc i64 %155 to i32
store i32 %161, i32* %160
%162 = or i64 %140, 3
%163 = getelementptr inbounds i32, i32* %13, i64 %162
%164 = load i32, i32* %163
%165 = add i32 %164, -1
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds i32, i32* %22, i64 %166
%168 = trunc i64 %162 to i32
store i32 %168, i32* %167
%169 = add nuw nsw i64 %140, 4
%170 = add i64 %141, 4
%171 = icmp eq i64 %170, %92
br i1 %171, label %225, label %139
172: ; preds = %80
%173 = udiv i32 %2, 3
%174 = udiv i32 %5, 3
%175 = add nuw i32 %173, %174
%176 = zext i32 %175 to i64
%177 = add nsw i64 %176, -1
%178 = and i64 %14, 3
%179 = icmp ult i64 %177, 3
br i1 %179, label %211, label %180
180: ; preds = %172
%181 = and i64 %14, 4294967292
br label %182
182: ; preds = %182, %180
%183 = phi i64 [ 0, %180 ], [ %203, %182 ]
%184 = phi i64 [ 0, %180 ], [ %209, %182 ]
%185 = or i64 %183, 1
%186 = getelementptr inbounds i32, i32* %22, i64 %183
%187 = load i32, i32* %186
%188 = zext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %13, i64 %188
%190 = trunc i64 %185 to i32
store i32 %190, i32* %189
%191 = or i64 %183, 2
%192 = getelementptr inbounds i32, i32* %22, i64 %185
%193 = load i32, i32* %192
%194 = zext i32 %193 to i64
%195 = getelementptr inbounds i32, i32* %13, i64 %194
%196 = trunc i64 %191 to i32
store i32 %196, i32* %195
%197 = or i64 %183, 3
%198 = getelementptr inbounds i32, i32* %22, i64 %191
%199 = load i32, i32* %198
%200 = zext i32 %199 to i64
%201 = getelementptr inbounds i32, i32* %13, i64 %200
%202 = trunc i64 %197 to i32
store i32 %202, i32* %201
%203 = add nuw nsw i64 %183, 4
%204 = getelementptr inbounds i32, i32* %22, i64 %197
%205 = load i32, i32* %204
%206 = zext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %13, i64 %206
%208 = trunc i64 %203 to i32
store i32 %208, i32* %207
%209 = add i64 %184, 4
%210 = icmp eq i64 %209, %181
br i1 %210, label %211, label %182
211: ; preds = %182, %172
%212 = phi i64 [ 0, %172 ], [ %203, %182 ]
%213 = icmp eq i64 %178, 0
br i1 %213, label %240, label %214
214: ; preds = %211, %214
%215 = phi i64 [ %217, %214 ], [ %212, %211 ]
%216 = phi i64 [ %223, %214 ], [ 0, %211 ]
%217 = add nuw nsw i64 %215, 1
%218 = getelementptr inbounds i32, i32* %22, i64 %215
%219 = load i32, i32* %218
%220 = zext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %13, i64 %220
%222 = trunc i64 %217 to i32
store i32 %222, i32* %221
%223 = add i64 %216, 1
%224 = icmp eq i64 %223, %178
br i1 %224, label %240, label %214
225: ; preds = %139, %83
%226 = phi i64 [ 0, %83 ], [ %169, %139 ]
%227 = icmp eq i64 %89, 0
br i1 %227, label %240, label %228
228: ; preds = %225, %228
%229 = phi i64 [ %237, %228 ], [ %226, %225 ]
%230 = phi i64 [ %238, %228 ], [ 0, %225 ]
%231 = getelementptr inbounds i32, i32* %13, i64 %229
%232 = load i32, i32* %231
%233 = add i32 %232, -1
%234 = zext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %22, i64 %234
%236 = trunc i64 %229 to i32
store i32 %236, i32* %235
%237 = add nuw nsw i64 %229, 1
%238 = add i64 %230, 1
%239 = icmp eq i64 %238, %89
br i1 %239, label %240, label %228
240: ; preds = %225, %228, %211, %214
br i1 %55, label %261, label %241
241: ; preds = %240
%242 = udiv i32 %2, 3
%243 = udiv i32 %5, 3
%244 = add nuw i32 %242, %243
%245 = and i64 %14, 1
%246 = icmp eq i32 %244, 1
br i1 %246, label %249, label %247
247: ; preds = %241
%248 = and i64 %14, 4294967294
br label %274
249: ; preds = %297, %241
%250 = phi i64 [ 0, %241 ], [ %299, %297 ]
%251 = phi i32 [ 0, %241 ], [ %298, %297 ]
%252 = icmp eq i64 %245, 0
br i1 %252, label %261, label %253
253: ; preds = %249
%254 = getelementptr inbounds i32, i32* %22, i64 %250
%255 = load i32, i32* %254
%256 = icmp ult i32 %255, %6
br i1 %256, label %257, label %261
257: ; preds = %253
%258 = mul i32 %255, 3
%259 = zext i32 %251 to i64
%260 = getelementptr inbounds i32, i32* %27, i64 %259
store i32 %258, i32* %260
br label %261
261: ; preds = %249, %257, %253, %49, %82, %240
%262 = call i32 @pass1(i32* %27, i32* %28, i32* %0, i32 %6, i32 %3)
%263 = icmp eq i32 %2, 0
br i1 %263, label %302, label %264
264: ; preds = %261
%265 = sub nsw i32 %6, %8
%266 = sub nsw i32 1, %6
%267 = udiv i32 %2, 3
%268 = add nuw i32 %267, %6
%269 = zext i32 %268 to i64
%270 = add nuw i32 %30, %6
%271 = zext i32 %270 to i64
%272 = insertelement <4 x i32> poison, i32 %6, i64 0
%273 = shufflevector <4 x i32> %272, <4 x i32> poison, <4 x i32> zeroinitializer
br label %303
274: ; preds = %297, %247
%275 = phi i64 [ 0, %247 ], [ %299, %297 ]
%276 = phi i32 [ 0, %247 ], [ %298, %297 ]
%277 = phi i64 [ 0, %247 ], [ %300, %297 ]
%278 = getelementptr inbounds i32, i32* %22, i64 %275
%279 = load i32, i32* %278
%280 = icmp ult i32 %279, %6
br i1 %280, label %281, label %286
281: ; preds = %274
%282 = mul i32 %279, 3
%283 = add i32 %276, 1
%284 = zext i32 %276 to i64
%285 = getelementptr inbounds i32, i32* %27, i64 %284
store i32 %282, i32* %285
br label %286
286: ; preds = %274, %281
%287 = phi i32 [ %283, %281 ], [ %276, %274 ]
%288 = or i64 %275, 1
%289 = getelementptr inbounds i32, i32* %22, i64 %288
%290 = load i32, i32* %289
%291 = icmp ult i32 %290, %6
br i1 %291, label %292, label %297
292: ; preds = %286
%293 = mul i32 %290, 3
%294 = add i32 %287, 1
%295 = zext i32 %287 to i64
%296 = getelementptr inbounds i32, i32* %27, i64 %295
store i32 %293, i32* %296
br label %297
297: ; preds = %292, %286
%298 = phi i32 [ %294, %292 ], [ %287, %286 ]
%299 = add nuw nsw i64 %275, 2
%300 = add i64 %277, 2
%301 = icmp eq i64 %300, %248
br i1 %301, label %249, label %274
302: ; preds = %615, %261
ret void
303: ; preds = %264, %615
%304 = phi i32 [ 0, %264 ], [ %619, %615 ]
%305 = phi i32 [ %265, %264 ], [ %617, %615 ]
%306 = phi i32 [ 0, %264 ], [ %616, %615 ]
%307 = zext i32 %305 to i64
%308 = getelementptr inbounds i32, i32* %22, i64 %307
%309 = load i32, i32* %308
%310 = icmp ult i32 %309, %6
br i1 %310, label %311, label %333
311: ; preds = %303
%312 = mul i32 %309, 3
%313 = add i32 %312, 1
%314 = zext i32 %306 to i64
%315 = getelementptr inbounds i32, i32* %28, i64 %314
%316 = load i32, i32* %315
%317 = zext i32 %313 to i64
%318 = getelementptr inbounds i32, i32* %0, i64 %317
%319 = load i32, i32* %318
%320 = add i32 %309, %6
%321 = zext i32 %320 to i64
%322 = getelementptr inbounds i32, i32* %13, i64 %321
%323 = load i32, i32* %322
%324 = zext i32 %316 to i64
%325 = getelementptr inbounds i32, i32* %0, i64 %324
%326 = load i32, i32* %325
%327 = udiv i32 %316, 3
%328 = zext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %13, i64 %328
%330 = load i32, i32* %329
%331 = call i64 @cmp2(i32 %319, i32 %323, i32 %326, i32 %330)
%332 = icmp eq i64 %331, 0
br i1 %332, label %506, label %365
333: ; preds = %303
%334 = sub i32 %309, %6
%335 = mul i32 %334, 3
%336 = add i32 %335, 2
%337 = zext i32 %306 to i64
%338 = getelementptr inbounds i32, i32* %28, i64 %337
%339 = load i32, i32* %338
%340 = zext i32 %336 to i64
%341 = getelementptr inbounds i32, i32* %0, i64 %340
%342 = load i32, i32* %341
%343 = add i32 %335, 3
%344 = zext i32 %343 to i64
%345 = getelementptr inbounds i32, i32* %0, i64 %344
%346 = load i32, i32* %345
%347 = add i32 %266, %309
%348 = zext i32 %347 to i64
%349 = getelementptr inbounds i32, i32* %13, i64 %348
%350 = load i32, i32* %349
%351 = zext i32 %339 to i64
%352 = getelementptr inbounds i32, i32* %0, i64 %351
%353 = load i32, i32* %352
%354 = add i32 %339, 1
%355 = zext i32 %354 to i64
%356 = getelementptr inbounds i32, i32* %0, i64 %355
%357 = load i32, i32* %356
%358 = udiv i32 %339, 3
%359 = add nuw i32 %358, %6
%360 = zext i32 %359 to i64
%361 = getelementptr inbounds i32, i32* %13, i64 %360
%362 = load i32, i32* %361
%363 = call i64 @cmp3(i32 %342, i32 %346, i32 %350, i32 %353, i32 %357, i32 %362)
%364 = icmp eq i64 %363, 0
br i1 %364, label %506, label %365
365: ; preds = %333, %311
%366 = phi i32 [ %336, %333 ], [ %313, %311 ]
%367 = zext i32 %304 to i64
%368 = getelementptr inbounds i32, i32* %1, i64 %367
store i32 %366, i32* %368
%369 = add i32 %305, 1
%370 = icmp eq i32 %369, %10
br i1 %370, label %371, label %615
371: ; preds = %365
%372 = add i32 %304, 1
%373 = icmp ult i32 %306, %6
br i1 %373, label %374, label %615
374: ; preds = %371
%375 = zext i32 %306 to i64
%376 = sub nsw i64 %26, %375
%377 = icmp ult i64 %376, 8
br i1 %377, label %453, label %378
378: ; preds = %374
%379 = xor i64 %375, -1
%380 = add nsw i64 %379, %26
%381 = trunc i64 %380 to i32
%382 = sub i32 -2, %304
%383 = icmp ult i32 %382, %381
%384 = icmp ugt i64 %380, 4294967295
%385 = or i1 %383, %384
br i1 %385, label %453, label %386
386: ; preds = %378
%387 = and i64 %376, -8
%388 = add nsw i64 %387, %375
%389 = trunc i64 %387 to i32
%390 = add i32 %372, %389
%391 = add nsw i64 %387, -8
%392 = lshr exact i64 %391, 3
%393 = add nuw nsw i64 %392, 1
%394 = and i64 %393, 1
%395 = icmp eq i64 %391, 0
br i1 %395, label %433, label %396
396: ; preds = %386
%397 = and i64 %393, 4611686018427387902
br label %398
398: ; preds = %398, %396
%399 = phi i64 [ 0, %396 ], [ %430, %398 ]
%400 = phi i64 [ 0, %396 ], [ %431, %398 ]
%401 = add i64 %399, %375
%402 = trunc i64 %399 to i32
%403 = add i32 %372, %402
%404 = getelementptr inbounds i32, i32* %28, i64 %401
%405 = bitcast i32* %404 to <4 x i32>*
%406 = load <4 x i32>, <4 x i32>* %405
%407 = getelementptr inbounds i32, i32* %404, i64 4
%408 = bitcast i32* %407 to <4 x i32>*
%409 = load <4 x i32>, <4 x i32>* %408
%410 = zext i32 %403 to i64
%411 = getelementptr inbounds i32, i32* %1, i64 %410
%412 = bitcast i32* %411 to <4 x i32>*
store <4 x i32> %406, <4 x i32>* %412
%413 = getelementptr inbounds i32, i32* %411, i64 4
%414 = bitcast i32* %413 to <4 x i32>*
store <4 x i32> %409, <4 x i32>* %414
%415 = or i64 %399, 8
%416 = add i64 %415, %375
%417 = trunc i64 %415 to i32
%418 = add i32 %372, %417
%419 = getelementptr inbounds i32, i32* %28, i64 %416
%420 = bitcast i32* %419 to <4 x i32>*
%421 = load <4 x i32>, <4 x i32>* %420
%422 = getelementptr inbounds i32, i32* %419, i64 4
%423 = bitcast i32* %422 to <4 x i32>*
%424 = load <4 x i32>, <4 x i32>* %423
%425 = zext i32 %418 to i64
%426 = getelementptr inbounds i32, i32* %1, i64 %425
%427 = bitcast i32* %426 to <4 x i32>*
store <4 x i32> %421, <4 x i32>* %427
%428 = getelementptr inbounds i32, i32* %426, i64 4
%429 = bitcast i32* %428 to <4 x i32>*
store <4 x i32> %424, <4 x i32>* %429
%430 = add nuw i64 %399, 16
%431 = add i64 %400, 2
%432 = icmp eq i64 %431, %397
br i1 %432, label %433, label %398
433: ; preds = %398, %386
%434 = phi i64 [ 0, %386 ], [ %430, %398 ]
%435 = icmp eq i64 %394, 0
br i1 %435, label %451, label %436
436: ; preds = %433
%437 = add i64 %434, %375
%438 = trunc i64 %434 to i32
%439 = add i32 %372, %438
%440 = getelementptr inbounds i32, i32* %28, i64 %437
%441 = bitcast i32* %440 to <4 x i32>*
%442 = load <4 x i32>, <4 x i32>* %441
%443 = getelementptr inbounds i32, i32* %440, i64 4
%444 = bitcast i32* %443 to <4 x i32>*
%445 = load <4 x i32>, <4 x i32>* %444
%446 = zext i32 %439 to i64
%447 = getelementptr inbounds i32, i32* %1, i64 %446
%448 = bitcast i32* %447 to <4 x i32>*
store <4 x i32> %442, <4 x i32>* %448
%449 = getelementptr inbounds i32, i32* %447, i64 4
%450 = bitcast i32* %449 to <4 x i32>*
store <4 x i32> %445, <4 x i32>* %450
br label %451
451: ; preds = %433, %436
%452 = icmp eq i64 %376, %387
br i1 %452, label %615, label %453
453: ; preds = %378, %374, %451
%454 = phi i64 [ %375, %378 ], [ %375, %374 ], [ %388, %451 ]
%455 = phi i32 [ %372, %378 ], [ %372, %374 ], [ %390, %451 ]
%456 = sub nsw i64 %26, %454
%457 = xor i64 %454, -1
%458 = add nsw i64 %457, %26
%459 = and i64 %456, 3
%460 = icmp eq i64 %459, 0
br i1 %460, label %473, label %461
461: ; preds = %453, %461
%462 = phi i64 [ %469, %461 ], [ %454, %453 ]
%463 = phi i32 [ %470, %461 ], [ %455, %453 ]
%464 = phi i64 [ %471, %461 ], [ 0, %453 ]
%465 = getelementptr inbounds i32, i32* %28, i64 %462
%466 = load i32, i32* %465
%467 = zext i32 %463 to i64
%468 = getelementptr inbounds i32, i32* %1, i64 %467
store i32 %466, i32* %468
%469 = add nuw nsw i64 %462, 1
%470 = add i32 %463, 1
%471 = add i64 %464, 1
%472 = icmp eq i64 %471, %459
br i1 %472, label %473, label %461
473: ; preds = %461, %453
%474 = phi i32 [ undef, %453 ], [ %470, %461 ]
%475 = phi i64 [ %454, %453 ], [ %469, %461 ]
%476 = phi i32 [ %455, %453 ], [ %470, %461 ]
%477 = icmp ult i64 %458, 3
br i1 %477, label %615, label %478
478: ; preds = %473, %478
%479 = phi i64 [ %503, %478 ], [ %475, %473 ]
%480 = phi i32 [ %504, %478 ], [ %476, %473 ]
%481 = getelementptr inbounds i32, i32* %28, i64 %479
%482 = load i32, i32* %481
%483 = zext i32 %480 to i64
%484 = getelementptr inbounds i32, i32* %1, i64 %483
store i32 %482, i32* %484
%485 = add nuw nsw i64 %479, 1
%486 = add i32 %480, 1
%487 = getelementptr inbounds i32, i32* %28, i64 %485
%488 = load i32, i32* %487
%489 = zext i32 %486 to i64
%490 = getelementptr inbounds i32, i32* %1, i64 %489
store i32 %488, i32* %490
%491 = add nuw nsw i64 %479, 2
%492 = add i32 %480, 2
%493 = getelementptr inbounds i32, i32* %28, i64 %491
%494 = load i32, i32* %493
%495 = zext i32 %492 to i64
%496 = getelementptr inbounds i32, i32* %1, i64 %495
store i32 %494, i32* %496
%497 = add nuw nsw i64 %479, 3
%498 = add i32 %480, 3
%499 = getelementptr inbounds i32, i32* %28, i64 %497
%500 = load i32, i32* %499
%501 = zext i32 %498 to i64
%502 = getelementptr inbounds i32, i32* %1, i64 %501
store i32 %500, i32* %502
%503 = add nuw nsw i64 %479, 4
%504 = add i32 %480, 4
%505 = icmp eq i64 %503, %26
br i1 %505, label %615, label %478
506: ; preds = %333, %311
%507 = phi i32 [ %339, %333 ], [ %316, %311 ]
%508 = zext i32 %304 to i64
%509 = getelementptr inbounds i32, i32* %1, i64 %508
store i32 %507, i32* %509
%510 = add i32 %306, 1
%511 = icmp eq i32 %510, %6
br i1 %511, label %512, label %615
512: ; preds = %506
%513 = add i32 %304, 1
%514 = icmp ult i32 %305, %10
br i1 %514, label %515, label %615
515: ; preds = %512
%516 = sub nsw i64 %271, %307
%517 = icmp ult i64 %516, 4
br i1 %517, label %596, label %518
518: ; preds = %515
%519 = xor i64 %307, -1
%520 = add nsw i64 %519, %269
%521 = trunc i64 %520 to i32
%522 = sub i32 -2, %304
%523 = icmp ult i32 %522, %521
%524 = icmp ugt i64 %520, 4294967295
%525 = or i1 %523, %524
br i1 %525, label %596, label %526
526: ; preds = %518
%527 = and i64 %516, -4
%528 = add nsw i64 %527, %307
%529 = trunc i64 %527 to i32
%530 = add i32 %513, %529
%531 = add nsw i64 %527, -4
%532 = lshr exact i64 %531, 2
%533 = add nuw nsw i64 %532, 1
%534 = and i64 %533, 1
%535 = icmp eq i64 %531, 0
br i1 %535, label %575, label %536
536: ; preds = %526
%537 = and i64 %533, 9223372036854775806
br label %538
538: ; preds = %538, %536
%539 = phi i64 [ 0, %536 ], [ %572, %538 ]
%540 = phi i64 [ 0, %536 ], [ %573, %538 ]
%541 = add i64 %539, %307
%542 = trunc i64 %539 to i32
%543 = add i32 %513, %542
%544 = getelementptr inbounds i32, i32* %22, i64 %541
%545 = bitcast i32* %544 to <4 x i32>*
%546 = load <4 x i32>, <4 x i32>* %545
%547 = icmp ult <4 x i32> %546, %273
%548 = select <4 x i1> %547, <4 x i32> zeroinitializer, <4 x i32> %273
%549 = sub <4 x i32> %546, %548
%550 = select <4 x i1> %547, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
%551 = mul <4 x i32> %549, <i32 3, i32 3, i32 3, i32 3>
%552 = add <4 x i32> %551, %550
%553 = zext i32 %543 to i64
%554 = getelementptr inbounds i32, i32* %1, i64 %553
%555 = bitcast i32* %554 to <4 x i32>*
store <4 x i32> %552, <4 x i32>* %555
%556 = or i64 %539, 4
%557 = add i64 %556, %307
%558 = trunc i64 %556 to i32
%559 = add i32 %513, %558
%560 = getelementptr inbounds i32, i32* %22, i64 %557
%561 = bitcast i32* %560 to <4 x i32>*
%562 = load <4 x i32>, <4 x i32>* %561
%563 = icmp ult <4 x i32> %562, %273
%564 = select <4 x i1> %563, <4 x i32> zeroinitializer, <4 x i32> %273
%565 = sub <4 x i32> %562, %564
%566 = select <4 x i1> %563, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
%567 = mul <4 x i32> %565, <i32 3, i32 3, i32 3, i32 3>
%568 = add <4 x i32> %567, %566
%569 = zext i32 %559 to i64
%570 = getelementptr inbounds i32, i32* %1, i64 %569
%571 = bitcast i32* %570 to <4 x i32>*
store <4 x i32> %568, <4 x i32>* %571
%572 = add nuw i64 %539, 8
%573 = add i64 %540, 2
%574 = icmp eq i64 %573, %537
br i1 %574, label %575, label %538
575: ; preds = %538, %526
%576 = phi i64 [ 0, %526 ], [ %572, %538 ]
%577 = icmp eq i64 %534, 0
br i1 %577, label %594, label %578
578: ; preds = %575
%579 = add i64 %576, %307
%580 = trunc i64 %576 to i32
%581 = add i32 %513, %580
%582 = getelementptr inbounds i32, i32* %22, i64 %579
%583 = bitcast i32* %582 to <4 x i32>*
%584 = load <4 x i32>, <4 x i32>* %583
%585 = icmp ult <4 x i32> %584, %273
%586 = select <4 x i1> %585, <4 x i32> zeroinitializer, <4 x i32> %273
%587 = sub <4 x i32> %584, %586
%588 = select <4 x i1> %585, <4 x i32> <i32 1, i32 1, i32 1, i32 1>, <4 x i32> <i32 2, i32 2, i32 2, i32 2>
%589 = mul <4 x i32> %587, <i32 3, i32 3, i32 3, i32 3>
%590 = add <4 x i32> %589, %588
%591 = zext i32 %581 to i64
%592 = getelementptr inbounds i32, i32* %1, i64 %591
%593 = bitcast i32* %592 to <4 x i32>*
store <4 x i32> %590, <4 x i32>* %593
br label %594
594: ; preds = %575, %578
%595 = icmp eq i64 %516, %527
br i1 %595, label %615, label %596
596: ; preds = %518, %515, %594
%597 = phi i64 [ %307, %518 ], [ %307, %515 ], [ %528, %594 ]
%598 = phi i32 [ %513, %518 ], [ %513, %515 ], [ %530, %594 ]
br label %599
599: ; preds = %596, %599
%600 = phi i64 [ %612, %599 ], [ %597, %596 ]
%601 = phi i32 [ %613, %599 ], [ %598, %596 ]
%602 = getelementptr inbounds i32, i32* %22, i64 %600
%603 = load i32, i32* %602
%604 = icmp ult i32 %603, %6
%605 = select i1 %604, i32 0, i32 %6
%606 = sub i32 %603, %605
%607 = select i1 %604, i32 1, i32 2
%608 = mul i32 %606, 3
%609 = add i32 %608, %607
%610 = zext i32 %601 to i64
%611 = getelementptr inbounds i32, i32* %1, i64 %610
store i32 %609, i32* %611
%612 = add nuw nsw i64 %600, 1
%613 = add i32 %601, 1
%614 = icmp eq i64 %612, %14
br i1 %614, label %615, label %599
615: ; preds = %473, %478, %599, %451, %594, %371, %512, %506, %365
%616 = phi i32 [ %306, %365 ], [ %510, %506 ], [ %6, %512 ], [ %306, %371 ], [ %6, %594 ], [ %6, %451 ], [ %6, %599 ], [ %6, %478 ], [ %6, %473 ]
%617 = phi i32 [ %369, %365 ], [ %305, %506 ], [ %305, %512 ], [ %10, %371 ], [ %10, %594 ], [ %10, %451 ], [ %10, %599 ], [ %10, %478 ], [ %10, %473 ]
%618 = phi i32 [ %304, %365 ], [ %304, %506 ], [ %513, %512 ], [ %372, %371 ], [ %530, %594 ], [ %390, %451 ], [ %613, %599 ], [ %474, %473 ], [ %504, %478 ]
%619 = add i32 %618, 1
%620 = icmp ult i32 %619, %2
br i1 %620, label %303, label %302
}