#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*/ printf(char *, ...);
int strlen(char const *);
unsigned long i_hash_string(unsigned char *k, unsigned long htsize) {
  unsigned long initval = htsize;
  register unsigned long int a, b, c, len;
  initval -= 1;
  if (strlen((const char *)k) < 1) {
    printf("i_hash_string failed, string length is < 1\n");
    return 0;
  }
  len = strlen((const char *)k) - 1;
  a = b = 0x9e3779b9;
  c = initval;
  while (len >= 12) {
    a += (k[0] + ((unsigned long int)k[1] << 8) +
          ((unsigned long int)k[2] << 16) + ((unsigned long int)k[3] << 24));
    b += (k[4] + ((unsigned long int)k[5] << 8) +
          ((unsigned long int)k[6] << 16) + ((unsigned long int)k[7] << 24));
    c += (k[8] + ((unsigned long int)k[9] << 8) +
          ((unsigned long int)k[10] << 16) + ((unsigned long int)k[11] << 24));
    {
      a -= b;
      a -= c;
      a ^= (c >> 13);
      b -= c;
      b -= a;
      b ^= (a << 8);
      c -= a;
      c -= b;
      c ^= (b >> 13);
      a -= b;
      a -= c;
      a ^= (c >> 12);
      b -= c;
      b -= a;
      b ^= (a << 16);
      c -= a;
      c -= b;
      c ^= (b >> 5);
      a -= b;
      a -= c;
      a ^= (c >> 3);
      b -= c;
      b -= a;
      b ^= (a << 10);
      c -= a;
      c -= b;
      c ^= (b >> 15);
    };
    k += 12;
    len -= 12;
  }
  c += len;
  switch (len) {
  case 11:
    c += ((unsigned long int)k[10] << 24);
  case 10:
    c += ((unsigned long int)k[9] << 16);
  case 9:
    c += ((unsigned long int)k[8] << 8);
  case 8:
    b += ((unsigned long int)k[7] << 24);
  case 7:
    b += ((unsigned long int)k[6] << 16);
  case 6:
    b += ((unsigned long int)k[5] << 8);
  case 5:
    b += k[4];
  case 4:
    a += ((unsigned long int)k[3] << 24);
  case 3:
    a += ((unsigned long int)k[2] << 16);
  case 2:
    a += ((unsigned long int)k[1] << 8);
  case 1:
    a += k[0];
  }
  {
    a -= b;
    a -= c;
    a ^= (c >> 13);
    b -= c;
    b -= a;
    b ^= (a << 8);
    c -= a;
    c -= b;
    c ^= (b >> 13);
    a -= b;
    a -= c;
    a ^= (c >> 12);
    b -= c;
    b -= a;
    b ^= (a << 16);
    c -= a;
    c -= b;
    c ^= (b >> 5);
    a -= b;
    a -= c;
    a ^= (c >> 3);
    b -= c;
    b -= a;
    b ^= (a << 10);
    c -= a;
    c -= b;
    c ^= (b >> 15);
  };
  c = (c % initval) + 1;
  if (c >= htsize) {
    printf("HT_FAILURE: i_hash_string calculated invalid hash of %lu (htsize "
           "is %lu). Returning fail-safe hash of 0\n",
           c, initval);
    return 0;
  }
  return (c);
}


