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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ hash_2n_n_mask(unsigned char *, unsigned char const *,
                                  unsigned char const *);
int /*<<< orphan*/ hash_n_n(unsigned char *, unsigned char const *);
int horst_verify(unsigned char *pk, const unsigned char *sig,
                 const unsigned char *m, unsigned long long mlen,
                 const unsigned char masks[2 * 16 * 32],
                 const unsigned char m_hash[64]) {
  unsigned char buffer[32 * 32];
  const unsigned char *level10;
  unsigned int idx;
  int i, j, k;
  level10 = sig;
  sig += 64 * 32;
  for (i = 0; i < 32; i++) {
    idx = m_hash[2 * i] + (m_hash[2 * i + 1] << 8);
    if (!(idx & 1)) {
      hash_n_n(buffer, sig);
      for (k = 0; k < 32; k++)
        buffer[32 + k] = sig[32 + k];
    } else {
      hash_n_n(buffer + 32, sig);
      for (k = 0; k < 32; k++)
        buffer[k] = sig[32 + k];
    }
    sig += 32 + 32;
    for (j = 1; j < 16 - 6; j++) {
      idx = idx >> 1;
      if (!(idx & 1)) {
        hash_2n_n_mask(buffer, buffer, masks + 2 * (j - 1) * 32);
        for (k = 0; k < 32; k++)
          buffer[32 + k] = sig[k];
      } else {
        hash_2n_n_mask(buffer + 32, buffer, masks + 2 * (j - 1) * 32);
        for (k = 0; k < 32; k++)
          buffer[k] = sig[k];
      }
      sig += 32;
    }
    idx = idx >> 1;
    hash_2n_n_mask(buffer, buffer, masks + 2 * (16 - 7) * 32);
    for (k = 0; k < 32; k++)
      if (level10[idx * 32 + k] != buffer[k])
        goto fail;
  }
  for (j = 0; j < 32; j++)
    hash_2n_n_mask(buffer + j * 32, level10 + 2 * j * 32,
                   masks + 2 * (16 - 6) * 32);
  for (j = 0; j < 16; j++)
    hash_2n_n_mask(buffer + j * 32, buffer + 2 * j * 32,
                   masks + 2 * (16 - 5) * 32);
  for (j = 0; j < 8; j++)
    hash_2n_n_mask(buffer + j * 32, buffer + 2 * j * 32,
                   masks + 2 * (16 - 4) * 32);
  for (j = 0; j < 4; j++)
    hash_2n_n_mask(buffer + j * 32, buffer + 2 * j * 32,
                   masks + 2 * (16 - 3) * 32);
  for (j = 0; j < 2; j++)
    hash_2n_n_mask(buffer + j * 32, buffer + 2 * j * 32,
                   masks + 2 * (16 - 2) * 32);
  hash_2n_n_mask(pk, buffer, masks + 2 * (16 - 1) * 32);
  return 0;
fail:
  for (k = 0; k < 32; k++)
    pk[k] = 0;
  return -1;
}


