#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 */
typedef int /*<<< orphan*/ x;

/* Variables and functions */
int /*<<< orphan*/ md5_decode(unsigned long *, unsigned char *, int);
int /*<<< orphan*/ memset(unsigned long *, int /*<<< orphan*/, int);
void md5_transform(unsigned long *state, unsigned char *block) {
  unsigned long a = state[0], b = state[1], c = state[2], d = state[3], x[16];
  md5_decode(x, block, 16);
  a += ((b & c) | (d & ~b)) + x[0] + (unsigned long)0xd76aa478;
  a &= 0xffffffff;
  a = b + ((a << 7) | (a >> (32 - 7)));
  ;
  d += ((a & b) | (c & ~a)) + x[1] + (unsigned long)0xe8c7b756;
  d &= 0xffffffff;
  d = a + ((d << 12) | (d >> (32 - 12)));
  ;
  c += ((d & a) | (b & ~d)) + x[2] + (unsigned long)0x242070db;
  c &= 0xffffffff;
  c = d + ((c << 17) | (c >> (32 - 17)));
  ;
  b += ((c & d) | (a & ~c)) + x[3] + (unsigned long)0xc1bdceee;
  b &= 0xffffffff;
  b = c + ((b << 22) | (b >> (32 - 22)));
  ;
  a += ((b & c) | (d & ~b)) + x[4] + (unsigned long)0xf57c0faf;
  a &= 0xffffffff;
  a = b + ((a << 7) | (a >> (32 - 7)));
  ;
  d += ((a & b) | (c & ~a)) + x[5] + (unsigned long)0x4787c62a;
  d &= 0xffffffff;
  d = a + ((d << 12) | (d >> (32 - 12)));
  ;
  c += ((d & a) | (b & ~d)) + x[6] + (unsigned long)0xa8304613;
  c &= 0xffffffff;
  c = d + ((c << 17) | (c >> (32 - 17)));
  ;
  b += ((c & d) | (a & ~c)) + x[7] + (unsigned long)0xfd469501;
  b &= 0xffffffff;
  b = c + ((b << 22) | (b >> (32 - 22)));
  ;
  a += ((b & c) | (d & ~b)) + x[8] + (unsigned long)0x698098d8;
  a &= 0xffffffff;
  a = b + ((a << 7) | (a >> (32 - 7)));
  ;
  d += ((a & b) | (c & ~a)) + x[9] + (unsigned long)0x8b44f7af;
  d &= 0xffffffff;
  d = a + ((d << 12) | (d >> (32 - 12)));
  ;
  c += ((d & a) | (b & ~d)) + x[10] + (unsigned long)0xffff5bb1;
  c &= 0xffffffff;
  c = d + ((c << 17) | (c >> (32 - 17)));
  ;
  b += ((c & d) | (a & ~c)) + x[11] + (unsigned long)0x895cd7be;
  b &= 0xffffffff;
  b = c + ((b << 22) | (b >> (32 - 22)));
  ;
  a += ((b & c) | (d & ~b)) + x[12] + (unsigned long)0x6b901122;
  a &= 0xffffffff;
  a = b + ((a << 7) | (a >> (32 - 7)));
  ;
  d += ((a & b) | (c & ~a)) + x[13] + (unsigned long)0xfd987193;
  d &= 0xffffffff;
  d = a + ((d << 12) | (d >> (32 - 12)));
  ;
  c += ((d & a) | (b & ~d)) + x[14] + (unsigned long)0xa679438e;
  c &= 0xffffffff;
  c = d + ((c << 17) | (c >> (32 - 17)));
  ;
  b += ((c & d) | (a & ~c)) + x[15] + (unsigned long)0x49b40821;
  b &= 0xffffffff;
  b = c + ((b << 22) | (b >> (32 - 22)));
  ;
  a += ((b & d) | (c & ~d)) + x[1] + (unsigned long)0xf61e2562;
  a &= 0xffffffff;
  a = b + ((a << 5) | (a >> (32 - 5)));
  ;
  d += ((a & c) | (b & ~c)) + x[6] + (unsigned long)0xc040b340;
  d &= 0xffffffff;
  d = a + ((d << 9) | (d >> (32 - 9)));
  ;
  c += ((d & b) | (a & ~b)) + x[11] + (unsigned long)0x265e5a51;
  c &= 0xffffffff;
  c = d + ((c << 14) | (c >> (32 - 14)));
  ;
  b += ((c & a) | (d & ~a)) + x[0] + (unsigned long)0xe9b6c7aa;
  b &= 0xffffffff;
  b = c + ((b << 20) | (b >> (32 - 20)));
  ;
  a += ((b & d) | (c & ~d)) + x[5] + (unsigned long)0xd62f105d;
  a &= 0xffffffff;
  a = b + ((a << 5) | (a >> (32 - 5)));
  ;
  d += ((a & c) | (b & ~c)) + x[10] + (unsigned long)0x2441453;
  d &= 0xffffffff;
  d = a + ((d << 9) | (d >> (32 - 9)));
  ;
  c += ((d & b) | (a & ~b)) + x[15] + (unsigned long)0xd8a1e681;
  c &= 0xffffffff;
  c = d + ((c << 14) | (c >> (32 - 14)));
  ;
  b += ((c & a) | (d & ~a)) + x[4] + (unsigned long)0xe7d3fbc8;
  b &= 0xffffffff;
  b = c + ((b << 20) | (b >> (32 - 20)));
  ;
  a += ((b & d) | (c & ~d)) + x[9] + (unsigned long)0x21e1cde6;
  a &= 0xffffffff;
  a = b + ((a << 5) | (a >> (32 - 5)));
  ;
  d += ((a & c) | (b & ~c)) + x[14] + (unsigned long)0xc33707d6;
  d &= 0xffffffff;
  d = a + ((d << 9) | (d >> (32 - 9)));
  ;
  c += ((d & b) | (a & ~b)) + x[3] + (unsigned long)0xf4d50d87;
  c &= 0xffffffff;
  c = d + ((c << 14) | (c >> (32 - 14)));
  ;
  b += ((c & a) | (d & ~a)) + x[8] + (unsigned long)0x455a14ed;
  b &= 0xffffffff;
  b = c + ((b << 20) | (b >> (32 - 20)));
  ;
  a += ((b & d) | (c & ~d)) + x[13] + (unsigned long)0xa9e3e905;
  a &= 0xffffffff;
  a = b + ((a << 5) | (a >> (32 - 5)));
  ;
  d += ((a & c) | (b & ~c)) + x[2] + (unsigned long)0xfcefa3f8;
  d &= 0xffffffff;
  d = a + ((d << 9) | (d >> (32 - 9)));
  ;
  c += ((d & b) | (a & ~b)) + x[7] + (unsigned long)0x676f02d9;
  c &= 0xffffffff;
  c = d + ((c << 14) | (c >> (32 - 14)));
  ;
  b += ((c & a) | (d & ~a)) + x[12] + (unsigned long)0x8d2a4c8a;
  b &= 0xffffffff;
  b = c + ((b << 20) | (b >> (32 - 20)));
  ;
  a += (b ^ c ^ d) + x[5] + (unsigned long)0xfffa3942;
  a &= 0xffffffff;
  a = b + ((a << 4) | (a >> (32 - 4)));
  ;
  d += (a ^ b ^ c) + x[8] + (unsigned long)0x8771f681;
  d &= 0xffffffff;
  d = a + ((d << 11) | (d >> (32 - 11)));
  ;
  c += (d ^ a ^ b) + x[11] + (unsigned long)0x6d9d6122;
  c &= 0xffffffff;
  c = d + ((c << 16) | (c >> (32 - 16)));
  ;
  b += (c ^ d ^ a) + x[14] + (unsigned long)0xfde5380c;
  b &= 0xffffffff;
  b = c + ((b << 23) | (b >> (32 - 23)));
  ;
  a += (b ^ c ^ d) + x[1] + (unsigned long)0xa4beea44;
  a &= 0xffffffff;
  a = b + ((a << 4) | (a >> (32 - 4)));
  ;
  d += (a ^ b ^ c) + x[4] + (unsigned long)0x4bdecfa9;
  d &= 0xffffffff;
  d = a + ((d << 11) | (d >> (32 - 11)));
  ;
  c += (d ^ a ^ b) + x[7] + (unsigned long)0xf6bb4b60;
  c &= 0xffffffff;
  c = d + ((c << 16) | (c >> (32 - 16)));
  ;
  b += (c ^ d ^ a) + x[10] + (unsigned long)0xbebfbc70;
  b &= 0xffffffff;
  b = c + ((b << 23) | (b >> (32 - 23)));
  ;
  a += (b ^ c ^ d) + x[13] + (unsigned long)0x289b7ec6;
  a &= 0xffffffff;
  a = b + ((a << 4) | (a >> (32 - 4)));
  ;
  d += (a ^ b ^ c) + x[0] + (unsigned long)0xeaa127fa;
  d &= 0xffffffff;
  d = a + ((d << 11) | (d >> (32 - 11)));
  ;
  c += (d ^ a ^ b) + x[3] + (unsigned long)0xd4ef3085;
  c &= 0xffffffff;
  c = d + ((c << 16) | (c >> (32 - 16)));
  ;
  b += (c ^ d ^ a) + x[6] + (unsigned long)0x4881d05;
  b &= 0xffffffff;
  b = c + ((b << 23) | (b >> (32 - 23)));
  ;
  a += (b ^ c ^ d) + x[9] + (unsigned long)0xd9d4d039;
  a &= 0xffffffff;
  a = b + ((a << 4) | (a >> (32 - 4)));
  ;
  d += (a ^ b ^ c) + x[12] + (unsigned long)0xe6db99e5;
  d &= 0xffffffff;
  d = a + ((d << 11) | (d >> (32 - 11)));
  ;
  c += (d ^ a ^ b) + x[15] + (unsigned long)0x1fa27cf8;
  c &= 0xffffffff;
  c = d + ((c << 16) | (c >> (32 - 16)));
  ;
  b += (c ^ d ^ a) + x[2] + (unsigned long)0xc4ac5665;
  b &= 0xffffffff;
  b = c + ((b << 23) | (b >> (32 - 23)));
  ;
  a += (c ^ (b | ~d)) + x[0] + (unsigned long)0xf4292244;
  a &= 0xffffffff;
  a = b + ((a << 6) | (a >> (32 - 6)));
  ;
  d += (b ^ (a | ~c)) + x[7] + (unsigned long)0x432aff97;
  d &= 0xffffffff;
  d = a + ((d << 10) | (d >> (32 - 10)));
  ;
  c += (a ^ (d | ~b)) + x[14] + (unsigned long)0xab9423a7;
  c &= 0xffffffff;
  c = d + ((c << 15) | (c >> (32 - 15)));
  ;
  b += (d ^ (c | ~a)) + x[5] + (unsigned long)0xfc93a039;
  b &= 0xffffffff;
  b = c + ((b << 21) | (b >> (32 - 21)));
  ;
  a += (c ^ (b | ~d)) + x[12] + (unsigned long)0x655b59c3;
  a &= 0xffffffff;
  a = b + ((a << 6) | (a >> (32 - 6)));
  ;
  d += (b ^ (a | ~c)) + x[3] + (unsigned long)0x8f0ccc92;
  d &= 0xffffffff;
  d = a + ((d << 10) | (d >> (32 - 10)));
  ;
  c += (a ^ (d | ~b)) + x[10] + (unsigned long)0xffeff47d;
  c &= 0xffffffff;
  c = d + ((c << 15) | (c >> (32 - 15)));
  ;
  b += (d ^ (c | ~a)) + x[1] + (unsigned long)0x85845dd1;
  b &= 0xffffffff;
  b = c + ((b << 21) | (b >> (32 - 21)));
  ;
  a += (c ^ (b | ~d)) + x[8] + (unsigned long)0x6fa87e4f;
  a &= 0xffffffff;
  a = b + ((a << 6) | (a >> (32 - 6)));
  ;
  d += (b ^ (a | ~c)) + x[15] + (unsigned long)0xfe2ce6e0;
  d &= 0xffffffff;
  d = a + ((d << 10) | (d >> (32 - 10)));
  ;
  c += (a ^ (d | ~b)) + x[6] + (unsigned long)0xa3014314;
  c &= 0xffffffff;
  c = d + ((c << 15) | (c >> (32 - 15)));
  ;
  b += (d ^ (c | ~a)) + x[13] + (unsigned long)0x4e0811a1;
  b &= 0xffffffff;
  b = c + ((b << 21) | (b >> (32 - 21)));
  ;
  a += (c ^ (b | ~d)) + x[4] + (unsigned long)0xf7537e82;
  a &= 0xffffffff;
  a = b + ((a << 6) | (a >> (32 - 6)));
  ;
  d += (b ^ (a | ~c)) + x[11] + (unsigned long)0xbd3af235;
  d &= 0xffffffff;
  d = a + ((d << 10) | (d >> (32 - 10)));
  ;
  c += (a ^ (d | ~b)) + x[2] + (unsigned long)0x2ad7d2bb;
  c &= 0xffffffff;
  c = d + ((c << 15) | (c >> (32 - 15)));
  ;
  b += (d ^ (c | ~a)) + x[9] + (unsigned long)0xeb86d391;
  b &= 0xffffffff;
  b = c + ((b << 21) | (b >> (32 - 21)));
  ;
  state[0] += a;
  state[1] += b;
  state[2] += c;
  state[3] += d;
  memset(x, 0, sizeof(x));
}


