#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 */
unsigned int rol(unsigned int, int);
void innerHash(unsigned int *result, unsigned int *w) {
  unsigned int save[5];
  save[0] = result[0];
  save[1] = result[1];
  save[2] = result[2];
  save[3] = result[3];
  save[4] = result[4];
  int j = 0;
  while (j < 16) {
    {
      const unsigned int t =
          rol(result[0], 5) +
          ((result[1] & result[2]) | (~result[1] & result[3])) + result[4] +
          0x5A827999 + w[j];
      result[4] = result[3];
      result[3] = result[2];
      result[2] = rol(result[1], 30);
      result[1] = result[0];
      result[0] = t;
    }
    j++;
  }
  while (j < 20) {
    w[j] = rol((w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16]), 1);
    {
      const unsigned int t =
          rol(result[0], 5) +
          ((result[1] & result[2]) | (~result[1] & result[3])) + result[4] +
          0x5A827999 + w[j];
      result[4] = result[3];
      result[3] = result[2];
      result[2] = rol(result[1], 30);
      result[1] = result[0];
      result[0] = t;
    }
    j++;
  }
  while (j < 40) {
    w[j] = rol((w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16]), 1);
    {
      const unsigned int t = rol(result[0], 5) +
                             (result[1] ^ result[2] ^ result[3]) + result[4] +
                             0x6ED9EBA1 + w[j];
      result[4] = result[3];
      result[3] = result[2];
      result[2] = rol(result[1], 30);
      result[1] = result[0];
      result[0] = t;
    }
    j++;
  }
  while (j < 60) {
    w[j] = rol((w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16]), 1);
    {
      const unsigned int t =
          rol(result[0], 5) +
          ((result[1] & result[2]) | (result[1] & result[3]) |
           (result[2] & result[3])) +
          result[4] + 0x8F1BBCDC + w[j];
      result[4] = result[3];
      result[3] = result[2];
      result[2] = rol(result[1], 30);
      result[1] = result[0];
      result[0] = t;
    }
    j++;
  }
  while (j < 80) {
    w[j] = rol((w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16]), 1);
    {
      const unsigned int t = rol(result[0], 5) +
                             (result[1] ^ result[2] ^ result[3]) + result[4] +
                             0xCA62C1D6 + w[j];
      result[4] = result[3];
      result[3] = result[2];
      result[2] = rol(result[1], 30);
      result[1] = result[0];
      result[0] = t;
    }
    j++;
  }
  result[0] += save[0];
  result[1] += save[1];
  result[2] += save[2];
  result[3] += save[3];
  result[4] += save[4];
}


