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


x86 assembly (clang, -O0):
<md5_transform>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x10,-0x64(%rbp)
jge    115f <md5_transform+0x4f>
mov    -0x10(%rbp),%rdi
mov    -0x64(%rbp),%eax
shl    $0x2,%eax
cltq
add    %rax,%rdi
mov    $0x0,%al
call   1030 <getu32@plt>
mov    %eax,%ecx
movslq -0x64(%rbp),%rax
mov    %ecx,-0x60(%rbp,%rax,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1127 <md5_transform+0x17>
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    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x60(%rbp),%eax
add    $0xd76aa478,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%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
add    -0x5c(%rbp),%eax
add    $0xe8c7b756,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%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
add    -0x58(%rbp),%eax
add    $0x242070db,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%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
add    -0x54(%rbp),%eax
add    $0xc1bdceee,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%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
add    -0x50(%rbp),%eax
add    $0xf57c0faf,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%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
add    -0x4c(%rbp),%eax
add    $0x4787c62a,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%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
add    -0x48(%rbp),%eax
add    $0xa8304613,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%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
add    -0x44(%rbp),%eax
add    $0xfd469501,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%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
add    -0x40(%rbp),%eax
add    $0x698098d8,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%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
add    -0x3c(%rbp),%eax
add    $0x8b44f7af,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%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
add    -0x38(%rbp),%eax
add    $0xffff5bb1,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%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
add    -0x34(%rbp),%eax
add    $0x895cd7be,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%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
add    -0x30(%rbp),%eax
add    $0x6b901122,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%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
add    -0x2c(%rbp),%eax
add    $0xfd987193,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%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
add    -0x28(%rbp),%eax
add    $0xa679438e,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%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
add    -0x24(%rbp),%eax
add    $0x49b40821,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%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
add    -0x5c(%rbp),%eax
add    $0xf61e2562,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%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
add    -0x48(%rbp),%eax
add    $0xc040b340,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%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
add    -0x34(%rbp),%eax
add    $0x265e5a51,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%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
add    -0x60(%rbp),%eax
add    $0xe9b6c7aa,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%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
add    -0x4c(%rbp),%eax
add    $0xd62f105d,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%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
add    -0x38(%rbp),%eax
add    $0x2441453,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%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
add    -0x24(%rbp),%eax
add    $0xd8a1e681,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%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
add    -0x50(%rbp),%eax
add    $0xe7d3fbc8,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%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
add    -0x3c(%rbp),%eax
add    $0x21e1cde6,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%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
add    -0x28(%rbp),%eax
add    $0xc33707d6,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%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
add    -0x54(%rbp),%eax
add    $0xf4d50d87,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%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
add    -0x40(%rbp),%eax
add    $0x455a14ed,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%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
add    -0x2c(%rbp),%eax
add    $0xa9e3e905,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%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
add    -0x58(%rbp),%eax
add    $0xfcefa3f8,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%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
add    -0x44(%rbp),%eax
add    $0x676f02d9,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%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
add    -0x30(%rbp),%eax
add    $0x8d2a4c8a,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
add    -0x4c(%rbp),%eax
add    $0xfffa3942,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
add    -0x40(%rbp),%eax
add    $0x8771f681,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
add    -0x34(%rbp),%eax
add    $0x6d9d6122,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
add    -0x28(%rbp),%eax
add    $0xfde5380c,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
add    -0x5c(%rbp),%eax
add    $0xa4beea44,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
add    -0x50(%rbp),%eax
add    $0x4bdecfa9,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
add    -0x44(%rbp),%eax
add    $0xf6bb4b60,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
add    -0x38(%rbp),%eax
add    $0xbebfbc70,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
add    -0x2c(%rbp),%eax
add    $0x289b7ec6,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
add    -0x60(%rbp),%eax
add    $0xeaa127fa,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
add    -0x54(%rbp),%eax
add    $0xd4ef3085,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
add    -0x48(%rbp),%eax
add    $0x4881d05,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
add    -0x3c(%rbp),%eax
add    $0xd9d4d039,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
add    -0x30(%rbp),%eax
add    $0xe6db99e5,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
add    -0x24(%rbp),%eax
add    $0x1fa27cf8,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
add    -0x58(%rbp),%eax
add    $0xc4ac5665,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x60(%rbp),%eax
add    $0xf4292244,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x44(%rbp),%eax
add    $0x432aff97,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x28(%rbp),%eax
add    $0xab9423a7,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x4c(%rbp),%eax
add    $0xfc93a039,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x30(%rbp),%eax
add    $0x655b59c3,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x54(%rbp),%eax
add    $0x8f0ccc92,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x38(%rbp),%eax
add    $0xffeff47d,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x5c(%rbp),%eax
add    $0x85845dd1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x40(%rbp),%eax
add    $0x6fa87e4f,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x24(%rbp),%eax
add    $0xfe2ce6e0,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x48(%rbp),%eax
add    $0xa3014314,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x2c(%rbp),%eax
add    $0x4e0811a1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x50(%rbp),%eax
add    $0xf7537e82,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x34(%rbp),%eax
add    $0xbd3af235,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x58(%rbp),%eax
add    $0x2ad7d2bb,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x3c(%rbp),%eax
add    $0xeb86d391,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
and    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
add    $0x70,%rsp
pop    %rbp
ret

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

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

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