#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*/ fill_out_sum(int, int, int *);
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
int hash(char *nmer, int sum[256], int num) {
  int key[6] = {1, 4, 16, 64, 256, 1024};
  int el, h, N_degen, t_degen, degen, i;
  degen = N_degen = 1;
  memset(sum, 0, sizeof(int) * 256);
  for (el = 0; el < num; el++) {
    switch (nmer[el]) {
    case 'a':
      break;
    case 'c':
      for (i = 0; i < degen; i++)
        sum[i] = sum[i] + key[el];
      break;
    case 'g':
      for (i = 0; i < degen; i++)
        sum[i] = sum[i] + 2 * key[el];
      break;
    case 't':
      for (i = 0; i < degen; i++)
        sum[i] = sum[i] + 3 * key[el];
      break;
    case 'y':
      N_degen = degen * 2;
      t_degen = N_degen - 1;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < (degen); i++) {
        sum[i] = sum[i] + key[el];
        sum[t_degen - i] = sum[t_degen - i] + 3 * key[el];
      }
      break;
    case 'r':
      N_degen = degen * 2;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < (degen); i++) {
        sum[i] = sum[i] + 2 * key[el];
      }
      break;
    case 'm':
      N_degen = degen * 2;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < (degen); i++) {
        sum[i] = sum[i] + key[el];
      }
      break;
    case 'k':
      N_degen = degen * 2;
      t_degen = N_degen - 1;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < (degen); i++) {
        sum[i] = sum[i] + 2 * key[el];
        sum[t_degen - i] = sum[t_degen - i] + 3 * key[el];
      }
      break;
    case 's':
      N_degen = degen * 2;
      t_degen = N_degen - 1;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < (degen); i++) {
        sum[i] = sum[i] + key[el];
        sum[t_degen - i] = sum[t_degen - i] + 2 * key[el];
      }
      break;
    case 'w':
      N_degen = degen * 2;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < (degen); i++) {
        sum[i] = sum[i] + 3 * key[el];
      }
      break;
    case 'b':
      h = 2 * degen;
      N_degen = degen * 3;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < degen; i++) {
        sum[i] = sum[i] + key[el];
        sum[i + degen] = sum[i + degen] + 2 * key[el];
        sum[i + h] = sum[i + h] + 3 * key[el];
      }
      break;
    case 'd':
      h = 2 * degen;
      N_degen = degen * 3;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < degen; i++) {
        sum[i + degen] = sum[i + degen] + 2 * key[el];
        sum[i + h] = sum[i + h] + 3 * key[el];
      }
      break;
    case 'h':
      h = 2 * degen;
      N_degen = degen * 3;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < degen; i++) {
        sum[i] = sum[i] + key[el];
        sum[i + h] = sum[i + h] + 3 * key[el];
      }
      break;
    case 'v':
      h = 2 * degen;
      N_degen = degen * 3;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < degen; i++) {
        sum[i] = sum[i] + key[el];
        sum[i + degen] = sum[i + degen] + 2 * key[el];
      }
      break;
    case 'n':
      h = 2 * degen;
      N_degen = degen * 4;
      fill_out_sum(degen, N_degen, sum);
      for (i = 0; i < degen; i++) {
        sum[i] = sum[i] + key[el];
        sum[i + degen] = sum[i + degen] + 2 * key[el];
        sum[i + h] = sum[i + h] + 3 * key[el];
      }
      break;
    default:
      break;
    }
    degen = N_degen;
  }
  return degen;
}