x86 assembly (clang, -O0):
<innerHash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jge    1209 <innerHash+0xf9>
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
and    0x8(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x4(%rdx),%edx
xor    $0xffffffff,%edx
mov    -0x8(%rbp),%rsi
and    0xc(%rsi),%edx
or     %edx,%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0x5a827999,%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edi
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x38(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1158 <innerHash+0x48>
jmp    120e <innerHash+0xfe>
cmpl   $0x14,-0x34(%rbp)
jge    1316 <innerHash+0x206>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0xe,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x10,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    $0x1,%esi
call   1030 <rol@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
and    0x8(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x4(%rdx),%edx
xor    $0xffffffff,%edx
mov    -0x8(%rbp),%rsi
and    0xc(%rsi),%edx
or     %edx,%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0x5a827999,%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edi
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x3c(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    120e <innerHash+0xfe>
jmp    131b <innerHash+0x20b>
cmpl   $0x28,-0x34(%rbp)
jge    1417 <innerHash+0x307>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0xe,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x10,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    $0x1,%esi
call   1030 <rol@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x8(%rbp),%rdx
xor    0xc(%rdx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0x6ed9eba1,%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edi
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x40(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    131b <innerHash+0x20b>
jmp    141c <innerHash+0x30c>
cmpl   $0x3c,-0x34(%rbp)
jge    1531 <innerHash+0x421>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0xe,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x10,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    $0x1,%esi
call   1030 <rol@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
and    0x8(%rdx),%ecx
mov    -0x8(%rbp),%rdx
mov    0x4(%rdx),%edx
mov    -0x8(%rbp),%rsi
and    0xc(%rsi),%edx
or     %edx,%ecx
mov    -0x8(%rbp),%rdx
mov    0x8(%rdx),%edx
mov    -0x8(%rbp),%rsi
and    0xc(%rsi),%edx
or     %edx,%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0x8f1bbcdc,%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edi
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x44(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    141c <innerHash+0x30c>
jmp    1536 <innerHash+0x426>
cmpl   $0x50,-0x34(%rbp)
jge    1632 <innerHash+0x522>
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x3,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x8,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0xe,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x10,%ecx
movslq %ecx,%rcx
xor    (%rax,%rcx,4),%edi
mov    $0x1,%esi
call   1030 <rol@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    -0x8(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x8(%rbp),%rdx
xor    0xc(%rdx),%ecx
add    %ecx,%eax
mov    -0x8(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0xca62c1d6,%eax
mov    -0x10(%rbp),%rcx
movslq -0x34(%rbp),%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x10(%rax)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edi
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x48(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1536 <innerHash+0x426>
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x2c(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<innerHash>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
mov    %rsi,%r14
mov    %rdi,%rbx
movdqu (%rdi),%xmm0
mov    0x10(%rdi),%r15d
movdqa %xmm0,(%rsp)
movd   %xmm0,%r12d
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
mov    %r12d,%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    0x4(%rbx),%edi
mov    0x8(%rbx),%r8d
mov    %r8d,%edx
and    %edi,%edx
mov    %edi,%esi
not    %esi
mov    0xc(%rbx),%ecx
and    %ecx,%esi
add    %eax,%edx
add    %esi,%edx
add    0x10(%rbx),%edx
mov    (%r14,%rbp,4),%eax
lea    (%rax,%rdx,1),%r12d
add    $0x5a827999,%r12d
mov    %ecx,0x10(%rbx)
mov    %r8d,0xc(%rbx)
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,0x8(%rbx)
mov    (%rbx),%eax
mov    %eax,0x4(%rbx)
mov    %r12d,(%rbx)
add    $0x1,%rbp
cmp    $0x10,%rbp
jne    1140 <innerHash+0x30>
xor    %ebp,%ebp
mov    0x20(%r14,%rbp,4),%edi
xor    0x34(%r14,%rbp,4),%edi
xor    0x8(%r14,%rbp,4),%edi
xor    (%r14,%rbp,4),%edi
mov    $0x1,%esi
call   1030 <rol@plt>
mov    %eax,0x40(%r14,%rbp,4)
mov    (%rbx),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    0x4(%rbx),%edi
mov    0x8(%rbx),%r8d
mov    %r8d,%edx
and    %edi,%edx
mov    %edi,%esi
not    %esi
mov    0xc(%rbx),%ecx
and    %ecx,%esi
add    %eax,%edx
add    %esi,%edx
add    0x10(%rbx),%edx
mov    0x40(%r14,%rbp,4),%eax
lea    (%rax,%rdx,1),%r12d
add    $0x5a827999,%r12d
mov    %ecx,0x10(%rbx)
mov    %r8d,0xc(%rbx)
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,0x8(%rbx)
mov    (%rbx),%eax
mov    %eax,0x4(%rbx)
mov    %r12d,(%rbx)
add    $0x1,%rbp
cmp    $0x4,%rbp
jne    11a0 <innerHash+0x90>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x30(%r14,%rbp,4),%edi
xor    0x44(%r14,%rbp,4),%edi
xor    0x18(%r14,%rbp,4),%edi
xor    0x10(%r14,%rbp,4),%edi
mov    $0x1,%esi
call   1030 <rol@plt>
mov    %eax,0x50(%r14,%rbp,4)
mov    (%rbx),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    0x4(%rbx),%edi
mov    0x8(%rbx),%ecx
mov    %ecx,%edx
xor    %edi,%edx
mov    0xc(%rbx),%esi
xor    %esi,%edx
add    %eax,%edx
add    0x10(%rbx),%edx
mov    0x50(%r14,%rbp,4),%eax
lea    (%rax,%rdx,1),%r12d
add    $0x6ed9eba1,%r12d
mov    %esi,0x10(%rbx)
mov    %ecx,0xc(%rbx)
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,0x8(%rbx)
mov    (%rbx),%eax
mov    %eax,0x4(%rbx)
mov    %r12d,(%rbx)
add    $0x1,%rbp
cmp    $0x14,%rbp
jne    1230 <innerHash+0x120>
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    0x80(%r14,%rbp,4),%edi
xor    0x94(%r14,%rbp,4),%edi
xor    0x68(%r14,%rbp,4),%edi
xor    0x60(%r14,%rbp,4),%edi
mov    $0x1,%esi
call   1030 <rol@plt>
mov    %eax,0xa0(%r14,%rbp,4)
mov    (%rbx),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    0x4(%rbx),%edi
mov    0x8(%rbx),%ecx
add    0x10(%rbx),%eax
add    0xa0(%r14,%rbp,4),%eax
mov    0xc(%rbx),%edx
mov    %edx,%esi
mov    %edx,0x10(%rbx)
or     %ecx,%edx
and    %edi,%edx
and    %ecx,%esi
or     %edx,%esi
lea    (%rsi,%rax,1),%r12d
add    $0x8f1bbcdc,%r12d
mov    %ecx,0xc(%rbx)
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,0x8(%rbx)
mov    (%rbx),%eax
mov    %eax,0x4(%rbx)
mov    %r12d,(%rbx)
add    $0x1,%rbp
cmp    $0x14,%rbp
jne    12b0 <innerHash+0x1a0>
xor    %ebp,%ebp
nopl   0x0(%rax)
mov    0xd0(%r14,%rbp,4),%edi
xor    0xe4(%r14,%rbp,4),%edi
xor    0xb8(%r14,%rbp,4),%edi
xor    0xb0(%r14,%rbp,4),%edi
mov    $0x1,%esi
call   1030 <rol@plt>
mov    %eax,0xf0(%r14,%rbp,4)
mov    (%rbx),%edi
mov    $0x5,%esi
call   1030 <rol@plt>
mov    0x4(%rbx),%edi
mov    0x8(%rbx),%ecx
mov    %ecx,%edx
xor    %edi,%edx
mov    0xc(%rbx),%esi
xor    %esi,%edx
add    %eax,%edx
add    0x10(%rbx),%edx
mov    0xf0(%r14,%rbp,4),%eax
lea    (%rax,%rdx,1),%r12d
add    $0xca62c1d6,%r12d
mov    %esi,0x10(%rbx)
mov    %ecx,0xc(%rbx)
mov    $0x1e,%esi
call   1030 <rol@plt>
mov    %eax,0x8(%rbx)
mov    (%rbx),%ecx
mov    %ecx,0x4(%rbx)
mov    %r12d,(%rbx)
add    $0x1,%rbp
cmp    $0x14,%rbp
jne    1340 <innerHash+0x230>
movd   0xc(%rbx),%xmm0
movd   %eax,%xmm1
punpckldq %xmm0,%xmm1
movd   %ecx,%xmm0
movd   %r12d,%xmm2
punpckldq %xmm0,%xmm2
punpcklqdq %xmm1,%xmm2
paddd  (%rsp),%xmm2
movdqu %xmm2,(%rbx)
add    %r15d,0x10(%rbx)
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @innerHash(i32* %0, i32* %1) {
%3 = getelementptr inbounds i32, i32* %0, i64 1
%4 = getelementptr inbounds i32, i32* %0, i64 2
%5 = getelementptr inbounds i32, i32* %0, i64 3
%6 = bitcast i32* %0 to <4 x i32>*
%7 = load <4 x i32>, <4 x i32>* %6
%8 = getelementptr inbounds i32, i32* %0, i64 4
%9 = load i32, i32* %8
%10 = extractelement <4 x i32> %7, i64 0
br label %11
11: ; preds = %2, %11
%12 = phi i32 [ %10, %2 ], [ %28, %11 ]
%13 = phi i64 [ 0, %2 ], [ %31, %11 ]
%14 = tail call i32 @rol(i32 %12, i32 5)
%15 = load i32, i32* %3
%16 = load i32, i32* %4
%17 = and i32 %16, %15
%18 = xor i32 %15, -1
%19 = load i32, i32* %5
%20 = and i32 %19, %18
%21 = load i32, i32* %8
%22 = getelementptr inbounds i32, i32* %1, i64 %13
%23 = load i32, i32* %22
%24 = add i32 %14, 1518500249
%25 = add i32 %24, %17
%26 = add i32 %25, %20
%27 = add i32 %26, %21
%28 = add i32 %27, %23
store i32 %19, i32* %8
store i32 %16, i32* %5
%29 = tail call i32 @rol(i32 %15, i32 30)
store i32 %29, i32* %4
%30 = load i32, i32* %0
store i32 %30, i32* %3
store i32 %28, i32* %0
%31 = add nuw nsw i64 %13, 1
%32 = icmp eq i64 %31, 16
br i1 %32, label %33, label %11
33: ; preds = %11, %33
%34 = phi i64 [ %69, %33 ], [ 16, %11 ]
%35 = add nsw i64 %34, -3
%36 = getelementptr inbounds i32, i32* %1, i64 %35
%37 = load i32, i32* %36
%38 = add nsw i64 %34, -8
%39 = getelementptr inbounds i32, i32* %1, i64 %38
%40 = load i32, i32* %39
%41 = xor i32 %40, %37
%42 = add nsw i64 %34, -14
%43 = getelementptr inbounds i32, i32* %1, i64 %42
%44 = load i32, i32* %43
%45 = xor i32 %41, %44
%46 = add nsw i64 %34, -16
%47 = getelementptr inbounds i32, i32* %1, i64 %46
%48 = load i32, i32* %47
%49 = xor i32 %45, %48
%50 = tail call i32 @rol(i32 %49, i32 1)
%51 = getelementptr inbounds i32, i32* %1, i64 %34
store i32 %50, i32* %51
%52 = load i32, i32* %0
%53 = tail call i32 @rol(i32 %52, i32 5)
%54 = load i32, i32* %3
%55 = load i32, i32* %4
%56 = and i32 %55, %54
%57 = xor i32 %54, -1
%58 = load i32, i32* %5
%59 = and i32 %58, %57
%60 = load i32, i32* %8
%61 = load i32, i32* %51
%62 = add i32 %53, 1518500249
%63 = add i32 %62, %56
%64 = add i32 %63, %59
%65 = add i32 %64, %60
%66 = add i32 %65, %61
store i32 %58, i32* %8
store i32 %55, i32* %5
%67 = tail call i32 @rol(i32 %54, i32 30)
store i32 %67, i32* %4
%68 = load i32, i32* %0
store i32 %68, i32* %3
store i32 %66, i32* %0
%69 = add nuw nsw i64 %34, 1
%70 = icmp eq i64 %69, 20
br i1 %70, label %71, label %33
71: ; preds = %33, %71
%72 = phi i64 [ %105, %71 ], [ 20, %33 ]
%73 = add nsw i64 %72, -3
%74 = getelementptr inbounds i32, i32* %1, i64 %73
%75 = load i32, i32* %74
%76 = add nsw i64 %72, -8
%77 = getelementptr inbounds i32, i32* %1, i64 %76
%78 = load i32, i32* %77
%79 = xor i32 %78, %75
%80 = add nsw i64 %72, -14
%81 = getelementptr inbounds i32, i32* %1, i64 %80
%82 = load i32, i32* %81
%83 = xor i32 %79, %82
%84 = add nsw i64 %72, -16
%85 = getelementptr inbounds i32, i32* %1, i64 %84
%86 = load i32, i32* %85
%87 = xor i32 %83, %86
%88 = tail call i32 @rol(i32 %87, i32 1)
%89 = getelementptr inbounds i32, i32* %1, i64 %72
store i32 %88, i32* %89
%90 = load i32, i32* %0
%91 = tail call i32 @rol(i32 %90, i32 5)
%92 = load i32, i32* %3
%93 = load i32, i32* %4
%94 = xor i32 %93, %92
%95 = load i32, i32* %5
%96 = xor i32 %94, %95
%97 = load i32, i32* %8
%98 = load i32, i32* %89
%99 = add i32 %91, 1859775393
%100 = add i32 %99, %96
%101 = add i32 %100, %97
%102 = add i32 %101, %98
store i32 %95, i32* %8
store i32 %93, i32* %5
%103 = tail call i32 @rol(i32 %92, i32 30)
store i32 %103, i32* %4
%104 = load i32, i32* %0
store i32 %104, i32* %3
store i32 %102, i32* %0
%105 = add nuw nsw i64 %72, 1
%106 = icmp eq i64 %105, 40
br i1 %106, label %107, label %71
107: ; preds = %71, %107
%108 = phi i64 [ %143, %107 ], [ 40, %71 ]
%109 = add nsw i64 %108, -3
%110 = getelementptr inbounds i32, i32* %1, i64 %109
%111 = load i32, i32* %110
%112 = add nsw i64 %108, -8
%113 = getelementptr inbounds i32, i32* %1, i64 %112
%114 = load i32, i32* %113
%115 = xor i32 %114, %111
%116 = add nsw i64 %108, -14
%117 = getelementptr inbounds i32, i32* %1, i64 %116
%118 = load i32, i32* %117
%119 = xor i32 %115, %118
%120 = add nsw i64 %108, -16
%121 = getelementptr inbounds i32, i32* %1, i64 %120
%122 = load i32, i32* %121
%123 = xor i32 %119, %122
%124 = tail call i32 @rol(i32 %123, i32 1)
%125 = getelementptr inbounds i32, i32* %1, i64 %108
store i32 %124, i32* %125
%126 = load i32, i32* %0
%127 = tail call i32 @rol(i32 %126, i32 5)
%128 = load i32, i32* %3
%129 = load i32, i32* %4
%130 = load i32, i32* %5
%131 = or i32 %130, %129
%132 = and i32 %131, %128
%133 = and i32 %130, %129
%134 = or i32 %132, %133
%135 = load i32, i32* %8
%136 = load i32, i32* %125
%137 = add i32 %127, -1894007588
%138 = add i32 %137, %135
%139 = add i32 %138, %136
%140 = add i32 %139, %134
store i32 %130, i32* %8
store i32 %129, i32* %5
%141 = tail call i32 @rol(i32 %128, i32 30)
store i32 %141, i32* %4
%142 = load i32, i32* %0
store i32 %142, i32* %3
store i32 %140, i32* %0
%143 = add nuw nsw i64 %108, 1
%144 = icmp eq i64 %143, 60
br i1 %144, label %145, label %107
145: ; preds = %107, %145
%146 = phi i64 [ %179, %145 ], [ 60, %107 ]
%147 = add nsw i64 %146, -3
%148 = getelementptr inbounds i32, i32* %1, i64 %147
%149 = load i32, i32* %148
%150 = add nsw i64 %146, -8
%151 = getelementptr inbounds i32, i32* %1, i64 %150
%152 = load i32, i32* %151
%153 = xor i32 %152, %149
%154 = add nsw i64 %146, -14
%155 = getelementptr inbounds i32, i32* %1, i64 %154
%156 = load i32, i32* %155
%157 = xor i32 %153, %156
%158 = add nsw i64 %146, -16
%159 = getelementptr inbounds i32, i32* %1, i64 %158
%160 = load i32, i32* %159
%161 = xor i32 %157, %160
%162 = tail call i32 @rol(i32 %161, i32 1)
%163 = getelementptr inbounds i32, i32* %1, i64 %146
store i32 %162, i32* %163
%164 = load i32, i32* %0
%165 = tail call i32 @rol(i32 %164, i32 5)
%166 = load i32, i32* %3
%167 = load i32, i32* %4
%168 = xor i32 %167, %166
%169 = load i32, i32* %5
%170 = xor i32 %168, %169
%171 = load i32, i32* %8
%172 = load i32, i32* %163
%173 = add i32 %165, -899497514
%174 = add i32 %173, %170
%175 = add i32 %174, %171
%176 = add i32 %175, %172
store i32 %169, i32* %8
store i32 %167, i32* %5
%177 = tail call i32 @rol(i32 %166, i32 30)
store i32 %177, i32* %4
%178 = load i32, i32* %0
store i32 %178, i32* %3
store i32 %176, i32* %0
%179 = add nuw nsw i64 %146, 1
%180 = icmp eq i64 %179, 80
br i1 %180, label %181, label %145
181: ; preds = %145
%182 = load i32, i32* %5
%183 = insertelement <4 x i32> poison, i32 %176, i64 0
%184 = insertelement <4 x i32> %183, i32 %178, i64 1
%185 = insertelement <4 x i32> %184, i32 %177, i64 2
%186 = insertelement <4 x i32> %185, i32 %182, i64 3
%187 = add <4 x i32> %186, %7
%188 = bitcast i32* %0 to <4 x i32>*
store <4 x i32> %187, <4 x i32>* %188
%189 = load i32, i32* %8
%190 = add i32 %189, %9
store i32 %190, i32* %8
ret void
}