x86 assembly (clang, -O0):
<horst_verify>:
push   %rbp
mov    %rsp,%rbp
sub    $0x460,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x448(%rbp)
mov    -0x18(%rbp),%rax
add    $0x800,%rax
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x450(%rbp)
cmpl   $0x20,-0x450(%rbp)
jge    148d <horst_verify+0x36d>
mov    -0x38(%rbp),%rax
mov    -0x450(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x38(%rbp),%rcx
mov    -0x450(%rbp),%edx
shl    $0x1,%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
mov    %eax,-0x44c(%rbp)
mov    -0x44c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1220 <horst_verify+0x100>
lea    -0x440(%rbp),%rdi
mov    -0x18(%rbp),%rsi
call   1030 <hash_n_n@plt>
movl   $0x0,-0x458(%rbp)
cmpl   $0x20,-0x458(%rbp)
jge    121b <horst_verify+0xfb>
mov    -0x18(%rbp),%rax
mov    -0x458(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x458(%rbp),%eax
add    $0x20,%eax
cltq
mov    %cl,-0x440(%rbp,%rax,1)
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    11d5 <horst_verify+0xb5>
jmp    1285 <horst_verify+0x165>
lea    -0x440(%rbp),%rdi
add    $0x20,%rdi
mov    -0x18(%rbp),%rsi
call   1030 <hash_n_n@plt>
movl   $0x0,-0x458(%rbp)
cmpl   $0x20,-0x458(%rbp)
jge    1280 <horst_verify+0x160>
mov    -0x18(%rbp),%rax
mov    -0x458(%rbp),%ecx
add    $0x20,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x458(%rbp),%rax
mov    %cl,-0x440(%rbp,%rax,1)
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    123e <horst_verify+0x11e>
jmp    1285 <horst_verify+0x165>
mov    -0x18(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x18(%rbp)
movl   $0x1,-0x454(%rbp)
cmpl   $0xa,-0x454(%rbp)
jge    13df <horst_verify+0x2bf>
mov    -0x44c(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x44c(%rbp)
mov    -0x44c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
jne    1344 <horst_verify+0x224>
lea    -0x440(%rbp),%rdi
lea    -0x440(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x454(%rbp),%eax
sub    $0x1,%eax
shl    $0x1,%eax
shl    $0x5,%eax
cltq
add    %rax,%rdx
call   1040 <hash_2n_n_mask@plt>
movl   $0x0,-0x458(%rbp)
cmpl   $0x20,-0x458(%rbp)
jge    133f <horst_verify+0x21f>
mov    -0x18(%rbp),%rax
movslq -0x458(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x458(%rbp),%eax
add    $0x20,%eax
cltq
mov    %cl,-0x440(%rbp,%rax,1)
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    12fe <horst_verify+0x1de>
jmp    13bf <horst_verify+0x29f>
lea    -0x440(%rbp),%rdi
add    $0x20,%rdi
lea    -0x440(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x454(%rbp),%eax
sub    $0x1,%eax
shl    $0x1,%eax
shl    $0x5,%eax
cltq
add    %rax,%rdx
call   1040 <hash_2n_n_mask@plt>
movl   $0x0,-0x458(%rbp)
cmpl   $0x20,-0x458(%rbp)
jge    13ba <horst_verify+0x29a>
mov    -0x18(%rbp),%rax
movslq -0x458(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x458(%rbp),%rax
mov    %cl,-0x440(%rbp,%rax,1)
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    137d <horst_verify+0x25d>
jmp    13bf <horst_verify+0x29f>
mov    -0x18(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x18(%rbp)
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    129b <horst_verify+0x17b>
mov    -0x44c(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x44c(%rbp)
lea    -0x440(%rbp),%rdi
lea    -0x440(%rbp),%rsi
mov    -0x30(%rbp),%rdx
add    $0x240,%rdx
call   1040 <hash_2n_n_mask@plt>
movl   $0x0,-0x458(%rbp)
cmpl   $0x20,-0x458(%rbp)
jge    1474 <horst_verify+0x354>
mov    -0x448(%rbp),%rax
mov    -0x44c(%rbp),%ecx
shl    $0x5,%ecx
add    -0x458(%rbp),%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
movslq -0x458(%rbp),%rcx
movzbl -0x440(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
je     145b <horst_verify+0x33b>
jmp    16bc <horst_verify+0x59c>
jmp    1460 <horst_verify+0x340>
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    1416 <horst_verify+0x2f6>
jmp    1479 <horst_verify+0x359>
mov    -0x450(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x450(%rbp)
jmp    1166 <horst_verify+0x46>
movl   $0x0,-0x454(%rbp)
cmpl   $0x20,-0x454(%rbp)
jge    14f5 <horst_verify+0x3d5>
lea    -0x440(%rbp),%rdi
mov    -0x454(%rbp),%eax
shl    $0x5,%eax
cltq
add    %rax,%rdi
mov    -0x448(%rbp),%rsi
mov    -0x454(%rbp),%eax
shl    $0x1,%eax
shl    $0x5,%eax
cltq
add    %rax,%rsi
mov    -0x30(%rbp),%rdx
add    $0x280,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    1497 <horst_verify+0x377>
movl   $0x0,-0x454(%rbp)
cmpl   $0x10,-0x454(%rbp)
jge    155d <horst_verify+0x43d>
lea    -0x440(%rbp),%rdi
mov    -0x454(%rbp),%eax
shl    $0x5,%eax
cltq
add    %rax,%rdi
lea    -0x440(%rbp),%rsi
mov    -0x454(%rbp),%eax
shl    $0x1,%eax
shl    $0x5,%eax
cltq
add    %rax,%rsi
mov    -0x30(%rbp),%rdx
add    $0x2c0,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    14ff <horst_verify+0x3df>
movl   $0x0,-0x454(%rbp)
cmpl   $0x8,-0x454(%rbp)
jge    15c5 <horst_verify+0x4a5>
lea    -0x440(%rbp),%rdi
mov    -0x454(%rbp),%eax
shl    $0x5,%eax
cltq
add    %rax,%rdi
lea    -0x440(%rbp),%rsi
mov    -0x454(%rbp),%eax
shl    $0x1,%eax
shl    $0x5,%eax
cltq
add    %rax,%rsi
mov    -0x30(%rbp),%rdx
add    $0x300,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    1567 <horst_verify+0x447>
movl   $0x0,-0x454(%rbp)
cmpl   $0x4,-0x454(%rbp)
jge    162d <horst_verify+0x50d>
lea    -0x440(%rbp),%rdi
mov    -0x454(%rbp),%eax
shl    $0x5,%eax
cltq
add    %rax,%rdi
lea    -0x440(%rbp),%rsi
mov    -0x454(%rbp),%eax
shl    $0x1,%eax
shl    $0x5,%eax
cltq
add    %rax,%rsi
mov    -0x30(%rbp),%rdx
add    $0x340,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    15cf <horst_verify+0x4af>
movl   $0x0,-0x454(%rbp)
cmpl   $0x2,-0x454(%rbp)
jge    1695 <horst_verify+0x575>
lea    -0x440(%rbp),%rdi
mov    -0x454(%rbp),%eax
shl    $0x5,%eax
cltq
add    %rax,%rdi
lea    -0x440(%rbp),%rsi
mov    -0x454(%rbp),%eax
shl    $0x1,%eax
shl    $0x5,%eax
cltq
add    %rax,%rsi
mov    -0x30(%rbp),%rdx
add    $0x380,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    -0x454(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x454(%rbp)
jmp    1637 <horst_verify+0x517>
mov    -0x10(%rbp),%rdi
lea    -0x440(%rbp),%rsi
mov    -0x30(%rbp),%rdx
add    $0x3c0,%rdx
call   1040 <hash_2n_n_mask@plt>
movl   $0x0,-0x4(%rbp)
jmp    16fd <horst_verify+0x5dd>
movl   $0x0,-0x458(%rbp)
cmpl   $0x20,-0x458(%rbp)
jge    16f6 <horst_verify+0x5d6>
mov    -0x10(%rbp),%rax
movslq -0x458(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x458(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x458(%rbp)
jmp    16c6 <horst_verify+0x5a6>
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x460,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<horst_verify>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x448,%rsp
mov    %r8,%r14
mov    %rdi,0x8(%rsp)
lea    0x800(%rsi),%rbx
lea    0x60(%rsp),%r13
lea    0x240(%r8),%rax
mov    %rax,0x30(%rsp)
mov    %rsi,0x10(%rsp)
lea    0x3(%rsi),%rax
mov    %rax,0x28(%rsp)
xor    %eax,%eax
mov    %r8,(%rsp)
mov    %r9,0x18(%rsp)
movzbl (%r9,%rax,2),%ebp
movzbl 0x1(%r9,%rax,2),%r12d
shl    $0x8,%r12d
test   $0x1,%bpl
mov    %rax,0x20(%rsp)
jne    1200 <horst_verify+0xe0>
lea    0x40(%rsp),%rdi
mov    %rbx,%rsi
call   1030 <hash_n_n@plt>
lea    0x40(%rbx),%rax
cmp    %rax,%r13
jae    1260 <horst_verify+0x140>
lea    0x20(%rbx),%rax
lea    0x80(%rsp),%rcx
cmp    %rcx,%rax
jae    1260 <horst_verify+0x140>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movzbl 0x20(%rbx,%rax,1),%ecx
mov    %cl,0x60(%rsp,%rax,1)
movzbl 0x21(%rbx,%rax,1),%ecx
mov    %cl,0x61(%rsp,%rax,1)
movzbl 0x22(%rbx,%rax,1),%ecx
mov    %cl,0x62(%rsp,%rax,1)
movzbl 0x23(%rbx,%rax,1),%ecx
mov    %cl,0x63(%rsp,%rax,1)
add    $0x4,%rax
cmp    $0x20,%rax
jne    11c0 <horst_verify+0xa0>
jmp    1292 <horst_verify+0x172>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r13,%rdi
mov    %rbx,%rsi
call   1030 <hash_n_n@plt>
lea    0x40(%rbx),%rax
lea    0x40(%rsp),%rcx
cmp    %rax,%rcx
jae    1280 <horst_verify+0x160>
lea    0x20(%rbx),%rax
cmp    %r13,%rax
jae    1280 <horst_verify+0x160>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl 0x20(%rbx,%rax,1),%ecx
mov    %cl,0x40(%rsp,%rax,1)
movzbl 0x21(%rbx,%rax,1),%ecx
mov    %cl,0x41(%rsp,%rax,1)
movzbl 0x22(%rbx,%rax,1),%ecx
mov    %cl,0x42(%rsp,%rax,1)
movzbl 0x23(%rbx,%rax,1),%ecx
mov    %cl,0x43(%rsp,%rax,1)
add    $0x4,%rax
cmp    $0x20,%rax
jne    1230 <horst_verify+0x110>
jmp    1292 <horst_verify+0x172>
movups 0x20(%rbx),%xmm0
movaps %xmm0,0x60(%rsp)
movups 0x30(%rbx),%xmm0
movaps %xmm0,0x70(%rsp)
jmp    1292 <horst_verify+0x172>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x20(%rbx),%xmm0
movaps %xmm0,0x40(%rsp)
movups 0x30(%rbx),%xmm0
movaps %xmm0,0x50(%rsp)
or     %ebp,%r12d
mov    %rbx,%rax
mov    %rbx,0x38(%rsp)
lea    0x40(%rbx),%rbp
mov    $0x1,%r15d
xor    %ebx,%ebx
jmp    12e8 <horst_verify+0x1c8>
nopl   0x0(%rax,%rax,1)
mov    %r13,%rdi
lea    0x40(%rsp),%rsi
call   1040 <hash_2n_n_mask@plt>
movups 0x0(%rbp),%xmm0
movaps %xmm0,0x40(%rsp)
movups 0x10(%rbp),%xmm0
movaps %xmm0,0x50(%rsp)
shr    %r12d
add    $0x20,%rbp
add    $0x1,%r15
add    $0x1,%rbx
cmp    $0xa,%r15
je     13a0 <horst_verify+0x280>
mov    %r15,%rax
shl    $0x6,%rax
lea    (%rax,%r14,1),%rdx
add    $0xffffffffffffffc0,%rdx
test   $0x2,%r12b
jne    12b0 <horst_verify+0x190>
mov    %rbx,%rax
shl    $0x5,%rax
mov    0x38(%rsp),%rcx
lea    (%rax,%rcx,1),%r14
add    $0x60,%r14
lea    0x40(%rsp),%rdi
mov    %rdi,%rsi
call   1040 <hash_2n_n_mask@plt>
mov    %r13,%rcx
cmp    %r14,%r13
jae    1380 <horst_verify+0x260>
lea    0x80(%rsp),%rax
cmp    %rax,%rbp
jae    1380 <horst_verify+0x260>
xor    %eax,%eax
mov    (%rsp),%r14
mov    %rcx,%r13
nopl   0x0(%rax)
movzbl 0x0(%rbp,%rax,1),%ecx
mov    %cl,0x60(%rsp,%rax,1)
movzbl 0x1(%rbp,%rax,1),%ecx
mov    %cl,0x61(%rsp,%rax,1)
movzbl 0x2(%rbp,%rax,1),%ecx
mov    %cl,0x62(%rsp,%rax,1)
movzbl 0x3(%rbp,%rax,1),%ecx
mov    %cl,0x63(%rsp,%rax,1)
add    $0x4,%rax
cmp    $0x20,%rax
jne    1340 <horst_verify+0x220>
jmp    12cf <horst_verify+0x1af>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%rbp),%xmm0
movaps %xmm0,0x60(%rsp)
movups 0x10(%rbp),%xmm0
movaps %xmm0,0x70(%rsp)
mov    (%rsp),%r14
mov    %rcx,%r13
jmp    12cf <horst_verify+0x1af>
xchg   %ax,%ax
lea    0x40(%rsp),%rdi
mov    %rdi,%rsi
mov    0x30(%rsp),%rdx
call   1040 <hash_2n_n_mask@plt>
shl    $0x4,%r12d
and    $0xfffe0,%r12d
add    0x28(%rsp),%r12
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x3(%r12,%rax,1),%ecx
cmp    0x40(%rsp,%rax,1),%cl
jne    1732 <horst_verify+0x612>
movzbl -0x2(%r12,%rax,1),%ecx
cmp    0x41(%rsp,%rax,1),%cl
jne    1732 <horst_verify+0x612>
movzbl -0x1(%r12,%rax,1),%ecx
cmp    0x42(%rsp,%rax,1),%cl
jne    1732 <horst_verify+0x612>
movzbl (%r12,%rax,1),%ecx
cmp    0x43(%rsp,%rax,1),%cl
jne    1732 <horst_verify+0x612>
add    $0x4,%rax
cmp    $0x20,%rax
jne    13d0 <horst_verify+0x2b0>
mov    0x20(%rsp),%rax
add    $0x1,%rax
mov    %rbp,%rbx
cmp    $0x20,%rax
mov    0x18(%rsp),%r9
jne    116a <horst_verify+0x4a>
lea    0x280(%r14),%r12
xor    %ebx,%ebx
mov    0x10(%rsp),%rbp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rsp,%rbx,1),%rdi
add    $0x40,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
add    $0x20,%rbx
add    $0x40,%rbp
cmp    $0x400,%rbx
jne    1450 <horst_verify+0x330>
lea    0x2c0(%r14),%r12
lea    0x40(%rsp),%rdi
mov    %rdi,%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x80(%rsp),%rbp
mov    %r13,%r15
mov    %r13,%rdi
mov    %rbp,%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0xc0(%rsp),%rsi
mov    %rbp,%rdi
mov    %rsi,%rbp
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0xa0(%rsp),%rdi
lea    0x100(%rsp),%rbx
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x140(%rsp),%rsi
mov    %rbp,%rdi
mov    %rsi,%rbp
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0xe0(%rsp),%rdi
lea    0x180(%rsp),%r13
mov    %r13,%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x1c0(%rsp),%rsi
mov    %rbx,%rdi
mov    %rsi,%rbx
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x120(%rsp),%rdi
lea    0x200(%rsp),%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x240(%rsp),%rsi
mov    %rbp,%rdi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x160(%rsp),%rdi
lea    0x280(%rsp),%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x2c0(%rsp),%rsi
mov    %r13,%rdi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x1a0(%rsp),%rdi
lea    0x300(%rsp),%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x340(%rsp),%rsi
mov    %rbx,%rdi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x1e0(%rsp),%rdi
lea    0x380(%rsp),%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x3c0(%rsp),%rsi
lea    0x200(%rsp),%rdi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x220(%rsp),%rdi
lea    0x400(%rsp),%rsi
mov    %r12,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    (%rsp),%rbx
lea    0x300(%rbx),%rbp
lea    0x40(%rsp),%rdi
mov    %rdi,%rsi
mov    %rdi,%r13
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    %r15,%rdi
lea    0x80(%rsp),%r14
mov    %r14,%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    %r14,%rdi
lea    0xc0(%rsp),%r12
mov    %r12,%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0xa0(%rsp),%rdi
lea    0x100(%rsp),%r14
mov    %r14,%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    %r12,%rdi
lea    0x140(%rsp),%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0xe0(%rsp),%rdi
lea    0x180(%rsp),%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    %r14,%rdi
mov    %r14,%r12
lea    0x1c0(%rsp),%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x120(%rsp),%rdi
lea    0x200(%rsp),%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x340(%rbx),%rbp
mov    %r13,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    %r15,%rdi
lea    0x80(%rsp),%r14
mov    %r14,%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    %r14,%rdi
lea    0xc0(%rsp),%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0xa0(%rsp),%rdi
mov    %r12,%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
lea    0x380(%rbx),%rbp
mov    %r13,%rdi
mov    %r13,%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
call   1040 <hash_2n_n_mask@plt>
mov    %rbx,%rdx
add    $0x3c0,%rdx
mov    0x8(%rsp),%rdi
mov    %r13,%rsi
call   1040 <hash_2n_n_mask@plt>
xor    %eax,%eax
jmp    1746 <horst_verify+0x626>
xorps  %xmm0,%xmm0
mov    0x8(%rsp),%rax
movups %xmm0,0x10(%rax)
movups %xmm0,(%rax)
mov    $0xffffffff,%eax
add    $0x448,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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