x86 assembly (clang, -O0):
<hash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    0xf36(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0xf33(%rip),%rax
mov    %rax,-0x28(%rbp)
mov    0xf30(%rip),%rax
mov    %rax,-0x20(%rbp)
movl   $0x1,-0x3c(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x10(%rbp),%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1040 <memset@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18af <hash+0x78f>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffff9f,%eax
mov    %eax,%ecx
mov    %rcx,-0x50(%rbp)
sub    $0x18,%eax
ja     1896 <hash+0x776>
mov    -0x50(%rbp),%rax
lea    0xe52(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    189b <hash+0x77b>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    11fb <hash+0xdb>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
add    -0x30(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11c3 <hash+0xa3>
jmp    189b <hash+0x77b>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1244 <hash+0x124>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1207 <hash+0xe7>
jmp    189b <hash+0x77b>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    128b <hash+0x16b>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
imul   $0x3,-0x30(%rbp,%rax,4),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1250 <hash+0x130>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    131b <hash+0x1fb>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
add    -0x30(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
imul   $0x3,-0x30(%rbp,%rax,4),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12b8 <hash+0x198>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    137c <hash+0x25c>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    133f <hash+0x21f>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    13d8 <hash+0x2b8>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
add    -0x30(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13a0 <hash+0x280>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    146d <hash+0x34d>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
imul   $0x3,-0x30(%rbp,%rax,4),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1405 <hash+0x2e5>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    14ff <hash+0x3df>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
add    -0x30(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x40(%rbp),%ecx
sub    -0x48(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    149a <hash+0x37a>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    155e <hash+0x43e>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
imul   $0x3,-0x30(%rbp,%rax,4),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1523 <hash+0x403>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
imul   $0x3,-0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1619 <hash+0x4f9>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
add    -0x30(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
imul   $0x3,-0x30(%rbp,%rax,4),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1589 <hash+0x469>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
imul   $0x3,-0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    16b6 <hash+0x596>
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
imul   $0x3,-0x30(%rbp,%rax,4),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1644 <hash+0x524>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
imul   $0x3,-0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1744 <hash+0x624>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
add    -0x30(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
imul   $0x3,-0x30(%rbp,%rax,4),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    16e1 <hash+0x5c1>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
imul   $0x3,-0x44(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    17d4 <hash+0x6b4>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
add    -0x30(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    176f <hash+0x64f>
jmp    189b <hash+0x77b>
mov    -0x44(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x44(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%edi
mov    -0x3c(%rbp),%esi
mov    -0x10(%rbp),%rdx
call   1030 <fill_out_sum@plt>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1891 <hash+0x771>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
add    -0x30(%rbp,%rax,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
mov    -0x30(%rbp,%rax,4),%eax
shl    $0x1,%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x44(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
movslq -0x34(%rbp),%rax
imul   $0x3,-0x30(%rbp,%rax,4),%eax
add    %eax,%edx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1801 <hash+0x6e1>
jmp    189b <hash+0x77b>
jmp    189b <hash+0x77b>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1179 <hash+0x59>
mov    -0x44(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<hash>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %edx,%ebp
mov    %rsi,%rbx
mov    %rdi,0x8(%rsp)
mov    %rsi,%rdi
xor    %esi,%esi
mov    $0x400,%edx
call   1040 <memset@plt>
test   %ebp,%ebp
jle    20ac <hash+0xf8c>
mov    %ebp,%r14d
lea    0x10(%rbx),%rax
mov    %rax,0x18(%rsp)
lea    0x4(%rbx),%rax
mov    %rax,0x20(%rsp)
mov    $0x1,%r15d
xor    %r12d,%r12d
mov    %r14,0x10(%rsp)
mov    0x8(%rsp),%rbp
jmp    1190 <hash+0x70>
nopl   0x0(%rax)
mov    %r13d,%r15d
add    $0x1,%r12
cmp    %r14,%r12
je     20b2 <hash+0xf92>
movsbl 0x0(%rbp,%r12,1),%eax
add    $0xffffff9e,%eax
cmp    $0x17,%eax
ja     1183 <hash+0x63>
lea    0x1e5b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
lea    (%r15,%r15,2),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    1180 <hash+0x60>
lea    (%r15,%r15,1),%ecx
lea    0x1e90(%rip),%rax
mov    (%rax,%r12,4),%eax
lea    (%rax,%rax,1),%r10d
lea    (%rax,%rax,2),%r11d
mov    %r15d,%ebp
movslq %ecx,%r8
cmp    $0x4,%r15d
jae    15ed <hash+0x4cd>
xor    %esi,%esi
lea    (%rbx,%r8,4),%rcx
lea    (%rbx,%rbp,4),%rdx
cs nopw 0x0(%rax,%rax,1)
add    %eax,(%rbx,%rsi,4)
add    %r10d,(%rdx,%rsi,4)
add    %r11d,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1200 <hash+0xe0>
jmp    1454 <hash+0x334>
test   %r15d,%r15d
jle    1183 <hash+0x63>
lea    0x1e37(%rip),%rax
mov    (%rax,%r12,4),%eax
mov    %r15d,%ecx
cmp    $0x8,%r15d
jae    172d <hash+0x60d>
xor    %edx,%edx
jmp    17f0 <hash+0x6d0>
lea    (%r15,%r15,2),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    1180 <hash+0x60>
lea    (%r15,%r15,1),%edx
lea    0x1df9(%rip),%rax
mov    (%rax,%r12,4),%ecx
lea    (%rcx,%rcx,2),%eax
add    %ecx,%ecx
mov    %r15d,%r10d
movslq %edx,%r8
cmp    $0x8,%r15d
jb     12a2 <hash+0x182>
lea    (%rbx,%r10,4),%rdx
lea    (%r8,%r10,1),%rsi
lea    (%rbx,%rsi,4),%rsi
cmp    %rsi,%rdx
jae    1eb8 <hash+0xd98>
lea    (%rbx,%r10,8),%rdx
lea    (%rbx,%r8,4),%rsi
cmp    %rdx,%rsi
jae    1eb8 <hash+0xd98>
xor    %r9d,%r9d
mov    %r9,%rsi
test   $0x1,%r10b
je     12c3 <hash+0x1a3>
lea    (%r9,%r10,1),%rdx
add    %ecx,(%rbx,%rdx,4)
lea    (%r9,%r8,1),%rdx
add    %eax,(%rbx,%rdx,4)
mov    %r9,%rsi
or     $0x1,%rsi
not    %r9
add    %r10,%r9
je     1180 <hash+0x60>
mov    0x20(%rsp),%rdi
lea    (%rdi,%r8,4),%rdx
lea    (%rdi,%r10,4),%rdi
nopl   0x0(%rax)
add    %ecx,-0x4(%rdi,%rsi,4)
add    %eax,-0x4(%rdx,%rsi,4)
add    %ecx,(%rdi,%rsi,4)
add    %eax,(%rdx,%rsi,4)
add    $0x2,%rsi
cmp    %rsi,%r10
jne    12e0 <hash+0x1c0>
jmp    1180 <hash+0x60>
test   %r15d,%r15d
jle    1183 <hash+0x63>
lea    0x1d54(%rip),%rax
mov    (%rax,%r12,4),%eax
add    %eax,%eax
mov    %r15d,%ecx
cmp    $0x8,%r15d
jae    1801 <hash+0x6e1>
xor    %edx,%edx
jmp    18c0 <hash+0x7a0>
lea    (%r15,%r15,2),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    1180 <hash+0x60>
lea    (%r15,%r15,1),%edx
lea    0x1d14(%rip),%rax
mov    (%rax,%r12,4),%eax
lea    (%rax,%rax,2),%ecx
movslq %edx,%rsi
mov    %r15d,%edx
cmp    $0x8,%r15d
jae    18d1 <hash+0x7b1>
xor    %r8d,%r8d
jmp    1fc9 <hash+0xea9>
lea    (%r15,%r15,1),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    15e5 <hash+0x4c5>
lea    0x1cd3(%rip),%rax
mov    (%rax,%r12,4),%ecx
lea    (%rcx,%rcx,2),%eax
add    %ecx,%ecx
mov    %r15d,%r8d
cmp    $0x1,%r15d
jne    1905 <hash+0x7e5>
xor    %esi,%esi
jmp    1942 <hash+0x822>
lea    (%r15,%r15,1),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    1180 <hash+0x60>
lea    0x1c94(%rip),%rax
mov    (%rax,%r12,4),%eax
mov    %r15d,%ecx
cmp    $0x8,%r15d
jae    1954 <hash+0x834>
xor    %edx,%edx
jmp    1a10 <hash+0x8f0>
lea    0x0(,%r15,4),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    1180 <hash+0x60>
lea    (%r15,%r15,1),%ecx
lea    0x1c52(%rip),%rax
mov    (%rax,%r12,4),%eax
lea    (%rax,%rax,1),%r10d
lea    (%rax,%rax,2),%r11d
mov    %r15d,%ebp
movslq %ecx,%r8
cmp    $0x4,%r15d
jae    1a21 <hash+0x901>
xor    %esi,%esi
lea    (%rbx,%r8,4),%rcx
lea    (%rbx,%rbp,4),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    %eax,(%rbx,%rsi,4)
add    %r10d,(%rdx,%rsi,4)
add    %r11d,(%rcx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1440 <hash+0x320>
mov    %r13d,%r15d
jmp    1ea9 <hash+0xd89>
lea    (%r15,%r15,1),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    1180 <hash+0x60>
lea    0x1be2(%rip),%rax
mov    (%rax,%r12,4),%eax
add    %eax,%eax
mov    %r15d,%ecx
cmp    $0x8,%r15d
jae    1b5d <hash+0xa3d>
xor    %edx,%edx
jmp    1c20 <hash+0xb00>
lea    (%r15,%r15,1),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    15e5 <hash+0x4c5>
lea    0x1ba6(%rip),%rax
mov    (%rax,%r12,4),%ecx
lea    (%rcx,%rcx,1),%eax
mov    %r15d,%r8d
cmp    $0x1,%r15d
je     15de <hash+0x4be>
mov    %r8d,%edi
and    $0xfffffffe,%edi
lea    -0x2(%r13),%edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
add    %ecx,(%rbx,%rsi,4)
lea    0x1(%rdx),%ebp
movslq %ebp,%rbp
add    %eax,(%rbx,%rbp,4)
add    %ecx,0x4(%rbx,%rsi,4)
movslq %edx,%rdx
add    %eax,(%rbx,%rdx,4)
add    $0x2,%rsi
add    $0xfffffffe,%edx
cmp    %rsi,%rdi
jne    14e0 <hash+0x3c0>
jmp    1e92 <hash+0xd72>
test   %r15d,%r15d
jle    1183 <hash+0x63>
lea    0x1b49(%rip),%rax
mov    (%rax,%r12,4),%eax
lea    (%rax,%rax,2),%eax
mov    %r15d,%ecx
cmp    $0x8,%r15d
jae    1c31 <hash+0xb11>
xor    %edx,%edx
jmp    1cf0 <hash+0xbd0>
lea    (%r15,%r15,2),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    1180 <hash+0x60>
lea    0x1b0c(%rip),%rax
mov    (%rax,%r12,4),%eax
lea    (%rax,%rax,1),%ecx
mov    %r15d,%edx
cmp    $0x8,%r15d
jae    1d01 <hash+0xbe1>
xor    %esi,%esi
jmp    1d79 <hash+0xc59>
lea    (%r15,%r15,1),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    1180 <hash+0x60>
lea    0x1acf(%rip),%rax
mov    (%rax,%r12,4),%eax
lea    (%rax,%rax,2),%eax
mov    %r15d,%ecx
cmp    $0x8,%r15d
jae    1d94 <hash+0xc74>
xor    %edx,%edx
jmp    1e50 <hash+0xd30>
lea    (%r15,%r15,1),%r13d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %rbx,%rdx
call   1030 <fill_out_sum@plt>
test   %r15d,%r15d
jle    15e5 <hash+0x4c5>
lea    0x1a96(%rip),%rax
mov    (%rax,%r12,4),%ecx
lea    (%rcx,%rcx,2),%eax
mov    %r15d,%r8d
cmp    $0x1,%r15d
jne    1e61 <hash+0xd41>
xor    %esi,%esi
jmp    1e92 <hash+0xd72>
mov    %r13d,%r15d
jmp    1183 <hash+0x63>
lea    (%rbx,%rbp,4),%rcx
lea    (%rbx,%rbp,8),%r9
lea    (%r8,%rbp,1),%rsi
lea    (%rbx,%rsi,4),%rsi
cmp    %rbx,%rsi
seta   %r15b
lea    (%rbx,%r8,4),%rdi
cmp    %rcx,%rdi
setb   %dl
cmp    %rsi,%rcx
setb   %cl
cmp    %r9,%rdi
setb   %dil
test   %dl,%r15b
jne    11ec <hash+0xcc>
mov    $0x0,%esi
and    %dil,%cl
jne    11ee <hash+0xce>
mov    %ebp,%esi
and    $0xfffffffc,%esi
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm2
movd   %r10d,%xmm0
pshufd $0x0,%xmm0,%xmm1
movd   %r11d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x4(%rsi),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     208a <hash+0xf6a>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    0x18(%rsp),%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rdx),%xmm3
paddd  %xmm2,%xmm3
movdqu %xmm3,-0x10(%rdx)
movdqu -0x10(%rdx,%rbp,4),%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm3,-0x10(%rdx,%rbp,4)
movdqu -0x10(%rdx,%r8,4),%xmm3
paddd  %xmm0,%xmm3
movdqu %xmm3,-0x10(%rdx,%r8,4)
movdqu (%rdx),%xmm3
paddd  %xmm2,%xmm3
movdqu %xmm3,(%rdx)
movdqu (%rdx,%rbp,4),%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm3,(%rdx,%rbp,4)
movdqu (%rdx,%r8,4),%xmm3
paddd  %xmm0,%xmm3
movdqu %xmm3,(%rdx,%r8,4)
add    $0x8,%rdi
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1680 <hash+0x560>
test   $0x1,%r9b
je     171f <hash+0x5ff>
movdqu (%rbx,%rdi,4),%xmm3
paddd  %xmm3,%xmm2
movdqu %xmm2,(%rbx,%rdi,4)
lea    (%rdi,%rbp,1),%rcx
movdqu (%rbx,%rcx,4),%xmm2
paddd  %xmm1,%xmm2
movdqu %xmm2,(%rbx,%rcx,4)
add    %r8,%rdi
movdqu (%rbx,%rdi,4),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,(%rbx,%rdi,4)
cmp    %rbp,%rsi
jne    11ee <hash+0xce>
jmp    1454 <hash+0x334>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2024 <hash+0xf04>
mov    %rbp,%rsi
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
and    %rdi,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
movdqu 0x20(%rbx,%rdi,4),%xmm3
movdqu 0x30(%rbx,%rdi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdi,4)
movdqu %xmm4,0x30(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1770 <hash+0x650>
test   $0x1,%bpl
je     17dc <hash+0x6bc>
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
cmp    %rcx,%rdx
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1183 <hash+0x63>
nop
add    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    17f0 <hash+0x6d0>
jmp    1183 <hash+0x63>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2035 <hash+0xf15>
mov    %rbp,%rsi
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
and    %rdi,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
movdqu 0x20(%rbx,%rdi,4),%xmm3
movdqu 0x30(%rbx,%rdi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdi,4)
movdqu %xmm4,0x30(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1840 <hash+0x720>
test   $0x1,%bpl
je     18ac <hash+0x78c>
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
cmp    %rcx,%rdx
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1183 <hash+0x63>
nop
add    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    18c0 <hash+0x7a0>
jmp    1183 <hash+0x63>
lea    (%rsi,%rdx,1),%rdi
lea    (%rbx,%rdi,4),%rdi
cmp    %rbx,%rdi
jbe    1f4f <hash+0xe2f>
lea    (%rbx,%rdx,4),%rdi
lea    (%rbx,%rsi,4),%rbp
cmp    %rdi,%rbp
jae    1f4f <hash+0xe2f>
xor    %r8d,%r8d
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
jmp    1fc9 <hash+0xea9>
mov    %r8d,%edi
and    $0xfffffffe,%edi
lea    -0x2(%r13),%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    %ecx,(%rbx,%rsi,4)
lea    0x1(%rdx),%ebp
movslq %ebp,%rbp
add    %eax,(%rbx,%rbp,4)
add    %ecx,0x4(%rbx,%rsi,4)
movslq %edx,%rdx
add    %eax,(%rbx,%rdx,4)
add    $0x2,%rsi
add    $0xfffffffe,%edx
cmp    %rsi,%rdi
jne    1920 <hash+0x800>
test   $0x1,%r8b
je     1ea6 <hash+0xd86>
add    %ecx,(%rbx,%rsi,4)
jmp    1e9b <hash+0xd7b>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2046 <hash+0xf26>
mov    %rbp,%rsi
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
and    %rdi,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
movdqu 0x20(%rbx,%rdi,4),%xmm3
movdqu 0x30(%rbx,%rdi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdi,4)
movdqu %xmm4,0x30(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1990 <hash+0x870>
test   $0x1,%bpl
je     19fc <hash+0x8dc>
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
cmp    %rcx,%rdx
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1180 <hash+0x60>
nop
add    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1a10 <hash+0x8f0>
jmp    1180 <hash+0x60>
lea    (%rbx,%rbp,4),%rcx
lea    (%rbx,%rbp,8),%r9
lea    (%r8,%rbp,1),%rsi
lea    (%rbx,%rsi,4),%rsi
cmp    %rbx,%rsi
seta   %r15b
lea    (%rbx,%r8,4),%rdi
cmp    %rcx,%rdi
setb   %dl
cmp    %rsi,%rcx
setb   %cl
cmp    %r9,%rdi
setb   %dil
test   %dl,%r15b
jne    142a <hash+0x30a>
mov    $0x0,%esi
and    %dil,%cl
jne    142c <hash+0x30c>
mov    %ebp,%esi
and    $0xfffffffc,%esi
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm2
movd   %r10d,%xmm0
pshufd $0x0,%xmm0,%xmm1
movd   %r11d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x4(%rsi),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     209b <hash+0xf7b>
mov    %r9,%rcx
and    $0xfffffffffffffffe,%rcx
mov    0x18(%rsp),%rdx
xor    %edi,%edi
xchg   %ax,%ax
movdqu -0x10(%rdx),%xmm3
paddd  %xmm2,%xmm3
movdqu %xmm3,-0x10(%rdx)
movdqu -0x10(%rdx,%rbp,4),%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm3,-0x10(%rdx,%rbp,4)
movdqu -0x10(%rdx,%r8,4),%xmm3
paddd  %xmm0,%xmm3
movdqu %xmm3,-0x10(%rdx,%r8,4)
movdqu (%rdx),%xmm3
paddd  %xmm2,%xmm3
movdqu %xmm3,(%rdx)
movdqu (%rdx,%rbp,4),%xmm3
paddd  %xmm1,%xmm3
movdqu %xmm3,(%rdx,%rbp,4)
movdqu (%rdx,%r8,4),%xmm3
paddd  %xmm0,%xmm3
movdqu %xmm3,(%rdx,%r8,4)
add    $0x8,%rdi
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rcx
jne    1ab0 <hash+0x990>
test   $0x1,%r9b
je     1b4f <hash+0xa2f>
movdqu (%rbx,%rdi,4),%xmm3
paddd  %xmm3,%xmm2
movdqu %xmm2,(%rbx,%rdi,4)
lea    (%rdi,%rbp,1),%rcx
movdqu (%rbx,%rcx,4),%xmm2
paddd  %xmm1,%xmm2
movdqu %xmm2,(%rbx,%rcx,4)
add    %r8,%rdi
movdqu (%rbx,%rdi,4),%xmm1
paddd  %xmm0,%xmm1
movdqu %xmm1,(%rbx,%rdi,4)
cmp    %rbp,%rsi
jne    142c <hash+0x30c>
jmp    1454 <hash+0x334>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2079 <hash+0xf59>
mov    %rbp,%rsi
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
and    %rdi,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
movdqu 0x20(%rbx,%rdi,4),%xmm3
movdqu 0x30(%rbx,%rdi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdi,4)
movdqu %xmm4,0x30(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1ba0 <hash+0xa80>
test   $0x1,%bpl
je     1c0c <hash+0xaec>
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
cmp    %rcx,%rdx
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1180 <hash+0x60>
nop
add    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1c20 <hash+0xb00>
jmp    1180 <hash+0x60>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2057 <hash+0xf37>
mov    %rbp,%rsi
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
and    %rdi,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
movdqu 0x20(%rbx,%rdi,4),%xmm3
movdqu 0x30(%rbx,%rdi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdi,4)
movdqu %xmm4,0x30(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1c70 <hash+0xb50>
test   $0x1,%bpl
je     1cdc <hash+0xbbc>
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
cmp    %rcx,%rdx
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1183 <hash+0x63>
nop
add    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1cf0 <hash+0xbd0>
jmp    1183 <hash+0x63>
mov    %edx,%esi
and    $0xfffffff8,%esi
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
movd   %ecx,%xmm1
pshufd $0x0,%xmm1,%xmm1
mov    %rsi,%rdi
mov    0x18(%rsp),%rbp
movdqu -0x10(%rbp),%xmm2
movdqu 0x0(%rbp),%xmm3
paddd  %xmm0,%xmm2
paddd  %xmm0,%xmm3
movdqu %xmm2,-0x10(%rbp)
movdqu %xmm3,0x0(%rbp)
movdqu -0x10(%rbp,%rdx,4),%xmm2
movdqu 0x0(%rbp,%rdx,4),%xmm3
paddd  %xmm1,%xmm2
paddd  %xmm1,%xmm3
movdqu %xmm2,-0x10(%rbp,%rdx,4)
movdqu %xmm3,0x0(%rbp,%rdx,4)
add    $0x20,%rbp
add    $0xfffffffffffffff8,%rdi
jne    1d20 <hash+0xc00>
cmp    %rdx,%rsi
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1180 <hash+0x60>
lea    (%rbx,%rdx,4),%rdi
nopl   (%rax)
add    %eax,(%rbx,%rsi,4)
add    %ecx,(%rdi,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1d80 <hash+0xc60>
jmp    1180 <hash+0x60>
mov    %ecx,%edx
and    $0xfffffff8,%edx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rsi,%rsi
je     2068 <hash+0xf48>
mov    %rbp,%rsi
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
and    %rdi,%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
movdqu 0x20(%rbx,%rdi,4),%xmm3
movdqu 0x30(%rbx,%rdi,4),%xmm4
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
paddd  %xmm0,%xmm3
paddd  %xmm0,%xmm4
movdqu %xmm3,0x20(%rbx,%rdi,4)
movdqu %xmm4,0x30(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1dd0 <hash+0xcb0>
test   $0x1,%bpl
je     1e3c <hash+0xd1c>
movdqu (%rbx,%rdi,4),%xmm1
movdqu 0x10(%rbx,%rdi,4),%xmm2
paddd  %xmm0,%xmm1
paddd  %xmm0,%xmm2
movdqu %xmm1,(%rbx,%rdi,4)
movdqu %xmm2,0x10(%rbx,%rdi,4)
cmp    %rcx,%rdx
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1180 <hash+0x60>
nop
add    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    1e50 <hash+0xd30>
jmp    1180 <hash+0x60>
mov    %r8d,%edi
and    $0xfffffffe,%edi
lea    -0x2(%r13),%edx
xor    %esi,%esi
nopl   (%rax)
add    %ecx,(%rbx,%rsi,4)
lea    0x1(%rdx),%ebp
movslq %ebp,%rbp
add    %eax,(%rbx,%rbp,4)
add    %ecx,0x4(%rbx,%rsi,4)
movslq %edx,%rdx
add    %eax,(%rbx,%rdx,4)
add    $0x2,%rsi
add    $0xfffffffe,%edx
cmp    %rsi,%rdi
jne    1e70 <hash+0xd50>
test   $0x1,%r8b
je     1ea6 <hash+0xd86>
add    %ecx,(%rbx,%rsi,4)
not    %esi
add    %r13d,%esi
movslq %esi,%rcx
add    %eax,(%rbx,%rcx,4)
mov    %r13d,%r15d
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
jmp    1183 <hash+0x63>
mov    %r10d,%r9d
and    $0xfffffff8,%r9d
movd   %ecx,%xmm0
pshufd $0x0,%xmm0,%xmm0
movd   %eax,%xmm1
pshufd $0x0,%xmm1,%xmm1
mov    0x18(%rsp),%rdx
lea    (%rdx,%r10,4),%rsi
lea    (%rdx,%r8,4),%rbp
lea    0x0(,%r10,4),%rdi
and    $0xffffffffffffffe0,%rdi
xor    %edx,%edx
nopl   0x0(%rax)
movdqu -0x10(%rsi,%rdx,1),%xmm2
movdqu (%rsi,%rdx,1),%xmm3
paddd  %xmm0,%xmm2
paddd  %xmm0,%xmm3
movdqu %xmm2,-0x10(%rsi,%rdx,1)
movdqu %xmm3,(%rsi,%rdx,1)
movdqu -0x10(%rbp,%rdx,1),%xmm2
movdqu 0x0(%rbp,%rdx,1),%xmm3
paddd  %xmm1,%xmm2
paddd  %xmm1,%xmm3
movdqu %xmm2,-0x10(%rbp,%rdx,1)
movdqu %xmm3,0x0(%rbp,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rdi
jne    1ef0 <hash+0xdd0>
cmp    %r10,%r9
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1180 <hash+0x60>
jmp    12a5 <hash+0x185>
mov    %edx,%r8d
and    $0xfffffff8,%r8d
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
movd   %ecx,%xmm1
pshufd $0x0,%xmm1,%xmm1
mov    %r8,%rdi
mov    0x18(%rsp),%rbp
movdqu -0x10(%rbp),%xmm2
movdqu 0x0(%rbp),%xmm3
paddd  %xmm0,%xmm2
paddd  %xmm0,%xmm3
movdqu %xmm2,-0x10(%rbp)
movdqu %xmm3,0x0(%rbp)
movdqu -0x10(%rbp,%rsi,4),%xmm2
movdqu 0x0(%rbp,%rsi,4),%xmm3
paddd  %xmm1,%xmm2
paddd  %xmm1,%xmm3
movdqu %xmm2,-0x10(%rbp,%rsi,4)
movdqu %xmm3,0x0(%rbp,%rsi,4)
add    $0x20,%rbp
add    $0xfffffffffffffff8,%rdi
jne    1f70 <hash+0xe50>
cmp    %rdx,%r8
mov    0x10(%rsp),%r14
mov    0x8(%rsp),%rbp
je     1180 <hash+0x60>
mov    %r8,%rdi
test   $0x1,%dl
je     1fe3 <hash+0xec3>
add    %eax,(%rbx,%r8,4)
lea    (%r8,%rsi,1),%rdi
add    %ecx,(%rbx,%rdi,4)
mov    %r8,%rdi
or     $0x1,%rdi
not    %r8
add    %rdx,%r8
je     1180 <hash+0x60>
mov    0x20(%rsp),%rbp
lea    0x0(,%rsi,4),%rsi
add    %rbp,%rsi
nop
add    %eax,(%rbx,%rdi,4)
add    %ecx,-0x4(%rsi,%rdi,4)
add    %eax,0x4(%rbx,%rdi,4)
add    %ecx,(%rsi,%rdi,4)
add    $0x2,%rdi
cmp    %rdi,%rdx
jne    2000 <hash+0xee0>
mov    %r13d,%r15d
mov    0x8(%rsp),%rbp
jmp    1183 <hash+0x63>
xor    %edi,%edi
test   $0x1,%bpl
jne    17be <hash+0x69e>
jmp    17dc <hash+0x6bc>
xor    %edi,%edi
test   $0x1,%bpl
jne    188e <hash+0x76e>
jmp    18ac <hash+0x78c>
xor    %edi,%edi
test   $0x1,%bpl
jne    19de <hash+0x8be>
jmp    19fc <hash+0x8dc>
xor    %edi,%edi
test   $0x1,%bpl
jne    1cbe <hash+0xb9e>
jmp    1cdc <hash+0xbbc>
xor    %edi,%edi
test   $0x1,%bpl
jne    1e1e <hash+0xcfe>
jmp    1e3c <hash+0xd1c>
xor    %edi,%edi
test   $0x1,%bpl
jne    1bee <hash+0xace>
jmp    1c0c <hash+0xaec>
xor    %edi,%edi
test   $0x1,%r9b
jne    16ee <hash+0x5ce>
jmp    171f <hash+0x5ff>
xor    %edi,%edi
test   $0x1,%r9b
jne    1b1e <hash+0x9fe>
jmp    1b4f <hash+0xa2f>
mov    $0x1,%r15d
mov    %r15d,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@__const.hash.key = [6 x i32] [i32 1, i32 4, i32 16, i32 64, i32 256, i32 1024]
define i32 @hash(i8* nocapture %0, i32* %1, i32 %2) {
%4 = tail call i32 @memset(i32* %1, i32 0, i32 1024)
%5 = icmp sgt i32 %2, 0
br i1 %5, label %6, label %1128
6: ; preds = %3
%7 = zext i32 %2 to i64
br label %8
8: ; preds = %6, %1124
%9 = phi i64 [ 0, %6 ], [ %1126, %1124 ]
%10 = phi i32 [ 1, %6 ], [ %1125, %1124 ]
%11 = getelementptr inbounds i8, i8* %0, i64 %9
%12 = load i8, i8* %11
%13 = sext i8 %12 to i32
switch i32 %13, label %1124 [
i32 110, label %958
i32 99, label %146
i32 103, label %80
i32 116, label %14
i32 121, label %232
i32 114, label %272
i32 109, label %347
i32 107, label %421
i32 115, label %462
i32 119, label %502
i32 98, label %577
i32 100, label %701
i32 104, label %803
i32 118, label %897
]
14: ; preds = %8
%15 = icmp sgt i32 %10, 0
br i1 %15, label %16, label %1124
16: ; preds = %14
%17 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%18 = load i32, i32* %17
%19 = mul nsw i32 %18, 3
%20 = zext i32 %10 to i64
%21 = icmp ult i32 %10, 8
br i1 %21, label %78, label %22
22: ; preds = %16
%23 = and i64 %20, 4294967288
%24 = insertelement <4 x i32> poison, i32 %19, i64 0
%25 = shufflevector <4 x i32> %24, <4 x i32> poison, <4 x i32> zeroinitializer
%26 = insertelement <4 x i32> poison, i32 %19, i64 0
%27 = shufflevector <4 x i32> %26, <4 x i32> poison, <4 x i32> zeroinitializer
%28 = add nsw i64 %23, -8
%29 = lshr exact i64 %28, 3
%30 = add nuw nsw i64 %29, 1
%31 = and i64 %30, 1
%32 = icmp eq i64 %28, 0
br i1 %32, label %62, label %33
33: ; preds = %22
%34 = and i64 %30, 4611686018427387902
br label %35
35: ; preds = %35, %33
%36 = phi i64 [ 0, %33 ], [ %59, %35 ]
%37 = phi i64 [ 0, %33 ], [ %60, %35 ]
%38 = getelementptr inbounds i32, i32* %1, i64 %36
%39 = bitcast i32* %38 to <4 x i32>*
%40 = load <4 x i32>, <4 x i32>* %39
%41 = getelementptr inbounds i32, i32* %38, i64 4
%42 = bitcast i32* %41 to <4 x i32>*
%43 = load <4 x i32>, <4 x i32>* %42
%44 = add nsw <4 x i32> %25, %40
%45 = add nsw <4 x i32> %27, %43
%46 = bitcast i32* %38 to <4 x i32>*
store <4 x i32> %44, <4 x i32>* %46
%47 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> %45, <4 x i32>* %47
%48 = or i64 %36, 8
%49 = getelementptr inbounds i32, i32* %1, i64 %48
%50 = bitcast i32* %49 to <4 x i32>*
%51 = load <4 x i32>, <4 x i32>* %50
%52 = getelementptr inbounds i32, i32* %49, i64 4
%53 = bitcast i32* %52 to <4 x i32>*
%54 = load <4 x i32>, <4 x i32>* %53
%55 = add nsw <4 x i32> %25, %51
%56 = add nsw <4 x i32> %27, %54
%57 = bitcast i32* %49 to <4 x i32>*
store <4 x i32> %55, <4 x i32>* %57
%58 = bitcast i32* %52 to <4 x i32>*
store <4 x i32> %56, <4 x i32>* %58
%59 = add nuw i64 %36, 16
%60 = add i64 %37, 2
%61 = icmp eq i64 %60, %34
br i1 %61, label %62, label %35
62: ; preds = %35, %22
%63 = phi i64 [ 0, %22 ], [ %59, %35 ]
%64 = icmp eq i64 %31, 0
br i1 %64, label %76, label %65
65: ; preds = %62
%66 = getelementptr inbounds i32, i32* %1, i64 %63
%67 = bitcast i32* %66 to <4 x i32>*
%68 = load <4 x i32>, <4 x i32>* %67
%69 = getelementptr inbounds i32, i32* %66, i64 4
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = add nsw <4 x i32> %25, %68
%73 = add nsw <4 x i32> %27, %71
%74 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> %72, <4 x i32>* %74
%75 = bitcast i32* %69 to <4 x i32>*
store <4 x i32> %73, <4 x i32>* %75
br label %76
76: ; preds = %62, %65
%77 = icmp eq i64 %23, %20
br i1 %77, label %1124, label %78
78: ; preds = %16, %76
%79 = phi i64 [ 0, %16 ], [ %23, %76 ]
br label %225
80: ; preds = %8
%81 = icmp sgt i32 %10, 0
br i1 %81, label %82, label %1124
82: ; preds = %80
%83 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%84 = load i32, i32* %83
%85 = shl nsw i32 %84, 1
%86 = zext i32 %10 to i64
%87 = icmp ult i32 %10, 8
br i1 %87, label %144, label %88
88: ; preds = %82
%89 = and i64 %86, 4294967288
%90 = insertelement <4 x i32> poison, i32 %85, i64 0
%91 = shufflevector <4 x i32> %90, <4 x i32> poison, <4 x i32> zeroinitializer
%92 = insertelement <4 x i32> poison, i32 %85, i64 0
%93 = shufflevector <4 x i32> %92, <4 x i32> poison, <4 x i32> zeroinitializer
%94 = add nsw i64 %89, -8
%95 = lshr exact i64 %94, 3
%96 = add nuw nsw i64 %95, 1
%97 = and i64 %96, 1
%98 = icmp eq i64 %94, 0
br i1 %98, label %128, label %99
99: ; preds = %88
%100 = and i64 %96, 4611686018427387902
br label %101
101: ; preds = %101, %99
%102 = phi i64 [ 0, %99 ], [ %125, %101 ]
%103 = phi i64 [ 0, %99 ], [ %126, %101 ]
%104 = getelementptr inbounds i32, i32* %1, i64 %102
%105 = bitcast i32* %104 to <4 x i32>*
%106 = load <4 x i32>, <4 x i32>* %105
%107 = getelementptr inbounds i32, i32* %104, i64 4
%108 = bitcast i32* %107 to <4 x i32>*
%109 = load <4 x i32>, <4 x i32>* %108
%110 = add nsw <4 x i32> %91, %106
%111 = add nsw <4 x i32> %93, %109
%112 = bitcast i32* %104 to <4 x i32>*
store <4 x i32> %110, <4 x i32>* %112
%113 = bitcast i32* %107 to <4 x i32>*
store <4 x i32> %111, <4 x i32>* %113
%114 = or i64 %102, 8
%115 = getelementptr inbounds i32, i32* %1, i64 %114
%116 = bitcast i32* %115 to <4 x i32>*
%117 = load <4 x i32>, <4 x i32>* %116
%118 = getelementptr inbounds i32, i32* %115, i64 4
%119 = bitcast i32* %118 to <4 x i32>*
%120 = load <4 x i32>, <4 x i32>* %119
%121 = add nsw <4 x i32> %91, %117
%122 = add nsw <4 x i32> %93, %120
%123 = bitcast i32* %115 to <4 x i32>*
store <4 x i32> %121, <4 x i32>* %123
%124 = bitcast i32* %118 to <4 x i32>*
store <4 x i32> %122, <4 x i32>* %124
%125 = add nuw i64 %102, 16
%126 = add i64 %103, 2
%127 = icmp eq i64 %126, %100
br i1 %127, label %128, label %101
128: ; preds = %101, %88
%129 = phi i64 [ 0, %88 ], [ %125, %101 ]
%130 = icmp eq i64 %97, 0
br i1 %130, label %142, label %131
131: ; preds = %128
%132 = getelementptr inbounds i32, i32* %1, i64 %129
%133 = bitcast i32* %132 to <4 x i32>*
%134 = load <4 x i32>, <4 x i32>* %133
%135 = getelementptr inbounds i32, i32* %132, i64 4
%136 = bitcast i32* %135 to <4 x i32>*
%137 = load <4 x i32>, <4 x i32>* %136
%138 = add nsw <4 x i32> %91, %134
%139 = add nsw <4 x i32> %93, %137
%140 = bitcast i32* %132 to <4 x i32>*
store <4 x i32> %138, <4 x i32>* %140
%141 = bitcast i32* %135 to <4 x i32>*
store <4 x i32> %139, <4 x i32>* %141
br label %142
142: ; preds = %128, %131
%143 = icmp eq i64 %89, %86
br i1 %143, label %1124, label %144
144: ; preds = %82, %142
%145 = phi i64 [ 0, %82 ], [ %89, %142 ]
br label %218
146: ; preds = %8
%147 = icmp sgt i32 %10, 0
br i1 %147, label %148, label %1124
148: ; preds = %146
%149 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%150 = load i32, i32* %149
%151 = zext i32 %10 to i64
%152 = icmp ult i32 %10, 8
br i1 %152, label %209, label %153
153: ; preds = %148
%154 = and i64 %151, 4294967288
%155 = insertelement <4 x i32> poison, i32 %150, i64 0
%156 = shufflevector <4 x i32> %155, <4 x i32> poison, <4 x i32> zeroinitializer
%157 = insertelement <4 x i32> poison, i32 %150, i64 0
%158 = shufflevector <4 x i32> %157, <4 x i32> poison, <4 x i32> zeroinitializer
%159 = add nsw i64 %154, -8
%160 = lshr exact i64 %159, 3
%161 = add nuw nsw i64 %160, 1
%162 = and i64 %161, 1
%163 = icmp eq i64 %159, 0
br i1 %163, label %193, label %164
164: ; preds = %153
%165 = and i64 %161, 4611686018427387902
br label %166
166: ; preds = %166, %164
%167 = phi i64 [ 0, %164 ], [ %190, %166 ]
%168 = phi i64 [ 0, %164 ], [ %191, %166 ]
%169 = getelementptr inbounds i32, i32* %1, i64 %167
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = getelementptr inbounds i32, i32* %169, i64 4
%173 = bitcast i32* %172 to <4 x i32>*
%174 = load <4 x i32>, <4 x i32>* %173
%175 = add nsw <4 x i32> %156, %171
%176 = add nsw <4 x i32> %158, %174
%177 = bitcast i32* %169 to <4 x i32>*
store <4 x i32> %175, <4 x i32>* %177
%178 = bitcast i32* %172 to <4 x i32>*
store <4 x i32> %176, <4 x i32>* %178
%179 = or i64 %167, 8
%180 = getelementptr inbounds i32, i32* %1, i64 %179
%181 = bitcast i32* %180 to <4 x i32>*
%182 = load <4 x i32>, <4 x i32>* %181
%183 = getelementptr inbounds i32, i32* %180, i64 4
%184 = bitcast i32* %183 to <4 x i32>*
%185 = load <4 x i32>, <4 x i32>* %184
%186 = add nsw <4 x i32> %156, %182
%187 = add nsw <4 x i32> %158, %185
%188 = bitcast i32* %180 to <4 x i32>*
store <4 x i32> %186, <4 x i32>* %188
%189 = bitcast i32* %183 to <4 x i32>*
store <4 x i32> %187, <4 x i32>* %189
%190 = add nuw i64 %167, 16
%191 = add i64 %168, 2
%192 = icmp eq i64 %191, %165
br i1 %192, label %193, label %166
193: ; preds = %166, %153
%194 = phi i64 [ 0, %153 ], [ %190, %166 ]
%195 = icmp eq i64 %162, 0
br i1 %195, label %207, label %196
196: ; preds = %193
%197 = getelementptr inbounds i32, i32* %1, i64 %194
%198 = bitcast i32* %197 to <4 x i32>*
%199 = load <4 x i32>, <4 x i32>* %198
%200 = getelementptr inbounds i32, i32* %197, i64 4
%201 = bitcast i32* %200 to <4 x i32>*
%202 = load <4 x i32>, <4 x i32>* %201
%203 = add nsw <4 x i32> %156, %199
%204 = add nsw <4 x i32> %158, %202
%205 = bitcast i32* %197 to <4 x i32>*
store <4 x i32> %203, <4 x i32>* %205
%206 = bitcast i32* %200 to <4 x i32>*
store <4 x i32> %204, <4 x i32>* %206
br label %207
207: ; preds = %193, %196
%208 = icmp eq i64 %154, %151
br i1 %208, label %1124, label %209
209: ; preds = %148, %207
%210 = phi i64 [ 0, %148 ], [ %154, %207 ]
br label %211
211: ; preds = %209, %211
%212 = phi i64 [ %216, %211 ], [ %210, %209 ]
%213 = getelementptr inbounds i32, i32* %1, i64 %212
%214 = load i32, i32* %213
%215 = add nsw i32 %150, %214
store i32 %215, i32* %213
%216 = add nuw nsw i64 %212, 1
%217 = icmp eq i64 %216, %151
br i1 %217, label %1124, label %211
218: ; preds = %144, %218
%219 = phi i64 [ %223, %218 ], [ %145, %144 ]
%220 = getelementptr inbounds i32, i32* %1, i64 %219
%221 = load i32, i32* %220
%222 = add nsw i32 %85, %221
store i32 %222, i32* %220
%223 = add nuw nsw i64 %219, 1
%224 = icmp eq i64 %223, %86
br i1 %224, label %1124, label %218
225: ; preds = %78, %225
%226 = phi i64 [ %230, %225 ], [ %79, %78 ]
%227 = getelementptr inbounds i32, i32* %1, i64 %226
%228 = load i32, i32* %227
%229 = add nsw i32 %19, %228
store i32 %229, i32* %227
%230 = add nuw nsw i64 %226, 1
%231 = icmp eq i64 %230, %20
br i1 %231, label %1124, label %225
232: ; preds = %8
%233 = shl nsw i32 %10, 1
%234 = tail call i32 @fill_out_sum(i32 %10, i32 %233, i32* %1)
%235 = icmp sgt i32 %10, 0
br i1 %235, label %236, label %1124
236: ; preds = %232
%237 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%238 = load i32, i32* %237
%239 = mul nsw i32 %238, 3
%240 = zext i32 %10 to i64
%241 = and i64 %240, 1
%242 = icmp eq i32 %10, 1
br i1 %242, label %1082, label %243
243: ; preds = %236
%244 = and i64 %240, 4294967294
br label %245
245: ; preds = %245, %243
%246 = phi i64 [ 0, %243 ], [ %269, %245 ]
%247 = phi i64 [ 0, %243 ], [ %270, %245 ]
%248 = getelementptr inbounds i32, i32* %1, i64 %246
%249 = load i32, i32* %248
%250 = add nsw i32 %238, %249
store i32 %250, i32* %248
%251 = trunc i64 %246 to i32
%252 = xor i32 %251, -1
%253 = add i32 %233, %252
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i32, i32* %1, i64 %254
%256 = load i32, i32* %255
%257 = add nsw i32 %256, %239
store i32 %257, i32* %255
%258 = or i64 %246, 1
%259 = getelementptr inbounds i32, i32* %1, i64 %258
%260 = load i32, i32* %259
%261 = add nsw i32 %238, %260
store i32 %261, i32* %259
%262 = trunc i64 %258 to i32
%263 = xor i32 %262, -1
%264 = add i32 %233, %263
%265 = sext i32 %264 to i64
%266 = getelementptr inbounds i32, i32* %1, i64 %265
%267 = load i32, i32* %266
%268 = add nsw i32 %267, %239
store i32 %268, i32* %266
%269 = add nuw nsw i64 %246, 2
%270 = add i64 %247, 2
%271 = icmp eq i64 %270, %244
br i1 %271, label %1082, label %245
272: ; preds = %8
%273 = shl nsw i32 %10, 1
%274 = tail call i32 @fill_out_sum(i32 %10, i32 %273, i32* %1)
%275 = icmp sgt i32 %10, 0
br i1 %275, label %276, label %1124
276: ; preds = %272
%277 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%278 = load i32, i32* %277
%279 = shl nsw i32 %278, 1
%280 = zext i32 %10 to i64
%281 = icmp ult i32 %10, 8
br i1 %281, label %338, label %282
282: ; preds = %276
%283 = and i64 %280, 4294967288
%284 = insertelement <4 x i32> poison, i32 %279, i64 0
%285 = shufflevector <4 x i32> %284, <4 x i32> poison, <4 x i32> zeroinitializer
%286 = insertelement <4 x i32> poison, i32 %279, i64 0
%287 = shufflevector <4 x i32> %286, <4 x i32> poison, <4 x i32> zeroinitializer
%288 = add nsw i64 %283, -8
%289 = lshr exact i64 %288, 3
%290 = add nuw nsw i64 %289, 1
%291 = and i64 %290, 1
%292 = icmp eq i64 %288, 0
br i1 %292, label %322, label %293
293: ; preds = %282
%294 = and i64 %290, 4611686018427387902
br label %295
295: ; preds = %295, %293
%296 = phi i64 [ 0, %293 ], [ %319, %295 ]
%297 = phi i64 [ 0, %293 ], [ %320, %295 ]
%298 = getelementptr inbounds i32, i32* %1, i64 %296
%299 = bitcast i32* %298 to <4 x i32>*
%300 = load <4 x i32>, <4 x i32>* %299
%301 = getelementptr inbounds i32, i32* %298, i64 4
%302 = bitcast i32* %301 to <4 x i32>*
%303 = load <4 x i32>, <4 x i32>* %302
%304 = add nsw <4 x i32> %285, %300
%305 = add nsw <4 x i32> %287, %303
%306 = bitcast i32* %298 to <4 x i32>*
store <4 x i32> %304, <4 x i32>* %306
%307 = bitcast i32* %301 to <4 x i32>*
store <4 x i32> %305, <4 x i32>* %307
%308 = or i64 %296, 8
%309 = getelementptr inbounds i32, i32* %1, i64 %308
%310 = bitcast i32* %309 to <4 x i32>*
%311 = load <4 x i32>, <4 x i32>* %310
%312 = getelementptr inbounds i32, i32* %309, i64 4
%313 = bitcast i32* %312 to <4 x i32>*
%314 = load <4 x i32>, <4 x i32>* %313
%315 = add nsw <4 x i32> %285, %311
%316 = add nsw <4 x i32> %287, %314
%317 = bitcast i32* %309 to <4 x i32>*
store <4 x i32> %315, <4 x i32>* %317
%318 = bitcast i32* %312 to <4 x i32>*
store <4 x i32> %316, <4 x i32>* %318
%319 = add nuw i64 %296, 16
%320 = add i64 %297, 2
%321 = icmp eq i64 %320, %294
br i1 %321, label %322, label %295
322: ; preds = %295, %282
%323 = phi i64 [ 0, %282 ], [ %319, %295 ]
%324 = icmp eq i64 %291, 0
br i1 %324, label %336, label %325
325: ; preds = %322
%326 = getelementptr inbounds i32, i32* %1, i64 %323
%327 = bitcast i32* %326 to <4 x i32>*
%328 = load <4 x i32>, <4 x i32>* %327
%329 = getelementptr inbounds i32, i32* %326, i64 4
%330 = bitcast i32* %329 to <4 x i32>*
%331 = load <4 x i32>, <4 x i32>* %330
%332 = add nsw <4 x i32> %285, %328
%333 = add nsw <4 x i32> %287, %331
%334 = bitcast i32* %326 to <4 x i32>*
store <4 x i32> %332, <4 x i32>* %334
%335 = bitcast i32* %329 to <4 x i32>*
store <4 x i32> %333, <4 x i32>* %335
br label %336
336: ; preds = %322, %325
%337 = icmp eq i64 %283, %280
br i1 %337, label %1124, label %338
338: ; preds = %276, %336
%339 = phi i64 [ 0, %276 ], [ %283, %336 ]
br label %340
340: ; preds = %338, %340
%341 = phi i64 [ %345, %340 ], [ %339, %338 ]
%342 = getelementptr inbounds i32, i32* %1, i64 %341
%343 = load i32, i32* %342
%344 = add nsw i32 %279, %343
store i32 %344, i32* %342
%345 = add nuw nsw i64 %341, 1
%346 = icmp eq i64 %345, %280
br i1 %346, label %1124, label %340
347: ; preds = %8
%348 = shl nsw i32 %10, 1
%349 = tail call i32 @fill_out_sum(i32 %10, i32 %348, i32* %1)
%350 = icmp sgt i32 %10, 0
br i1 %350, label %351, label %1124
351: ; preds = %347
%352 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%353 = load i32, i32* %352
%354 = zext i32 %10 to i64
%355 = icmp ult i32 %10, 8
br i1 %355, label %412, label %356
356: ; preds = %351
%357 = and i64 %354, 4294967288
%358 = insertelement <4 x i32> poison, i32 %353, i64 0
%359 = shufflevector <4 x i32> %358, <4 x i32> poison, <4 x i32> zeroinitializer
%360 = insertelement <4 x i32> poison, i32 %353, i64 0
%361 = shufflevector <4 x i32> %360, <4 x i32> poison, <4 x i32> zeroinitializer
%362 = add nsw i64 %357, -8
%363 = lshr exact i64 %362, 3
%364 = add nuw nsw i64 %363, 1
%365 = and i64 %364, 1
%366 = icmp eq i64 %362, 0
br i1 %366, label %396, label %367
367: ; preds = %356
%368 = and i64 %364, 4611686018427387902
br label %369
369: ; preds = %369, %367
%370 = phi i64 [ 0, %367 ], [ %393, %369 ]
%371 = phi i64 [ 0, %367 ], [ %394, %369 ]
%372 = getelementptr inbounds i32, i32* %1, i64 %370
%373 = bitcast i32* %372 to <4 x i32>*
%374 = load <4 x i32>, <4 x i32>* %373
%375 = getelementptr inbounds i32, i32* %372, i64 4
%376 = bitcast i32* %375 to <4 x i32>*
%377 = load <4 x i32>, <4 x i32>* %376
%378 = add nsw <4 x i32> %359, %374
%379 = add nsw <4 x i32> %361, %377
%380 = bitcast i32* %372 to <4 x i32>*
store <4 x i32> %378, <4 x i32>* %380
%381 = bitcast i32* %375 to <4 x i32>*
store <4 x i32> %379, <4 x i32>* %381
%382 = or i64 %370, 8
%383 = getelementptr inbounds i32, i32* %1, i64 %382
%384 = bitcast i32* %383 to <4 x i32>*
%385 = load <4 x i32>, <4 x i32>* %384
%386 = getelementptr inbounds i32, i32* %383, i64 4
%387 = bitcast i32* %386 to <4 x i32>*
%388 = load <4 x i32>, <4 x i32>* %387
%389 = add nsw <4 x i32> %359, %385
%390 = add nsw <4 x i32> %361, %388
%391 = bitcast i32* %383 to <4 x i32>*
store <4 x i32> %389, <4 x i32>* %391
%392 = bitcast i32* %386 to <4 x i32>*
store <4 x i32> %390, <4 x i32>* %392
%393 = add nuw i64 %370, 16
%394 = add i64 %371, 2
%395 = icmp eq i64 %394, %368
br i1 %395, label %396, label %369
396: ; preds = %369, %356
%397 = phi i64 [ 0, %356 ], [ %393, %369 ]
%398 = icmp eq i64 %365, 0
br i1 %398, label %410, label %399
399: ; preds = %396
%400 = getelementptr inbounds i32, i32* %1, i64 %397
%401 = bitcast i32* %400 to <4 x i32>*
%402 = load <4 x i32>, <4 x i32>* %401
%403 = getelementptr inbounds i32, i32* %400, i64 4
%404 = bitcast i32* %403 to <4 x i32>*
%405 = load <4 x i32>, <4 x i32>* %404
%406 = add nsw <4 x i32> %359, %402
%407 = add nsw <4 x i32> %361, %405
%408 = bitcast i32* %400 to <4 x i32>*
store <4 x i32> %406, <4 x i32>* %408
%409 = bitcast i32* %403 to <4 x i32>*
store <4 x i32> %407, <4 x i32>* %409
br label %410
410: ; preds = %396, %399
%411 = icmp eq i64 %357, %354
br i1 %411, label %1124, label %412
412: ; preds = %351, %410
%413 = phi i64 [ 0, %351 ], [ %357, %410 ]
br label %414
414: ; preds = %412, %414
%415 = phi i64 [ %419, %414 ], [ %413, %412 ]
%416 = getelementptr inbounds i32, i32* %1, i64 %415
%417 = load i32, i32* %416
%418 = add nsw i32 %353, %417
store i32 %418, i32* %416
%419 = add nuw nsw i64 %415, 1
%420 = icmp eq i64 %419, %354
br i1 %420, label %1124, label %414
421: ; preds = %8
%422 = shl nsw i32 %10, 1
%423 = tail call i32 @fill_out_sum(i32 %10, i32 %422, i32* %1)
%424 = icmp sgt i32 %10, 0
br i1 %424, label %425, label %1124
425: ; preds = %421
%426 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%427 = load i32, i32* %426
%428 = shl nsw i32 %427, 1
%429 = mul nsw i32 %427, 3
%430 = zext i32 %10 to i64
%431 = and i64 %430, 1
%432 = icmp eq i32 %10, 1
br i1 %432, label %1096, label %433
433: ; preds = %425
%434 = and i64 %430, 4294967294
br label %435
435: ; preds = %435, %433
%436 = phi i64 [ 0, %433 ], [ %459, %435 ]
%437 = phi i64 [ 0, %433 ], [ %460, %435 ]
%438 = getelementptr inbounds i32, i32* %1, i64 %436
%439 = load i32, i32* %438
%440 = add nsw i32 %428, %439
store i32 %440, i32* %438
%441 = trunc i64 %436 to i32
%442 = xor i32 %441, -1
%443 = add i32 %422, %442
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds i32, i32* %1, i64 %444
%446 = load i32, i32* %445
%447 = add nsw i32 %446, %429
store i32 %447, i32* %445
%448 = or i64 %436, 1
%449 = getelementptr inbounds i32, i32* %1, i64 %448
%450 = load i32, i32* %449
%451 = add nsw i32 %428, %450
store i32 %451, i32* %449
%452 = trunc i64 %448 to i32
%453 = xor i32 %452, -1
%454 = add i32 %422, %453
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds i32, i32* %1, i64 %455
%457 = load i32, i32* %456
%458 = add nsw i32 %457, %429
store i32 %458, i32* %456
%459 = add nuw nsw i64 %436, 2
%460 = add i64 %437, 2
%461 = icmp eq i64 %460, %434
br i1 %461, label %1096, label %435
462: ; preds = %8
%463 = shl nsw i32 %10, 1
%464 = tail call i32 @fill_out_sum(i32 %10, i32 %463, i32* %1)
%465 = icmp sgt i32 %10, 0
br i1 %465, label %466, label %1124
466: ; preds = %462
%467 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%468 = load i32, i32* %467
%469 = shl nsw i32 %468, 1
%470 = zext i32 %10 to i64
%471 = and i64 %470, 1
%472 = icmp eq i32 %10, 1
br i1 %472, label %1110, label %473
473: ; preds = %466
%474 = and i64 %470, 4294967294
br label %475
475: ; preds = %475, %473
%476 = phi i64 [ 0, %473 ], [ %499, %475 ]
%477 = phi i64 [ 0, %473 ], [ %500, %475 ]
%478 = getelementptr inbounds i32, i32* %1, i64 %476
%479 = load i32, i32* %478
%480 = add nsw i32 %468, %479
store i32 %480, i32* %478
%481 = trunc i64 %476 to i32
%482 = xor i32 %481, -1
%483 = add i32 %463, %482
%484 = sext i32 %483 to i64
%485 = getelementptr inbounds i32, i32* %1, i64 %484
%486 = load i32, i32* %485
%487 = add nsw i32 %486, %469
store i32 %487, i32* %485
%488 = or i64 %476, 1
%489 = getelementptr inbounds i32, i32* %1, i64 %488
%490 = load i32, i32* %489
%491 = add nsw i32 %468, %490
store i32 %491, i32* %489
%492 = trunc i64 %488 to i32
%493 = xor i32 %492, -1
%494 = add i32 %463, %493
%495 = sext i32 %494 to i64
%496 = getelementptr inbounds i32, i32* %1, i64 %495
%497 = load i32, i32* %496
%498 = add nsw i32 %497, %469
store i32 %498, i32* %496
%499 = add nuw nsw i64 %476, 2
%500 = add i64 %477, 2
%501 = icmp eq i64 %500, %474
br i1 %501, label %1110, label %475
502: ; preds = %8
%503 = shl nsw i32 %10, 1
%504 = tail call i32 @fill_out_sum(i32 %10, i32 %503, i32* %1)
%505 = icmp sgt i32 %10, 0
br i1 %505, label %506, label %1124
506: ; preds = %502
%507 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%508 = load i32, i32* %507
%509 = mul nsw i32 %508, 3
%510 = zext i32 %10 to i64
%511 = icmp ult i32 %10, 8
br i1 %511, label %568, label %512
512: ; preds = %506
%513 = and i64 %510, 4294967288
%514 = insertelement <4 x i32> poison, i32 %509, i64 0
%515 = shufflevector <4 x i32> %514, <4 x i32> poison, <4 x i32> zeroinitializer
%516 = insertelement <4 x i32> poison, i32 %509, i64 0
%517 = shufflevector <4 x i32> %516, <4 x i32> poison, <4 x i32> zeroinitializer
%518 = add nsw i64 %513, -8
%519 = lshr exact i64 %518, 3
%520 = add nuw nsw i64 %519, 1
%521 = and i64 %520, 1
%522 = icmp eq i64 %518, 0
br i1 %522, label %552, label %523
523: ; preds = %512
%524 = and i64 %520, 4611686018427387902
br label %525
525: ; preds = %525, %523
%526 = phi i64 [ 0, %523 ], [ %549, %525 ]
%527 = phi i64 [ 0, %523 ], [ %550, %525 ]
%528 = getelementptr inbounds i32, i32* %1, i64 %526
%529 = bitcast i32* %528 to <4 x i32>*
%530 = load <4 x i32>, <4 x i32>* %529
%531 = getelementptr inbounds i32, i32* %528, i64 4
%532 = bitcast i32* %531 to <4 x i32>*
%533 = load <4 x i32>, <4 x i32>* %532
%534 = add nsw <4 x i32> %515, %530
%535 = add nsw <4 x i32> %517, %533
%536 = bitcast i32* %528 to <4 x i32>*
store <4 x i32> %534, <4 x i32>* %536
%537 = bitcast i32* %531 to <4 x i32>*
store <4 x i32> %535, <4 x i32>* %537
%538 = or i64 %526, 8
%539 = getelementptr inbounds i32, i32* %1, i64 %538
%540 = bitcast i32* %539 to <4 x i32>*
%541 = load <4 x i32>, <4 x i32>* %540
%542 = getelementptr inbounds i32, i32* %539, i64 4
%543 = bitcast i32* %542 to <4 x i32>*
%544 = load <4 x i32>, <4 x i32>* %543
%545 = add nsw <4 x i32> %515, %541
%546 = add nsw <4 x i32> %517, %544
%547 = bitcast i32* %539 to <4 x i32>*
store <4 x i32> %545, <4 x i32>* %547
%548 = bitcast i32* %542 to <4 x i32>*
store <4 x i32> %546, <4 x i32>* %548
%549 = add nuw i64 %526, 16
%550 = add i64 %527, 2
%551 = icmp eq i64 %550, %524
br i1 %551, label %552, label %525
552: ; preds = %525, %512
%553 = phi i64 [ 0, %512 ], [ %549, %525 ]
%554 = icmp eq i64 %521, 0
br i1 %554, label %566, label %555
555: ; preds = %552
%556 = getelementptr inbounds i32, i32* %1, i64 %553
%557 = bitcast i32* %556 to <4 x i32>*
%558 = load <4 x i32>, <4 x i32>* %557
%559 = getelementptr inbounds i32, i32* %556, i64 4
%560 = bitcast i32* %559 to <4 x i32>*
%561 = load <4 x i32>, <4 x i32>* %560
%562 = add nsw <4 x i32> %515, %558
%563 = add nsw <4 x i32> %517, %561
%564 = bitcast i32* %556 to <4 x i32>*
store <4 x i32> %562, <4 x i32>* %564
%565 = bitcast i32* %559 to <4 x i32>*
store <4 x i32> %563, <4 x i32>* %565
br label %566
566: ; preds = %552, %555
%567 = icmp eq i64 %513, %510
br i1 %567, label %1124, label %568
568: ; preds = %506, %566
%569 = phi i64 [ 0, %506 ], [ %513, %566 ]
br label %570
570: ; preds = %568, %570
%571 = phi i64 [ %575, %570 ], [ %569, %568 ]
%572 = getelementptr inbounds i32, i32* %1, i64 %571
%573 = load i32, i32* %572
%574 = add nsw i32 %509, %573
store i32 %574, i32* %572
%575 = add nuw nsw i64 %571, 1
%576 = icmp eq i64 %575, %510
br i1 %576, label %1124, label %570
577: ; preds = %8
%578 = mul nsw i32 %10, 3
%579 = tail call i32 @fill_out_sum(i32 %10, i32 %578, i32* %1)
%580 = icmp sgt i32 %10, 0
br i1 %580, label %581, label %1124
581: ; preds = %577
%582 = shl nuw nsw i32 %10, 1
%583 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%584 = load i32, i32* %583
%585 = shl nsw i32 %584, 1
%586 = mul nsw i32 %584, 3
%587 = zext i32 %10 to i64
%588 = sext i32 %582 to i64
%589 = zext i32 %10 to i64
%590 = icmp ult i32 %10, 4
br i1 %590, label %684, label %591
591: ; preds = %581
%592 = getelementptr i32, i32* %1, i64 %589
%593 = shl nuw nsw i64 %589, 1
%594 = getelementptr i32, i32* %1, i64 %593
%595 = getelementptr i32, i32* %1, i64 %588
%596 = add nsw i64 %588, %589
%597 = getelementptr i32, i32* %1, i64 %596
%598 = icmp ugt i32* %597, %1
%599 = icmp ult i32* %595, %592
%600 = and i1 %598, %599
%601 = icmp ult i32* %592, %597
%602 = icmp ult i32* %595, %594
%603 = and i1 %601, %602
%604 = or i1 %600, %603
br i1 %604, label %684, label %605
605: ; preds = %591
%606 = and i64 %589, 4294967292
%607 = insertelement <4 x i32> poison, i32 %584, i64 0
%608 = shufflevector <4 x i32> %607, <4 x i32> poison, <4 x i32> zeroinitializer
%609 = insertelement <4 x i32> poison, i32 %585, i64 0
%610 = shufflevector <4 x i32> %609, <4 x i32> poison, <4 x i32> zeroinitializer
%611 = insertelement <4 x i32> poison, i32 %586, i64 0
%612 = shufflevector <4 x i32> %611, <4 x i32> poison, <4 x i32> zeroinitializer
%613 = add nsw i64 %606, -4
%614 = lshr exact i64 %613, 2
%615 = add nuw nsw i64 %614, 1
%616 = and i64 %615, 1
%617 = icmp eq i64 %613, 0
br i1 %617, label %661, label %618
618: ; preds = %605
%619 = and i64 %615, 9223372036854775806
br label %620
620: ; preds = %620, %618
%621 = phi i64 [ 0, %618 ], [ %658, %620 ]
%622 = phi i64 [ 0, %618 ], [ %659, %620 ]
%623 = getelementptr inbounds i32, i32* %1, i64 %621
%624 = bitcast i32* %623 to <4 x i32>*
%625 = load <4 x i32>, <4 x i32>* %624
%626 = add nsw <4 x i32> %608, %625
%627 = bitcast i32* %623 to <4 x i32>*
store <4 x i32> %626, <4 x i32>* %627
%628 = add nuw nsw i64 %621, %587
%629 = getelementptr inbounds i32, i32* %1, i64 %628
%630 = bitcast i32* %629 to <4 x i32>*
%631 = load <4 x i32>, <4 x i32>* %630
%632 = add nsw <4 x i32> %631, %610
%633 = bitcast i32* %629 to <4 x i32>*
store <4 x i32> %632, <4 x i32>* %633
%634 = add nsw i64 %621, %588
%635 = getelementptr inbounds i32, i32* %1, i64 %634
%636 = bitcast i32* %635 to <4 x i32>*
%637 = load <4 x i32>, <4 x i32>* %636
%638 = add nsw <4 x i32> %637, %612
%639 = bitcast i32* %635 to <4 x i32>*
store <4 x i32> %638, <4 x i32>* %639
%640 = or i64 %621, 4
%641 = getelementptr inbounds i32, i32* %1, i64 %640
%642 = bitcast i32* %641 to <4 x i32>*
%643 = load <4 x i32>, <4 x i32>* %642
%644 = add nsw <4 x i32> %608, %643
%645 = bitcast i32* %641 to <4 x i32>*
store <4 x i32> %644, <4 x i32>* %645
%646 = add nuw nsw i64 %640, %587
%647 = getelementptr inbounds i32, i32* %1, i64 %646
%648 = bitcast i32* %647 to <4 x i32>*
%649 = load <4 x i32>, <4 x i32>* %648
%650 = add nsw <4 x i32> %649, %610
%651 = bitcast i32* %647 to <4 x i32>*
store <4 x i32> %650, <4 x i32>* %651
%652 = add nsw i64 %640, %588
%653 = getelementptr inbounds i32, i32* %1, i64 %652
%654 = bitcast i32* %653 to <4 x i32>*
%655 = load <4 x i32>, <4 x i32>* %654
%656 = add nsw <4 x i32> %655, %612
%657 = bitcast i32* %653 to <4 x i32>*
store <4 x i32> %656, <4 x i32>* %657
%658 = add nuw i64 %621, 8
%659 = add i64 %622, 2
%660 = icmp eq i64 %659, %619
br i1 %660, label %661, label %620
661: ; preds = %620, %605
%662 = phi i64 [ 0, %605 ], [ %658, %620 ]
%663 = icmp eq i64 %616, 0
br i1 %663, label %682, label %664
664: ; preds = %661
%665 = getelementptr inbounds i32, i32* %1, i64 %662
%666 = bitcast i32* %665 to <4 x i32>*
%667 = load <4 x i32>, <4 x i32>* %666
%668 = add nsw <4 x i32> %608, %667
%669 = bitcast i32* %665 to <4 x i32>*
store <4 x i32> %668, <4 x i32>* %669
%670 = add nuw nsw i64 %662, %587
%671 = getelementptr inbounds i32, i32* %1, i64 %670
%672 = bitcast i32* %671 to <4 x i32>*
%673 = load <4 x i32>, <4 x i32>* %672
%674 = add nsw <4 x i32> %673, %610
%675 = bitcast i32* %671 to <4 x i32>*
store <4 x i32> %674, <4 x i32>* %675
%676 = add nsw i64 %662, %588
%677 = getelementptr inbounds i32, i32* %1, i64 %676
%678 = bitcast i32* %677 to <4 x i32>*
%679 = load <4 x i32>, <4 x i32>* %678
%680 = add nsw <4 x i32> %679, %612
%681 = bitcast i32* %677 to <4 x i32>*
store <4 x i32> %680, <4 x i32>* %681
br label %682
682: ; preds = %661, %664
%683 = icmp eq i64 %606, %589
br i1 %683, label %1124, label %684
684: ; preds = %591, %581, %682
%685 = phi i64 [ 0, %591 ], [ 0, %581 ], [ %606, %682 ]
br label %686
686: ; preds = %684, %686
%687 = phi i64 [ %699, %686 ], [ %685, %684 ]
%688 = getelementptr inbounds i32, i32* %1, i64 %687
%689 = load i32, i32* %688
%690 = add nsw i32 %584, %689
store i32 %690, i32* %688
%691 = add nuw nsw i64 %687, %587
%692 = getelementptr inbounds i32, i32* %1, i64 %691
%693 = load i32, i32* %692
%694 = add nsw i32 %693, %585
store i32 %694, i32* %692
%695 = add nsw i64 %687, %588
%696 = getelementptr inbounds i32, i32* %1, i64 %695
%697 = load i32, i32* %696
%698 = add nsw i32 %697, %586
store i32 %698, i32* %696
%699 = add nuw nsw i64 %687, 1
%700 = icmp eq i64 %699, %589
br i1 %700, label %1124, label %686
701: ; preds = %8
%702 = mul nsw i32 %10, 3
%703 = tail call i32 @fill_out_sum(i32 %10, i32 %702, i32* %1)
%704 = icmp sgt i32 %10, 0
br i1 %704, label %705, label %1124
705: ; preds = %701
%706 = shl nuw nsw i32 %10, 1
%707 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%708 = load i32, i32* %707
%709 = shl nsw i32 %708, 1
%710 = mul nsw i32 %708, 3
%711 = zext i32 %10 to i64
%712 = sext i32 %706 to i64
%713 = zext i32 %10 to i64
%714 = icmp ult i32 %10, 8
br i1 %714, label %763, label %715
715: ; preds = %705
%716 = getelementptr i32, i32* %1, i64 %713
%717 = shl nuw nsw i64 %713, 1
%718 = getelementptr i32, i32* %1, i64 %717
%719 = getelementptr i32, i32* %1, i64 %712
%720 = add nsw i64 %712, %713
%721 = getelementptr i32, i32* %1, i64 %720
%722 = icmp ult i32* %716, %721
%723 = icmp ult i32* %719, %718
%724 = and i1 %722, %723
br i1 %724, label %763, label %725
725: ; preds = %715
%726 = and i64 %713, 4294967288
%727 = insertelement <4 x i32> poison, i32 %709, i64 0
%728 = shufflevector <4 x i32> %727, <4 x i32> poison, <4 x i32> zeroinitializer
%729 = insertelement <4 x i32> poison, i32 %709, i64 0
%730 = shufflevector <4 x i32> %729, <4 x i32> poison, <4 x i32> zeroinitializer
%731 = insertelement <4 x i32> poison, i32 %710, i64 0
%732 = shufflevector <4 x i32> %731, <4 x i32> poison, <4 x i32> zeroinitializer
%733 = insertelement <4 x i32> poison, i32 %710, i64 0
%734 = shufflevector <4 x i32> %733, <4 x i32> poison, <4 x i32> zeroinitializer
br label %735
735: ; preds = %735, %725
%736 = phi i64 [ 0, %725 ], [ %759, %735 ]
%737 = add nuw nsw i64 %736, %711
%738 = getelementptr inbounds i32, i32* %1, i64 %737
%739 = bitcast i32* %738 to <4 x i32>*
%740 = load <4 x i32>, <4 x i32>* %739
%741 = getelementptr inbounds i32, i32* %738, i64 4
%742 = bitcast i32* %741 to <4 x i32>*
%743 = load <4 x i32>, <4 x i32>* %742
%744 = add nsw <4 x i32> %728, %740
%745 = add nsw <4 x i32> %730, %743
%746 = bitcast i32* %738 to <4 x i32>*
store <4 x i32> %744, <4 x i32>* %746
%747 = bitcast i32* %741 to <4 x i32>*
store <4 x i32> %745, <4 x i32>* %747
%748 = add nsw i64 %736, %712
%749 = getelementptr inbounds i32, i32* %1, i64 %748
%750 = bitcast i32* %749 to <4 x i32>*
%751 = load <4 x i32>, <4 x i32>* %750
%752 = getelementptr inbounds i32, i32* %749, i64 4
%753 = bitcast i32* %752 to <4 x i32>*
%754 = load <4 x i32>, <4 x i32>* %753
%755 = add nsw <4 x i32> %751, %732
%756 = add nsw <4 x i32> %754, %734
%757 = bitcast i32* %749 to <4 x i32>*
store <4 x i32> %755, <4 x i32>* %757
%758 = bitcast i32* %752 to <4 x i32>*
store <4 x i32> %756, <4 x i32>* %758
%759 = add nuw i64 %736, 8
%760 = icmp eq i64 %759, %726
br i1 %760, label %761, label %735
761: ; preds = %735
%762 = icmp eq i64 %726, %713
br i1 %762, label %1124, label %763
763: ; preds = %715, %705, %761
%764 = phi i64 [ 0, %715 ], [ 0, %705 ], [ %726, %761 ]
%765 = xor i64 %764, -1
%766 = and i64 %713, 1
%767 = icmp eq i64 %766, 0
br i1 %767, label %778, label %768
768: ; preds = %763
%769 = add nuw nsw i64 %764, %711
%770 = getelementptr inbounds i32, i32* %1, i64 %769
%771 = load i32, i32* %770
%772 = add nsw i32 %709, %771
store i32 %772, i32* %770
%773 = add nsw i64 %764, %712
%774 = getelementptr inbounds i32, i32* %1, i64 %773
%775 = load i32, i32* %774
%776 = add nsw i32 %775, %710
store i32 %776, i32* %774
%777 = or i64 %764, 1
br label %778
778: ; preds = %768, %763
%779 = phi i64 [ %764, %763 ], [ %777, %768 ]
%780 = sub nsw i64 0, %713
%781 = icmp eq i64 %765, %780
br i1 %781, label %1124, label %782
782: ; preds = %778, %782
%783 = phi i64 [ %801, %782 ], [ %779, %778 ]
%784 = add nuw nsw i64 %783, %711
%785 = getelementptr inbounds i32, i32* %1, i64 %784
%786 = load i32, i32* %785
%787 = add nsw i32 %709, %786
store i32 %787, i32* %785
%788 = add nsw i64 %783, %712
%789 = getelementptr inbounds i32, i32* %1, i64 %788
%790 = load i32, i32* %789
%791 = add nsw i32 %790, %710
store i32 %791, i32* %789
%792 = add nuw nsw i64 %783, 1
%793 = add nuw nsw i64 %792, %711
%794 = getelementptr inbounds i32, i32* %1, i64 %793
%795 = load i32, i32* %794
%796 = add nsw i32 %709, %795
store i32 %796, i32* %794
%797 = add nsw i64 %792, %712
%798 = getelementptr inbounds i32, i32* %1, i64 %797
%799 = load i32, i32* %798
%800 = add nsw i32 %799, %710
store i32 %800, i32* %798
%801 = add nuw nsw i64 %783, 2
%802 = icmp eq i64 %801, %713
br i1 %802, label %1124, label %782
803: ; preds = %8
%804 = mul nsw i32 %10, 3
%805 = tail call i32 @fill_out_sum(i32 %10, i32 %804, i32* %1)
%806 = icmp sgt i32 %10, 0
br i1 %806, label %807, label %1124
807: ; preds = %803
%808 = shl nuw nsw i32 %10, 1
%809 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%810 = load i32, i32* %809
%811 = mul nsw i32 %810, 3
%812 = sext i32 %808 to i64
%813 = zext i32 %10 to i64
%814 = icmp ult i32 %10, 8
br i1 %814, label %860, label %815
815: ; preds = %807
%816 = getelementptr i32, i32* %1, i64 %813
%817 = getelementptr i32, i32* %1, i64 %812
%818 = add nsw i64 %812, %813
%819 = getelementptr i32, i32* %1, i64 %818
%820 = icmp ugt i32* %819, %1
%821 = icmp ult i32* %817, %816
%822 = and i1 %820, %821
br i1 %822, label %860, label %823
823: ; preds = %815
%824 = and i64 %813, 4294967288
%825 = insertelement <4 x i32> poison, i32 %810, i64 0
%826 = shufflevector <4 x i32> %825, <4 x i32> poison, <4 x i32> zeroinitializer
%827 = insertelement <4 x i32> poison, i32 %810, i64 0
%828 = shufflevector <4 x i32> %827, <4 x i32> poison, <4 x i32> zeroinitializer
%829 = insertelement <4 x i32> poison, i32 %811, i64 0
%830 = shufflevector <4 x i32> %829, <4 x i32> poison, <4 x i32> zeroinitializer
%831 = insertelement <4 x i32> poison, i32 %811, i64 0
%832 = shufflevector <4 x i32> %831, <4 x i32> poison, <4 x i32> zeroinitializer
br label %833
833: ; preds = %833, %823
%834 = phi i64 [ 0, %823 ], [ %856, %833 ]
%835 = getelementptr inbounds i32, i32* %1, i64 %834
%836 = bitcast i32* %835 to <4 x i32>*
%837 = load <4 x i32>, <4 x i32>* %836
%838 = getelementptr inbounds i32, i32* %835, i64 4
%839 = bitcast i32* %838 to <4 x i32>*
%840 = load <4 x i32>, <4 x i32>* %839
%841 = add nsw <4 x i32> %826, %837
%842 = add nsw <4 x i32> %828, %840
%843 = bitcast i32* %835 to <4 x i32>*
store <4 x i32> %841, <4 x i32>* %843
%844 = bitcast i32* %838 to <4 x i32>*
store <4 x i32> %842, <4 x i32>* %844
%845 = add nsw i64 %834, %812
%846 = getelementptr inbounds i32, i32* %1, i64 %845
%847 = bitcast i32* %846 to <4 x i32>*
%848 = load <4 x i32>, <4 x i32>* %847
%849 = getelementptr inbounds i32, i32* %846, i64 4
%850 = bitcast i32* %849 to <4 x i32>*
%851 = load <4 x i32>, <4 x i32>* %850
%852 = add nsw <4 x i32> %848, %830
%853 = add nsw <4 x i32> %851, %832
%854 = bitcast i32* %846 to <4 x i32>*
store <4 x i32> %852, <4 x i32>* %854
%855 = bitcast i32* %849 to <4 x i32>*
store <4 x i32> %853, <4 x i32>* %855
%856 = add nuw i64 %834, 8
%857 = icmp eq i64 %856, %824
br i1 %857, label %858, label %833
858: ; preds = %833
%859 = icmp eq i64 %824, %813
br i1 %859, label %1124, label %860
860: ; preds = %815, %807, %858
%861 = phi i64 [ 0, %815 ], [ 0, %807 ], [ %824, %858 ]
%862 = xor i64 %861, -1
%863 = and i64 %813, 1
%864 = icmp eq i64 %863, 0
br i1 %864, label %874, label %865
865: ; preds = %860
%866 = getelementptr inbounds i32, i32* %1, i64 %861
%867 = load i32, i32* %866
%868 = add nsw i32 %810, %867
store i32 %868, i32* %866
%869 = add nsw i64 %861, %812
%870 = getelementptr inbounds i32, i32* %1, i64 %869
%871 = load i32, i32* %870
%872 = add nsw i32 %871, %811
store i32 %872, i32* %870
%873 = or i64 %861, 1
br label %874
874: ; preds = %865, %860
%875 = phi i64 [ %861, %860 ], [ %873, %865 ]
%876 = sub nsw i64 0, %813
%877 = icmp eq i64 %862, %876
br i1 %877, label %1124, label %878
878: ; preds = %874, %878
%879 = phi i64 [ %895, %878 ], [ %875, %874 ]
%880 = getelementptr inbounds i32, i32* %1, i64 %879
%881 = load i32, i32* %880
%882 = add nsw i32 %810, %881
store i32 %882, i32* %880
%883 = add nsw i64 %879, %812
%884 = getelementptr inbounds i32, i32* %1, i64 %883
%885 = load i32, i32* %884
%886 = add nsw i32 %885, %811
store i32 %886, i32* %884
%887 = add nuw nsw i64 %879, 1
%888 = getelementptr inbounds i32, i32* %1, i64 %887
%889 = load i32, i32* %888
%890 = add nsw i32 %810, %889
store i32 %890, i32* %888
%891 = add nsw i64 %887, %812
%892 = getelementptr inbounds i32, i32* %1, i64 %891
%893 = load i32, i32* %892
%894 = add nsw i32 %893, %811
store i32 %894, i32* %892
%895 = add nuw nsw i64 %879, 2
%896 = icmp eq i64 %895, %813
br i1 %896, label %1124, label %878
897: ; preds = %8
%898 = mul nsw i32 %10, 3
%899 = tail call i32 @fill_out_sum(i32 %10, i32 %898, i32* %1)
%900 = icmp sgt i32 %10, 0
br i1 %900, label %901, label %1124
901: ; preds = %897
%902 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%903 = load i32, i32* %902
%904 = shl nsw i32 %903, 1
%905 = zext i32 %10 to i64
%906 = zext i32 %10 to i64
%907 = icmp ult i32 %10, 8
br i1 %907, label %945, label %908
908: ; preds = %901
%909 = and i64 %906, 4294967288
%910 = insertelement <4 x i32> poison, i32 %903, i64 0
%911 = shufflevector <4 x i32> %910, <4 x i32> poison, <4 x i32> zeroinitializer
%912 = insertelement <4 x i32> poison, i32 %903, i64 0
%913 = shufflevector <4 x i32> %912, <4 x i32> poison, <4 x i32> zeroinitializer
%914 = insertelement <4 x i32> poison, i32 %904, i64 0
%915 = shufflevector <4 x i32> %914, <4 x i32> poison, <4 x i32> zeroinitializer
%916 = insertelement <4 x i32> poison, i32 %904, i64 0
%917 = shufflevector <4 x i32> %916, <4 x i32> poison, <4 x i32> zeroinitializer
br label %918
918: ; preds = %918, %908
%919 = phi i64 [ 0, %908 ], [ %941, %918 ]
%920 = getelementptr inbounds i32, i32* %1, i64 %919
%921 = bitcast i32* %920 to <4 x i32>*
%922 = load <4 x i32>, <4 x i32>* %921
%923 = getelementptr inbounds i32, i32* %920, i64 4
%924 = bitcast i32* %923 to <4 x i32>*
%925 = load <4 x i32>, <4 x i32>* %924
%926 = add nsw <4 x i32> %911, %922
%927 = add nsw <4 x i32> %913, %925
%928 = bitcast i32* %920 to <4 x i32>*
store <4 x i32> %926, <4 x i32>* %928
%929 = bitcast i32* %923 to <4 x i32>*
store <4 x i32> %927, <4 x i32>* %929
%930 = add nuw nsw i64 %919, %905
%931 = getelementptr inbounds i32, i32* %1, i64 %930
%932 = bitcast i32* %931 to <4 x i32>*
%933 = load <4 x i32>, <4 x i32>* %932
%934 = getelementptr inbounds i32, i32* %931, i64 4
%935 = bitcast i32* %934 to <4 x i32>*
%936 = load <4 x i32>, <4 x i32>* %935
%937 = add nsw <4 x i32> %933, %915
%938 = add nsw <4 x i32> %936, %917
%939 = bitcast i32* %931 to <4 x i32>*
store <4 x i32> %937, <4 x i32>* %939
%940 = bitcast i32* %934 to <4 x i32>*
store <4 x i32> %938, <4 x i32>* %940
%941 = add nuw i64 %919, 8
%942 = icmp eq i64 %941, %909
br i1 %942, label %943, label %918
943: ; preds = %918
%944 = icmp eq i64 %909, %906
br i1 %944, label %1124, label %945
945: ; preds = %901, %943
%946 = phi i64 [ 0, %901 ], [ %909, %943 ]
br label %947
947: ; preds = %945, %947
%948 = phi i64 [ %956, %947 ], [ %946, %945 ]
%949 = getelementptr inbounds i32, i32* %1, i64 %948
%950 = load i32, i32* %949
%951 = add nsw i32 %903, %950
store i32 %951, i32* %949
%952 = add nuw nsw i64 %948, %905
%953 = getelementptr inbounds i32, i32* %1, i64 %952
%954 = load i32, i32* %953
%955 = add nsw i32 %954, %904
store i32 %955, i32* %953
%956 = add nuw nsw i64 %948, 1
%957 = icmp eq i64 %956, %906
br i1 %957, label %1124, label %947
958: ; preds = %8
%959 = shl nsw i32 %10, 2
%960 = tail call i32 @fill_out_sum(i32 %10, i32 %959, i32* %1)
%961 = icmp sgt i32 %10, 0
br i1 %961, label %962, label %1124
962: ; preds = %958
%963 = shl nuw nsw i32 %10, 1
%964 = getelementptr inbounds [6 x i32], [6 x i32]* @__const.hash.key, i64 0, i64 %9
%965 = load i32, i32* %964
%966 = shl nsw i32 %965, 1
%967 = mul nsw i32 %965, 3
%968 = zext i32 %10 to i64
%969 = sext i32 %963 to i64
%970 = zext i32 %10 to i64
%971 = icmp ult i32 %10, 4
br i1 %971, label %1065, label %972
972: ; preds = %962
%973 = getelementptr i32, i32* %1, i64 %970
%974 = shl nuw nsw i64 %970, 1
%975 = getelementptr i32, i32* %1, i64 %974
%976 = getelementptr i32, i32* %1, i64 %969
%977 = add nsw i64 %969, %970
%978 = getelementptr i32, i32* %1, i64 %977
%979 = icmp ugt i32* %978, %1
%980 = icmp ult i32* %976, %973
%981 = and i1 %979, %980
%982 = icmp ult i32* %973, %978
%983 = icmp ult i32* %976, %975
%984 = and i1 %982, %983
%985 = or i1 %981, %984
br i1 %985, label %1065, label %986
986: ; preds = %972
%987 = and i64 %970, 4294967292
%988 = insertelement <4 x i32> poison, i32 %965, i64 0
%989 = shufflevector <4 x i32> %988, <4 x i32> poison, <4 x i32> zeroinitializer
%990 = insertelement <4 x i32> poison, i32 %966, i64 0
%991 = shufflevector <4 x i32> %990, <4 x i32> poison, <4 x i32> zeroinitializer
%992 = insertelement <4 x i32> poison, i32 %967, i64 0
%993 = shufflevector <4 x i32> %992, <4 x i32> poison, <4 x i32> zeroinitializer
%994 = add nsw i64 %987, -4
%995 = lshr exact i64 %994, 2
%996 = add nuw nsw i64 %995, 1
%997 = and i64 %996, 1
%998 = icmp eq i64 %994, 0
br i1 %998, label %1042, label %999
999: ; preds = %986
%1000 = and i64 %996, 9223372036854775806
br label %1001
1001: ; preds = %1001, %999
%1002 = phi i64 [ 0, %999 ], [ %1039, %1001 ]
%1003 = phi i64 [ 0, %999 ], [ %1040, %1001 ]
%1004 = getelementptr inbounds i32, i32* %1, i64 %1002
%1005 = bitcast i32* %1004 to <4 x i32>*
%1006 = load <4 x i32>, <4 x i32>* %1005
%1007 = add nsw <4 x i32> %989, %1006
%1008 = bitcast i32* %1004 to <4 x i32>*
store <4 x i32> %1007, <4 x i32>* %1008
%1009 = add nuw nsw i64 %1002, %968
%1010 = getelementptr inbounds i32, i32* %1, i64 %1009
%1011 = bitcast i32* %1010 to <4 x i32>*
%1012 = load <4 x i32>, <4 x i32>* %1011
%1013 = add nsw <4 x i32> %1012, %991
%1014 = bitcast i32* %1010 to <4 x i32>*
store <4 x i32> %1013, <4 x i32>* %1014
%1015 = add nsw i64 %1002, %969
%1016 = getelementptr inbounds i32, i32* %1, i64 %1015
%1017 = bitcast i32* %1016 to <4 x i32>*
%1018 = load <4 x i32>, <4 x i32>* %1017
%1019 = add nsw <4 x i32> %1018, %993
%1020 = bitcast i32* %1016 to <4 x i32>*
store <4 x i32> %1019, <4 x i32>* %1020
%1021 = or i64 %1002, 4
%1022 = getelementptr inbounds i32, i32* %1, i64 %1021
%1023 = bitcast i32* %1022 to <4 x i32>*
%1024 = load <4 x i32>, <4 x i32>* %1023
%1025 = add nsw <4 x i32> %989, %1024
%1026 = bitcast i32* %1022 to <4 x i32>*
store <4 x i32> %1025, <4 x i32>* %1026
%1027 = add nuw nsw i64 %1021, %968
%1028 = getelementptr inbounds i32, i32* %1, i64 %1027
%1029 = bitcast i32* %1028 to <4 x i32>*
%1030 = load <4 x i32>, <4 x i32>* %1029
%1031 = add nsw <4 x i32> %1030, %991
%1032 = bitcast i32* %1028 to <4 x i32>*
store <4 x i32> %1031, <4 x i32>* %1032
%1033 = add nsw i64 %1021, %969
%1034 = getelementptr inbounds i32, i32* %1, i64 %1033
%1035 = bitcast i32* %1034 to <4 x i32>*
%1036 = load <4 x i32>, <4 x i32>* %1035
%1037 = add nsw <4 x i32> %1036, %993
%1038 = bitcast i32* %1034 to <4 x i32>*
store <4 x i32> %1037, <4 x i32>* %1038
%1039 = add nuw i64 %1002, 8
%1040 = add i64 %1003, 2
%1041 = icmp eq i64 %1040, %1000
br i1 %1041, label %1042, label %1001
1042: ; preds = %1001, %986
%1043 = phi i64 [ 0, %986 ], [ %1039, %1001 ]
%1044 = icmp eq i64 %997, 0
br i1 %1044, label %1063, label %1045
1045: ; preds = %1042
%1046 = getelementptr inbounds i32, i32* %1, i64 %1043
%1047 = bitcast i32* %1046 to <4 x i32>*
%1048 = load <4 x i32>, <4 x i32>* %1047
%1049 = add nsw <4 x i32> %989, %1048
%1050 = bitcast i32* %1046 to <4 x i32>*
store <4 x i32> %1049, <4 x i32>* %1050
%1051 = add nuw nsw i64 %1043, %968
%1052 = getelementptr inbounds i32, i32* %1, i64 %1051
%1053 = bitcast i32* %1052 to <4 x i32>*
%1054 = load <4 x i32>, <4 x i32>* %1053
%1055 = add nsw <4 x i32> %1054, %991
%1056 = bitcast i32* %1052 to <4 x i32>*
store <4 x i32> %1055, <4 x i32>* %1056
%1057 = add nsw i64 %1043, %969
%1058 = getelementptr inbounds i32, i32* %1, i64 %1057
%1059 = bitcast i32* %1058 to <4 x i32>*
%1060 = load <4 x i32>, <4 x i32>* %1059
%1061 = add nsw <4 x i32> %1060, %993
%1062 = bitcast i32* %1058 to <4 x i32>*
store <4 x i32> %1061, <4 x i32>* %1062
br label %1063
1063: ; preds = %1042, %1045
%1064 = icmp eq i64 %987, %970
br i1 %1064, label %1124, label %1065
1065: ; preds = %972, %962, %1063
%1066 = phi i64 [ 0, %972 ], [ 0, %962 ], [ %987, %1063 ]
br label %1067
1067: ; preds = %1065, %1067
%1068 = phi i64 [ %1080, %1067 ], [ %1066, %1065 ]
%1069 = getelementptr inbounds i32, i32* %1, i64 %1068
%1070 = load i32, i32* %1069
%1071 = add nsw i32 %965, %1070
store i32 %1071, i32* %1069
%1072 = add nuw nsw i64 %1068, %968
%1073 = getelementptr inbounds i32, i32* %1, i64 %1072
%1074 = load i32, i32* %1073
%1075 = add nsw i32 %1074, %966
store i32 %1075, i32* %1073
%1076 = add nsw i64 %1068, %969
%1077 = getelementptr inbounds i32, i32* %1, i64 %1076
%1078 = load i32, i32* %1077
%1079 = add nsw i32 %1078, %967
store i32 %1079, i32* %1077
%1080 = add nuw nsw i64 %1068, 1
%1081 = icmp eq i64 %1080, %970
br i1 %1081, label %1124, label %1067
1082: ; preds = %245, %236
%1083 = phi i64 [ 0, %236 ], [ %269, %245 ]
%1084 = icmp eq i64 %241, 0
br i1 %1084, label %1124, label %1085
1085: ; preds = %1082
%1086 = getelementptr inbounds i32, i32* %1, i64 %1083
%1087 = load i32, i32* %1086
%1088 = add nsw i32 %238, %1087
store i32 %1088, i32* %1086
%1089 = trunc i64 %1083 to i32
%1090 = xor i32 %1089, -1
%1091 = add i32 %233, %1090
%1092 = sext i32 %1091 to i64
%1093 = getelementptr inbounds i32, i32* %1, i64 %1092
%1094 = load i32, i32* %1093
%1095 = add nsw i32 %1094, %239
store i32 %1095, i32* %1093
br label %1124
1096: ; preds = %435, %425
%1097 = phi i64 [ 0, %425 ], [ %459, %435 ]
%1098 = icmp eq i64 %431, 0
br i1 %1098, label %1124, label %1099
1099: ; preds = %1096
%1100 = getelementptr inbounds i32, i32* %1, i64 %1097
%1101 = load i32, i32* %1100
%1102 = add nsw i32 %428, %1101
store i32 %1102, i32* %1100
%1103 = trunc i64 %1097 to i32
%1104 = xor i32 %1103, -1
%1105 = add i32 %422, %1104
%1106 = sext i32 %1105 to i64
%1107 = getelementptr inbounds i32, i32* %1, i64 %1106
%1108 = load i32, i32* %1107
%1109 = add nsw i32 %1108, %429
store i32 %1109, i32* %1107
br label %1124
1110: ; preds = %475, %466
%1111 = phi i64 [ 0, %466 ], [ %499, %475 ]
%1112 = icmp eq i64 %471, 0
br i1 %1112, label %1124, label %1113
1113: ; preds = %1110
%1114 = getelementptr inbounds i32, i32* %1, i64 %1111
%1115 = load i32, i32* %1114
%1116 = add nsw i32 %468, %1115
store i32 %1116, i32* %1114
%1117 = trunc i64 %1111 to i32
%1118 = xor i32 %1117, -1
%1119 = add i32 %463, %1118
%1120 = sext i32 %1119 to i64
%1121 = getelementptr inbounds i32, i32* %1, i64 %1120
%1122 = load i32, i32* %1121
%1123 = add nsw i32 %1122, %469
store i32 %1123, i32* %1121
br label %1124
1124: ; preds = %947, %874, %878, %778, %782, %686, %570, %1113, %1110, %1099, %1096, %414, %340, %1085, %1082, %225, %218, %211, %1067, %943, %858, %761, %682, %566, %410, %336, %76, %142, %207, %1063, %897, %803, %701, %577, %502, %462, %421, %347, %272, %232, %14, %80, %146, %958, %8
%1125 = phi i32 [ %10, %8 ], [ %959, %958 ], [ %10, %146 ], [ %10, %80 ], [ %10, %14 ], [ %233, %232 ], [ %273, %272 ], [ %348, %347 ], [ %422, %421 ], [ %463, %462 ], [ %503, %502 ], [ %578, %577 ], [ %702, %701 ], [ %804, %803 ], [ %898, %897 ], [ %959, %1063 ], [ %10, %207 ], [ %10, %142 ], [ %10, %76 ], [ %273, %336 ], [ %348, %410 ], [ %503, %566 ], [ %578, %682 ], [ %702, %761 ], [ %804, %858 ], [ %898, %943 ], [ %959, %1067 ], [ %10, %211 ], [ %10, %218 ], [ %10, %225 ], [ %233, %1082 ], [ %233, %1085 ], [ %273, %340 ], [ %348, %414 ], [ %422, %1096 ], [ %422, %1099 ], [ %463, %1110 ], [ %463, %1113 ], [ %503, %570 ], [ %578, %686 ], [ %702, %782 ], [ %702, %778 ], [ %804, %878 ], [ %804, %874 ], [ %898, %947 ]
%1126 = add nuw nsw i64 %9, 1
%1127 = icmp eq i64 %1126, %7
br i1 %1127, label %1128, label %8
1128: ; preds = %1124, %3
%1129 = phi i32 [ 1, %3 ], [ %1125, %1124 ]
ret i32 %1129
}