x86 assembly (clang, -O0):
<md5_transform>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    %rax,-0x30(%rbp)
lea    -0xb0(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    $0x10,%edx
call   1040 <md5_decode@plt>
mov    -0x20(%rbp),%rax
and    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0xb0(%rbp),%rax
movabs $0xd76aa478,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x7,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x19,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0xa8(%rbp),%rax
movabs $0xe8c7b756,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xc,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x14,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
and    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0xa0(%rbp),%rax
add    $0x242070db,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x11,%rcx
mov    -0x28(%rbp),%rdx
shr    $0xf,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
and    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x98(%rbp),%rax
movabs $0xc1bdceee,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x16,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xa,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
and    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x90(%rbp),%rax
movabs $0xf57c0faf,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x7,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x19,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x88(%rbp),%rax
add    $0x4787c62a,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xc,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x14,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
and    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x80(%rbp),%rax
movabs $0xa8304613,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x11,%rcx
mov    -0x28(%rbp),%rdx
shr    $0xf,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
and    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x78(%rbp),%rax
movabs $0xfd469501,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x16,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xa,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
and    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x70(%rbp),%rax
add    $0x698098d8,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x7,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x19,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x68(%rbp),%rax
movabs $0x8b44f7af,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xc,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x14,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
and    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x60(%rbp),%rax
movabs $0xffff5bb1,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x11,%rcx
mov    -0x28(%rbp),%rdx
shr    $0xf,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
and    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x58(%rbp),%rax
movabs $0x895cd7be,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x16,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xa,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
and    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x50(%rbp),%rax
add    $0x6b901122,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x7,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x19,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x48(%rbp),%rax
movabs $0xfd987193,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xc,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x14,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
and    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x40(%rbp),%rax
movabs $0xa679438e,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x11,%rcx
mov    -0x28(%rbp),%rdx
shr    $0xf,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
and    -0x30(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x38(%rbp),%rax
add    $0x49b40821,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x16,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xa,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
and    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0xa8(%rbp),%rax
movabs $0xf61e2562,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x5,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1b,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x80(%rbp),%rax
movabs $0xc040b340,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x9,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x17,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
and    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x58(%rbp),%rax
add    $0x265e5a51,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0xe,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x12,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
and    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0xb0(%rbp),%rax
movabs $0xe9b6c7aa,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x14,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xc,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
and    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x88(%rbp),%rax
movabs $0xd62f105d,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x5,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1b,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x60(%rbp),%rax
add    $0x2441453,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x9,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x17,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
and    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x38(%rbp),%rax
movabs $0xd8a1e681,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0xe,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x12,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
and    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x90(%rbp),%rax
movabs $0xe7d3fbc8,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x14,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xc,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
and    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x68(%rbp),%rax
add    $0x21e1cde6,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x5,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1b,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x40(%rbp),%rax
movabs $0xc33707d6,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x9,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x17,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
and    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x98(%rbp),%rax
movabs $0xf4d50d87,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0xe,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x12,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
and    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x70(%rbp),%rax
add    $0x455a14ed,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x14,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xc,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
and    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x48(%rbp),%rax
movabs $0xa9e3e905,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x5,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1b,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0xa0(%rbp),%rax
movabs $0xfcefa3f8,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0x9,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x17,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
and    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x78(%rbp),%rax
add    $0x676f02d9,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0xe,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x12,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
and    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
and    %rdx,%rcx
or     %rcx,%rax
add    -0x50(%rbp),%rax
movabs $0x8d2a4c8a,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x14,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xc,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
xor    -0x28(%rbp),%rax
xor    -0x30(%rbp),%rax
add    -0x88(%rbp),%rax
movabs $0xfffa3942,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x4,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1c,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
xor    -0x20(%rbp),%rax
xor    -0x28(%rbp),%rax
add    -0x70(%rbp),%rax
movabs $0x8771f681,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xb,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x15,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
xor    -0x18(%rbp),%rax
xor    -0x20(%rbp),%rax
add    -0x58(%rbp),%rax
add    $0x6d9d6122,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x10,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x10,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
xor    -0x30(%rbp),%rax
xor    -0x18(%rbp),%rax
add    -0x40(%rbp),%rax
movabs $0xfde5380c,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x17,%rcx
mov    -0x20(%rbp),%rdx
shr    $0x9,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
xor    -0x28(%rbp),%rax
xor    -0x30(%rbp),%rax
add    -0xa8(%rbp),%rax
movabs $0xa4beea44,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x4,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1c,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
xor    -0x20(%rbp),%rax
xor    -0x28(%rbp),%rax
add    -0x90(%rbp),%rax
add    $0x4bdecfa9,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xb,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x15,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
xor    -0x18(%rbp),%rax
xor    -0x20(%rbp),%rax
add    -0x78(%rbp),%rax
movabs $0xf6bb4b60,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x10,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x10,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
xor    -0x30(%rbp),%rax
xor    -0x18(%rbp),%rax
add    -0x60(%rbp),%rax
movabs $0xbebfbc70,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x17,%rcx
mov    -0x20(%rbp),%rdx
shr    $0x9,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
xor    -0x28(%rbp),%rax
xor    -0x30(%rbp),%rax
add    -0x48(%rbp),%rax
add    $0x289b7ec6,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x4,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1c,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
xor    -0x20(%rbp),%rax
xor    -0x28(%rbp),%rax
add    -0xb0(%rbp),%rax
movabs $0xeaa127fa,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xb,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x15,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
xor    -0x18(%rbp),%rax
xor    -0x20(%rbp),%rax
add    -0x98(%rbp),%rax
movabs $0xd4ef3085,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x10,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x10,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
xor    -0x30(%rbp),%rax
xor    -0x18(%rbp),%rax
add    -0x80(%rbp),%rax
add    $0x4881d05,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x17,%rcx
mov    -0x20(%rbp),%rdx
shr    $0x9,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
xor    -0x28(%rbp),%rax
xor    -0x30(%rbp),%rax
add    -0x68(%rbp),%rax
movabs $0xd9d4d039,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x4,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1c,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
xor    -0x20(%rbp),%rax
xor    -0x28(%rbp),%rax
add    -0x50(%rbp),%rax
movabs $0xe6db99e5,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xb,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x15,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
xor    -0x18(%rbp),%rax
xor    -0x20(%rbp),%rax
add    -0x38(%rbp),%rax
add    $0x1fa27cf8,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x10,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x10,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
xor    -0x30(%rbp),%rax
xor    -0x18(%rbp),%rax
add    -0xa0(%rbp),%rax
movabs $0xc4ac5665,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x17,%rcx
mov    -0x20(%rbp),%rdx
shr    $0x9,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0xb0(%rbp),%rax
movabs $0xf4292244,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x6,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1a,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x78(%rbp),%rax
add    $0x432aff97,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xa,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x16,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x40(%rbp),%rax
movabs $0xab9423a7,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0xf,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x11,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x88(%rbp),%rax
movabs $0xfc93a039,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x15,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xb,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x50(%rbp),%rax
add    $0x655b59c3,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x6,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1a,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x98(%rbp),%rax
movabs $0x8f0ccc92,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xa,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x16,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x60(%rbp),%rax
movabs $0xffeff47d,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0xf,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x11,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0xa8(%rbp),%rax
movabs $0x85845dd1,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x15,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xb,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x70(%rbp),%rax
add    $0x6fa87e4f,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x6,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1a,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x38(%rbp),%rax
movabs $0xfe2ce6e0,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xa,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x16,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x80(%rbp),%rax
movabs $0xa3014314,%rcx
add    %rcx,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0xf,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x11,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x48(%rbp),%rax
add    $0x4e0811a1,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x15,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xb,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x30(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x90(%rbp),%rax
movabs $0xf7537e82,%rcx
add    %rcx,%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
movabs $0xffffffff,%rax
and    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
shl    $0x6,%rcx
mov    -0x18(%rbp),%rdx
shr    $0x1a,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x58(%rbp),%rax
movabs $0xbd3af235,%rcx
add    %rcx,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
movabs $0xffffffff,%rax
and    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
shl    $0xa,%rcx
mov    -0x30(%rbp),%rdx
shr    $0x16,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x20(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0xa0(%rbp),%rax
add    $0x2ad7d2bb,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
movabs $0xffffffff,%rax
and    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0xf,%rcx
mov    -0x28(%rbp),%rdx
shr    $0x11,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x18(%rbp),%rdx
xor    $0xffffffffffffffff,%rdx
or     %rdx,%rcx
xor    %rcx,%rax
add    -0x68(%rbp),%rax
movabs $0xeb86d391,%rcx
add    %rcx,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
movabs $0xffffffff,%rax
and    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x15,%rcx
mov    -0x20(%rbp),%rdx
shr    $0xb,%rdx
or     %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x8(%rbp),%rax
add    (%rax),%rcx
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rcx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%rcx
mov    %rcx,0x8(%rax)
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
add    0x10(%rax),%rcx
mov    %rcx,0x10(%rax)
mov    -0x30(%rbp),%rcx
mov    -0x8(%rbp),%rax
add    0x18(%rax),%rcx
mov    %rcx,0x18(%rax)
lea    -0xb0(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1030 <memset@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<md5_transform>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rdi,0x88(%rsp)
mov    0x8(%rdi),%r14
mov    0x10(%rdi),%r15d
mov    0x18(%rdi),%r12d
mov    %r15d,%ebp
and    %r14d,%ebp
add    (%rdi),%ebp
lea    0x90(%rsp),%rdi
mov    $0x10,%edx
call   1040 <md5_decode@plt>
mov    %r14d,%eax
not    %eax
and    %r12d,%eax
add    %ebp,%eax
mov    0x90(%rsp),%ecx
mov    %rcx,0x30(%rsp)
mov    0x98(%rsp),%r13d
lea    (%rcx,%rax,1),%edx
add    $0xd76aa478,%edx
mov    %rdx,%rax
shl    $0x7,%rax
shr    $0x19,%rdx
add    %r14,%rdx
add    %rax,%rdx
mov    %edx,%eax
and    %r14d,%eax
mov    %edx,%ecx
not    %ecx
and    %r15d,%ecx
add    %r13d,%r12d
mov    %r13,0x28(%rsp)
add    %ecx,%r12d
lea    (%rax,%r12,1),%esi
add    $0xe8c7b756,%esi
mov    %rsi,%rax
shl    $0xc,%rax
shr    $0x14,%rsi
add    %rdx,%rsi
add    %rax,%rsi
mov    %esi,%eax
and    %edx,%eax
mov    %esi,%ecx
not    %ecx
and    %r14d,%ecx
mov    0xa0(%rsp),%edi
mov    %rdi,0x80(%rsp)
add    %edi,%r15d
add    %ecx,%r15d
add    %r15d,%eax
add    $0x242070db,%eax
mov    %rax,%rcx
shl    $0x11,%rcx
shr    $0xf,%rax
add    %rsi,%rax
add    %rcx,%rax
mov    %eax,%ecx
and    %esi,%ecx
mov    %eax,%edi
not    %edi
and    %edx,%edi
mov    0xa8(%rsp),%ebp
mov    %rbp,0x70(%rsp)
add    %r14d,%ebp
add    %ebp,%edi
lea    (%rcx,%rdi,1),%r8d
add    $0xc1bdceee,%r8d
mov    %r8,%rdi
shl    $0x16,%rdi
shr    $0xa,%r8
add    %rax,%r8
add    %rdi,%r8
mov    %r8d,%edi
and    %eax,%edi
mov    %r8d,%ecx
not    %ecx
and    %esi,%ecx
mov    0xb0(%rsp),%ebp
mov    %rbp,0x18(%rsp)
add    %ebp,%edx
add    %edx,%ecx
lea    (%rdi,%rcx,1),%edx
add    $0xf57c0faf,%edx
mov    %rdx,%rcx
shl    $0x7,%rcx
shr    $0x19,%rdx
add    %r8,%rdx
add    %rcx,%rdx
mov    %edx,%ecx
and    %r8d,%ecx
mov    %edx,%edi
not    %edi
and    %eax,%edi
mov    0xb8(%rsp),%ebp
mov    %rbp,0x8(%rsp)
add    %ebp,%esi
add    %esi,%edi
lea    (%rcx,%rdi,1),%esi
add    $0x4787c62a,%esi
mov    %rsi,%rcx
shl    $0xc,%rcx
shr    $0x14,%rsi
add    %rdx,%rsi
add    %rcx,%rsi
mov    %esi,%ecx
and    %edx,%ecx
mov    %esi,%edi
not    %edi
and    %r8d,%edi
mov    0xc0(%rsp),%ebp
add    %ebp,%eax
mov    %rbp,0x78(%rsp)
add    %eax,%edi
lea    (%rcx,%rdi,1),%eax
add    $0xa8304613,%eax
mov    %rax,%rcx
shl    $0x11,%rcx
shr    $0xf,%rax
add    %rsi,%rax
add    %rcx,%rax
mov    %eax,%r9d
and    %esi,%r9d
mov    %eax,%edi
not    %edi
and    %edx,%edi
mov    0xc8(%rsp),%ecx
mov    %rcx,0x68(%rsp)
add    %ecx,%edi
add    %r8d,%edi
lea    (%r9,%rdi,1),%ecx
add    $0xfd469501,%ecx
mov    %rcx,%rdi
shl    $0x16,%rdi
shr    $0xa,%rcx
add    %rax,%rcx
add    %rdi,%rcx
mov    %ecx,%edi
not    %edi
and    %esi,%edi
mov    0xd0(%rsp),%ebx
mov    %rbx,0x10(%rsp)
add    %ebx,%edx
add    %edx,%edi
mov    %ecx,%edx
and    %eax,%edx
lea    (%rdx,%rdi,1),%r8d
add    $0x698098d8,%r8d
mov    %r8,%rdx
shl    $0x7,%rdx
shr    $0x19,%r8
add    %rcx,%r8
add    %rdx,%r8
mov    %r8d,%edx
not    %edx
and    %eax,%edx
mov    0xd8(%rsp),%r15d
add    %r15d,%esi
mov    %r15,0x50(%rsp)
add    %esi,%edx
mov    %r8d,%esi
and    %ecx,%esi
add    %edx,%esi
add    $0x8b44f7af,%esi
mov    %rsi,%rdx
shl    $0xc,%rdx
shr    $0x14,%rsi
add    %r8,%rsi
add    %rdx,%rsi
mov    %esi,%edx
not    %edx
and    %ecx,%edx
mov    0xe0(%rsp),%edi
add    %edi,%eax
mov    %rdi,%r12
mov    %rdi,0x48(%rsp)
add    %eax,%edx
mov    %esi,%eax
and    %r8d,%eax
add    %eax,%edx
add    $0xffff5bb1,%edx
mov    %rdx,%rax
shl    $0x11,%rax
shr    $0xf,%rdx
add    %rsi,%rdx
add    %rax,%rdx
mov    %edx,%eax
not    %eax
and    %r8d,%eax
mov    0xe8(%rsp),%r10d
add    %r10d,%ecx
mov    %r10,0x20(%rsp)
add    %ecx,%eax
mov    %edx,%ecx
and    %esi,%ecx
add    %ecx,%eax
add    $0x895cd7be,%eax
mov    %rax,%rcx
shl    $0x16,%rcx
shr    $0xa,%rax
add    %rdx,%rax
add    %rcx,%rax
mov    %eax,%ecx
not    %ecx
and    %esi,%ecx
mov    0xf0(%rsp),%edi
mov    %rdi,0x58(%rsp)
add    %r8d,%edi
add    %edi,%ecx
mov    %eax,%edi
and    %edx,%edi
lea    (%rdi,%rcx,1),%r8d
add    $0x6b901122,%r8d
mov    %r8,%rdi
shl    $0x7,%rdi
shr    $0x19,%r8
add    %rax,%r8
add    %rdi,%r8
mov    %r8d,%edi
not    %edi
and    %edx,%edi
mov    0xf8(%rsp),%ecx
add    %ecx,%esi
mov    %rcx,%r11
add    %esi,%edi
mov    %r8d,%esi
and    %eax,%esi
add    %edi,%esi
add    $0xfd987193,%esi
mov    %rsi,%rdi
shl    $0xc,%rdi
shr    $0x14,%rsi
add    %r8,%rsi
add    %rdi,%rsi
mov    %esi,%r9d
not    %r9d
mov    %eax,%edi
and    %r9d,%edi
mov    0x100(%rsp),%ecx
add    %ecx,%edx
mov    %rcx,%r14
add    %edx,%edi
mov    %esi,%edx
and    %r8d,%edx
add    %edi,%edx
add    $0xa679438e,%edx
mov    %rdx,%rdi
shl    $0x11,%rdi
shr    $0xf,%rdx
add    %rsi,%rdx
add    %rdi,%rdx
mov    0x108(%rsp),%ecx
add    %ecx,%eax
mov    %rcx,%rbx
mov    %rcx,0x60(%rsp)
mov    %edx,%edi
not    %edi
mov    %r8d,%ecx
and    %edi,%ecx
add    %eax,%ecx
mov    %edx,%eax
and    %esi,%eax
add    %ecx,%eax
add    $0x49b40821,%eax
mov    %rax,%rcx
shl    $0x16,%rcx
shr    $0xa,%rax
add    %rdx,%rax
add    %rcx,%rax
and    %edx,%r9d
add    %r13d,%r9d
add    %r8d,%r9d
mov    %eax,%ecx
and    %esi,%ecx
add    %ecx,%r9d
add    $0xf61e2562,%r9d
mov    %r9,%rcx
shl    $0x5,%rcx
shr    $0x1b,%r9
add    %rax,%r9
add    %rcx,%r9
and    %eax,%edi
add    %ebp,%edi
add    %esi,%edi
mov    %r9d,%ecx
and    %edx,%ecx
add    %ecx,%edi
add    $0xc040b340,%edi
mov    %rdi,%rcx
shl    $0x9,%rcx
shr    $0x17,%rdi
add    %r9,%rdi
add    %rcx,%rdi
mov    %eax,%ecx
not    %ecx
and    %r9d,%ecx
add    %r10d,%edx
add    %edx,%ecx
mov    %edi,%edx
and    %eax,%edx
lea    (%rdx,%rcx,1),%r8d
add    $0x265e5a51,%r8d
mov    %r8,%rcx
shl    $0xe,%rcx
shr    $0x12,%r8
add    %rdi,%r8
add    %rcx,%r8
mov    0x30(%rsp),%rcx
add    %ecx,%eax
mov    %r9d,%ecx
not    %ecx
and    %edi,%ecx
add    %eax,%ecx
mov    %r8d,%eax
and    %r9d,%eax
lea    (%rax,%rcx,1),%edx
add    $0xe9b6c7aa,%edx
mov    %rdx,%rax
shl    $0x14,%rax
shr    $0xc,%rdx
add    %r8,%rdx
add    %rax,%rdx
mov    0x8(%rsp),%r10
mov    %edi,%ecx
not    %ecx
and    %r8d,%ecx
add    %r10d,%ecx
add    %r9d,%ecx
mov    %edx,%eax
and    %edi,%eax
lea    (%rax,%rcx,1),%esi
add    $0xd62f105d,%esi
mov    %rsi,%rax
shl    $0x5,%rax
shr    $0x1b,%rsi
add    %rdx,%rsi
add    %rax,%rsi
mov    %r8d,%ecx
not    %ecx
and    %edx,%ecx
add    %r12d,%ecx
add    %edi,%ecx
mov    %esi,%eax
and    %r8d,%eax
add    %ecx,%eax
add    $0x2441453,%eax
mov    %rax,%rcx
shl    $0x9,%rcx
shr    $0x17,%rax
add    %rsi,%rax
add    %rcx,%rax
mov    %edx,%edi
not    %edi
and    %esi,%edi
add    %ebx,%edi
add    %r8d,%edi
mov    %eax,%ecx
and    %edx,%ecx
add    %edi,%ecx
add    $0xd8a1e681,%ecx
mov    %rcx,%rdi
shl    $0xe,%rdi
shr    $0x12,%rcx
add    %rax,%rcx
add    %rdi,%rcx
mov    0x18(%rsp),%r9
add    %r9d,%edx
mov    %esi,%edi
not    %edi
and    %eax,%edi
add    %edx,%edi
mov    %ecx,%edx
and    %esi,%edx
add    %edi,%edx
add    $0xe7d3fbc8,%edx
mov    %rdx,%rdi
shl    $0x14,%rdi
shr    $0xc,%rdx
add    %rcx,%rdx
add    %rdi,%rdx
add    %r15d,%esi
mov    %eax,%edi
not    %edi
and    %ecx,%edi
add    %esi,%edi
mov    %edx,%esi
and    %eax,%esi
add    %edi,%esi
add    $0x21e1cde6,%esi
mov    %rsi,%rdi
shl    $0x5,%rdi
shr    $0x1b,%rsi
add    %rdx,%rsi
add    %rdi,%rsi
mov    %r14,%rbx
mov    %r14,0x38(%rsp)
add    %r14d,%eax
mov    %ecx,%edi
not    %edi
and    %edx,%edi
add    %eax,%edi
mov    %esi,%eax
and    %ecx,%eax
add    %edi,%eax
add    $0xc33707d6,%eax
mov    %rax,%rdi
shl    $0x9,%rdi
shr    $0x17,%rax
add    %rsi,%rax
add    %rdi,%rax
mov    0x70(%rsp),%r13
add    %r13d,%ecx
mov    %edx,%edi
not    %edi
and    %esi,%edi
add    %ecx,%edi
mov    %eax,%ecx
and    %edx,%ecx
add    %edi,%ecx
add    $0xf4d50d87,%ecx
mov    %rcx,%rdi
shl    $0xe,%rdi
shr    $0x12,%rcx
add    %rax,%rcx
add    %rdi,%rcx
mov    0x10(%rsp),%rbp
add    %ebp,%edx
mov    %esi,%edi
not    %edi
and    %eax,%edi
add    %edx,%edi
mov    %ecx,%edx
and    %esi,%edx
add    %edi,%edx
add    $0x455a14ed,%edx
mov    %rdx,%rdi
shl    $0x14,%rdi
shr    $0xc,%rdx
add    %rcx,%rdx
add    %rdi,%rdx
add    %r11d,%esi
mov    %r11,%r15
mov    %r11,0x40(%rsp)
mov    %eax,%edi
not    %edi
and    %ecx,%edi
add    %esi,%edi
mov    %edx,%esi
and    %eax,%esi
add    %edi,%esi
add    $0xa9e3e905,%esi
mov    %rsi,%rdi
shl    $0x5,%rdi
shr    $0x1b,%rsi
add    %rdx,%rsi
add    %rdi,%rsi
mov    0x80(%rsp),%r11
add    %r11d,%eax
mov    %ecx,%edi
not    %edi
and    %edx,%edi
add    %eax,%edi
mov    %esi,%eax
and    %ecx,%eax
add    %edi,%eax
add    $0xfcefa3f8,%eax
mov    %rax,%rdi
shl    $0x9,%rdi
shr    $0x17,%rax
add    %rsi,%rax
add    %rdi,%rax
mov    0x68(%rsp),%r14
add    %r14d,%ecx
mov    %edx,%edi
not    %edi
and    %esi,%edi
add    %ecx,%edi
mov    %eax,%ecx
and    %edx,%ecx
add    %edi,%ecx
add    $0x676f02d9,%ecx
mov    %rcx,%rdi
shl    $0xe,%rdi
shr    $0x12,%rcx
add    %rax,%rcx
add    %rdi,%rcx
mov    0x58(%rsp),%r12
add    %r12d,%edx
mov    %esi,%edi
not    %edi
and    %eax,%edi
add    %edx,%edi
mov    %ecx,%edx
and    %esi,%edx
lea    (%rdx,%rdi,1),%r8d
add    $0x8d2a4c8a,%r8d
mov    %r8,%rdi
shl    $0x14,%rdi
shr    $0xc,%r8
add    %rcx,%r8
add    %rdi,%r8
add    %r10d,%esi
mov    %r8d,%edx
xor    %ecx,%edx
mov    %edx,%edi
xor    %eax,%edi
add    %edi,%esi
add    $0xfffa3942,%esi
mov    %rsi,%rdi
shl    $0x4,%rdi
shr    $0x1c,%rsi
add    %r8,%rsi
add    %rdi,%rsi
xor    %esi,%edx
add    %ebp,%eax
add    %edx,%eax
add    $0x8771f681,%eax
mov    %rax,%rdx
shl    $0xb,%rdx
shr    $0x15,%rax
add    %rsi,%rax
add    %rdx,%rax
mov    %esi,%edx
xor    %r8d,%edx
xor    %eax,%edx
mov    0x20(%rsp),%rdi
add    %edi,%ecx
add    %edx,%ecx
add    $0x6d9d6122,%ecx
mov    %rcx,%rdx
shl    $0x10,%rdx
shr    $0x10,%rcx
add    %rax,%rcx
add    %rdx,%rcx
mov    %eax,%edx
xor    %esi,%edx
xor    %ecx,%edx
lea    (%rbx,%r8,1),%edi
add    %edi,%edx
add    $0xfde5380c,%edx
mov    %rdx,%rdi
shl    $0x17,%rdi
shr    $0x9,%rdx
add    %rcx,%rdx
add    %rdi,%rdx
mov    0x28(%rsp),%rdi
add    %edi,%esi
mov    %ecx,%edi
xor    %eax,%edi
xor    %edx,%edi
add    %edi,%esi
add    $0xa4beea44,%esi
mov    %rsi,%rdi
shl    $0x4,%rdi
shr    $0x1c,%rsi
add    %rdx,%rsi
add    %rdi,%rsi
mov    %edx,%edi
xor    %ecx,%edi
xor    %esi,%edi
add    %r9d,%eax
add    %edi,%eax
add    $0x4bdecfa9,%eax
mov    %rax,%rdi
shl    $0xb,%rdi
shr    $0x15,%rax
add    %rsi,%rax
add    %rdi,%rax
add    %r14d,%ecx
mov    %esi,%edi
xor    %edx,%edi
xor    %eax,%edi
add    %edi,%ecx
add    $0xf6bb4b60,%ecx
mov    %rcx,%rdi
shl    $0x10,%rdi
shr    $0x10,%rcx
add    %rax,%rcx
add    %rdi,%rcx
mov    %eax,%edi
xor    %esi,%edi
xor    %ecx,%edi
mov    0x48(%rsp),%r10
add    %r10d,%edx
add    %edi,%edx
add    $0xbebfbc70,%edx
mov    %rdx,%rdi
shl    $0x17,%rdi
shr    $0x9,%rdx
add    %rcx,%rdx
add    %rdi,%rdx
add    %r15d,%esi
mov    %ecx,%edi
xor    %eax,%edi
xor    %edx,%edi
add    %edi,%esi
add    $0x289b7ec6,%esi
mov    %rsi,%rdi
shl    $0x4,%rdi
shr    $0x1c,%rsi
add    %rdx,%rsi
add    %rdi,%rsi
mov    %edx,%edi
xor    %ecx,%edi
xor    %esi,%edi
mov    0x30(%rsp),%rbp
add    %ebp,%eax
add    %eax,%edi
add    $0xeaa127fa,%edi
mov    %rdi,%rax
shl    $0xb,%rax
shr    $0x15,%rdi
add    %rsi,%rdi
add    %rax,%rdi
lea    (%rcx,%r13,1),%eax
mov    %esi,%ecx
xor    %edx,%ecx
xor    %edi,%ecx
add    %ecx,%eax
add    $0xd4ef3085,%eax
mov    %rax,%rcx
shl    $0x10,%rcx
shr    $0x10,%rax
add    %rdi,%rax
add    %rcx,%rax
mov    %edi,%ecx
xor    %esi,%ecx
xor    %eax,%ecx
mov    0x78(%rsp),%r15
add    %r15d,%edx
lea    (%rcx,%rdx,1),%r8d
add    $0x4881d05,%r8d
mov    %r8,%rcx
shl    $0x17,%rcx
shr    $0x9,%r8
add    %rax,%r8
add    %rcx,%r8
mov    0x50(%rsp),%r9
lea    (%r9,%rsi,1),%ecx
mov    %eax,%edx
xor    %edi,%edx
xor    %r8d,%edx
add    %ecx,%edx
add    $0xd9d4d039,%edx
mov    %rdx,%rcx
shl    $0x4,%rcx
shr    $0x1c,%rdx
add    %r8,%rdx
add    %rcx,%rdx
mov    %r8d,%ecx
xor    %eax,%ecx
xor    %edx,%ecx
lea    (%r12,%rdi,1),%esi
add    %esi,%ecx
add    $0xe6db99e5,%ecx
mov    %rcx,%rsi
shl    $0xb,%rsi
shr    $0x15,%rcx
add    %rdx,%rcx
add    %rsi,%rcx
mov    0x60(%rsp),%rbx
add    %ebx,%eax
mov    %ecx,%esi
xor    %edx,%esi
mov    %rbp,%rdi
add    %edx,%edi
xor    %r8d,%edx
xor    %ecx,%edx
add    %eax,%edx
add    $0x1fa27cf8,%edx
mov    %rdx,%rax
shl    $0x10,%rax
shr    $0x10,%rdx
add    %rcx,%rdx
add    %rax,%rdx
xor    %edx,%esi
lea    (%r11,%r8,1),%eax
mov    %r11,%r8
add    %eax,%esi
add    $0xc4ac5665,%esi
mov    %rsi,%rax
shl    $0x17,%rax
shr    $0x9,%rsi
add    %rdx,%rsi
add    %rax,%rsi
add    %ecx,%r14d
not    %ecx
or     %esi,%ecx
xor    %edx,%ecx
lea    (%rcx,%rdi,1),%eax
add    $0xf4292244,%eax
mov    %rax,%rcx
shl    $0x6,%rcx
shr    $0x1a,%rax
add    %rsi,%rax
add    %rcx,%rax
mov    0x38(%rsp),%r11
add    %edx,%r11d
not    %edx
or     %eax,%edx
xor    %esi,%edx
add    %r14d,%edx
add    $0x432aff97,%edx
mov    %rdx,%rcx
shl    $0xa,%rcx
shr    $0x16,%rdx
add    %rax,%rdx
add    %rcx,%rdx
mov    0x8(%rsp),%rdi
add    %esi,%edi
not    %esi
or     %edx,%esi
xor    %eax,%esi
add    %r11d,%esi
add    $0xab9423a7,%esi
mov    %rsi,%rcx
shl    $0xf,%rcx
shr    $0x11,%rsi
add    %rdx,%rsi
add    %rcx,%rsi
add    %eax,%r12d
not    %eax
or     %esi,%eax
xor    %edx,%eax
lea    (%rax,%rdi,1),%ecx
add    $0xfc93a039,%ecx
mov    %rcx,%rax
shl    $0x15,%rax
shr    $0xb,%rcx
add    %rsi,%rcx
add    %rax,%rcx
mov    %r13,%rdi
add    %edx,%edi
not    %edx
or     %ecx,%edx
xor    %esi,%edx
add    %r12d,%edx
add    $0x655b59c3,%edx
mov    %rdx,%rax
shl    $0x6,%rax
shr    $0x1a,%rdx
add    %rcx,%rdx
add    %rax,%rdx
mov    %r10,%rbp
add    %esi,%ebp
not    %esi
or     %edx,%esi
xor    %ecx,%esi
add    %edi,%esi
add    $0x8f0ccc92,%esi
mov    %rsi,%rax
shl    $0xa,%rax
shr    $0x16,%rsi
add    %rdx,%rsi
add    %rax,%rsi
mov    $0x85845dd1,%eax
add    0x28(%rsp),%eax
add    %ecx,%eax
not    %ecx
or     %esi,%ecx
xor    %edx,%ecx
lea    (%rcx,%rbp,1),%edi
add    $0xffeff47d,%edi
mov    %rdi,%rcx
shl    $0xf,%rcx
shr    $0x11,%rdi
add    %rsi,%rdi
add    %rcx,%rdi
mov    0x10(%rsp),%rbp
add    %edx,%ebp
mov    %edx,%ecx
not    %ecx
or     %edi,%ecx
xor    %esi,%ecx
add    %ecx,%eax
mov    %rax,%rcx
shl    $0x15,%rcx
shr    $0xb,%rax
add    %rdi,%rax
add    %rcx,%rax
add    %esi,%ebx
not    %esi
or     %eax,%esi
xor    %edi,%esi
lea    (%rsi,%rbp,1),%ecx
add    $0x6fa87e4f,%ecx
mov    %rcx,%rdx
shl    $0x6,%rdx
shr    $0x1a,%rcx
add    %rax,%rcx
add    %rdx,%rcx
mov    %r15,%rbp
add    %edi,%ebp
not    %edi
or     %ecx,%edi
xor    %eax,%edi
lea    (%rdi,%rbx,1),%edx
add    $0xfe2ce6e0,%edx
mov    %rdx,%rsi
shl    $0xa,%rsi
shr    $0x16,%rdx
add    %rcx,%rdx
add    %rsi,%rdx
mov    0x40(%rsp),%rbx
add    %eax,%ebx
not    %eax
or     %edx,%eax
xor    %ecx,%eax
add    %ebp,%eax
add    $0xa3014314,%eax
mov    %rax,%rsi
shl    $0xf,%rsi
shr    $0x11,%rax
add    %rdx,%rax
add    %rsi,%rax
mov    0x18(%rsp),%rdi
add    %ecx,%edi
not    %ecx
or     %eax,%ecx
xor    %edx,%ecx
add    %ebx,%ecx
add    $0x4e0811a1,%ecx
mov    %rcx,%rsi
shl    $0x15,%rsi
shr    $0xb,%rcx
add    %rax,%rcx
add    %rsi,%rcx
mov    0x20(%rsp),%rbp
add    %edx,%ebp
not    %edx
or     %ecx,%edx
xor    %eax,%edx
add    %edi,%edx
add    $0xf7537e82,%edx
mov    %rdx,%rsi
shl    $0x6,%rsi
shr    $0x1a,%rdx
add    %rcx,%rdx
add    %rsi,%rdx
mov    %r8,%rdi
add    %eax,%edi
not    %eax
or     %edx,%eax
xor    %ecx,%eax
add    %ebp,%eax
add    $0xbd3af235,%eax
mov    %rax,%rsi
shl    $0xa,%rsi
shr    $0x16,%rax
add    %rdx,%rax
add    %rsi,%rax
mov    %r9,%rbp
add    %ecx,%ebp
not    %ecx
or     %eax,%ecx
xor    %edx,%ecx
add    %edi,%ecx
add    $0x2ad7d2bb,%ecx
mov    %rcx,%rsi
shl    $0xf,%rsi
shr    $0x11,%rcx
mov    0x88(%rsp),%rbx
add    %rdx,(%rbx)
add    %rax,%rcx
add    %rsi,%rcx
not    %edx
or     %ecx,%edx
xor    %eax,%edx
add    %ebp,%edx
add    $0xeb86d391,%edx
mov    %rdx,%rsi
shr    $0xb,%rdx
mov    0x8(%rbx),%rdi
add    %rcx,%rdi
add    %rdx,%rdi
shl    $0x15,%rsi
add    %rsi,%rdi
mov    %rdi,0x8(%rbx)
add    %rcx,0x10(%rbx)
add    %rax,0x18(%rbx)
lea    0x90(%rsp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1030 <memset@plt>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @md5_transform(i64* %0, i8* %1) {
%3 = alloca i64*
%4 = alloca i8*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca [16 x i64]
store i64* %0, i64** %3
store i8* %1, i8** %4
%10 = load i64*, i64** %3
%11 = getelementptr inbounds i64, i64* %10, i64 0
%12 = load i64, i64* %11
store i64 %12, i64* %5
%13 = load i64*, i64** %3
%14 = getelementptr inbounds i64, i64* %13, i64 1
%15 = load i64, i64* %14
store i64 %15, i64* %6
%16 = load i64*, i64** %3
%17 = getelementptr inbounds i64, i64* %16, i64 2
%18 = load i64, i64* %17
store i64 %18, i64* %7
%19 = load i64*, i64** %3
%20 = getelementptr inbounds i64, i64* %19, i64 3
%21 = load i64, i64* %20
store i64 %21, i64* %8
%22 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 0
%23 = load i8*, i8** %4
%24 = call i32 @md5_decode(i64* %22, i8* %23, i32 16)
%25 = load i64, i64* %6
%26 = load i64, i64* %7
%27 = and i64 %25, %26
%28 = load i64, i64* %8
%29 = load i64, i64* %6
%30 = xor i64 %29, -1
%31 = and i64 %28, %30
%32 = or i64 %27, %31
%33 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 0
%34 = load i64, i64* %33
%35 = add i64 %32, %34
%36 = add i64 %35, 3614090360
%37 = load i64, i64* %5
%38 = add i64 %37, %36
store i64 %38, i64* %5
%39 = load i64, i64* %5
%40 = and i64 %39, 4294967295
store i64 %40, i64* %5
%41 = load i64, i64* %6
%42 = load i64, i64* %5
%43 = shl i64 %42, 7
%44 = load i64, i64* %5
%45 = lshr i64 %44, 25
%46 = or i64 %43, %45
%47 = add i64 %41, %46
store i64 %47, i64* %5
%48 = load i64, i64* %5
%49 = load i64, i64* %6
%50 = and i64 %48, %49
%51 = load i64, i64* %7
%52 = load i64, i64* %5
%53 = xor i64 %52, -1
%54 = and i64 %51, %53
%55 = or i64 %50, %54
%56 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 1
%57 = load i64, i64* %56
%58 = add i64 %55, %57
%59 = add i64 %58, 3905402710
%60 = load i64, i64* %8
%61 = add i64 %60, %59
store i64 %61, i64* %8
%62 = load i64, i64* %8
%63 = and i64 %62, 4294967295
store i64 %63, i64* %8
%64 = load i64, i64* %5
%65 = load i64, i64* %8
%66 = shl i64 %65, 12
%67 = load i64, i64* %8
%68 = lshr i64 %67, 20
%69 = or i64 %66, %68
%70 = add i64 %64, %69
store i64 %70, i64* %8
%71 = load i64, i64* %8
%72 = load i64, i64* %5
%73 = and i64 %71, %72
%74 = load i64, i64* %6
%75 = load i64, i64* %8
%76 = xor i64 %75, -1
%77 = and i64 %74, %76
%78 = or i64 %73, %77
%79 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 2
%80 = load i64, i64* %79
%81 = add i64 %78, %80
%82 = add i64 %81, 606105819
%83 = load i64, i64* %7
%84 = add i64 %83, %82
store i64 %84, i64* %7
%85 = load i64, i64* %7
%86 = and i64 %85, 4294967295
store i64 %86, i64* %7
%87 = load i64, i64* %8
%88 = load i64, i64* %7
%89 = shl i64 %88, 17
%90 = load i64, i64* %7
%91 = lshr i64 %90, 15
%92 = or i64 %89, %91
%93 = add i64 %87, %92
store i64 %93, i64* %7
%94 = load i64, i64* %7
%95 = load i64, i64* %8
%96 = and i64 %94, %95
%97 = load i64, i64* %5
%98 = load i64, i64* %7
%99 = xor i64 %98, -1
%100 = and i64 %97, %99
%101 = or i64 %96, %100
%102 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 3
%103 = load i64, i64* %102
%104 = add i64 %101, %103
%105 = add i64 %104, 3250441966
%106 = load i64, i64* %6
%107 = add i64 %106, %105
store i64 %107, i64* %6
%108 = load i64, i64* %6
%109 = and i64 %108, 4294967295
store i64 %109, i64* %6
%110 = load i64, i64* %7
%111 = load i64, i64* %6
%112 = shl i64 %111, 22
%113 = load i64, i64* %6
%114 = lshr i64 %113, 10
%115 = or i64 %112, %114
%116 = add i64 %110, %115
store i64 %116, i64* %6
%117 = load i64, i64* %6
%118 = load i64, i64* %7
%119 = and i64 %117, %118
%120 = load i64, i64* %8
%121 = load i64, i64* %6
%122 = xor i64 %121, -1
%123 = and i64 %120, %122
%124 = or i64 %119, %123
%125 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 4
%126 = load i64, i64* %125
%127 = add i64 %124, %126
%128 = add i64 %127, 4118548399
%129 = load i64, i64* %5
%130 = add i64 %129, %128
store i64 %130, i64* %5
%131 = load i64, i64* %5
%132 = and i64 %131, 4294967295
store i64 %132, i64* %5
%133 = load i64, i64* %6
%134 = load i64, i64* %5
%135 = shl i64 %134, 7
%136 = load i64, i64* %5
%137 = lshr i64 %136, 25
%138 = or i64 %135, %137
%139 = add i64 %133, %138
store i64 %139, i64* %5
%140 = load i64, i64* %5
%141 = load i64, i64* %6
%142 = and i64 %140, %141
%143 = load i64, i64* %7
%144 = load i64, i64* %5
%145 = xor i64 %144, -1
%146 = and i64 %143, %145
%147 = or i64 %142, %146
%148 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 5
%149 = load i64, i64* %148
%150 = add i64 %147, %149
%151 = add i64 %150, 1200080426
%152 = load i64, i64* %8
%153 = add i64 %152, %151
store i64 %153, i64* %8
%154 = load i64, i64* %8
%155 = and i64 %154, 4294967295
store i64 %155, i64* %8
%156 = load i64, i64* %5
%157 = load i64, i64* %8
%158 = shl i64 %157, 12
%159 = load i64, i64* %8
%160 = lshr i64 %159, 20
%161 = or i64 %158, %160
%162 = add i64 %156, %161
store i64 %162, i64* %8
%163 = load i64, i64* %8
%164 = load i64, i64* %5
%165 = and i64 %163, %164
%166 = load i64, i64* %6
%167 = load i64, i64* %8
%168 = xor i64 %167, -1
%169 = and i64 %166, %168
%170 = or i64 %165, %169
%171 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 6
%172 = load i64, i64* %171
%173 = add i64 %170, %172
%174 = add i64 %173, 2821735955
%175 = load i64, i64* %7
%176 = add i64 %175, %174
store i64 %176, i64* %7
%177 = load i64, i64* %7
%178 = and i64 %177, 4294967295
store i64 %178, i64* %7
%179 = load i64, i64* %8
%180 = load i64, i64* %7
%181 = shl i64 %180, 17
%182 = load i64, i64* %7
%183 = lshr i64 %182, 15
%184 = or i64 %181, %183
%185 = add i64 %179, %184
store i64 %185, i64* %7
%186 = load i64, i64* %7
%187 = load i64, i64* %8
%188 = and i64 %186, %187
%189 = load i64, i64* %5
%190 = load i64, i64* %7
%191 = xor i64 %190, -1
%192 = and i64 %189, %191
%193 = or i64 %188, %192
%194 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 7
%195 = load i64, i64* %194
%196 = add i64 %193, %195
%197 = add i64 %196, 4249261313
%198 = load i64, i64* %6
%199 = add i64 %198, %197
store i64 %199, i64* %6
%200 = load i64, i64* %6
%201 = and i64 %200, 4294967295
store i64 %201, i64* %6
%202 = load i64, i64* %7
%203 = load i64, i64* %6
%204 = shl i64 %203, 22
%205 = load i64, i64* %6
%206 = lshr i64 %205, 10
%207 = or i64 %204, %206
%208 = add i64 %202, %207
store i64 %208, i64* %6
%209 = load i64, i64* %6
%210 = load i64, i64* %7
%211 = and i64 %209, %210
%212 = load i64, i64* %8
%213 = load i64, i64* %6
%214 = xor i64 %213, -1
%215 = and i64 %212, %214
%216 = or i64 %211, %215
%217 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 8
%218 = load i64, i64* %217
%219 = add i64 %216, %218
%220 = add i64 %219, 1770035416
%221 = load i64, i64* %5
%222 = add i64 %221, %220
store i64 %222, i64* %5
%223 = load i64, i64* %5
%224 = and i64 %223, 4294967295
store i64 %224, i64* %5
%225 = load i64, i64* %6
%226 = load i64, i64* %5
%227 = shl i64 %226, 7
%228 = load i64, i64* %5
%229 = lshr i64 %228, 25
%230 = or i64 %227, %229
%231 = add i64 %225, %230
store i64 %231, i64* %5
%232 = load i64, i64* %5
%233 = load i64, i64* %6
%234 = and i64 %232, %233
%235 = load i64, i64* %7
%236 = load i64, i64* %5
%237 = xor i64 %236, -1
%238 = and i64 %235, %237
%239 = or i64 %234, %238
%240 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 9
%241 = load i64, i64* %240
%242 = add i64 %239, %241
%243 = add i64 %242, 2336552879
%244 = load i64, i64* %8
%245 = add i64 %244, %243
store i64 %245, i64* %8
%246 = load i64, i64* %8
%247 = and i64 %246, 4294967295
store i64 %247, i64* %8
%248 = load i64, i64* %5
%249 = load i64, i64* %8
%250 = shl i64 %249, 12
%251 = load i64, i64* %8
%252 = lshr i64 %251, 20
%253 = or i64 %250, %252
%254 = add i64 %248, %253
store i64 %254, i64* %8
%255 = load i64, i64* %8
%256 = load i64, i64* %5
%257 = and i64 %255, %256
%258 = load i64, i64* %6
%259 = load i64, i64* %8
%260 = xor i64 %259, -1
%261 = and i64 %258, %260
%262 = or i64 %257, %261
%263 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 10
%264 = load i64, i64* %263
%265 = add i64 %262, %264
%266 = add i64 %265, 4294925233
%267 = load i64, i64* %7
%268 = add i64 %267, %266
store i64 %268, i64* %7
%269 = load i64, i64* %7
%270 = and i64 %269, 4294967295
store i64 %270, i64* %7
%271 = load i64, i64* %8
%272 = load i64, i64* %7
%273 = shl i64 %272, 17
%274 = load i64, i64* %7
%275 = lshr i64 %274, 15
%276 = or i64 %273, %275
%277 = add i64 %271, %276
store i64 %277, i64* %7
%278 = load i64, i64* %7
%279 = load i64, i64* %8
%280 = and i64 %278, %279
%281 = load i64, i64* %5
%282 = load i64, i64* %7
%283 = xor i64 %282, -1
%284 = and i64 %281, %283
%285 = or i64 %280, %284
%286 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 11
%287 = load i64, i64* %286
%288 = add i64 %285, %287
%289 = add i64 %288, 2304563134
%290 = load i64, i64* %6
%291 = add i64 %290, %289
store i64 %291, i64* %6
%292 = load i64, i64* %6
%293 = and i64 %292, 4294967295
store i64 %293, i64* %6
%294 = load i64, i64* %7
%295 = load i64, i64* %6
%296 = shl i64 %295, 22
%297 = load i64, i64* %6
%298 = lshr i64 %297, 10
%299 = or i64 %296, %298
%300 = add i64 %294, %299
store i64 %300, i64* %6
%301 = load i64, i64* %6
%302 = load i64, i64* %7
%303 = and i64 %301, %302
%304 = load i64, i64* %8
%305 = load i64, i64* %6
%306 = xor i64 %305, -1
%307 = and i64 %304, %306
%308 = or i64 %303, %307
%309 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 12
%310 = load i64, i64* %309
%311 = add i64 %308, %310
%312 = add i64 %311, 1804603682
%313 = load i64, i64* %5
%314 = add i64 %313, %312
store i64 %314, i64* %5
%315 = load i64, i64* %5
%316 = and i64 %315, 4294967295
store i64 %316, i64* %5
%317 = load i64, i64* %6
%318 = load i64, i64* %5
%319 = shl i64 %318, 7
%320 = load i64, i64* %5
%321 = lshr i64 %320, 25
%322 = or i64 %319, %321
%323 = add i64 %317, %322
store i64 %323, i64* %5
%324 = load i64, i64* %5
%325 = load i64, i64* %6
%326 = and i64 %324, %325
%327 = load i64, i64* %7
%328 = load i64, i64* %5
%329 = xor i64 %328, -1
%330 = and i64 %327, %329
%331 = or i64 %326, %330
%332 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 13
%333 = load i64, i64* %332
%334 = add i64 %331, %333
%335 = add i64 %334, 4254626195
%336 = load i64, i64* %8
%337 = add i64 %336, %335
store i64 %337, i64* %8
%338 = load i64, i64* %8
%339 = and i64 %338, 4294967295
store i64 %339, i64* %8
%340 = load i64, i64* %5
%341 = load i64, i64* %8
%342 = shl i64 %341, 12
%343 = load i64, i64* %8
%344 = lshr i64 %343, 20
%345 = or i64 %342, %344
%346 = add i64 %340, %345
store i64 %346, i64* %8
%347 = load i64, i64* %8
%348 = load i64, i64* %5
%349 = and i64 %347, %348
%350 = load i64, i64* %6
%351 = load i64, i64* %8
%352 = xor i64 %351, -1
%353 = and i64 %350, %352
%354 = or i64 %349, %353
%355 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 14
%356 = load i64, i64* %355
%357 = add i64 %354, %356
%358 = add i64 %357, 2792965006
%359 = load i64, i64* %7
%360 = add i64 %359, %358
store i64 %360, i64* %7
%361 = load i64, i64* %7
%362 = and i64 %361, 4294967295
store i64 %362, i64* %7
%363 = load i64, i64* %8
%364 = load i64, i64* %7
%365 = shl i64 %364, 17
%366 = load i64, i64* %7
%367 = lshr i64 %366, 15
%368 = or i64 %365, %367
%369 = add i64 %363, %368
store i64 %369, i64* %7
%370 = load i64, i64* %7
%371 = load i64, i64* %8
%372 = and i64 %370, %371
%373 = load i64, i64* %5
%374 = load i64, i64* %7
%375 = xor i64 %374, -1
%376 = and i64 %373, %375
%377 = or i64 %372, %376
%378 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 15
%379 = load i64, i64* %378
%380 = add i64 %377, %379
%381 = add i64 %380, 1236535329
%382 = load i64, i64* %6
%383 = add i64 %382, %381
store i64 %383, i64* %6
%384 = load i64, i64* %6
%385 = and i64 %384, 4294967295
store i64 %385, i64* %6
%386 = load i64, i64* %7
%387 = load i64, i64* %6
%388 = shl i64 %387, 22
%389 = load i64, i64* %6
%390 = lshr i64 %389, 10
%391 = or i64 %388, %390
%392 = add i64 %386, %391
store i64 %392, i64* %6
%393 = load i64, i64* %6
%394 = load i64, i64* %8
%395 = and i64 %393, %394
%396 = load i64, i64* %7
%397 = load i64, i64* %8
%398 = xor i64 %397, -1
%399 = and i64 %396, %398
%400 = or i64 %395, %399
%401 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 1
%402 = load i64, i64* %401
%403 = add i64 %400, %402
%404 = add i64 %403, 4129170786
%405 = load i64, i64* %5
%406 = add i64 %405, %404
store i64 %406, i64* %5
%407 = load i64, i64* %5
%408 = and i64 %407, 4294967295
store i64 %408, i64* %5
%409 = load i64, i64* %6
%410 = load i64, i64* %5
%411 = shl i64 %410, 5
%412 = load i64, i64* %5
%413 = lshr i64 %412, 27
%414 = or i64 %411, %413
%415 = add i64 %409, %414
store i64 %415, i64* %5
%416 = load i64, i64* %5
%417 = load i64, i64* %7
%418 = and i64 %416, %417
%419 = load i64, i64* %6
%420 = load i64, i64* %7
%421 = xor i64 %420, -1
%422 = and i64 %419, %421
%423 = or i64 %418, %422
%424 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 6
%425 = load i64, i64* %424
%426 = add i64 %423, %425
%427 = add i64 %426, 3225465664
%428 = load i64, i64* %8
%429 = add i64 %428, %427
store i64 %429, i64* %8
%430 = load i64, i64* %8
%431 = and i64 %430, 4294967295
store i64 %431, i64* %8
%432 = load i64, i64* %5
%433 = load i64, i64* %8
%434 = shl i64 %433, 9
%435 = load i64, i64* %8
%436 = lshr i64 %435, 23
%437 = or i64 %434, %436
%438 = add i64 %432, %437
store i64 %438, i64* %8
%439 = load i64, i64* %8
%440 = load i64, i64* %6
%441 = and i64 %439, %440
%442 = load i64, i64* %5
%443 = load i64, i64* %6
%444 = xor i64 %443, -1
%445 = and i64 %442, %444
%446 = or i64 %441, %445
%447 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 11
%448 = load i64, i64* %447
%449 = add i64 %446, %448
%450 = add i64 %449, 643717713
%451 = load i64, i64* %7
%452 = add i64 %451, %450
store i64 %452, i64* %7
%453 = load i64, i64* %7
%454 = and i64 %453, 4294967295
store i64 %454, i64* %7
%455 = load i64, i64* %8
%456 = load i64, i64* %7
%457 = shl i64 %456, 14
%458 = load i64, i64* %7
%459 = lshr i64 %458, 18
%460 = or i64 %457, %459
%461 = add i64 %455, %460
store i64 %461, i64* %7
%462 = load i64, i64* %7
%463 = load i64, i64* %5
%464 = and i64 %462, %463
%465 = load i64, i64* %8
%466 = load i64, i64* %5
%467 = xor i64 %466, -1
%468 = and i64 %465, %467
%469 = or i64 %464, %468
%470 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 0
%471 = load i64, i64* %470
%472 = add i64 %469, %471
%473 = add i64 %472, 3921069994
%474 = load i64, i64* %6
%475 = add i64 %474, %473
store i64 %475, i64* %6
%476 = load i64, i64* %6
%477 = and i64 %476, 4294967295
store i64 %477, i64* %6
%478 = load i64, i64* %7
%479 = load i64, i64* %6
%480 = shl i64 %479, 20
%481 = load i64, i64* %6
%482 = lshr i64 %481, 12
%483 = or i64 %480, %482
%484 = add i64 %478, %483
store i64 %484, i64* %6
%485 = load i64, i64* %6
%486 = load i64, i64* %8
%487 = and i64 %485, %486
%488 = load i64, i64* %7
%489 = load i64, i64* %8
%490 = xor i64 %489, -1
%491 = and i64 %488, %490
%492 = or i64 %487, %491
%493 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 5
%494 = load i64, i64* %493
%495 = add i64 %492, %494
%496 = add i64 %495, 3593408605
%497 = load i64, i64* %5
%498 = add i64 %497, %496
store i64 %498, i64* %5
%499 = load i64, i64* %5
%500 = and i64 %499, 4294967295
store i64 %500, i64* %5
%501 = load i64, i64* %6
%502 = load i64, i64* %5
%503 = shl i64 %502, 5
%504 = load i64, i64* %5
%505 = lshr i64 %504, 27
%506 = or i64 %503, %505
%507 = add i64 %501, %506
store i64 %507, i64* %5
%508 = load i64, i64* %5
%509 = load i64, i64* %7
%510 = and i64 %508, %509
%511 = load i64, i64* %6
%512 = load i64, i64* %7
%513 = xor i64 %512, -1
%514 = and i64 %511, %513
%515 = or i64 %510, %514
%516 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 10
%517 = load i64, i64* %516
%518 = add i64 %515, %517
%519 = add i64 %518, 38016083
%520 = load i64, i64* %8
%521 = add i64 %520, %519
store i64 %521, i64* %8
%522 = load i64, i64* %8
%523 = and i64 %522, 4294967295
store i64 %523, i64* %8
%524 = load i64, i64* %5
%525 = load i64, i64* %8
%526 = shl i64 %525, 9
%527 = load i64, i64* %8
%528 = lshr i64 %527, 23
%529 = or i64 %526, %528
%530 = add i64 %524, %529
store i64 %530, i64* %8
%531 = load i64, i64* %8
%532 = load i64, i64* %6
%533 = and i64 %531, %532
%534 = load i64, i64* %5
%535 = load i64, i64* %6
%536 = xor i64 %535, -1
%537 = and i64 %534, %536
%538 = or i64 %533, %537
%539 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 15
%540 = load i64, i64* %539
%541 = add i64 %538, %540
%542 = add i64 %541, 3634488961
%543 = load i64, i64* %7
%544 = add i64 %543, %542
store i64 %544, i64* %7
%545 = load i64, i64* %7
%546 = and i64 %545, 4294967295
store i64 %546, i64* %7
%547 = load i64, i64* %8
%548 = load i64, i64* %7
%549 = shl i64 %548, 14
%550 = load i64, i64* %7
%551 = lshr i64 %550, 18
%552 = or i64 %549, %551
%553 = add i64 %547, %552
store i64 %553, i64* %7
%554 = load i64, i64* %7
%555 = load i64, i64* %5
%556 = and i64 %554, %555
%557 = load i64, i64* %8
%558 = load i64, i64* %5
%559 = xor i64 %558, -1
%560 = and i64 %557, %559
%561 = or i64 %556, %560
%562 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 4
%563 = load i64, i64* %562
%564 = add i64 %561, %563
%565 = add i64 %564, 3889429448
%566 = load i64, i64* %6
%567 = add i64 %566, %565
store i64 %567, i64* %6
%568 = load i64, i64* %6
%569 = and i64 %568, 4294967295
store i64 %569, i64* %6
%570 = load i64, i64* %7
%571 = load i64, i64* %6
%572 = shl i64 %571, 20
%573 = load i64, i64* %6
%574 = lshr i64 %573, 12
%575 = or i64 %572, %574
%576 = add i64 %570, %575
store i64 %576, i64* %6
%577 = load i64, i64* %6
%578 = load i64, i64* %8
%579 = and i64 %577, %578
%580 = load i64, i64* %7
%581 = load i64, i64* %8
%582 = xor i64 %581, -1
%583 = and i64 %580, %582
%584 = or i64 %579, %583
%585 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 9
%586 = load i64, i64* %585
%587 = add i64 %584, %586
%588 = add i64 %587, 568446438
%589 = load i64, i64* %5
%590 = add i64 %589, %588
store i64 %590, i64* %5
%591 = load i64, i64* %5
%592 = and i64 %591, 4294967295
store i64 %592, i64* %5
%593 = load i64, i64* %6
%594 = load i64, i64* %5
%595 = shl i64 %594, 5
%596 = load i64, i64* %5
%597 = lshr i64 %596, 27
%598 = or i64 %595, %597
%599 = add i64 %593, %598
store i64 %599, i64* %5
%600 = load i64, i64* %5
%601 = load i64, i64* %7
%602 = and i64 %600, %601
%603 = load i64, i64* %6
%604 = load i64, i64* %7
%605 = xor i64 %604, -1
%606 = and i64 %603, %605
%607 = or i64 %602, %606
%608 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 14
%609 = load i64, i64* %608
%610 = add i64 %607, %609
%611 = add i64 %610, 3275163606
%612 = load i64, i64* %8
%613 = add i64 %612, %611
store i64 %613, i64* %8
%614 = load i64, i64* %8
%615 = and i64 %614, 4294967295
store i64 %615, i64* %8
%616 = load i64, i64* %5
%617 = load i64, i64* %8
%618 = shl i64 %617, 9
%619 = load i64, i64* %8
%620 = lshr i64 %619, 23
%621 = or i64 %618, %620
%622 = add i64 %616, %621
store i64 %622, i64* %8
%623 = load i64, i64* %8
%624 = load i64, i64* %6
%625 = and i64 %623, %624
%626 = load i64, i64* %5
%627 = load i64, i64* %6
%628 = xor i64 %627, -1
%629 = and i64 %626, %628
%630 = or i64 %625, %629
%631 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 3
%632 = load i64, i64* %631
%633 = add i64 %630, %632
%634 = add i64 %633, 4107603335
%635 = load i64, i64* %7
%636 = add i64 %635, %634
store i64 %636, i64* %7
%637 = load i64, i64* %7
%638 = and i64 %637, 4294967295
store i64 %638, i64* %7
%639 = load i64, i64* %8
%640 = load i64, i64* %7
%641 = shl i64 %640, 14
%642 = load i64, i64* %7
%643 = lshr i64 %642, 18
%644 = or i64 %641, %643
%645 = add i64 %639, %644
store i64 %645, i64* %7
%646 = load i64, i64* %7
%647 = load i64, i64* %5
%648 = and i64 %646, %647
%649 = load i64, i64* %8
%650 = load i64, i64* %5
%651 = xor i64 %650, -1
%652 = and i64 %649, %651
%653 = or i64 %648, %652
%654 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 8
%655 = load i64, i64* %654
%656 = add i64 %653, %655
%657 = add i64 %656, 1163531501
%658 = load i64, i64* %6
%659 = add i64 %658, %657
store i64 %659, i64* %6
%660 = load i64, i64* %6
%661 = and i64 %660, 4294967295
store i64 %661, i64* %6
%662 = load i64, i64* %7
%663 = load i64, i64* %6
%664 = shl i64 %663, 20
%665 = load i64, i64* %6
%666 = lshr i64 %665, 12
%667 = or i64 %664, %666
%668 = add i64 %662, %667
store i64 %668, i64* %6
%669 = load i64, i64* %6
%670 = load i64, i64* %8
%671 = and i64 %669, %670
%672 = load i64, i64* %7
%673 = load i64, i64* %8
%674 = xor i64 %673, -1
%675 = and i64 %672, %674
%676 = or i64 %671, %675
%677 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 13
%678 = load i64, i64* %677
%679 = add i64 %676, %678
%680 = add i64 %679, 2850285829
%681 = load i64, i64* %5
%682 = add i64 %681, %680
store i64 %682, i64* %5
%683 = load i64, i64* %5
%684 = and i64 %683, 4294967295
store i64 %684, i64* %5
%685 = load i64, i64* %6
%686 = load i64, i64* %5
%687 = shl i64 %686, 5
%688 = load i64, i64* %5
%689 = lshr i64 %688, 27
%690 = or i64 %687, %689
%691 = add i64 %685, %690
store i64 %691, i64* %5
%692 = load i64, i64* %5
%693 = load i64, i64* %7
%694 = and i64 %692, %693
%695 = load i64, i64* %6
%696 = load i64, i64* %7
%697 = xor i64 %696, -1
%698 = and i64 %695, %697
%699 = or i64 %694, %698
%700 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 2
%701 = load i64, i64* %700
%702 = add i64 %699, %701
%703 = add i64 %702, 4243563512
%704 = load i64, i64* %8
%705 = add i64 %704, %703
store i64 %705, i64* %8
%706 = load i64, i64* %8
%707 = and i64 %706, 4294967295
store i64 %707, i64* %8
%708 = load i64, i64* %5
%709 = load i64, i64* %8
%710 = shl i64 %709, 9
%711 = load i64, i64* %8
%712 = lshr i64 %711, 23
%713 = or i64 %710, %712
%714 = add i64 %708, %713
store i64 %714, i64* %8
%715 = load i64, i64* %8
%716 = load i64, i64* %6
%717 = and i64 %715, %716
%718 = load i64, i64* %5
%719 = load i64, i64* %6
%720 = xor i64 %719, -1
%721 = and i64 %718, %720
%722 = or i64 %717, %721
%723 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 7
%724 = load i64, i64* %723
%725 = add i64 %722, %724
%726 = add i64 %725, 1735328473
%727 = load i64, i64* %7
%728 = add i64 %727, %726
store i64 %728, i64* %7
%729 = load i64, i64* %7
%730 = and i64 %729, 4294967295
store i64 %730, i64* %7
%731 = load i64, i64* %8
%732 = load i64, i64* %7
%733 = shl i64 %732, 14
%734 = load i64, i64* %7
%735 = lshr i64 %734, 18
%736 = or i64 %733, %735
%737 = add i64 %731, %736
store i64 %737, i64* %7
%738 = load i64, i64* %7
%739 = load i64, i64* %5
%740 = and i64 %738, %739
%741 = load i64, i64* %8
%742 = load i64, i64* %5
%743 = xor i64 %742, -1
%744 = and i64 %741, %743
%745 = or i64 %740, %744
%746 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 12
%747 = load i64, i64* %746
%748 = add i64 %745, %747
%749 = add i64 %748, 2368359562
%750 = load i64, i64* %6
%751 = add i64 %750, %749
store i64 %751, i64* %6
%752 = load i64, i64* %6
%753 = and i64 %752, 4294967295
store i64 %753, i64* %6
%754 = load i64, i64* %7
%755 = load i64, i64* %6
%756 = shl i64 %755, 20
%757 = load i64, i64* %6
%758 = lshr i64 %757, 12
%759 = or i64 %756, %758
%760 = add i64 %754, %759
store i64 %760, i64* %6
%761 = load i64, i64* %6
%762 = load i64, i64* %7
%763 = xor i64 %761, %762
%764 = load i64, i64* %8
%765 = xor i64 %763, %764
%766 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 5
%767 = load i64, i64* %766
%768 = add i64 %765, %767
%769 = add i64 %768, 4294588738
%770 = load i64, i64* %5
%771 = add i64 %770, %769
store i64 %771, i64* %5
%772 = load i64, i64* %5
%773 = and i64 %772, 4294967295
store i64 %773, i64* %5
%774 = load i64, i64* %6
%775 = load i64, i64* %5
%776 = shl i64 %775, 4
%777 = load i64, i64* %5
%778 = lshr i64 %777, 28
%779 = or i64 %776, %778
%780 = add i64 %774, %779
store i64 %780, i64* %5
%781 = load i64, i64* %5
%782 = load i64, i64* %6
%783 = xor i64 %781, %782
%784 = load i64, i64* %7
%785 = xor i64 %783, %784
%786 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 8
%787 = load i64, i64* %786
%788 = add i64 %785, %787
%789 = add i64 %788, 2272392833
%790 = load i64, i64* %8
%791 = add i64 %790, %789
store i64 %791, i64* %8
%792 = load i64, i64* %8
%793 = and i64 %792, 4294967295
store i64 %793, i64* %8
%794 = load i64, i64* %5
%795 = load i64, i64* %8
%796 = shl i64 %795, 11
%797 = load i64, i64* %8
%798 = lshr i64 %797, 21
%799 = or i64 %796, %798
%800 = add i64 %794, %799
store i64 %800, i64* %8
%801 = load i64, i64* %8
%802 = load i64, i64* %5
%803 = xor i64 %801, %802
%804 = load i64, i64* %6
%805 = xor i64 %803, %804
%806 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 11
%807 = load i64, i64* %806
%808 = add i64 %805, %807
%809 = add i64 %808, 1839030562
%810 = load i64, i64* %7
%811 = add i64 %810, %809
store i64 %811, i64* %7
%812 = load i64, i64* %7
%813 = and i64 %812, 4294967295
store i64 %813, i64* %7
%814 = load i64, i64* %8
%815 = load i64, i64* %7
%816 = shl i64 %815, 16
%817 = load i64, i64* %7
%818 = lshr i64 %817, 16
%819 = or i64 %816, %818
%820 = add i64 %814, %819
store i64 %820, i64* %7
%821 = load i64, i64* %7
%822 = load i64, i64* %8
%823 = xor i64 %821, %822
%824 = load i64, i64* %5
%825 = xor i64 %823, %824
%826 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 14
%827 = load i64, i64* %826
%828 = add i64 %825, %827
%829 = add i64 %828, 4259657740
%830 = load i64, i64* %6
%831 = add i64 %830, %829
store i64 %831, i64* %6
%832 = load i64, i64* %6
%833 = and i64 %832, 4294967295
store i64 %833, i64* %6
%834 = load i64, i64* %7
%835 = load i64, i64* %6
%836 = shl i64 %835, 23
%837 = load i64, i64* %6
%838 = lshr i64 %837, 9
%839 = or i64 %836, %838
%840 = add i64 %834, %839
store i64 %840, i64* %6
%841 = load i64, i64* %6
%842 = load i64, i64* %7
%843 = xor i64 %841, %842
%844 = load i64, i64* %8
%845 = xor i64 %843, %844
%846 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 1
%847 = load i64, i64* %846
%848 = add i64 %845, %847
%849 = add i64 %848, 2763975236
%850 = load i64, i64* %5
%851 = add i64 %850, %849
store i64 %851, i64* %5
%852 = load i64, i64* %5
%853 = and i64 %852, 4294967295
store i64 %853, i64* %5
%854 = load i64, i64* %6
%855 = load i64, i64* %5
%856 = shl i64 %855, 4
%857 = load i64, i64* %5
%858 = lshr i64 %857, 28
%859 = or i64 %856, %858
%860 = add i64 %854, %859
store i64 %860, i64* %5
%861 = load i64, i64* %5
%862 = load i64, i64* %6
%863 = xor i64 %861, %862
%864 = load i64, i64* %7
%865 = xor i64 %863, %864
%866 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 4
%867 = load i64, i64* %866
%868 = add i64 %865, %867
%869 = add i64 %868, 1272893353
%870 = load i64, i64* %8
%871 = add i64 %870, %869
store i64 %871, i64* %8
%872 = load i64, i64* %8
%873 = and i64 %872, 4294967295
store i64 %873, i64* %8
%874 = load i64, i64* %5
%875 = load i64, i64* %8
%876 = shl i64 %875, 11
%877 = load i64, i64* %8
%878 = lshr i64 %877, 21
%879 = or i64 %876, %878
%880 = add i64 %874, %879
store i64 %880, i64* %8
%881 = load i64, i64* %8
%882 = load i64, i64* %5
%883 = xor i64 %881, %882
%884 = load i64, i64* %6
%885 = xor i64 %883, %884
%886 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 7
%887 = load i64, i64* %886
%888 = add i64 %885, %887
%889 = add i64 %888, 4139469664
%890 = load i64, i64* %7
%891 = add i64 %890, %889
store i64 %891, i64* %7
%892 = load i64, i64* %7
%893 = and i64 %892, 4294967295
store i64 %893, i64* %7
%894 = load i64, i64* %8
%895 = load i64, i64* %7
%896 = shl i64 %895, 16
%897 = load i64, i64* %7
%898 = lshr i64 %897, 16
%899 = or i64 %896, %898
%900 = add i64 %894, %899
store i64 %900, i64* %7
%901 = load i64, i64* %7
%902 = load i64, i64* %8
%903 = xor i64 %901, %902
%904 = load i64, i64* %5
%905 = xor i64 %903, %904
%906 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 10
%907 = load i64, i64* %906
%908 = add i64 %905, %907
%909 = add i64 %908, 3200236656
%910 = load i64, i64* %6
%911 = add i64 %910, %909
store i64 %911, i64* %6
%912 = load i64, i64* %6
%913 = and i64 %912, 4294967295
store i64 %913, i64* %6
%914 = load i64, i64* %7
%915 = load i64, i64* %6
%916 = shl i64 %915, 23
%917 = load i64, i64* %6
%918 = lshr i64 %917, 9
%919 = or i64 %916, %918
%920 = add i64 %914, %919
store i64 %920, i64* %6
%921 = load i64, i64* %6
%922 = load i64, i64* %7
%923 = xor i64 %921, %922
%924 = load i64, i64* %8
%925 = xor i64 %923, %924
%926 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 13
%927 = load i64, i64* %926
%928 = add i64 %925, %927
%929 = add i64 %928, 681279174
%930 = load i64, i64* %5
%931 = add i64 %930, %929
store i64 %931, i64* %5
%932 = load i64, i64* %5
%933 = and i64 %932, 4294967295
store i64 %933, i64* %5
%934 = load i64, i64* %6
%935 = load i64, i64* %5
%936 = shl i64 %935, 4
%937 = load i64, i64* %5
%938 = lshr i64 %937, 28
%939 = or i64 %936, %938
%940 = add i64 %934, %939
store i64 %940, i64* %5
%941 = load i64, i64* %5
%942 = load i64, i64* %6
%943 = xor i64 %941, %942
%944 = load i64, i64* %7
%945 = xor i64 %943, %944
%946 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 0
%947 = load i64, i64* %946
%948 = add i64 %945, %947
%949 = add i64 %948, 3936430074
%950 = load i64, i64* %8
%951 = add i64 %950, %949
store i64 %951, i64* %8
%952 = load i64, i64* %8
%953 = and i64 %952, 4294967295
store i64 %953, i64* %8
%954 = load i64, i64* %5
%955 = load i64, i64* %8
%956 = shl i64 %955, 11
%957 = load i64, i64* %8
%958 = lshr i64 %957, 21
%959 = or i64 %956, %958
%960 = add i64 %954, %959
store i64 %960, i64* %8
%961 = load i64, i64* %8
%962 = load i64, i64* %5
%963 = xor i64 %961, %962
%964 = load i64, i64* %6
%965 = xor i64 %963, %964
%966 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 3
%967 = load i64, i64* %966
%968 = add i64 %965, %967
%969 = add i64 %968, 3572445317
%970 = load i64, i64* %7
%971 = add i64 %970, %969
store i64 %971, i64* %7
%972 = load i64, i64* %7
%973 = and i64 %972, 4294967295
store i64 %973, i64* %7
%974 = load i64, i64* %8
%975 = load i64, i64* %7
%976 = shl i64 %975, 16
%977 = load i64, i64* %7
%978 = lshr i64 %977, 16
%979 = or i64 %976, %978
%980 = add i64 %974, %979
store i64 %980, i64* %7
%981 = load i64, i64* %7
%982 = load i64, i64* %8
%983 = xor i64 %981, %982
%984 = load i64, i64* %5
%985 = xor i64 %983, %984
%986 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 6
%987 = load i64, i64* %986
%988 = add i64 %985, %987
%989 = add i64 %988, 76029189
%990 = load i64, i64* %6
%991 = add i64 %990, %989
store i64 %991, i64* %6
%992 = load i64, i64* %6
%993 = and i64 %992, 4294967295
store i64 %993, i64* %6
%994 = load i64, i64* %7
%995 = load i64, i64* %6
%996 = shl i64 %995, 23
%997 = load i64, i64* %6
%998 = lshr i64 %997, 9
%999 = or i64 %996, %998
%1000 = add i64 %994, %999
store i64 %1000, i64* %6
%1001 = load i64, i64* %6
%1002 = load i64, i64* %7
%1003 = xor i64 %1001, %1002
%1004 = load i64, i64* %8
%1005 = xor i64 %1003, %1004
%1006 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 9
%1007 = load i64, i64* %1006
%1008 = add i64 %1005, %1007
%1009 = add i64 %1008, 3654602809
%1010 = load i64, i64* %5
%1011 = add i64 %1010, %1009
store i64 %1011, i64* %5
%1012 = load i64, i64* %5
%1013 = and i64 %1012, 4294967295
store i64 %1013, i64* %5
%1014 = load i64, i64* %6
%1015 = load i64, i64* %5
%1016 = shl i64 %1015, 4
%1017 = load i64, i64* %5
%1018 = lshr i64 %1017, 28
%1019 = or i64 %1016, %1018
%1020 = add i64 %1014, %1019
store i64 %1020, i64* %5
%1021 = load i64, i64* %5
%1022 = load i64, i64* %6
%1023 = xor i64 %1021, %1022
%1024 = load i64, i64* %7
%1025 = xor i64 %1023, %1024
%1026 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 12
%1027 = load i64, i64* %1026
%1028 = add i64 %1025, %1027
%1029 = add i64 %1028, 3873151461
%1030 = load i64, i64* %8
%1031 = add i64 %1030, %1029
store i64 %1031, i64* %8
%1032 = load i64, i64* %8
%1033 = and i64 %1032, 4294967295
store i64 %1033, i64* %8
%1034 = load i64, i64* %5
%1035 = load i64, i64* %8
%1036 = shl i64 %1035, 11
%1037 = load i64, i64* %8
%1038 = lshr i64 %1037, 21
%1039 = or i64 %1036, %1038
%1040 = add i64 %1034, %1039
store i64 %1040, i64* %8
%1041 = load i64, i64* %8
%1042 = load i64, i64* %5
%1043 = xor i64 %1041, %1042
%1044 = load i64, i64* %6
%1045 = xor i64 %1043, %1044
%1046 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 15
%1047 = load i64, i64* %1046
%1048 = add i64 %1045, %1047
%1049 = add i64 %1048, 530742520
%1050 = load i64, i64* %7
%1051 = add i64 %1050, %1049
store i64 %1051, i64* %7
%1052 = load i64, i64* %7
%1053 = and i64 %1052, 4294967295
store i64 %1053, i64* %7
%1054 = load i64, i64* %8
%1055 = load i64, i64* %7
%1056 = shl i64 %1055, 16
%1057 = load i64, i64* %7
%1058 = lshr i64 %1057, 16
%1059 = or i64 %1056, %1058
%1060 = add i64 %1054, %1059
store i64 %1060, i64* %7
%1061 = load i64, i64* %7
%1062 = load i64, i64* %8
%1063 = xor i64 %1061, %1062
%1064 = load i64, i64* %5
%1065 = xor i64 %1063, %1064
%1066 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 2
%1067 = load i64, i64* %1066
%1068 = add i64 %1065, %1067
%1069 = add i64 %1068, 3299628645
%1070 = load i64, i64* %6
%1071 = add i64 %1070, %1069
store i64 %1071, i64* %6
%1072 = load i64, i64* %6
%1073 = and i64 %1072, 4294967295
store i64 %1073, i64* %6
%1074 = load i64, i64* %7
%1075 = load i64, i64* %6
%1076 = shl i64 %1075, 23
%1077 = load i64, i64* %6
%1078 = lshr i64 %1077, 9
%1079 = or i64 %1076, %1078
%1080 = add i64 %1074, %1079
store i64 %1080, i64* %6
%1081 = load i64, i64* %7
%1082 = load i64, i64* %6
%1083 = load i64, i64* %8
%1084 = xor i64 %1083, -1
%1085 = or i64 %1082, %1084
%1086 = xor i64 %1081, %1085
%1087 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 0
%1088 = load i64, i64* %1087
%1089 = add i64 %1086, %1088
%1090 = add i64 %1089, 4096336452
%1091 = load i64, i64* %5
%1092 = add i64 %1091, %1090
store i64 %1092, i64* %5
%1093 = load i64, i64* %5
%1094 = and i64 %1093, 4294967295
store i64 %1094, i64* %5
%1095 = load i64, i64* %6
%1096 = load i64, i64* %5
%1097 = shl i64 %1096, 6
%1098 = load i64, i64* %5
%1099 = lshr i64 %1098, 26
%1100 = or i64 %1097, %1099
%1101 = add i64 %1095, %1100
store i64 %1101, i64* %5
%1102 = load i64, i64* %6
%1103 = load i64, i64* %5
%1104 = load i64, i64* %7
%1105 = xor i64 %1104, -1
%1106 = or i64 %1103, %1105
%1107 = xor i64 %1102, %1106
%1108 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 7
%1109 = load i64, i64* %1108
%1110 = add i64 %1107, %1109
%1111 = add i64 %1110, 1126891415
%1112 = load i64, i64* %8
%1113 = add i64 %1112, %1111
store i64 %1113, i64* %8
%1114 = load i64, i64* %8
%1115 = and i64 %1114, 4294967295
store i64 %1115, i64* %8
%1116 = load i64, i64* %5
%1117 = load i64, i64* %8
%1118 = shl i64 %1117, 10
%1119 = load i64, i64* %8
%1120 = lshr i64 %1119, 22
%1121 = or i64 %1118, %1120
%1122 = add i64 %1116, %1121
store i64 %1122, i64* %8
%1123 = load i64, i64* %5
%1124 = load i64, i64* %8
%1125 = load i64, i64* %6
%1126 = xor i64 %1125, -1
%1127 = or i64 %1124, %1126
%1128 = xor i64 %1123, %1127
%1129 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 14
%1130 = load i64, i64* %1129
%1131 = add i64 %1128, %1130
%1132 = add i64 %1131, 2878612391
%1133 = load i64, i64* %7
%1134 = add i64 %1133, %1132
store i64 %1134, i64* %7
%1135 = load i64, i64* %7
%1136 = and i64 %1135, 4294967295
store i64 %1136, i64* %7
%1137 = load i64, i64* %8
%1138 = load i64, i64* %7
%1139 = shl i64 %1138, 15
%1140 = load i64, i64* %7
%1141 = lshr i64 %1140, 17
%1142 = or i64 %1139, %1141
%1143 = add i64 %1137, %1142
store i64 %1143, i64* %7
%1144 = load i64, i64* %8
%1145 = load i64, i64* %7
%1146 = load i64, i64* %5
%1147 = xor i64 %1146, -1
%1148 = or i64 %1145, %1147
%1149 = xor i64 %1144, %1148
%1150 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 5
%1151 = load i64, i64* %1150
%1152 = add i64 %1149, %1151
%1153 = add i64 %1152, 4237533241
%1154 = load i64, i64* %6
%1155 = add i64 %1154, %1153
store i64 %1155, i64* %6
%1156 = load i64, i64* %6
%1157 = and i64 %1156, 4294967295
store i64 %1157, i64* %6
%1158 = load i64, i64* %7
%1159 = load i64, i64* %6
%1160 = shl i64 %1159, 21
%1161 = load i64, i64* %6
%1162 = lshr i64 %1161, 11
%1163 = or i64 %1160, %1162
%1164 = add i64 %1158, %1163
store i64 %1164, i64* %6
%1165 = load i64, i64* %7
%1166 = load i64, i64* %6
%1167 = load i64, i64* %8
%1168 = xor i64 %1167, -1
%1169 = or i64 %1166, %1168
%1170 = xor i64 %1165, %1169
%1171 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 12
%1172 = load i64, i64* %1171
%1173 = add i64 %1170, %1172
%1174 = add i64 %1173, 1700485571
%1175 = load i64, i64* %5
%1176 = add i64 %1175, %1174
store i64 %1176, i64* %5
%1177 = load i64, i64* %5
%1178 = and i64 %1177, 4294967295
store i64 %1178, i64* %5
%1179 = load i64, i64* %6
%1180 = load i64, i64* %5
%1181 = shl i64 %1180, 6
%1182 = load i64, i64* %5
%1183 = lshr i64 %1182, 26
%1184 = or i64 %1181, %1183
%1185 = add i64 %1179, %1184
store i64 %1185, i64* %5
%1186 = load i64, i64* %6
%1187 = load i64, i64* %5
%1188 = load i64, i64* %7
%1189 = xor i64 %1188, -1
%1190 = or i64 %1187, %1189
%1191 = xor i64 %1186, %1190
%1192 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 3
%1193 = load i64, i64* %1192
%1194 = add i64 %1191, %1193
%1195 = add i64 %1194, 2399980690
%1196 = load i64, i64* %8
%1197 = add i64 %1196, %1195
store i64 %1197, i64* %8
%1198 = load i64, i64* %8
%1199 = and i64 %1198, 4294967295
store i64 %1199, i64* %8
%1200 = load i64, i64* %5
%1201 = load i64, i64* %8
%1202 = shl i64 %1201, 10
%1203 = load i64, i64* %8
%1204 = lshr i64 %1203, 22
%1205 = or i64 %1202, %1204
%1206 = add i64 %1200, %1205
store i64 %1206, i64* %8
%1207 = load i64, i64* %5
%1208 = load i64, i64* %8
%1209 = load i64, i64* %6
%1210 = xor i64 %1209, -1
%1211 = or i64 %1208, %1210
%1212 = xor i64 %1207, %1211
%1213 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 10
%1214 = load i64, i64* %1213
%1215 = add i64 %1212, %1214
%1216 = add i64 %1215, 4293915773
%1217 = load i64, i64* %7
%1218 = add i64 %1217, %1216
store i64 %1218, i64* %7
%1219 = load i64, i64* %7
%1220 = and i64 %1219, 4294967295
store i64 %1220, i64* %7
%1221 = load i64, i64* %8
%1222 = load i64, i64* %7
%1223 = shl i64 %1222, 15
%1224 = load i64, i64* %7
%1225 = lshr i64 %1224, 17
%1226 = or i64 %1223, %1225
%1227 = add i64 %1221, %1226
store i64 %1227, i64* %7
%1228 = load i64, i64* %8
%1229 = load i64, i64* %7
%1230 = load i64, i64* %5
%1231 = xor i64 %1230, -1
%1232 = or i64 %1229, %1231
%1233 = xor i64 %1228, %1232
%1234 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 1
%1235 = load i64, i64* %1234
%1236 = add i64 %1233, %1235
%1237 = add i64 %1236, 2240044497
%1238 = load i64, i64* %6
%1239 = add i64 %1238, %1237
store i64 %1239, i64* %6
%1240 = load i64, i64* %6
%1241 = and i64 %1240, 4294967295
store i64 %1241, i64* %6
%1242 = load i64, i64* %7
%1243 = load i64, i64* %6
%1244 = shl i64 %1243, 21
%1245 = load i64, i64* %6
%1246 = lshr i64 %1245, 11
%1247 = or i64 %1244, %1246
%1248 = add i64 %1242, %1247
store i64 %1248, i64* %6
%1249 = load i64, i64* %7
%1250 = load i64, i64* %6
%1251 = load i64, i64* %8
%1252 = xor i64 %1251, -1
%1253 = or i64 %1250, %1252
%1254 = xor i64 %1249, %1253
%1255 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 8
%1256 = load i64, i64* %1255
%1257 = add i64 %1254, %1256
%1258 = add i64 %1257, 1873313359
%1259 = load i64, i64* %5
%1260 = add i64 %1259, %1258
store i64 %1260, i64* %5
%1261 = load i64, i64* %5
%1262 = and i64 %1261, 4294967295
store i64 %1262, i64* %5
%1263 = load i64, i64* %6
%1264 = load i64, i64* %5
%1265 = shl i64 %1264, 6
%1266 = load i64, i64* %5
%1267 = lshr i64 %1266, 26
%1268 = or i64 %1265, %1267
%1269 = add i64 %1263, %1268
store i64 %1269, i64* %5
%1270 = load i64, i64* %6
%1271 = load i64, i64* %5
%1272 = load i64, i64* %7
%1273 = xor i64 %1272, -1
%1274 = or i64 %1271, %1273
%1275 = xor i64 %1270, %1274
%1276 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 15
%1277 = load i64, i64* %1276
%1278 = add i64 %1275, %1277
%1279 = add i64 %1278, 4264355552
%1280 = load i64, i64* %8
%1281 = add i64 %1280, %1279
store i64 %1281, i64* %8
%1282 = load i64, i64* %8
%1283 = and i64 %1282, 4294967295
store i64 %1283, i64* %8
%1284 = load i64, i64* %5
%1285 = load i64, i64* %8
%1286 = shl i64 %1285, 10
%1287 = load i64, i64* %8
%1288 = lshr i64 %1287, 22
%1289 = or i64 %1286, %1288
%1290 = add i64 %1284, %1289
store i64 %1290, i64* %8
%1291 = load i64, i64* %5
%1292 = load i64, i64* %8
%1293 = load i64, i64* %6
%1294 = xor i64 %1293, -1
%1295 = or i64 %1292, %1294
%1296 = xor i64 %1291, %1295
%1297 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 6
%1298 = load i64, i64* %1297
%1299 = add i64 %1296, %1298
%1300 = add i64 %1299, 2734768916
%1301 = load i64, i64* %7
%1302 = add i64 %1301, %1300
store i64 %1302, i64* %7
%1303 = load i64, i64* %7
%1304 = and i64 %1303, 4294967295
store i64 %1304, i64* %7
%1305 = load i64, i64* %8
%1306 = load i64, i64* %7
%1307 = shl i64 %1306, 15
%1308 = load i64, i64* %7
%1309 = lshr i64 %1308, 17
%1310 = or i64 %1307, %1309
%1311 = add i64 %1305, %1310
store i64 %1311, i64* %7
%1312 = load i64, i64* %8
%1313 = load i64, i64* %7
%1314 = load i64, i64* %5
%1315 = xor i64 %1314, -1
%1316 = or i64 %1313, %1315
%1317 = xor i64 %1312, %1316
%1318 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 13
%1319 = load i64, i64* %1318
%1320 = add i64 %1317, %1319
%1321 = add i64 %1320, 1309151649
%1322 = load i64, i64* %6
%1323 = add i64 %1322, %1321
store i64 %1323, i64* %6
%1324 = load i64, i64* %6
%1325 = and i64 %1324, 4294967295
store i64 %1325, i64* %6
%1326 = load i64, i64* %7
%1327 = load i64, i64* %6
%1328 = shl i64 %1327, 21
%1329 = load i64, i64* %6
%1330 = lshr i64 %1329, 11
%1331 = or i64 %1328, %1330
%1332 = add i64 %1326, %1331
store i64 %1332, i64* %6
%1333 = load i64, i64* %7
%1334 = load i64, i64* %6
%1335 = load i64, i64* %8
%1336 = xor i64 %1335, -1
%1337 = or i64 %1334, %1336
%1338 = xor i64 %1333, %1337
%1339 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 4
%1340 = load i64, i64* %1339
%1341 = add i64 %1338, %1340
%1342 = add i64 %1341, 4149444226
%1343 = load i64, i64* %5
%1344 = add i64 %1343, %1342
store i64 %1344, i64* %5
%1345 = load i64, i64* %5
%1346 = and i64 %1345, 4294967295
store i64 %1346, i64* %5
%1347 = load i64, i64* %6
%1348 = load i64, i64* %5
%1349 = shl i64 %1348, 6
%1350 = load i64, i64* %5
%1351 = lshr i64 %1350, 26
%1352 = or i64 %1349, %1351
%1353 = add i64 %1347, %1352
store i64 %1353, i64* %5
%1354 = load i64, i64* %6
%1355 = load i64, i64* %5
%1356 = load i64, i64* %7
%1357 = xor i64 %1356, -1
%1358 = or i64 %1355, %1357
%1359 = xor i64 %1354, %1358
%1360 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 11
%1361 = load i64, i64* %1360
%1362 = add i64 %1359, %1361
%1363 = add i64 %1362, 3174756917
%1364 = load i64, i64* %8
%1365 = add i64 %1364, %1363
store i64 %1365, i64* %8
%1366 = load i64, i64* %8
%1367 = and i64 %1366, 4294967295
store i64 %1367, i64* %8
%1368 = load i64, i64* %5
%1369 = load i64, i64* %8
%1370 = shl i64 %1369, 10
%1371 = load i64, i64* %8
%1372 = lshr i64 %1371, 22
%1373 = or i64 %1370, %1372
%1374 = add i64 %1368, %1373
store i64 %1374, i64* %8
%1375 = load i64, i64* %5
%1376 = load i64, i64* %8
%1377 = load i64, i64* %6
%1378 = xor i64 %1377, -1
%1379 = or i64 %1376, %1378
%1380 = xor i64 %1375, %1379
%1381 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 2
%1382 = load i64, i64* %1381
%1383 = add i64 %1380, %1382
%1384 = add i64 %1383, 718787259
%1385 = load i64, i64* %7
%1386 = add i64 %1385, %1384
store i64 %1386, i64* %7
%1387 = load i64, i64* %7
%1388 = and i64 %1387, 4294967295
store i64 %1388, i64* %7
%1389 = load i64, i64* %8
%1390 = load i64, i64* %7
%1391 = shl i64 %1390, 15
%1392 = load i64, i64* %7
%1393 = lshr i64 %1392, 17
%1394 = or i64 %1391, %1393
%1395 = add i64 %1389, %1394
store i64 %1395, i64* %7
%1396 = load i64, i64* %8
%1397 = load i64, i64* %7
%1398 = load i64, i64* %5
%1399 = xor i64 %1398, -1
%1400 = or i64 %1397, %1399
%1401 = xor i64 %1396, %1400
%1402 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 9
%1403 = load i64, i64* %1402
%1404 = add i64 %1401, %1403
%1405 = add i64 %1404, 3951481745
%1406 = load i64, i64* %6
%1407 = add i64 %1406, %1405
store i64 %1407, i64* %6
%1408 = load i64, i64* %6
%1409 = and i64 %1408, 4294967295
store i64 %1409, i64* %6
%1410 = load i64, i64* %7
%1411 = load i64, i64* %6
%1412 = shl i64 %1411, 21
%1413 = load i64, i64* %6
%1414 = lshr i64 %1413, 11
%1415 = or i64 %1412, %1414
%1416 = add i64 %1410, %1415
store i64 %1416, i64* %6
%1417 = load i64, i64* %5
%1418 = load i64*, i64** %3
%1419 = getelementptr inbounds i64, i64* %1418, i64 0
%1420 = load i64, i64* %1419
%1421 = add i64 %1420, %1417
store i64 %1421, i64* %1419
%1422 = load i64, i64* %6
%1423 = load i64*, i64** %3
%1424 = getelementptr inbounds i64, i64* %1423, i64 1
%1425 = load i64, i64* %1424
%1426 = add i64 %1425, %1422
store i64 %1426, i64* %1424
%1427 = load i64, i64* %7
%1428 = load i64*, i64** %3
%1429 = getelementptr inbounds i64, i64* %1428, i64 2
%1430 = load i64, i64* %1429
%1431 = add i64 %1430, %1427
store i64 %1431, i64* %1429
%1432 = load i64, i64* %8
%1433 = load i64*, i64** %3
%1434 = getelementptr inbounds i64, i64* %1433, i64 3
%1435 = load i64, i64* %1434
%1436 = add i64 %1435, %1432
store i64 %1436, i64* %1434
%1437 = getelementptr inbounds [16 x i64], [16 x i64]* %9, i64 0, i64 0
%1438 = call i32 @memset(i64* %1437, i32 0, i32 128)
ret void
}

LLVM IR (-O2):
define void @md5_transform(i64* nocapture %0, i8* %1) {
%3 = alloca [16 x i64]
%4 = load i64, i64* %0
%5 = getelementptr inbounds i64, i64* %0, i64 1
%6 = load i64, i64* %5
%7 = getelementptr inbounds i64, i64* %0, i64 2
%8 = load i64, i64* %7
%9 = getelementptr inbounds i64, i64* %0, i64 3
%10 = load i64, i64* %9
%11 = bitcast [16 x i64]* %3 to i8*
%12 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 0
%13 = call i32 @md5_decode(i64* %12, i8* %1, i32 16)
%14 = and i64 %8, %6
%15 = xor i64 %6, -1
%16 = and i64 %10, %15
%17 = load i64, i64* %12
%18 = add i64 %4, 3614090360
%19 = add i64 %18, %14
%20 = add i64 %19, %16
%21 = add i64 %20, %17
%22 = and i64 %21, 4294967295
%23 = shl nuw nsw i64 %22, 7
%24 = lshr i64 %22, 25
%25 = add i64 %24, %6
%26 = add i64 %25, %23
%27 = and i64 %26, %6
%28 = xor i64 %26, -1
%29 = and i64 %8, %28
%30 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 1
%31 = load i64, i64* %30
%32 = add i64 %10, 3905402710
%33 = add i64 %32, %31
%34 = add i64 %33, %29
%35 = add i64 %34, %27
%36 = and i64 %35, 4294967295
%37 = shl nuw nsw i64 %36, 12
%38 = lshr i64 %36, 20
%39 = add i64 %38, %26
%40 = add i64 %39, %37
%41 = and i64 %40, %26
%42 = xor i64 %40, -1
%43 = and i64 %6, %42
%44 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 2
%45 = load i64, i64* %44
%46 = add i64 %8, 606105819
%47 = add i64 %46, %45
%48 = add i64 %47, %43
%49 = add i64 %48, %41
%50 = and i64 %49, 4294967295
%51 = shl nuw nsw i64 %50, 17
%52 = lshr i64 %50, 15
%53 = add i64 %52, %40
%54 = add i64 %53, %51
%55 = and i64 %54, %40
%56 = xor i64 %54, -1
%57 = and i64 %26, %56
%58 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 3
%59 = load i64, i64* %58
%60 = add i64 %6, 3250441966
%61 = add i64 %60, %59
%62 = add i64 %61, %57
%63 = add i64 %62, %55
%64 = and i64 %63, 4294967295
%65 = shl nuw nsw i64 %64, 22
%66 = lshr i64 %64, 10
%67 = add i64 %66, %54
%68 = add i64 %67, %65
%69 = and i64 %68, %54
%70 = xor i64 %68, -1
%71 = and i64 %40, %70
%72 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 4
%73 = load i64, i64* %72
%74 = add i64 %73, 4118548399
%75 = add i64 %74, %26
%76 = add i64 %75, %71
%77 = add i64 %76, %69
%78 = and i64 %77, 4294967295
%79 = shl nuw nsw i64 %78, 7
%80 = lshr i64 %78, 25
%81 = add i64 %80, %68
%82 = add i64 %81, %79
%83 = and i64 %82, %68
%84 = xor i64 %82, -1
%85 = and i64 %54, %84
%86 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 5
%87 = load i64, i64* %86
%88 = add i64 %87, 1200080426
%89 = add i64 %88, %40
%90 = add i64 %89, %85
%91 = add i64 %90, %83
%92 = and i64 %91, 4294967295
%93 = shl nuw nsw i64 %92, 12
%94 = lshr i64 %92, 20
%95 = add i64 %94, %82
%96 = add i64 %95, %93
%97 = and i64 %96, %82
%98 = xor i64 %96, -1
%99 = and i64 %68, %98
%100 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 6
%101 = load i64, i64* %100
%102 = add i64 %101, 2821735955
%103 = add i64 %102, %54
%104 = add i64 %103, %99
%105 = add i64 %104, %97
%106 = and i64 %105, 4294967295
%107 = shl nuw nsw i64 %106, 17
%108 = lshr i64 %106, 15
%109 = add i64 %108, %96
%110 = add i64 %109, %107
%111 = and i64 %110, %96
%112 = xor i64 %110, -1
%113 = and i64 %82, %112
%114 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 7
%115 = load i64, i64* %114
%116 = add i64 %115, 4249261313
%117 = add i64 %116, %68
%118 = add i64 %117, %113
%119 = add i64 %118, %111
%120 = and i64 %119, 4294967295
%121 = shl nuw nsw i64 %120, 22
%122 = lshr i64 %120, 10
%123 = add i64 %122, %110
%124 = add i64 %123, %121
%125 = and i64 %124, %110
%126 = xor i64 %124, -1
%127 = and i64 %96, %126
%128 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 8
%129 = load i64, i64* %128
%130 = add i64 %129, 1770035416
%131 = add i64 %130, %82
%132 = add i64 %131, %127
%133 = add i64 %132, %125
%134 = and i64 %133, 4294967295
%135 = shl nuw nsw i64 %134, 7
%136 = lshr i64 %134, 25
%137 = add i64 %136, %124
%138 = add i64 %137, %135
%139 = and i64 %138, %124
%140 = xor i64 %138, -1
%141 = and i64 %110, %140
%142 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 9
%143 = load i64, i64* %142
%144 = add i64 %143, 2336552879
%145 = add i64 %144, %96
%146 = add i64 %145, %141
%147 = add i64 %146, %139
%148 = and i64 %147, 4294967295
%149 = shl nuw nsw i64 %148, 12
%150 = lshr i64 %148, 20
%151 = add i64 %150, %138
%152 = add i64 %151, %149
%153 = and i64 %152, %138
%154 = xor i64 %152, -1
%155 = and i64 %124, %154
%156 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 10
%157 = load i64, i64* %156
%158 = add i64 %157, 4294925233
%159 = add i64 %158, %110
%160 = add i64 %159, %155
%161 = add i64 %160, %153
%162 = and i64 %161, 4294967295
%163 = shl nuw nsw i64 %162, 17
%164 = lshr i64 %162, 15
%165 = add i64 %164, %152
%166 = add i64 %165, %163
%167 = and i64 %166, %152
%168 = xor i64 %166, -1
%169 = and i64 %138, %168
%170 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 11
%171 = load i64, i64* %170
%172 = add i64 %171, 2304563134
%173 = add i64 %172, %124
%174 = add i64 %173, %169
%175 = add i64 %174, %167
%176 = and i64 %175, 4294967295
%177 = shl nuw nsw i64 %176, 22
%178 = lshr i64 %176, 10
%179 = add i64 %178, %166
%180 = add i64 %179, %177
%181 = and i64 %180, %166
%182 = xor i64 %180, -1
%183 = and i64 %152, %182
%184 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 12
%185 = load i64, i64* %184
%186 = add i64 %185, 1804603682
%187 = add i64 %186, %138
%188 = add i64 %187, %183
%189 = add i64 %188, %181
%190 = and i64 %189, 4294967295
%191 = shl nuw nsw i64 %190, 7
%192 = lshr i64 %190, 25
%193 = add i64 %192, %180
%194 = add i64 %193, %191
%195 = and i64 %194, %180
%196 = xor i64 %194, -1
%197 = and i64 %166, %196
%198 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 13
%199 = load i64, i64* %198
%200 = add i64 %199, 4254626195
%201 = add i64 %200, %152
%202 = add i64 %201, %197
%203 = add i64 %202, %195
%204 = and i64 %203, 4294967295
%205 = shl nuw nsw i64 %204, 12
%206 = lshr i64 %204, 20
%207 = add i64 %206, %194
%208 = add i64 %207, %205
%209 = and i64 %208, %194
%210 = xor i64 %208, -1
%211 = and i64 %180, %210
%212 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 14
%213 = load i64, i64* %212
%214 = add i64 %213, 2792965006
%215 = add i64 %214, %166
%216 = add i64 %215, %211
%217 = add i64 %216, %209
%218 = and i64 %217, 4294967295
%219 = shl nuw nsw i64 %218, 17
%220 = lshr i64 %218, 15
%221 = add i64 %220, %208
%222 = add i64 %221, %219
%223 = and i64 %222, %208
%224 = xor i64 %222, -1
%225 = and i64 %194, %224
%226 = getelementptr inbounds [16 x i64], [16 x i64]* %3, i64 0, i64 15
%227 = load i64, i64* %226
%228 = add i64 %227, 1236535329
%229 = add i64 %228, %180
%230 = add i64 %229, %225
%231 = add i64 %230, %223
%232 = and i64 %231, 4294967295
%233 = shl nuw nsw i64 %232, 22
%234 = lshr i64 %232, 10
%235 = add i64 %234, %222
%236 = add i64 %235, %233
%237 = and i64 %236, %208
%238 = and i64 %222, %210
%239 = add i64 %31, 4129170786
%240 = add i64 %239, %194
%241 = add i64 %240, %238
%242 = add i64 %241, %237
%243 = and i64 %242, 4294967295
%244 = shl nuw nsw i64 %243, 5
%245 = lshr i64 %243, 27
%246 = add i64 %245, %236
%247 = add i64 %246, %244
%248 = and i64 %247, %222
%249 = and i64 %236, %224
%250 = add i64 %101, 3225465664
%251 = add i64 %250, %208
%252 = add i64 %251, %249
%253 = add i64 %252, %248
%254 = and i64 %253, 4294967295
%255 = shl nuw nsw i64 %254, 9
%256 = lshr i64 %254, 23
%257 = add i64 %256, %247
%258 = add i64 %257, %255
%259 = and i64 %258, %236
%260 = xor i64 %236, -1
%261 = and i64 %247, %260
%262 = add i64 %171, 643717713
%263 = add i64 %262, %222
%264 = add i64 %263, %261
%265 = add i64 %264, %259
%266 = and i64 %265, 4294967295
%267 = shl nuw nsw i64 %266, 14
%268 = lshr i64 %266, 18
%269 = add i64 %268, %258
%270 = add i64 %269, %267
%271 = and i64 %270, %247
%272 = xor i64 %247, -1
%273 = and i64 %258, %272
%274 = add i64 %17, 3921069994
%275 = add i64 %274, %236
%276 = add i64 %275, %273
%277 = add i64 %276, %271
%278 = and i64 %277, 4294967295
%279 = shl nuw nsw i64 %278, 20
%280 = lshr i64 %278, 12
%281 = add i64 %280, %270
%282 = add i64 %281, %279
%283 = and i64 %282, %258
%284 = xor i64 %258, -1
%285 = and i64 %270, %284
%286 = add i64 %87, 3593408605
%287 = add i64 %286, %247
%288 = add i64 %287, %285
%289 = add i64 %288, %283
%290 = and i64 %289, 4294967295
%291 = shl nuw nsw i64 %290, 5
%292 = lshr i64 %290, 27
%293 = add i64 %292, %282
%294 = add i64 %293, %291
%295 = and i64 %294, %270
%296 = xor i64 %270, -1
%297 = and i64 %282, %296
%298 = add i64 %157, 38016083
%299 = add i64 %298, %258
%300 = add i64 %299, %297
%301 = add i64 %300, %295
%302 = and i64 %301, 4294967295
%303 = shl nuw nsw i64 %302, 9
%304 = lshr i64 %302, 23
%305 = add i64 %304, %294
%306 = add i64 %305, %303
%307 = and i64 %306, %282
%308 = xor i64 %282, -1
%309 = and i64 %294, %308
%310 = add i64 %227, 3634488961
%311 = add i64 %310, %270
%312 = add i64 %311, %309
%313 = add i64 %312, %307
%314 = and i64 %313, 4294967295
%315 = shl nuw nsw i64 %314, 14
%316 = lshr i64 %314, 18
%317 = add i64 %316, %306
%318 = add i64 %317, %315
%319 = and i64 %318, %294
%320 = xor i64 %294, -1
%321 = and i64 %306, %320
%322 = add i64 %73, 3889429448
%323 = add i64 %322, %282
%324 = add i64 %323, %321
%325 = add i64 %324, %319
%326 = and i64 %325, 4294967295
%327 = shl nuw nsw i64 %326, 20
%328 = lshr i64 %326, 12
%329 = add i64 %328, %318
%330 = add i64 %329, %327
%331 = and i64 %330, %306
%332 = xor i64 %306, -1
%333 = and i64 %318, %332
%334 = add i64 %143, 568446438
%335 = add i64 %334, %294
%336 = add i64 %335, %333
%337 = add i64 %336, %331
%338 = and i64 %337, 4294967295
%339 = shl nuw nsw i64 %338, 5
%340 = lshr i64 %338, 27
%341 = add i64 %340, %330
%342 = add i64 %341, %339
%343 = and i64 %342, %318
%344 = xor i64 %318, -1
%345 = and i64 %330, %344
%346 = add i64 %213, 3275163606
%347 = add i64 %346, %306
%348 = add i64 %347, %345
%349 = add i64 %348, %343
%350 = and i64 %349, 4294967295
%351 = shl nuw nsw i64 %350, 9
%352 = lshr i64 %350, 23
%353 = add i64 %352, %342
%354 = add i64 %353, %351
%355 = and i64 %354, %330
%356 = xor i64 %330, -1
%357 = and i64 %342, %356
%358 = add i64 %59, 4107603335
%359 = add i64 %358, %318
%360 = add i64 %359, %357
%361 = add i64 %360, %355
%362 = and i64 %361, 4294967295
%363 = shl nuw nsw i64 %362, 14
%364 = lshr i64 %362, 18
%365 = add i64 %364, %354
%366 = add i64 %365, %363
%367 = and i64 %366, %342
%368 = xor i64 %342, -1
%369 = and i64 %354, %368
%370 = add i64 %129, 1163531501
%371 = add i64 %370, %330
%372 = add i64 %371, %369
%373 = add i64 %372, %367
%374 = and i64 %373, 4294967295
%375 = shl nuw nsw i64 %374, 20
%376 = lshr i64 %374, 12
%377 = add i64 %376, %366
%378 = add i64 %377, %375
%379 = and i64 %378, %354
%380 = xor i64 %354, -1
%381 = and i64 %366, %380
%382 = add i64 %199, 2850285829
%383 = add i64 %382, %342
%384 = add i64 %383, %381
%385 = add i64 %384, %379
%386 = and i64 %385, 4294967295
%387 = shl nuw nsw i64 %386, 5
%388 = lshr i64 %386, 27
%389 = add i64 %388, %378
%390 = add i64 %389, %387
%391 = and i64 %390, %366
%392 = xor i64 %366, -1
%393 = and i64 %378, %392
%394 = add i64 %45, 4243563512
%395 = add i64 %394, %354
%396 = add i64 %395, %393
%397 = add i64 %396, %391
%398 = and i64 %397, 4294967295
%399 = shl nuw nsw i64 %398, 9
%400 = lshr i64 %398, 23
%401 = add i64 %400, %390
%402 = add i64 %401, %399
%403 = and i64 %402, %378
%404 = xor i64 %378, -1
%405 = and i64 %390, %404
%406 = add i64 %115, 1735328473
%407 = add i64 %406, %366
%408 = add i64 %407, %405
%409 = add i64 %408, %403
%410 = and i64 %409, 4294967295
%411 = shl nuw nsw i64 %410, 14
%412 = lshr i64 %410, 18
%413 = add i64 %412, %402
%414 = add i64 %413, %411
%415 = and i64 %414, %390
%416 = xor i64 %390, -1
%417 = and i64 %402, %416
%418 = add i64 %185, 2368359562
%419 = add i64 %418, %378
%420 = add i64 %419, %417
%421 = add i64 %420, %415
%422 = and i64 %421, 4294967295
%423 = shl nuw nsw i64 %422, 20
%424 = lshr i64 %422, 12
%425 = add i64 %424, %414
%426 = add i64 %425, %423
%427 = xor i64 %426, %414
%428 = xor i64 %427, %402
%429 = add i64 %87, 4294588738
%430 = add i64 %429, %390
%431 = add i64 %430, %428
%432 = and i64 %431, 4294967295
%433 = shl nuw nsw i64 %432, 4
%434 = lshr i64 %432, 28
%435 = add i64 %434, %426
%436 = add i64 %435, %433
%437 = xor i64 %427, %436
%438 = add i64 %129, 2272392833
%439 = add i64 %438, %402
%440 = add i64 %439, %437
%441 = and i64 %440, 4294967295
%442 = shl nuw nsw i64 %441, 11
%443 = lshr i64 %441, 21
%444 = add i64 %443, %436
%445 = add i64 %444, %442
%446 = xor i64 %436, %426
%447 = xor i64 %446, %445
%448 = add i64 %171, 1839030562
%449 = add i64 %448, %414
%450 = add i64 %449, %447
%451 = and i64 %450, 4294967295
%452 = shl nuw nsw i64 %451, 16
%453 = lshr i64 %451, 16
%454 = add i64 %453, %445
%455 = add i64 %454, %452
%456 = xor i64 %445, %436
%457 = xor i64 %456, %455
%458 = add i64 %213, 4259657740
%459 = add i64 %458, %426
%460 = add i64 %459, %457
%461 = and i64 %460, 4294967295
%462 = shl nuw nsw i64 %461, 23
%463 = lshr i64 %461, 9
%464 = add i64 %463, %455
%465 = add i64 %464, %462
%466 = xor i64 %455, %445
%467 = xor i64 %466, %465
%468 = add i64 %31, 2763975236
%469 = add i64 %468, %436
%470 = add i64 %469, %467
%471 = and i64 %470, 4294967295
%472 = shl nuw nsw i64 %471, 4
%473 = lshr i64 %471, 28
%474 = add i64 %473, %465
%475 = add i64 %474, %472
%476 = xor i64 %465, %455
%477 = xor i64 %476, %475
%478 = add i64 %73, 1272893353
%479 = add i64 %478, %445
%480 = add i64 %479, %477
%481 = and i64 %480, 4294967295
%482 = shl nuw nsw i64 %481, 11
%483 = lshr i64 %481, 21
%484 = add i64 %483, %475
%485 = add i64 %484, %482
%486 = xor i64 %475, %465
%487 = xor i64 %486, %485
%488 = add i64 %115, 4139469664
%489 = add i64 %488, %455
%490 = add i64 %489, %487
%491 = and i64 %490, 4294967295
%492 = shl nuw nsw i64 %491, 16
%493 = lshr i64 %491, 16
%494 = add i64 %493, %485
%495 = add i64 %494, %492
%496 = xor i64 %485, %475
%497 = xor i64 %496, %495
%498 = add i64 %157, 3200236656
%499 = add i64 %498, %465
%500 = add i64 %499, %497
%501 = and i64 %500, 4294967295
%502 = shl nuw nsw i64 %501, 23
%503 = lshr i64 %501, 9
%504 = add i64 %503, %495
%505 = add i64 %504, %502
%506 = xor i64 %495, %485
%507 = xor i64 %506, %505
%508 = add i64 %199, 681279174
%509 = add i64 %508, %475
%510 = add i64 %509, %507
%511 = and i64 %510, 4294967295
%512 = shl nuw nsw i64 %511, 4
%513 = lshr i64 %511, 28
%514 = add i64 %513, %505
%515 = add i64 %514, %512
%516 = xor i64 %505, %495
%517 = xor i64 %516, %515
%518 = add i64 %17, 3936430074
%519 = add i64 %518, %485
%520 = add i64 %519, %517
%521 = and i64 %520, 4294967295
%522 = shl nuw nsw i64 %521, 11
%523 = lshr i64 %521, 21
%524 = add i64 %523, %515
%525 = add i64 %524, %522
%526 = xor i64 %515, %505
%527 = xor i64 %526, %525
%528 = add i64 %59, 3572445317
%529 = add i64 %528, %495
%530 = add i64 %529, %527
%531 = and i64 %530, 4294967295
%532 = shl nuw nsw i64 %531, 16
%533 = lshr i64 %531, 16
%534 = add i64 %533, %525
%535 = add i64 %534, %532
%536 = xor i64 %525, %515
%537 = xor i64 %536, %535
%538 = add i64 %101, 76029189
%539 = add i64 %538, %505
%540 = add i64 %539, %537
%541 = and i64 %540, 4294967295
%542 = shl nuw nsw i64 %541, 23
%543 = lshr i64 %541, 9
%544 = add i64 %543, %535
%545 = add i64 %544, %542
%546 = xor i64 %535, %525
%547 = xor i64 %546, %545
%548 = add i64 %143, 3654602809
%549 = add i64 %548, %515
%550 = add i64 %549, %547
%551 = and i64 %550, 4294967295
%552 = shl nuw nsw i64 %551, 4
%553 = lshr i64 %551, 28
%554 = add i64 %553, %545
%555 = add i64 %554, %552
%556 = xor i64 %545, %535
%557 = xor i64 %556, %555
%558 = add i64 %185, 3873151461
%559 = add i64 %558, %525
%560 = add i64 %559, %557
%561 = and i64 %560, 4294967295
%562 = shl nuw nsw i64 %561, 11
%563 = lshr i64 %561, 21
%564 = add i64 %563, %555
%565 = add i64 %564, %562
%566 = xor i64 %555, %545
%567 = xor i64 %566, %565
%568 = add i64 %227, 530742520
%569 = add i64 %568, %535
%570 = add i64 %569, %567
%571 = and i64 %570, 4294967295
%572 = shl nuw nsw i64 %571, 16
%573 = lshr i64 %571, 16
%574 = add i64 %573, %565
%575 = add i64 %574, %572
%576 = xor i64 %565, %555
%577 = xor i64 %576, %575
%578 = add i64 %45, 3299628645
%579 = add i64 %578, %545
%580 = add i64 %579, %577
%581 = and i64 %580, 4294967295
%582 = shl nuw nsw i64 %581, 23
%583 = lshr i64 %581, 9
%584 = add i64 %583, %575
%585 = add i64 %584, %582
%586 = xor i64 %565, -1
%587 = or i64 %585, %586
%588 = xor i64 %587, %575
%589 = add i64 %17, 4096336452
%590 = add i64 %589, %555
%591 = add i64 %590, %588
%592 = and i64 %591, 4294967295
%593 = shl nuw nsw i64 %592, 6
%594 = lshr i64 %592, 26
%595 = add i64 %594, %585
%596 = add i64 %595, %593
%597 = xor i64 %575, -1
%598 = or i64 %596, %597
%599 = xor i64 %598, %585
%600 = add i64 %115, 1126891415
%601 = add i64 %600, %565
%602 = add i64 %601, %599
%603 = and i64 %602, 4294967295
%604 = shl nuw nsw i64 %603, 10
%605 = lshr i64 %603, 22
%606 = add i64 %605, %596
%607 = add i64 %606, %604
%608 = xor i64 %585, -1
%609 = or i64 %607, %608
%610 = xor i64 %609, %596
%611 = add i64 %213, 2878612391
%612 = add i64 %611, %575
%613 = add i64 %612, %610
%614 = and i64 %613, 4294967295
%615 = shl nuw nsw i64 %614, 15
%616 = lshr i64 %614, 17
%617 = add i64 %616, %607
%618 = add i64 %617, %615
%619 = xor i64 %596, -1
%620 = or i64 %618, %619
%621 = xor i64 %620, %607
%622 = add i64 %87, 4237533241
%623 = add i64 %622, %585
%624 = add i64 %623, %621
%625 = and i64 %624, 4294967295
%626 = shl nuw nsw i64 %625, 21
%627 = lshr i64 %625, 11
%628 = add i64 %627, %618
%629 = add i64 %628, %626
%630 = xor i64 %607, -1
%631 = or i64 %629, %630
%632 = xor i64 %631, %618
%633 = add i64 %185, 1700485571
%634 = add i64 %633, %596
%635 = add i64 %634, %632
%636 = and i64 %635, 4294967295
%637 = shl nuw nsw i64 %636, 6
%638 = lshr i64 %636, 26
%639 = add i64 %638, %629
%640 = add i64 %639, %637
%641 = xor i64 %618, -1
%642 = or i64 %640, %641
%643 = xor i64 %642, %629
%644 = add i64 %59, 2399980690
%645 = add i64 %644, %607
%646 = add i64 %645, %643
%647 = and i64 %646, 4294967295
%648 = shl nuw nsw i64 %647, 10
%649 = lshr i64 %647, 22
%650 = add i64 %649, %640
%651 = add i64 %650, %648
%652 = xor i64 %629, -1
%653 = or i64 %651, %652
%654 = xor i64 %653, %640
%655 = add i64 %157, 4293915773
%656 = add i64 %655, %618
%657 = add i64 %656, %654
%658 = and i64 %657, 4294967295
%659 = shl nuw nsw i64 %658, 15
%660 = lshr i64 %658, 17
%661 = add i64 %660, %651
%662 = add i64 %661, %659
%663 = xor i64 %640, -1
%664 = or i64 %662, %663
%665 = xor i64 %664, %651
%666 = add i64 %31, 2240044497
%667 = add i64 %666, %629
%668 = add i64 %667, %665
%669 = and i64 %668, 4294967295
%670 = shl nuw nsw i64 %669, 21
%671 = lshr i64 %669, 11
%672 = add i64 %671, %662
%673 = add i64 %672, %670
%674 = xor i64 %651, -1
%675 = or i64 %673, %674
%676 = xor i64 %675, %662
%677 = add i64 %129, 1873313359
%678 = add i64 %677, %640
%679 = add i64 %678, %676
%680 = and i64 %679, 4294967295
%681 = shl nuw nsw i64 %680, 6
%682 = lshr i64 %680, 26
%683 = add i64 %682, %673
%684 = add i64 %683, %681
%685 = xor i64 %662, -1
%686 = or i64 %684, %685
%687 = xor i64 %686, %673
%688 = add i64 %227, 4264355552
%689 = add i64 %688, %651
%690 = add i64 %689, %687
%691 = and i64 %690, 4294967295
%692 = shl nuw nsw i64 %691, 10
%693 = lshr i64 %691, 22
%694 = add i64 %693, %684
%695 = add i64 %694, %692
%696 = xor i64 %673, -1
%697 = or i64 %695, %696
%698 = xor i64 %697, %684
%699 = add i64 %101, 2734768916
%700 = add i64 %699, %662
%701 = add i64 %700, %698
%702 = and i64 %701, 4294967295
%703 = shl nuw nsw i64 %702, 15
%704 = lshr i64 %702, 17
%705 = add i64 %704, %695
%706 = add i64 %705, %703
%707 = xor i64 %684, -1
%708 = or i64 %706, %707
%709 = xor i64 %708, %695
%710 = add i64 %199, 1309151649
%711 = add i64 %710, %673
%712 = add i64 %711, %709
%713 = and i64 %712, 4294967295
%714 = shl nuw nsw i64 %713, 21
%715 = lshr i64 %713, 11
%716 = add i64 %715, %706
%717 = add i64 %716, %714
%718 = xor i64 %695, -1
%719 = or i64 %717, %718
%720 = xor i64 %719, %706
%721 = add i64 %73, 4149444226
%722 = add i64 %721, %684
%723 = add i64 %722, %720
%724 = and i64 %723, 4294967295
%725 = shl nuw nsw i64 %724, 6
%726 = lshr i64 %724, 26
%727 = add i64 %726, %717
%728 = add i64 %727, %725
%729 = xor i64 %706, -1
%730 = or i64 %728, %729
%731 = xor i64 %730, %717
%732 = add i64 %171, 3174756917
%733 = add i64 %732, %695
%734 = add i64 %733, %731
%735 = and i64 %734, 4294967295
%736 = shl nuw nsw i64 %735, 10
%737 = lshr i64 %735, 22
%738 = add i64 %737, %728
%739 = add i64 %738, %736
%740 = xor i64 %717, -1
%741 = or i64 %739, %740
%742 = xor i64 %741, %728
%743 = add i64 %45, 718787259
%744 = add i64 %743, %706
%745 = add i64 %744, %742
%746 = and i64 %745, 4294967295
%747 = shl nuw nsw i64 %746, 15
%748 = lshr i64 %746, 17
%749 = add i64 %748, %739
%750 = add i64 %749, %747
%751 = xor i64 %728, -1
%752 = or i64 %750, %751
%753 = xor i64 %752, %739
%754 = add i64 %143, 3951481745
%755 = add i64 %754, %717
%756 = add i64 %755, %753
%757 = and i64 %756, 4294967295
%758 = shl nuw nsw i64 %757, 21
%759 = lshr i64 %757, 11
%760 = load i64, i64* %0
%761 = add i64 %728, %760
store i64 %761, i64* %0
%762 = load i64, i64* %5
%763 = add i64 %750, %762
%764 = add i64 %763, %759
%765 = add i64 %764, %758
store i64 %765, i64* %5
%766 = load i64, i64* %7
%767 = add i64 %750, %766
store i64 %767, i64* %7
%768 = load i64, i64* %9
%769 = add i64 %739, %768
store i64 %769, i64* %9
%770 = call i32 @memset(i64* %12, i32 0, i32 128)
ret void
}