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

/* Forward declarations */

/* Type definitions */

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


x86 assembly (clang, -O0):
<MD5Transform>:
push   %rbp
mov    %rsp,%rbp
sub    $0x120,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x20(%rbp)
lea    -0x120(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    $0x40,%edx
call   1030 <MD5Decode@plt>
mov    -0x18(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
add    -0x120(%rbp),%eax
add    $0xd76aa478,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x1c(%rbp),%ecx
or     %ecx,%eax
add    -0x11c(%rbp),%eax
add    $0xe8c7b756,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
shr    $0x14,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x18(%rbp),%ecx
or     %ecx,%eax
add    -0x118(%rbp),%eax
add    $0x242070db,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
shr    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x14(%rbp),%ecx
or     %ecx,%eax
add    -0x114(%rbp),%eax
add    $0xc1bdceee,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
shr    $0xa,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
add    -0x110(%rbp),%eax
add    $0xf57c0faf,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x1c(%rbp),%ecx
or     %ecx,%eax
add    -0x10c(%rbp),%eax
add    $0x4787c62a,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
shr    $0x14,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x18(%rbp),%ecx
or     %ecx,%eax
add    -0x108(%rbp),%eax
add    $0xa8304613,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
shr    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x14(%rbp),%ecx
or     %ecx,%eax
add    -0x104(%rbp),%eax
add    $0xfd469501,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
shr    $0xa,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
add    -0x100(%rbp),%eax
add    $0x698098d8,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x1c(%rbp),%ecx
or     %ecx,%eax
add    -0xfc(%rbp),%eax
add    $0x8b44f7af,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
shr    $0x14,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x18(%rbp),%ecx
or     %ecx,%eax
add    -0xf8(%rbp),%eax
add    $0xffff5bb1,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
shr    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x14(%rbp),%ecx
or     %ecx,%eax
add    -0xf4(%rbp),%eax
add    $0x895cd7be,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
shr    $0xa,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
add    -0xf0(%rbp),%eax
add    $0x6b901122,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x1c(%rbp),%ecx
or     %ecx,%eax
add    -0xec(%rbp),%eax
add    $0xfd987193,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
shr    $0x14,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x18(%rbp),%ecx
or     %ecx,%eax
add    -0xe8(%rbp),%eax
add    $0xa679438e,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
shr    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
xor    $0xffffffff,%ecx
and    -0x14(%rbp),%ecx
or     %ecx,%eax
add    -0xe4(%rbp),%eax
add    $0x49b40821,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
shr    $0xa,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x11c(%rbp),%eax
add    $0xf61e2562,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x108(%rbp),%eax
add    $0xc040b340,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0xf4(%rbp),%eax
add    $0x265e5a51,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x12,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x120(%rbp),%eax
add    $0xe9b6c7aa,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x10c(%rbp),%eax
add    $0xd62f105d,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0xf8(%rbp),%eax
add    $0x2441453,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0xe4(%rbp),%eax
add    $0xd8a1e681,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x12,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x110(%rbp),%eax
add    $0xe7d3fbc8,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0xfc(%rbp),%eax
add    $0x21e1cde6,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0xe8(%rbp),%eax
add    $0xc33707d6,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x114(%rbp),%eax
add    $0xf4d50d87,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x12,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x100(%rbp),%eax
add    $0x455a14ed,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0xec(%rbp),%eax
add    $0xa9e3e905,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x118(%rbp),%eax
add    $0xfcefa3f8,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0x104(%rbp),%eax
add    $0x676f02d9,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x12,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
add    -0xf0(%rbp),%eax
add    $0x8d2a4c8a,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
add    -0x10c(%rbp),%eax
add    $0xfffa3942,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
add    -0x100(%rbp),%eax
add    $0x8771f681,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
add    -0xf4(%rbp),%eax
add    $0x6d9d6122,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
add    -0xe8(%rbp),%eax
add    $0xfde5380c,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
add    -0x11c(%rbp),%eax
add    $0xa4beea44,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
add    -0x110(%rbp),%eax
add    $0x4bdecfa9,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
add    -0x104(%rbp),%eax
add    $0xf6bb4b60,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
add    -0xf8(%rbp),%eax
add    $0xbebfbc70,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
add    -0xec(%rbp),%eax
add    $0x289b7ec6,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
add    -0x120(%rbp),%eax
add    $0xeaa127fa,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
add    -0x114(%rbp),%eax
add    $0xd4ef3085,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
add    -0x108(%rbp),%eax
add    $0x4881d05,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
add    -0xfc(%rbp),%eax
add    $0xd9d4d039,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
add    -0xf0(%rbp),%eax
add    $0xe6db99e5,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
add    -0xe4(%rbp),%eax
add    $0x1fa27cf8,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
add    -0x118(%rbp),%eax
add    $0xc4ac5665,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x120(%rbp),%eax
add    $0xf4292244,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x104(%rbp),%eax
add    $0x432aff97,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0xe8(%rbp),%eax
add    $0xab9423a7,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x10c(%rbp),%eax
add    $0xfc93a039,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0xf0(%rbp),%eax
add    $0x655b59c3,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x114(%rbp),%eax
add    $0x8f0ccc92,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0xf8(%rbp),%eax
add    $0xffeff47d,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x11c(%rbp),%eax
add    $0x85845dd1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x100(%rbp),%eax
add    $0x6fa87e4f,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0xe4(%rbp),%eax
add    $0xfe2ce6e0,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x108(%rbp),%eax
add    $0xa3014314,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0xec(%rbp),%eax
add    $0x4e0811a1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x110(%rbp),%eax
add    $0xf7537e82,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0xf4(%rbp),%eax
add    $0xbd3af235,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x118(%rbp),%eax
add    $0x2ad7d2bb,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0xfc(%rbp),%eax
add    $0xeb86d391,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
add    $0x120,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MD5Transform>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %rdi,0x48(%rsp)
mov    0x4(%rdi),%r12d
mov    0x8(%rdi),%r14d
mov    0xc(%rdi),%r15d
mov    %r14d,%ebp
and    %r12d,%ebp
add    (%rdi),%ebp
lea    0x50(%rsp),%rdi
mov    $0x40,%edx
call   1030 <MD5Decode@plt>
mov    %r12d,%eax
not    %eax
and    %r15d,%eax
add    %ebp,%eax
mov    0x50(%rsp),%ecx
mov    %rcx,0x40(%rsp)
mov    0x54(%rsp),%r13d
lea    (%rcx,%rax,1),%esi
add    $0xd76aa478,%esi
rol    $0x7,%esi
add    %r12d,%esi
mov    %esi,%eax
and    %r12d,%eax
mov    %esi,%ecx
not    %ecx
and    %r14d,%ecx
add    %r13d,%r15d
add    %ecx,%r15d
add    %r15d,%eax
add    $0xe8c7b756,%eax
rol    $0xc,%eax
add    %esi,%eax
mov    %eax,%ecx
and    %esi,%ecx
mov    %eax,%edx
not    %edx
and    %r12d,%edx
mov    0x58(%rsp),%edi
mov    %edi,0x2c(%rsp)
add    %edi,%r14d
add    %edx,%r14d
add    %r14d,%ecx
add    $0x242070db,%ecx
rol    $0x11,%ecx
add    %eax,%ecx
mov    %ecx,%edx
and    %eax,%edx
mov    %ecx,%edi
not    %edi
and    %esi,%edi
mov    0x5c(%rsp),%ebp
mov    %ebp,0x10(%rsp)
add    %ebp,%r12d
add    %edi,%r12d
add    %r12d,%edx
add    $0xc1bdceee,%edx
rol    $0x16,%edx
add    %ecx,%edx
mov    %edx,%r8d
and    %ecx,%r8d
mov    %edx,%ebp
not    %ebp
and    %eax,%ebp
mov    0x60(%rsp),%edi
mov    %edi,0x8(%rsp)
add    %edi,%esi
add    %ebp,%esi
add    %r8d,%esi
add    $0xf57c0faf,%esi
rol    $0x7,%esi
add    %edx,%esi
mov    %esi,%r8d
and    %edx,%r8d
mov    %esi,%ebp
not    %ebp
and    %ecx,%ebp
mov    0x64(%rsp),%edi
mov    %rdi,0x30(%rsp)
add    %edi,%eax
add    %ebp,%eax
add    %r8d,%eax
add    $0x4787c62a,%eax
rol    $0xc,%eax
add    %esi,%eax
mov    %eax,%r8d
and    %esi,%r8d
mov    %eax,%ebp
not    %ebp
and    %edx,%ebp
mov    0x68(%rsp),%r15d
add    %r15d,%ecx
mov    %r15d,0x24(%rsp)
add    %ebp,%ecx
add    %r8d,%ecx
add    $0xa8304613,%ecx
rol    $0x11,%ecx
add    %eax,%ecx
mov    %ecx,%edi
and    %eax,%edi
mov    %ecx,%ebp
not    %ebp
and    %esi,%ebp
mov    0x6c(%rsp),%ebx
mov    %ebx,0x28(%rsp)
add    %ebx,%edx
add    %ebp,%edx
add    %edi,%edx
add    $0xfd469501,%edx
rol    $0x16,%edx
add    %ecx,%edx
mov    %edx,%edi
not    %edi
and    %eax,%edi
mov    0x70(%rsp),%ebp
mov    %ebp,0x4(%rsp)
add    %ebp,%esi
add    %edi,%esi
mov    %edx,%edi
and    %ecx,%edi
add    %edi,%esi
add    $0x698098d8,%esi
rol    $0x7,%esi
add    %edx,%esi
mov    %esi,%edi
not    %edi
and    %ecx,%edi
mov    0x74(%rsp),%r12d
add    %r12d,%eax
add    %edi,%eax
mov    %esi,%edi
and    %edx,%edi
add    %edi,%eax
add    $0x8b44f7af,%eax
rol    $0xc,%eax
add    %esi,%eax
mov    %eax,%edi
not    %edi
and    %edx,%edi
mov    0x78(%rsp),%ebp
add    %ebp,%ecx
mov    %ebp,%r11d
mov    %ebp,0x18(%rsp)
add    %edi,%ecx
mov    %eax,%edi
and    %esi,%edi
add    %edi,%ecx
add    $0xffff5bb1,%ecx
rol    $0x11,%ecx
add    %eax,%ecx
mov    %ecx,%edi
not    %edi
and    %esi,%edi
mov    0x7c(%rsp),%ebp
add    %ebp,%edx
mov    %ebp,0xc(%rsp)
add    %edi,%edx
mov    %ecx,%edi
and    %eax,%edi
lea    (%rdi,%rdx,1),%r8d
add    $0x895cd7be,%r8d
rol    $0x16,%r8d
add    %ecx,%r8d
mov    %r8d,%edx
not    %edx
and    %eax,%edx
mov    0x80(%rsp),%edi
mov    %edi,0x1c(%rsp)
add    %edi,%esi
add    %edx,%esi
mov    %r8d,%edx
and    %ecx,%edx
add    %esi,%edx
add    $0x6b901122,%edx
rol    $0x7,%edx
add    %r8d,%edx
mov    %edx,%esi
not    %esi
and    %ecx,%esi
mov    0x84(%rsp),%edi
mov    %edi,(%rsp)
add    %edi,%eax
add    %esi,%eax
mov    %edx,%esi
and    %r8d,%esi
lea    (%rsi,%rax,1),%edi
add    $0xfd987193,%edi
rol    $0xc,%edi
add    %edx,%edi
mov    %edi,%r9d
not    %r9d
mov    %r8d,%eax
and    %r9d,%eax
mov    0x88(%rsp),%r14d
add    %r14d,%ecx
add    %eax,%ecx
mov    %edi,%eax
and    %edx,%eax
lea    (%rax,%rcx,1),%esi
add    $0xa679438e,%esi
rol    $0x11,%esi
add    %edi,%esi
mov    %esi,%r10d
not    %r10d
mov    %r13,0x38(%rsp)
lea    (%rdx,%r13,1),%ecx
and    %r10d,%edx
mov    0x8c(%rsp),%ebx
add    %ebx,%r8d
mov    %ebx,0x20(%rsp)
add    %edx,%r8d
mov    %esi,%eax
and    %edi,%eax
add    %r8d,%eax
add    $0x49b40821,%eax
and    %esi,%r9d
add    %ecx,%r9d
rol    $0x16,%eax
add    %esi,%eax
mov    %eax,%ecx
and    %edi,%ecx
add    %r9d,%ecx
add    $0xf61e2562,%ecx
and    %eax,%r10d
add    %r15d,%edi
add    %r10d,%edi
rol    $0x5,%ecx
add    %eax,%ecx
mov    %ecx,%edx
and    %esi,%edx
lea    (%rdx,%rdi,1),%r8d
add    $0xc040b340,%r8d
rol    $0x9,%r8d
mov    %eax,%edx
not    %edx
and    %ecx,%edx
add    %ebp,%esi
add    %edx,%esi
add    %ecx,%r8d
mov    %r8d,%edx
and    %eax,%edx
add    %esi,%edx
add    $0x265e5a51,%edx
mov    %ecx,%esi
not    %esi
and    %r8d,%esi
add    0x40(%rsp),%eax
add    %esi,%eax
rol    $0xe,%edx
add    %r8d,%edx
mov    %edx,%esi
and    %ecx,%esi
lea    (%rsi,%rax,1),%edi
add    $0xe9b6c7aa,%edi
mov    %r8d,%eax
not    %eax
and    %edx,%eax
mov    0x30(%rsp),%rbp
add    %ebp,%ecx
add    %eax,%ecx
rol    $0x14,%edi
add    %edx,%edi
mov    %edi,%eax
and    %r8d,%eax
lea    (%rax,%rcx,1),%esi
add    $0xd62f105d,%esi
rol    $0x5,%esi
mov    %edx,%eax
not    %eax
and    %edi,%eax
add    %r11d,%r8d
add    %eax,%r8d
add    %edi,%esi
mov    %esi,%eax
and    %edx,%eax
lea    (%rax,%r8,1),%ecx
add    $0x2441453,%ecx
mov    %edi,%eax
not    %eax
and    %esi,%eax
add    %ebx,%edx
add    %eax,%edx
rol    $0x9,%ecx
add    %esi,%ecx
mov    %ecx,%eax
and    %edi,%eax
add    %eax,%edx
add    $0xd8a1e681,%edx
mov    %esi,%eax
not    %eax
and    %ecx,%eax
mov    0x8(%rsp),%r11d
add    %r11d,%edi
add    %eax,%edi
rol    $0xe,%edx
add    %ecx,%edx
mov    %edx,%eax
and    %esi,%eax
add    %edi,%eax
add    $0xe7d3fbc8,%eax
rol    $0x14,%eax
mov    %ecx,%edi
not    %edi
and    %edx,%edi
mov    %r12d,%r13d
add    %r12d,%esi
add    %edi,%esi
add    %edx,%eax
mov    %eax,%edi
and    %ecx,%edi
add    %edi,%esi
add    $0x21e1cde6,%esi
mov    %edx,%edi
not    %edi
and    %eax,%edi
mov    %r14d,0x14(%rsp)
add    %r14d,%ecx
add    %edi,%ecx
rol    $0x5,%esi
add    %eax,%esi
mov    %esi,%edi
and    %edx,%edi
add    %edi,%ecx
add    $0xc33707d6,%ecx
mov    %eax,%edi
not    %edi
and    %esi,%edi
add    0x10(%rsp),%edx
add    %edi,%edx
rol    $0x9,%ecx
add    %esi,%ecx
mov    %ecx,%edi
and    %eax,%edi
add    %edi,%edx
add    $0xf4d50d87,%edx
rol    $0xe,%edx
mov    %esi,%edi
not    %edi
and    %ecx,%edi
mov    0x4(%rsp),%ebx
add    %ebx,%eax
add    %edi,%eax
add    %ecx,%edx
mov    %edx,%edi
and    %esi,%edi
add    %edi,%eax
add    $0x455a14ed,%eax
mov    %ecx,%edi
not    %edi
and    %edx,%edi
mov    (%rsp),%r10d
add    %r10d,%esi
add    %edi,%esi
rol    $0x14,%eax
add    %edx,%eax
mov    %eax,%edi
and    %ecx,%edi
add    %edi,%esi
add    $0xa9e3e905,%esi
mov    %edx,%edi
not    %edi
and    %eax,%edi
mov    0x2c(%rsp),%r15d
add    %r15d,%ecx
add    %edi,%ecx
rol    $0x5,%esi
add    %eax,%esi
mov    %esi,%edi
and    %edx,%edi
add    %edi,%ecx
add    $0xfcefa3f8,%ecx
rol    $0x9,%ecx
mov    %eax,%edi
not    %edi
and    %esi,%edi
mov    0x28(%rsp),%r9d
add    %r9d,%edx
add    %edi,%edx
add    %esi,%ecx
mov    %ecx,%edi
and    %eax,%edi
add    %edi,%edx
add    $0x676f02d9,%edx
rol    $0xe,%edx
add    %ecx,%edx
mov    %edx,%edi
and    %esi,%edi
lea    (%rsi,%rbp,1),%r8d
not    %esi
and    %ecx,%esi
mov    0x1c(%rsp),%r12d
add    %r12d,%eax
add    %esi,%eax
add    %eax,%edi
add    $0x8d2a4c8a,%edi
rol    $0x14,%edi
add    %edx,%edi
mov    %edi,%eax
xor    %edx,%eax
mov    %eax,%esi
xor    %ecx,%esi
add    %r8d,%esi
add    $0xfffa3942,%esi
rol    $0x4,%esi
add    %edi,%esi
xor    %esi,%eax
add    %ebx,%ecx
add    %ecx,%eax
add    $0x8771f681,%eax
rol    $0xb,%eax
add    %esi,%eax
mov    %esi,%ecx
xor    %edi,%ecx
xor    %eax,%ecx
add    0xc(%rsp),%edx
add    %edx,%ecx
add    $0x6d9d6122,%ecx
rol    $0x10,%ecx
add    %eax,%ecx
mov    %eax,%edx
xor    %esi,%edx
xor    %ecx,%edx
add    %r14d,%edi
add    %edi,%edx
add    $0xfde5380c,%edx
rol    $0x17,%edx
add    %ecx,%edx
mov    %ecx,%edi
xor    %eax,%edi
xor    %edx,%edi
add    0x38(%rsp),%esi
add    %edi,%esi
add    $0xa4beea44,%esi
rol    $0x4,%esi
add    %edx,%esi
mov    %edx,%edi
xor    %ecx,%edi
xor    %esi,%edi
add    %r11d,%eax
add    %edi,%eax
add    $0x4bdecfa9,%eax
rol    $0xb,%eax
add    %esi,%eax
mov    %esi,%edi
xor    %edx,%edi
xor    %eax,%edi
add    %r9d,%ecx
mov    %r9d,%r14d
add    %edi,%ecx
add    $0xf6bb4b60,%ecx
rol    $0x10,%ecx
add    %eax,%ecx
mov    %eax,%edi
xor    %esi,%edi
xor    %ecx,%edi
mov    0x18(%rsp),%r11d
add    %r11d,%edx
add    %edi,%edx
add    $0xbebfbc70,%edx
rol    $0x17,%edx
add    %ecx,%edx
mov    %ecx,%edi
xor    %eax,%edi
xor    %edx,%edi
add    %r10d,%esi
add    %edi,%esi
add    $0x289b7ec6,%esi
rol    $0x4,%esi
add    %edx,%esi
mov    %edx,%edi
xor    %ecx,%edi
xor    %esi,%edi
mov    0x40(%rsp),%rbp
add    %ebp,%eax
add    %edi,%eax
add    $0xeaa127fa,%eax
rol    $0xb,%eax
add    %esi,%eax
mov    %esi,%edi
xor    %edx,%edi
xor    %eax,%edi
mov    0x10(%rsp),%r9d
add    %r9d,%ecx
add    %ecx,%edi
add    $0xd4ef3085,%edi
rol    $0x10,%edi
add    %eax,%edi
mov    %eax,%ecx
xor    %esi,%ecx
xor    %edi,%ecx
mov    0x24(%rsp),%ebx
add    %ebx,%edx
add    %ecx,%edx
add    $0x4881d05,%edx
rol    $0x17,%edx
add    %edi,%edx
mov    %edi,%ecx
xor    %eax,%ecx
xor    %edx,%ecx
add    %r13d,%esi
add    %esi,%ecx
add    $0xd9d4d039,%ecx
rol    $0x4,%ecx
add    %edx,%ecx
mov    %edx,%esi
xor    %edi,%esi
xor    %ecx,%esi
add    %r12d,%eax
add    %esi,%eax
add    $0xe6db99e5,%eax
rol    $0xb,%eax
add    %ecx,%eax
mov    %ecx,%esi
xor    %edx,%esi
xor    %eax,%esi
mov    0x20(%rsp),%r10d
add    %r10d,%edi
add    %edi,%esi
add    $0x1fa27cf8,%esi
rol    $0x10,%esi
add    %eax,%esi
mov    %eax,%edi
xor    %ecx,%edi
xor    %esi,%edi
add    %r15d,%edx
add    %edx,%edi
add    $0xc4ac5665,%edi
rol    $0x17,%edi
add    %ebp,%ecx
add    %esi,%edi
mov    %eax,%edx
not    %edx
or     %edi,%edx
xor    %esi,%edx
add    %edx,%ecx
add    $0xf4292244,%ecx
rol    $0x6,%ecx
add    %r14d,%eax
add    %edi,%ecx
mov    %esi,%edx
not    %edx
or     %ecx,%edx
xor    %edi,%edx
add    %eax,%edx
add    $0x432aff97,%edx
rol    $0xa,%edx
add    0x14(%rsp),%esi
add    %ecx,%edx
mov    %edi,%eax
not    %eax
or     %edx,%eax
xor    %ecx,%eax
add    %eax,%esi
add    $0xab9423a7,%esi
rol    $0xf,%esi
add    0x30(%rsp),%edi
add    %edx,%esi
mov    %ecx,%eax
not    %eax
or     %esi,%eax
xor    %edx,%eax
add    %eax,%edi
add    $0xfc93a039,%edi
rol    $0x15,%edi
add    %r12d,%ecx
add    %esi,%edi
mov    %edx,%eax
not    %eax
or     %edi,%eax
xor    %esi,%eax
lea    (%rax,%rcx,1),%ebp
add    $0x655b59c3,%ebp
rol    $0x6,%ebp
add    %r9d,%edx
add    %edi,%ebp
mov    %esi,%eax
not    %eax
or     %ebp,%eax
xor    %edi,%eax
add    %edx,%eax
add    $0x8f0ccc92,%eax
rol    $0xa,%eax
add    %ebp,%eax
add    %r11d,%esi
mov    %edi,%ecx
not    %ecx
or     %eax,%ecx
xor    %ebp,%ecx
lea    (%rcx,%rsi,1),%r8d
add    $0xffeff47d,%r8d
rol    $0xf,%r8d
add    %eax,%r8d
add    0x38(%rsp),%edi
mov    %ebp,%ecx
not    %ecx
or     %r8d,%ecx
xor    %eax,%ecx
add    %edi,%ecx
add    $0x85845dd1,%ecx
rol    $0x15,%ecx
add    %r8d,%ecx
add    0x4(%rsp),%ebp
mov    %eax,%edx
not    %edx
or     %ecx,%edx
xor    %r8d,%edx
add    %ebp,%edx
add    $0x6fa87e4f,%edx
rol    $0x6,%edx
add    %ecx,%edx
add    %r10d,%eax
mov    %r8d,%esi
not    %esi
or     %edx,%esi
xor    %ecx,%esi
add    %eax,%esi
add    $0xfe2ce6e0,%esi
rol    $0xa,%esi
add    %edx,%esi
add    %ebx,%r8d
mov    %ecx,%eax
not    %eax
or     %esi,%eax
xor    %edx,%eax
lea    (%rax,%r8,1),%edi
add    $0xa3014314,%edi
rol    $0xf,%edi
add    %esi,%edi
add    (%rsp),%ecx
mov    %edx,%eax
not    %eax
or     %edi,%eax
xor    %esi,%eax
add    %ecx,%eax
add    $0x4e0811a1,%eax
rol    $0x15,%eax
add    %edi,%eax
add    0x8(%rsp),%edx
mov    %esi,%ecx
not    %ecx
or     %eax,%ecx
xor    %edi,%ecx
add    %edx,%ecx
add    $0xf7537e82,%ecx
rol    $0x6,%ecx
add    %eax,%ecx
add    0xc(%rsp),%esi
mov    %edi,%edx
not    %edx
or     %ecx,%edx
xor    %eax,%edx
add    %esi,%edx
add    $0xbd3af235,%edx
rol    $0xa,%edx
add    %ecx,%edx
add    %r15d,%edi
mov    %eax,%esi
not    %esi
or     %edx,%esi
xor    %ecx,%esi
add    %edi,%esi
add    $0x2ad7d2bb,%esi
rol    $0xf,%esi
mov    0x48(%rsp),%rdi
add    %ecx,(%rdi)
add    %r13d,%eax
add    %edx,%esi
not    %ecx
or     %esi,%ecx
xor    %edx,%ecx
add    %ecx,%eax
add    $0xeb86d391,%eax
rol    $0x15,%eax
mov    0x4(%rdi),%ecx
add    %esi,%ecx
add    %eax,%ecx
mov    %ecx,0x4(%rdi)
add    %esi,0x8(%rdi)
add    %edx,0xc(%rdi)
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @MD5Transform(i32* nocapture %0, i8* %1) {
%3 = alloca [64 x i32]
%4 = load i32, i32* %0
%5 = getelementptr inbounds i32, i32* %0, i64 1
%6 = load i32, i32* %5
%7 = getelementptr inbounds i32, i32* %0, i64 2
%8 = load i32, i32* %7
%9 = getelementptr inbounds i32, i32* %0, i64 3
%10 = load i32, i32* %9
%11 = bitcast [64 x i32]* %3 to i8*
%12 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 0
%13 = call i32 @MD5Decode(i32* %12, i8* %1, i32 64)
%14 = and i32 %8, %6
%15 = xor i32 %6, -1
%16 = and i32 %10, %15
%17 = load i32, i32* %12
%18 = add i32 %4, -680876936
%19 = add i32 %18, %14
%20 = add i32 %19, %16
%21 = add i32 %20, %17
%22 = call i32 @llvm.fshl.i32(i32 %21, i32 %21, i32 7)
%23 = add i32 %22, %6
%24 = and i32 %23, %6
%25 = xor i32 %23, -1
%26 = and i32 %8, %25
%27 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 1
%28 = load i32, i32* %27
%29 = add i32 %10, -389564586
%30 = add i32 %29, %28
%31 = add i32 %30, %26
%32 = add i32 %31, %24
%33 = call i32 @llvm.fshl.i32(i32 %32, i32 %32, i32 12)
%34 = add i32 %33, %23
%35 = and i32 %34, %23
%36 = xor i32 %34, -1
%37 = and i32 %6, %36
%38 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 2
%39 = load i32, i32* %38
%40 = add i32 %8, 606105819
%41 = add i32 %40, %39
%42 = add i32 %41, %37
%43 = add i32 %42, %35
%44 = call i32 @llvm.fshl.i32(i32 %43, i32 %43, i32 17)
%45 = add i32 %44, %34
%46 = and i32 %45, %34
%47 = xor i32 %45, -1
%48 = and i32 %23, %47
%49 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 3
%50 = load i32, i32* %49
%51 = add i32 %6, -1044525330
%52 = add i32 %51, %50
%53 = add i32 %52, %48
%54 = add i32 %53, %46
%55 = call i32 @llvm.fshl.i32(i32 %54, i32 %54, i32 22)
%56 = add i32 %55, %45
%57 = and i32 %56, %45
%58 = xor i32 %56, -1
%59 = and i32 %34, %58
%60 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 4
%61 = load i32, i32* %60
%62 = add i32 %61, -176418897
%63 = add i32 %62, %23
%64 = add i32 %63, %59
%65 = add i32 %64, %57
%66 = call i32 @llvm.fshl.i32(i32 %65, i32 %65, i32 7)
%67 = add i32 %66, %56
%68 = and i32 %67, %56
%69 = xor i32 %67, -1
%70 = and i32 %45, %69
%71 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 5
%72 = load i32, i32* %71
%73 = add i32 %72, 1200080426
%74 = add i32 %73, %34
%75 = add i32 %74, %70
%76 = add i32 %75, %68
%77 = call i32 @llvm.fshl.i32(i32 %76, i32 %76, i32 12)
%78 = add i32 %77, %67
%79 = and i32 %78, %67
%80 = xor i32 %78, -1
%81 = and i32 %56, %80
%82 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 6
%83 = load i32, i32* %82
%84 = add i32 %83, -1473231341
%85 = add i32 %84, %45
%86 = add i32 %85, %81
%87 = add i32 %86, %79
%88 = call i32 @llvm.fshl.i32(i32 %87, i32 %87, i32 17)
%89 = add i32 %88, %78
%90 = and i32 %89, %78
%91 = xor i32 %89, -1
%92 = and i32 %67, %91
%93 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 7
%94 = load i32, i32* %93
%95 = add i32 %94, -45705983
%96 = add i32 %95, %56
%97 = add i32 %96, %92
%98 = add i32 %97, %90
%99 = call i32 @llvm.fshl.i32(i32 %98, i32 %98, i32 22)
%100 = add i32 %99, %89
%101 = and i32 %100, %89
%102 = xor i32 %100, -1
%103 = and i32 %78, %102
%104 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 8
%105 = load i32, i32* %104
%106 = add i32 %105, 1770035416
%107 = add i32 %106, %67
%108 = add i32 %107, %103
%109 = add i32 %108, %101
%110 = call i32 @llvm.fshl.i32(i32 %109, i32 %109, i32 7)
%111 = add i32 %110, %100
%112 = and i32 %111, %100
%113 = xor i32 %111, -1
%114 = and i32 %89, %113
%115 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 9
%116 = load i32, i32* %115
%117 = add i32 %116, -1958414417
%118 = add i32 %117, %78
%119 = add i32 %118, %114
%120 = add i32 %119, %112
%121 = call i32 @llvm.fshl.i32(i32 %120, i32 %120, i32 12)
%122 = add i32 %121, %111
%123 = and i32 %122, %111
%124 = xor i32 %122, -1
%125 = and i32 %100, %124
%126 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 10
%127 = load i32, i32* %126
%128 = add i32 %127, -42063
%129 = add i32 %128, %89
%130 = add i32 %129, %125
%131 = add i32 %130, %123
%132 = call i32 @llvm.fshl.i32(i32 %131, i32 %131, i32 17)
%133 = add i32 %132, %122
%134 = and i32 %133, %122
%135 = xor i32 %133, -1
%136 = and i32 %111, %135
%137 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 11
%138 = load i32, i32* %137
%139 = add i32 %138, -1990404162
%140 = add i32 %139, %100
%141 = add i32 %140, %136
%142 = add i32 %141, %134
%143 = call i32 @llvm.fshl.i32(i32 %142, i32 %142, i32 22)
%144 = add i32 %143, %133
%145 = and i32 %144, %133
%146 = xor i32 %144, -1
%147 = and i32 %122, %146
%148 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 12
%149 = load i32, i32* %148
%150 = add i32 %149, 1804603682
%151 = add i32 %150, %111
%152 = add i32 %151, %147
%153 = add i32 %152, %145
%154 = call i32 @llvm.fshl.i32(i32 %153, i32 %153, i32 7)
%155 = add i32 %154, %144
%156 = and i32 %155, %144
%157 = xor i32 %155, -1
%158 = and i32 %133, %157
%159 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 13
%160 = load i32, i32* %159
%161 = add i32 %160, -40341101
%162 = add i32 %161, %122
%163 = add i32 %162, %158
%164 = add i32 %163, %156
%165 = call i32 @llvm.fshl.i32(i32 %164, i32 %164, i32 12)
%166 = add i32 %165, %155
%167 = and i32 %166, %155
%168 = xor i32 %166, -1
%169 = and i32 %144, %168
%170 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 14
%171 = load i32, i32* %170
%172 = add i32 %171, -1502002290
%173 = add i32 %172, %133
%174 = add i32 %173, %169
%175 = add i32 %174, %167
%176 = call i32 @llvm.fshl.i32(i32 %175, i32 %175, i32 17)
%177 = add i32 %176, %166
%178 = and i32 %177, %166
%179 = xor i32 %177, -1
%180 = and i32 %155, %179
%181 = getelementptr inbounds [64 x i32], [64 x i32]* %3, i64 0, i64 15
%182 = load i32, i32* %181
%183 = add i32 %182, 1236535329
%184 = add i32 %183, %144
%185 = add i32 %184, %180
%186 = add i32 %185, %178
%187 = call i32 @llvm.fshl.i32(i32 %186, i32 %186, i32 22)
%188 = add i32 %187, %177
%189 = and i32 %188, %166
%190 = and i32 %177, %168
%191 = add i32 %28, -165796510
%192 = add i32 %191, %155
%193 = add i32 %192, %190
%194 = add i32 %193, %189
%195 = call i32 @llvm.fshl.i32(i32 %194, i32 %194, i32 5)
%196 = add i32 %195, %188
%197 = and i32 %196, %177
%198 = and i32 %188, %179
%199 = add i32 %83, -1069501632
%200 = add i32 %199, %166
%201 = add i32 %200, %198
%202 = add i32 %201, %197
%203 = call i32 @llvm.fshl.i32(i32 %202, i32 %202, i32 9)
%204 = add i32 %203, %196
%205 = and i32 %204, %188
%206 = xor i32 %188, -1
%207 = and i32 %196, %206
%208 = add i32 %138, 643717713
%209 = add i32 %208, %177
%210 = add i32 %209, %207
%211 = add i32 %210, %205
%212 = call i32 @llvm.fshl.i32(i32 %211, i32 %211, i32 14)
%213 = add i32 %212, %204
%214 = and i32 %213, %196
%215 = xor i32 %196, -1
%216 = and i32 %204, %215
%217 = add i32 %17, -373897302
%218 = add i32 %217, %188
%219 = add i32 %218, %216
%220 = add i32 %219, %214
%221 = call i32 @llvm.fshl.i32(i32 %220, i32 %220, i32 20)
%222 = add i32 %221, %213
%223 = and i32 %222, %204
%224 = xor i32 %204, -1
%225 = and i32 %213, %224
%226 = add i32 %72, -701558691
%227 = add i32 %226, %196
%228 = add i32 %227, %225
%229 = add i32 %228, %223
%230 = call i32 @llvm.fshl.i32(i32 %229, i32 %229, i32 5)
%231 = add i32 %230, %222
%232 = and i32 %231, %213
%233 = xor i32 %213, -1
%234 = and i32 %222, %233
%235 = add i32 %127, 38016083
%236 = add i32 %235, %204
%237 = add i32 %236, %234
%238 = add i32 %237, %232
%239 = call i32 @llvm.fshl.i32(i32 %238, i32 %238, i32 9)
%240 = add i32 %239, %231
%241 = and i32 %240, %222
%242 = xor i32 %222, -1
%243 = and i32 %231, %242
%244 = add i32 %182, -660478335
%245 = add i32 %244, %213
%246 = add i32 %245, %243
%247 = add i32 %246, %241
%248 = call i32 @llvm.fshl.i32(i32 %247, i32 %247, i32 14)
%249 = add i32 %248, %240
%250 = and i32 %249, %231
%251 = xor i32 %231, -1
%252 = and i32 %240, %251
%253 = add i32 %61, -405537848
%254 = add i32 %253, %222
%255 = add i32 %254, %252
%256 = add i32 %255, %250
%257 = call i32 @llvm.fshl.i32(i32 %256, i32 %256, i32 20)
%258 = add i32 %257, %249
%259 = and i32 %258, %240
%260 = xor i32 %240, -1
%261 = and i32 %249, %260
%262 = add i32 %116, 568446438
%263 = add i32 %262, %231
%264 = add i32 %263, %261
%265 = add i32 %264, %259
%266 = call i32 @llvm.fshl.i32(i32 %265, i32 %265, i32 5)
%267 = add i32 %266, %258
%268 = and i32 %267, %249
%269 = xor i32 %249, -1
%270 = and i32 %258, %269
%271 = add i32 %171, -1019803690
%272 = add i32 %271, %240
%273 = add i32 %272, %270
%274 = add i32 %273, %268
%275 = call i32 @llvm.fshl.i32(i32 %274, i32 %274, i32 9)
%276 = add i32 %275, %267
%277 = and i32 %276, %258
%278 = xor i32 %258, -1
%279 = and i32 %267, %278
%280 = add i32 %50, -187363961
%281 = add i32 %280, %249
%282 = add i32 %281, %279
%283 = add i32 %282, %277
%284 = call i32 @llvm.fshl.i32(i32 %283, i32 %283, i32 14)
%285 = add i32 %284, %276
%286 = and i32 %285, %267
%287 = xor i32 %267, -1
%288 = and i32 %276, %287
%289 = add i32 %105, 1163531501
%290 = add i32 %289, %258
%291 = add i32 %290, %288
%292 = add i32 %291, %286
%293 = call i32 @llvm.fshl.i32(i32 %292, i32 %292, i32 20)
%294 = add i32 %293, %285
%295 = and i32 %294, %276
%296 = xor i32 %276, -1
%297 = and i32 %285, %296
%298 = add i32 %160, -1444681467
%299 = add i32 %298, %267
%300 = add i32 %299, %297
%301 = add i32 %300, %295
%302 = call i32 @llvm.fshl.i32(i32 %301, i32 %301, i32 5)
%303 = add i32 %302, %294
%304 = and i32 %303, %285
%305 = xor i32 %285, -1
%306 = and i32 %294, %305
%307 = add i32 %39, -51403784
%308 = add i32 %307, %276
%309 = add i32 %308, %306
%310 = add i32 %309, %304
%311 = call i32 @llvm.fshl.i32(i32 %310, i32 %310, i32 9)
%312 = add i32 %311, %303
%313 = and i32 %312, %294
%314 = xor i32 %294, -1
%315 = and i32 %303, %314
%316 = add i32 %94, 1735328473
%317 = add i32 %316, %285
%318 = add i32 %317, %315
%319 = add i32 %318, %313
%320 = call i32 @llvm.fshl.i32(i32 %319, i32 %319, i32 14)
%321 = add i32 %320, %312
%322 = and i32 %321, %303
%323 = xor i32 %303, -1
%324 = and i32 %312, %323
%325 = add i32 %149, -1926607734
%326 = add i32 %325, %294
%327 = add i32 %326, %324
%328 = add i32 %327, %322
%329 = call i32 @llvm.fshl.i32(i32 %328, i32 %328, i32 20)
%330 = add i32 %329, %321
%331 = xor i32 %330, %321
%332 = xor i32 %331, %312
%333 = add i32 %72, -378558
%334 = add i32 %333, %303
%335 = add i32 %334, %332
%336 = call i32 @llvm.fshl.i32(i32 %335, i32 %335, i32 4)
%337 = add i32 %336, %330
%338 = xor i32 %331, %337
%339 = add i32 %105, -2022574463
%340 = add i32 %339, %312
%341 = add i32 %340, %338
%342 = call i32 @llvm.fshl.i32(i32 %341, i32 %341, i32 11)
%343 = add i32 %342, %337
%344 = xor i32 %337, %330
%345 = xor i32 %344, %343
%346 = add i32 %138, 1839030562
%347 = add i32 %346, %321
%348 = add i32 %347, %345
%349 = call i32 @llvm.fshl.i32(i32 %348, i32 %348, i32 16)
%350 = add i32 %349, %343
%351 = xor i32 %343, %337
%352 = xor i32 %351, %350
%353 = add i32 %171, -35309556
%354 = add i32 %353, %330
%355 = add i32 %354, %352
%356 = call i32 @llvm.fshl.i32(i32 %355, i32 %355, i32 23)
%357 = add i32 %356, %350
%358 = xor i32 %350, %343
%359 = xor i32 %358, %357
%360 = add i32 %28, -1530992060
%361 = add i32 %360, %337
%362 = add i32 %361, %359
%363 = call i32 @llvm.fshl.i32(i32 %362, i32 %362, i32 4)
%364 = add i32 %363, %357
%365 = xor i32 %357, %350
%366 = xor i32 %365, %364
%367 = add i32 %61, 1272893353
%368 = add i32 %367, %343
%369 = add i32 %368, %366
%370 = call i32 @llvm.fshl.i32(i32 %369, i32 %369, i32 11)
%371 = add i32 %370, %364
%372 = xor i32 %364, %357
%373 = xor i32 %372, %371
%374 = add i32 %94, -155497632
%375 = add i32 %374, %350
%376 = add i32 %375, %373
%377 = call i32 @llvm.fshl.i32(i32 %376, i32 %376, i32 16)
%378 = add i32 %377, %371
%379 = xor i32 %371, %364
%380 = xor i32 %379, %378
%381 = add i32 %127, -1094730640
%382 = add i32 %381, %357
%383 = add i32 %382, %380
%384 = call i32 @llvm.fshl.i32(i32 %383, i32 %383, i32 23)
%385 = add i32 %384, %378
%386 = xor i32 %378, %371
%387 = xor i32 %386, %385
%388 = add i32 %160, 681279174
%389 = add i32 %388, %364
%390 = add i32 %389, %387
%391 = call i32 @llvm.fshl.i32(i32 %390, i32 %390, i32 4)
%392 = add i32 %391, %385
%393 = xor i32 %385, %378
%394 = xor i32 %393, %392
%395 = add i32 %17, -358537222
%396 = add i32 %395, %371
%397 = add i32 %396, %394
%398 = call i32 @llvm.fshl.i32(i32 %397, i32 %397, i32 11)
%399 = add i32 %398, %392
%400 = xor i32 %392, %385
%401 = xor i32 %400, %399
%402 = add i32 %50, -722521979
%403 = add i32 %402, %378
%404 = add i32 %403, %401
%405 = call i32 @llvm.fshl.i32(i32 %404, i32 %404, i32 16)
%406 = add i32 %405, %399
%407 = xor i32 %399, %392
%408 = xor i32 %407, %406
%409 = add i32 %83, 76029189
%410 = add i32 %409, %385
%411 = add i32 %410, %408
%412 = call i32 @llvm.fshl.i32(i32 %411, i32 %411, i32 23)
%413 = add i32 %412, %406
%414 = xor i32 %406, %399
%415 = xor i32 %414, %413
%416 = add i32 %116, -640364487
%417 = add i32 %416, %392
%418 = add i32 %417, %415
%419 = call i32 @llvm.fshl.i32(i32 %418, i32 %418, i32 4)
%420 = add i32 %419, %413
%421 = xor i32 %413, %406
%422 = xor i32 %421, %420
%423 = add i32 %149, -421815835
%424 = add i32 %423, %399
%425 = add i32 %424, %422
%426 = call i32 @llvm.fshl.i32(i32 %425, i32 %425, i32 11)
%427 = add i32 %426, %420
%428 = xor i32 %420, %413
%429 = xor i32 %428, %427
%430 = add i32 %182, 530742520
%431 = add i32 %430, %406
%432 = add i32 %431, %429
%433 = call i32 @llvm.fshl.i32(i32 %432, i32 %432, i32 16)
%434 = add i32 %433, %427
%435 = xor i32 %427, %420
%436 = xor i32 %435, %434
%437 = add i32 %39, -995338651
%438 = add i32 %437, %413
%439 = add i32 %438, %436
%440 = call i32 @llvm.fshl.i32(i32 %439, i32 %439, i32 23)
%441 = add i32 %440, %434
%442 = xor i32 %427, -1
%443 = or i32 %441, %442
%444 = xor i32 %443, %434
%445 = add i32 %17, -198630844
%446 = add i32 %445, %420
%447 = add i32 %446, %444
%448 = call i32 @llvm.fshl.i32(i32 %447, i32 %447, i32 6)
%449 = add i32 %448, %441
%450 = xor i32 %434, -1
%451 = or i32 %449, %450
%452 = xor i32 %451, %441
%453 = add i32 %94, 1126891415
%454 = add i32 %453, %427
%455 = add i32 %454, %452
%456 = call i32 @llvm.fshl.i32(i32 %455, i32 %455, i32 10)
%457 = add i32 %456, %449
%458 = xor i32 %441, -1
%459 = or i32 %457, %458
%460 = xor i32 %459, %449
%461 = add i32 %171, -1416354905
%462 = add i32 %461, %434
%463 = add i32 %462, %460
%464 = call i32 @llvm.fshl.i32(i32 %463, i32 %463, i32 15)
%465 = add i32 %464, %457
%466 = xor i32 %449, -1
%467 = or i32 %465, %466
%468 = xor i32 %467, %457
%469 = add i32 %72, -57434055
%470 = add i32 %469, %441
%471 = add i32 %470, %468
%472 = call i32 @llvm.fshl.i32(i32 %471, i32 %471, i32 21)
%473 = add i32 %472, %465
%474 = xor i32 %457, -1
%475 = or i32 %473, %474
%476 = xor i32 %475, %465
%477 = add i32 %149, 1700485571
%478 = add i32 %477, %449
%479 = add i32 %478, %476
%480 = call i32 @llvm.fshl.i32(i32 %479, i32 %479, i32 6)
%481 = add i32 %480, %473
%482 = xor i32 %465, -1
%483 = or i32 %481, %482
%484 = xor i32 %483, %473
%485 = add i32 %50, -1894986606
%486 = add i32 %485, %457
%487 = add i32 %486, %484
%488 = call i32 @llvm.fshl.i32(i32 %487, i32 %487, i32 10)
%489 = add i32 %488, %481
%490 = xor i32 %473, -1
%491 = or i32 %489, %490
%492 = xor i32 %491, %481
%493 = add i32 %127, -1051523
%494 = add i32 %493, %465
%495 = add i32 %494, %492
%496 = call i32 @llvm.fshl.i32(i32 %495, i32 %495, i32 15)
%497 = add i32 %496, %489
%498 = xor i32 %481, -1
%499 = or i32 %497, %498
%500 = xor i32 %499, %489
%501 = add i32 %28, -2054922799
%502 = add i32 %501, %473
%503 = add i32 %502, %500
%504 = call i32 @llvm.fshl.i32(i32 %503, i32 %503, i32 21)
%505 = add i32 %504, %497
%506 = xor i32 %489, -1
%507 = or i32 %505, %506
%508 = xor i32 %507, %497
%509 = add i32 %105, 1873313359
%510 = add i32 %509, %481
%511 = add i32 %510, %508
%512 = call i32 @llvm.fshl.i32(i32 %511, i32 %511, i32 6)
%513 = add i32 %512, %505
%514 = xor i32 %497, -1
%515 = or i32 %513, %514
%516 = xor i32 %515, %505
%517 = add i32 %182, -30611744
%518 = add i32 %517, %489
%519 = add i32 %518, %516
%520 = call i32 @llvm.fshl.i32(i32 %519, i32 %519, i32 10)
%521 = add i32 %520, %513
%522 = xor i32 %505, -1
%523 = or i32 %521, %522
%524 = xor i32 %523, %513
%525 = add i32 %83, -1560198380
%526 = add i32 %525, %497
%527 = add i32 %526, %524
%528 = call i32 @llvm.fshl.i32(i32 %527, i32 %527, i32 15)
%529 = add i32 %528, %521
%530 = xor i32 %513, -1
%531 = or i32 %529, %530
%532 = xor i32 %531, %521
%533 = add i32 %160, 1309151649
%534 = add i32 %533, %505
%535 = add i32 %534, %532
%536 = call i32 @llvm.fshl.i32(i32 %535, i32 %535, i32 21)
%537 = add i32 %536, %529
%538 = xor i32 %521, -1
%539 = or i32 %537, %538
%540 = xor i32 %539, %529
%541 = add i32 %61, -145523070
%542 = add i32 %541, %513
%543 = add i32 %542, %540
%544 = call i32 @llvm.fshl.i32(i32 %543, i32 %543, i32 6)
%545 = add i32 %544, %537
%546 = xor i32 %529, -1
%547 = or i32 %545, %546
%548 = xor i32 %547, %537
%549 = add i32 %138, -1120210379
%550 = add i32 %549, %521
%551 = add i32 %550, %548
%552 = call i32 @llvm.fshl.i32(i32 %551, i32 %551, i32 10)
%553 = add i32 %552, %545
%554 = xor i32 %537, -1
%555 = or i32 %553, %554
%556 = xor i32 %555, %545
%557 = add i32 %39, 718787259
%558 = add i32 %557, %529
%559 = add i32 %558, %556
%560 = call i32 @llvm.fshl.i32(i32 %559, i32 %559, i32 15)
%561 = add i32 %560, %553
%562 = xor i32 %545, -1
%563 = or i32 %561, %562
%564 = xor i32 %563, %553
%565 = add i32 %116, -343485551
%566 = add i32 %565, %537
%567 = add i32 %566, %564
%568 = call i32 @llvm.fshl.i32(i32 %567, i32 %567, i32 21)
%569 = load i32, i32* %0
%570 = add i32 %545, %569
store i32 %570, i32* %0
%571 = load i32, i32* %5
%572 = add i32 %561, %571
%573 = add i32 %572, %568
store i32 %573, i32* %5
%574 = load i32, i32* %7
%575 = add i32 %561, %574
store i32 %575, i32* %7
%576 = load i32, i32* %9
%577 = add i32 %553, %576
store i32 %577, i32* %9
ret void
}