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


x86 assembly (clang, -O0):
<MD5_Transform>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%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)
mov    -0x10(%rbp),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1030 <ByteReverse@plt>
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%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    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%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    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%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    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%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    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%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    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%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    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%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    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%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    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%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    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%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    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%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    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%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    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%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    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%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    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%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    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%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    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%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    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%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    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%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    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%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    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%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    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%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    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%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    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%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    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%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    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%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    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%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    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%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    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%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    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%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    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%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    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%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
mov    -0x10(%rbp),%rcx
add    (%rcx),%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
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%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
mov    -0x10(%rbp),%rcx
add    (%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%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
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%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    -0x10(%rbp),%rdi
mov    $0x10,%esi
mov    $0x0,%al
call   1030 <ByteReverse@plt>
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    $0x20,%rsp
pop    %rbp
ret

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

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

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