x86 assembly (clang, -O0):
<i_hash_string>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
cmp    $0x1,%eax
jge    1171 <i_hash_string+0x51>
lea    0xecf(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0x8(%rbp)
jmp    1710 <i_hash_string+0x5f0>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
sub    $0x1,%eax
cltq
mov    %rax,-0x40(%rbp)
mov    $0x9e3779b9,%eax
mov    %rax,-0x30(%rbp)
mov    $0x9e3779b9,%eax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0xc,-0x40(%rbp)
jb     1419 <i_hash_string+0x2f9>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
shl    $0x8,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
shl    $0x10,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
shl    $0x18,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x8,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x10,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
shl    $0x18,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x9(%rcx),%ecx
shl    $0x8,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
shl    $0x10,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rcx
movzbl 0xb(%rcx),%ecx
shl    $0x18,%rcx
add    %rcx,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
shr    $0xd,%rax
xor    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
xor    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
shr    $0xd,%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
shr    $0xc,%rax
xor    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x10,%rax
xor    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
shr    $0x5,%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
shr    $0x3,%rax
xor    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
shl    $0xa,%rax
xor    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
shr    $0xf,%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x40(%rbp)
jmp    119d <i_hash_string+0x7d>
mov    -0x40(%rbp),%rcx
mov    -0x38(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x48(%rbp)
sub    $0xa,%rax
ja     1525 <i_hash_string+0x405>
mov    -0x48(%rbp),%rax
lea    0xbb7(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
shl    $0x18,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
shl    $0x10,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
shl    $0x8,%rax
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
shl    $0x18,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
shl    $0x10,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
shl    $0x8,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0x18,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0x10,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x8,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
shr    $0xd,%rax
xor    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x8,%rax
xor    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
shr    $0xd,%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
shr    $0xc,%rax
xor    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
shl    $0x10,%rax
xor    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
shr    $0x5,%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x28(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
shr    $0x3,%rax
xor    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
shl    $0xa,%rax
xor    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rcx
mov    -0x38(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x30(%rbp),%rax
shr    $0xf,%rax
xor    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
xor    %ecx,%ecx
mov    %ecx,%edx
divq   -0x20(%rbp)
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     1708 <i_hash_string+0x5e8>
mov    -0x38(%rbp),%rsi
mov    -0x20(%rbp),%rdx
lea    0x964(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movq   $0x0,-0x8(%rbp)
jmp    1710 <i_hash_string+0x5f0>
mov    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<i_hash_string>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rsi,%r15
mov    %rdi,%r12
call   1040 <strlen@plt>
test   %eax,%eax
jle    123b <i_hash_string+0x10b>
lea    -0x1(%r15),%r14
mov    $0x9e3779b9,%ebx
mov    %r12,%rdi
call   1040 <strlen@plt>
add    $0xffffffff,%eax
movslq %eax,%rdx
cmp    $0xc,%edx
jb     124c <i_hash_string+0x11c>
mov    %r14,%rax
mov    $0x9e3779b9,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r12),%esi
mov    0x4(%r12),%edi
add    %rcx,%rsi
add    %rbx,%rdi
mov    0x8(%r12),%ecx
add    %rax,%rcx
sub    %rdi,%rsi
sub    %rcx,%rsi
mov    %rcx,%rax
shr    $0xd,%rax
xor    %rsi,%rax
sub    %rcx,%rdi
sub    %rax,%rdi
mov    %rax,%rsi
shl    $0x8,%rsi
xor    %rdi,%rsi
sub    %rax,%rcx
sub    %rsi,%rcx
mov    %rsi,%rdi
shr    $0xd,%rdi
xor    %rcx,%rdi
sub    %rsi,%rax
sub    %rdi,%rax
mov    %rdi,%rbx
shr    $0xc,%rbx
xor    %rax,%rbx
sub    %rdi,%rsi
sub    %rbx,%rsi
mov    %rbx,%rax
shl    $0x10,%rax
xor    %rsi,%rax
sub    %rbx,%rdi
sub    %rax,%rdi
mov    %rax,%rsi
shr    $0x5,%rsi
xor    %rdi,%rsi
sub    %rax,%rbx
sub    %rsi,%rbx
mov    %rsi,%rcx
shr    $0x3,%rcx
xor    %rbx,%rcx
sub    %rsi,%rax
sub    %rcx,%rax
mov    %rcx,%rbx
shl    $0xa,%rbx
xor    %rax,%rbx
sub    %rcx,%rsi
sub    %rbx,%rsi
mov    %rbx,%rax
shr    $0xf,%rax
xor    %rsi,%rax
add    $0xc,%r12
add    $0xfffffffffffffff4,%rdx
cmp    $0xb,%rdx
ja     1180 <i_hash_string+0x50>
jmp    1254 <i_hash_string+0x124>
lea    0xe53(%rip),%rdi
call   1030 <puts@plt>
jmp    13ad <i_hash_string+0x27d>
mov    $0x9e3779b9,%ecx
mov    %r14,%rax
add    %rdx,%rax
add    $0xffffffffffffffff,%rdx
cmp    $0xa,%rdx
ja     12fb <i_hash_string+0x1cb>
lea    0xd94(%rip),%rsi
movslq (%rsi,%rdx,4),%rdx
add    %rsi,%rdx
jmp    *%rdx
movzbl 0xa(%r12),%edx
shl    $0x18,%rdx
add    %rdx,%rax
movzbl 0x9(%r12),%edx
shl    $0x10,%rdx
add    %rdx,%rax
movzbl 0x8(%r12),%edx
shl    $0x8,%rdx
add    %rdx,%rax
movzbl 0x7(%r12),%edx
shl    $0x18,%rdx
add    %rdx,%rbx
movzbl 0x6(%r12),%edx
shl    $0x10,%rdx
add    %rdx,%rbx
movzbl 0x5(%r12),%edx
shl    $0x8,%rdx
add    %rdx,%rbx
movzbl 0x4(%r12),%edx
add    %rdx,%rbx
movzbl 0x3(%r12),%edx
shl    $0x18,%rdx
add    %rdx,%rcx
movzbl 0x2(%r12),%edx
shl    $0x10,%rdx
add    %rdx,%rcx
movzbl 0x1(%r12),%edx
shl    $0x8,%rdx
add    %rdx,%rcx
movzbl (%r12),%edx
add    %rdx,%rcx
sub    %rbx,%rcx
sub    %rax,%rcx
mov    %rax,%rdx
shr    $0xd,%rdx
xor    %rcx,%rdx
sub    %rax,%rbx
sub    %rdx,%rbx
mov    %rdx,%rcx
shl    $0x8,%rcx
xor    %rbx,%rcx
sub    %rdx,%rax
sub    %rcx,%rax
mov    %rcx,%rsi
shr    $0xd,%rsi
xor    %rax,%rsi
sub    %rcx,%rdx
sub    %rsi,%rdx
mov    %rsi,%rax
shr    $0xc,%rax
xor    %rdx,%rax
sub    %rsi,%rcx
sub    %rax,%rcx
mov    %rax,%rdx
shl    $0x10,%rdx
xor    %rcx,%rdx
sub    %rax,%rsi
sub    %rdx,%rsi
mov    %rdx,%rcx
shr    $0x5,%rcx
xor    %rsi,%rcx
sub    %rdx,%rax
sub    %rcx,%rax
mov    %rcx,%rsi
shr    $0x3,%rsi
xor    %rax,%rsi
sub    %rcx,%rdx
sub    %rsi,%rdx
mov    %rsi,%rax
shl    $0xa,%rax
xor    %rdx,%rax
add    %rax,%rsi
sub    %rsi,%rcx
shr    $0xf,%rax
xor    %rcx,%rax
xor    %edx,%edx
div    %r14
mov    %rdx,%rax
add    $0x1,%rax
cmp    %r15,%rax
jb     13af <i_hash_string+0x27f>
lea    0xc8c(%rip),%rdi
mov    %rax,%rsi
mov    %r14,%rdx
xor    %eax,%eax
call   1050 <printf@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [44 x i8] c"i_hash_string failed, string length is < 1\0A\00"
@.str.1 = [105 x i8] c"HT_FAILURE: i_hash_string calculated invalid hash of %lu (htsize is %lu). Returning fail-safe hash of 0\0A\00"
define i64 @i_hash_string(i8* %0, i64 %1) {
%3 = alloca i64
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
store i8* %0, i8** %4
store i64 %1, i64* %5
%11 = load i64, i64* %5
store i64 %11, i64* %6
%12 = load i64, i64* %6
%13 = sub i64 %12, 1
store i64 %13, i64* %6
%14 = load i8*, i8** %4
%15 = call i32 @strlen(i8* %14)
%16 = icmp slt i32 %15, 1
br i1 %16, label %17, label %19
17: ; preds = %2
%18 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str, i64 0, i64 0))
store i64 0, i64* %3
br label %390
19: ; preds = %2
%20 = load i8*, i8** %4
%21 = call i32 @strlen(i8* %20)
%22 = sub nsw i32 %21, 1
%23 = sext i32 %22 to i64
store i64 %23, i64* %10
store i64 2654435769, i64* %8
store i64 2654435769, i64* %7
%24 = load i64, i64* %6
store i64 %24, i64* %9
br label %25
25: ; preds = %28, %19
%26 = load i64, i64* %10
%27 = icmp uge i64 %26, 12
br i1 %27, label %28, label %195
28: ; preds = %25
%29 = load i8*, i8** %4
%30 = getelementptr inbounds i8, i8* %29, i64 0
%31 = load i8, i8* %30
%32 = zext i8 %31 to i64
%33 = load i8*, i8** %4
%34 = getelementptr inbounds i8, i8* %33, i64 1
%35 = load i8, i8* %34
%36 = zext i8 %35 to i64
%37 = shl i64 %36, 8
%38 = add i64 %32, %37
%39 = load i8*, i8** %4
%40 = getelementptr inbounds i8, i8* %39, i64 2
%41 = load i8, i8* %40
%42 = zext i8 %41 to i64
%43 = shl i64 %42, 16
%44 = add i64 %38, %43
%45 = load i8*, i8** %4
%46 = getelementptr inbounds i8, i8* %45, i64 3
%47 = load i8, i8* %46
%48 = zext i8 %47 to i64
%49 = shl i64 %48, 24
%50 = add i64 %44, %49
%51 = load i64, i64* %7
%52 = add i64 %51, %50
store i64 %52, i64* %7
%53 = load i8*, i8** %4
%54 = getelementptr inbounds i8, i8* %53, i64 4
%55 = load i8, i8* %54
%56 = zext i8 %55 to i64
%57 = load i8*, i8** %4
%58 = getelementptr inbounds i8, i8* %57, i64 5
%59 = load i8, i8* %58
%60 = zext i8 %59 to i64
%61 = shl i64 %60, 8
%62 = add i64 %56, %61
%63 = load i8*, i8** %4
%64 = getelementptr inbounds i8, i8* %63, i64 6
%65 = load i8, i8* %64
%66 = zext i8 %65 to i64
%67 = shl i64 %66, 16
%68 = add i64 %62, %67
%69 = load i8*, i8** %4
%70 = getelementptr inbounds i8, i8* %69, i64 7
%71 = load i8, i8* %70
%72 = zext i8 %71 to i64
%73 = shl i64 %72, 24
%74 = add i64 %68, %73
%75 = load i64, i64* %8
%76 = add i64 %75, %74
store i64 %76, i64* %8
%77 = load i8*, i8** %4
%78 = getelementptr inbounds i8, i8* %77, i64 8
%79 = load i8, i8* %78
%80 = zext i8 %79 to i64
%81 = load i8*, i8** %4
%82 = getelementptr inbounds i8, i8* %81, i64 9
%83 = load i8, i8* %82
%84 = zext i8 %83 to i64
%85 = shl i64 %84, 8
%86 = add i64 %80, %85
%87 = load i8*, i8** %4
%88 = getelementptr inbounds i8, i8* %87, i64 10
%89 = load i8, i8* %88
%90 = zext i8 %89 to i64
%91 = shl i64 %90, 16
%92 = add i64 %86, %91
%93 = load i8*, i8** %4
%94 = getelementptr inbounds i8, i8* %93, i64 11
%95 = load i8, i8* %94
%96 = zext i8 %95 to i64
%97 = shl i64 %96, 24
%98 = add i64 %92, %97
%99 = load i64, i64* %9
%100 = add i64 %99, %98
store i64 %100, i64* %9
%101 = load i64, i64* %8
%102 = load i64, i64* %7
%103 = sub i64 %102, %101
store i64 %103, i64* %7
%104 = load i64, i64* %9
%105 = load i64, i64* %7
%106 = sub i64 %105, %104
store i64 %106, i64* %7
%107 = load i64, i64* %9
%108 = lshr i64 %107, 13
%109 = load i64, i64* %7
%110 = xor i64 %109, %108
store i64 %110, i64* %7
%111 = load i64, i64* %9
%112 = load i64, i64* %8
%113 = sub i64 %112, %111
store i64 %113, i64* %8
%114 = load i64, i64* %7
%115 = load i64, i64* %8
%116 = sub i64 %115, %114
store i64 %116, i64* %8
%117 = load i64, i64* %7
%118 = shl i64 %117, 8
%119 = load i64, i64* %8
%120 = xor i64 %119, %118
store i64 %120, i64* %8
%121 = load i64, i64* %7
%122 = load i64, i64* %9
%123 = sub i64 %122, %121
store i64 %123, i64* %9
%124 = load i64, i64* %8
%125 = load i64, i64* %9
%126 = sub i64 %125, %124
store i64 %126, i64* %9
%127 = load i64, i64* %8
%128 = lshr i64 %127, 13
%129 = load i64, i64* %9
%130 = xor i64 %129, %128
store i64 %130, i64* %9
%131 = load i64, i64* %8
%132 = load i64, i64* %7
%133 = sub i64 %132, %131
store i64 %133, i64* %7
%134 = load i64, i64* %9
%135 = load i64, i64* %7
%136 = sub i64 %135, %134
store i64 %136, i64* %7
%137 = load i64, i64* %9
%138 = lshr i64 %137, 12
%139 = load i64, i64* %7
%140 = xor i64 %139, %138
store i64 %140, i64* %7
%141 = load i64, i64* %9
%142 = load i64, i64* %8
%143 = sub i64 %142, %141
store i64 %143, i64* %8
%144 = load i64, i64* %7
%145 = load i64, i64* %8
%146 = sub i64 %145, %144
store i64 %146, i64* %8
%147 = load i64, i64* %7
%148 = shl i64 %147, 16
%149 = load i64, i64* %8
%150 = xor i64 %149, %148
store i64 %150, i64* %8
%151 = load i64, i64* %7
%152 = load i64, i64* %9
%153 = sub i64 %152, %151
store i64 %153, i64* %9
%154 = load i64, i64* %8
%155 = load i64, i64* %9
%156 = sub i64 %155, %154
store i64 %156, i64* %9
%157 = load i64, i64* %8
%158 = lshr i64 %157, 5
%159 = load i64, i64* %9
%160 = xor i64 %159, %158
store i64 %160, i64* %9
%161 = load i64, i64* %8
%162 = load i64, i64* %7
%163 = sub i64 %162, %161
store i64 %163, i64* %7
%164 = load i64, i64* %9
%165 = load i64, i64* %7
%166 = sub i64 %165, %164
store i64 %166, i64* %7
%167 = load i64, i64* %9
%168 = lshr i64 %167, 3
%169 = load i64, i64* %7
%170 = xor i64 %169, %168
store i64 %170, i64* %7
%171 = load i64, i64* %9
%172 = load i64, i64* %8
%173 = sub i64 %172, %171
store i64 %173, i64* %8
%174 = load i64, i64* %7
%175 = load i64, i64* %8
%176 = sub i64 %175, %174
store i64 %176, i64* %8
%177 = load i64, i64* %7
%178 = shl i64 %177, 10
%179 = load i64, i64* %8
%180 = xor i64 %179, %178
store i64 %180, i64* %8
%181 = load i64, i64* %7
%182 = load i64, i64* %9
%183 = sub i64 %182, %181
store i64 %183, i64* %9
%184 = load i64, i64* %8
%185 = load i64, i64* %9
%186 = sub i64 %185, %184
store i64 %186, i64* %9
%187 = load i64, i64* %8
%188 = lshr i64 %187, 15
%189 = load i64, i64* %9
%190 = xor i64 %189, %188
store i64 %190, i64* %9
%191 = load i8*, i8** %4
%192 = getelementptr inbounds i8, i8* %191, i64 12
store i8* %192, i8** %4
%193 = load i64, i64* %10
%194 = sub i64 %193, 12
store i64 %194, i64* %10
br label %25
195: ; preds = %25
%196 = load i64, i64* %10
%197 = load i64, i64* %9
%198 = add i64 %197, %196
store i64 %198, i64* %9
%199 = load i64, i64* %10
switch i64 %199, label %286 [
i64 11, label %200
i64 10, label %208
i64 9, label %216
i64 8, label %224
i64 7, label %232
i64 6, label %240
i64 5, label %248
i64 4, label %255
i64 3, label %263
i64 2, label %271
i64 1, label %279
]
200: ; preds = %195
%201 = load i8*, i8** %4
%202 = getelementptr inbounds i8, i8* %201, i64 10
%203 = load i8, i8* %202
%204 = zext i8 %203 to i64
%205 = shl i64 %204, 24
%206 = load i64, i64* %9
%207 = add i64 %206, %205
store i64 %207, i64* %9
br label %208
208: ; preds = %195, %200
%209 = load i8*, i8** %4
%210 = getelementptr inbounds i8, i8* %209, i64 9
%211 = load i8, i8* %210
%212 = zext i8 %211 to i64
%213 = shl i64 %212, 16
%214 = load i64, i64* %9
%215 = add i64 %214, %213
store i64 %215, i64* %9
br label %216
216: ; preds = %195, %208
%217 = load i8*, i8** %4
%218 = getelementptr inbounds i8, i8* %217, i64 8
%219 = load i8, i8* %218
%220 = zext i8 %219 to i64
%221 = shl i64 %220, 8
%222 = load i64, i64* %9
%223 = add i64 %222, %221
store i64 %223, i64* %9
br label %224
224: ; preds = %195, %216
%225 = load i8*, i8** %4
%226 = getelementptr inbounds i8, i8* %225, i64 7
%227 = load i8, i8* %226
%228 = zext i8 %227 to i64
%229 = shl i64 %228, 24
%230 = load i64, i64* %8
%231 = add i64 %230, %229
store i64 %231, i64* %8
br label %232
232: ; preds = %195, %224
%233 = load i8*, i8** %4
%234 = getelementptr inbounds i8, i8* %233, i64 6
%235 = load i8, i8* %234
%236 = zext i8 %235 to i64
%237 = shl i64 %236, 16
%238 = load i64, i64* %8
%239 = add i64 %238, %237
store i64 %239, i64* %8
br label %240
240: ; preds = %195, %232
%241 = load i8*, i8** %4
%242 = getelementptr inbounds i8, i8* %241, i64 5
%243 = load i8, i8* %242
%244 = zext i8 %243 to i64
%245 = shl i64 %244, 8
%246 = load i64, i64* %8
%247 = add i64 %246, %245
store i64 %247, i64* %8
br label %248
248: ; preds = %195, %240
%249 = load i8*, i8** %4
%250 = getelementptr inbounds i8, i8* %249, i64 4
%251 = load i8, i8* %250
%252 = zext i8 %251 to i64
%253 = load i64, i64* %8
%254 = add i64 %253, %252
store i64 %254, i64* %8
br label %255
255: ; preds = %195, %248
%256 = load i8*, i8** %4
%257 = getelementptr inbounds i8, i8* %256, i64 3
%258 = load i8, i8* %257
%259 = zext i8 %258 to i64
%260 = shl i64 %259, 24
%261 = load i64, i64* %7
%262 = add i64 %261, %260
store i64 %262, i64* %7
br label %263
263: ; preds = %195, %255
%264 = load i8*, i8** %4
%265 = getelementptr inbounds i8, i8* %264, i64 2
%266 = load i8, i8* %265
%267 = zext i8 %266 to i64
%268 = shl i64 %267, 16
%269 = load i64, i64* %7
%270 = add i64 %269, %268
store i64 %270, i64* %7
br label %271
271: ; preds = %195, %263
%272 = load i8*, i8** %4
%273 = getelementptr inbounds i8, i8* %272, i64 1
%274 = load i8, i8* %273
%275 = zext i8 %274 to i64
%276 = shl i64 %275, 8
%277 = load i64, i64* %7
%278 = add i64 %277, %276
store i64 %278, i64* %7
br label %279
279: ; preds = %195, %271
%280 = load i8*, i8** %4
%281 = getelementptr inbounds i8, i8* %280, i64 0
%282 = load i8, i8* %281
%283 = zext i8 %282 to i64
%284 = load i64, i64* %7
%285 = add i64 %284, %283
store i64 %285, i64* %7
br label %286
286: ; preds = %279, %195
%287 = load i64, i64* %8
%288 = load i64, i64* %7
%289 = sub i64 %288, %287
store i64 %289, i64* %7
%290 = load i64, i64* %9
%291 = load i64, i64* %7
%292 = sub i64 %291, %290
store i64 %292, i64* %7
%293 = load i64, i64* %9
%294 = lshr i64 %293, 13
%295 = load i64, i64* %7
%296 = xor i64 %295, %294
store i64 %296, i64* %7
%297 = load i64, i64* %9
%298 = load i64, i64* %8
%299 = sub i64 %298, %297
store i64 %299, i64* %8
%300 = load i64, i64* %7
%301 = load i64, i64* %8
%302 = sub i64 %301, %300
store i64 %302, i64* %8
%303 = load i64, i64* %7
%304 = shl i64 %303, 8
%305 = load i64, i64* %8
%306 = xor i64 %305, %304
store i64 %306, i64* %8
%307 = load i64, i64* %7
%308 = load i64, i64* %9
%309 = sub i64 %308, %307
store i64 %309, i64* %9
%310 = load i64, i64* %8
%311 = load i64, i64* %9
%312 = sub i64 %311, %310
store i64 %312, i64* %9
%313 = load i64, i64* %8
%314 = lshr i64 %313, 13
%315 = load i64, i64* %9
%316 = xor i64 %315, %314
store i64 %316, i64* %9
%317 = load i64, i64* %8
%318 = load i64, i64* %7
%319 = sub i64 %318, %317
store i64 %319, i64* %7
%320 = load i64, i64* %9
%321 = load i64, i64* %7
%322 = sub i64 %321, %320
store i64 %322, i64* %7
%323 = load i64, i64* %9
%324 = lshr i64 %323, 12
%325 = load i64, i64* %7
%326 = xor i64 %325, %324
store i64 %326, i64* %7
%327 = load i64, i64* %9
%328 = load i64, i64* %8
%329 = sub i64 %328, %327
store i64 %329, i64* %8
%330 = load i64, i64* %7
%331 = load i64, i64* %8
%332 = sub i64 %331, %330
store i64 %332, i64* %8
%333 = load i64, i64* %7
%334 = shl i64 %333, 16
%335 = load i64, i64* %8
%336 = xor i64 %335, %334
store i64 %336, i64* %8
%337 = load i64, i64* %7
%338 = load i64, i64* %9
%339 = sub i64 %338, %337
store i64 %339, i64* %9
%340 = load i64, i64* %8
%341 = load i64, i64* %9
%342 = sub i64 %341, %340
store i64 %342, i64* %9
%343 = load i64, i64* %8
%344 = lshr i64 %343, 5
%345 = load i64, i64* %9
%346 = xor i64 %345, %344
store i64 %346, i64* %9
%347 = load i64, i64* %8
%348 = load i64, i64* %7
%349 = sub i64 %348, %347
store i64 %349, i64* %7
%350 = load i64, i64* %9
%351 = load i64, i64* %7
%352 = sub i64 %351, %350
store i64 %352, i64* %7
%353 = load i64, i64* %9
%354 = lshr i64 %353, 3
%355 = load i64, i64* %7
%356 = xor i64 %355, %354
store i64 %356, i64* %7
%357 = load i64, i64* %9
%358 = load i64, i64* %8
%359 = sub i64 %358, %357
store i64 %359, i64* %8
%360 = load i64, i64* %7
%361 = load i64, i64* %8
%362 = sub i64 %361, %360
store i64 %362, i64* %8
%363 = load i64, i64* %7
%364 = shl i64 %363, 10
%365 = load i64, i64* %8
%366 = xor i64 %365, %364
store i64 %366, i64* %8
%367 = load i64, i64* %7
%368 = load i64, i64* %9
%369 = sub i64 %368, %367
store i64 %369, i64* %9
%370 = load i64, i64* %8
%371 = load i64, i64* %9
%372 = sub i64 %371, %370
store i64 %372, i64* %9
%373 = load i64, i64* %8
%374 = lshr i64 %373, 15
%375 = load i64, i64* %9
%376 = xor i64 %375, %374
store i64 %376, i64* %9
%377 = load i64, i64* %9
%378 = load i64, i64* %6
%379 = urem i64 %377, %378
%380 = add i64 %379, 1
store i64 %380, i64* %9
%381 = load i64, i64* %9
%382 = load i64, i64* %5
%383 = icmp uge i64 %381, %382
br i1 %383, label %384, label %388
384: ; preds = %286
%385 = load i64, i64* %9
%386 = load i64, i64* %6
%387 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([105 x i8], [105 x i8]* @.str.1, i64 0, i64 0), i64 %385, i64 %386)
store i64 0, i64* %3
br label %390
388: ; preds = %286
%389 = load i64, i64* %9
store i64 %389, i64* %3
br label %390
390: ; preds = %388, %384, %17
%391 = load i64, i64* %3
ret i64 %391
}

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