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


x86 assembly (clang, -O0):
<seahorse_md5_transform>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%eax
add    $0xd76aa478,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
add    $0xe8c7b756,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
shr    $0x14,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
add    $0x242070db,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
shr    $0xf,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
add    $0xc1bdceee,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
shr    $0xa,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0xf57c0faf,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%eax
add    $0x4787c62a,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
shr    $0x14,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%eax
add    $0xa8304613,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
shr    $0xf,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%eax
add    $0xfd469501,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
shr    $0xa,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%eax
add    $0x698098d8,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%eax
add    $0x8b44f7af,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
shr    $0x14,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%eax
add    $0xffff5bb1,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
shr    $0xf,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%eax
add    $0x895cd7be,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
shr    $0xa,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%eax
add    $0x6b901122,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
shr    $0x19,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%eax
add    $0xfd987193,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
shr    $0x14,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%eax
add    $0xa679438e,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
shr    $0xf,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%eax
add    $0x49b40821,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
shr    $0xa,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
add    $0xf61e2562,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%eax
add    $0xc040b340,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%eax
add    $0x265e5a51,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x12,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%eax
add    $0xe9b6c7aa,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%eax
add    $0xd62f105d,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%eax
add    $0x2441453,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%eax
add    $0xd8a1e681,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x12,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0xe7d3fbc8,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%eax
add    $0x21e1cde6,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%eax
add    $0xc33707d6,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
add    $0xf4d50d87,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x12,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%eax
add    $0x455a14ed,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%eax
add    $0xa9e3e905,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1b,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
add    $0xfcefa3f8,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
shr    $0x17,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%eax
add    $0x676f02d9,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x12,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%eax
add    $0x8d2a4c8a,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
shr    $0xc,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%eax
add    $0xfffa3942,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%eax
add    $0x8771f681,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%eax
add    $0x6d9d6122,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%eax
add    $0xfde5380c,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
add    $0xa4beea44,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0x4bdecfa9,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%eax
add    $0xf6bb4b60,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%eax
add    $0xbebfbc70,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%eax
add    $0x289b7ec6,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%eax
add    $0xeaa127fa,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
add    $0xd4ef3085,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%eax
add    $0x4881d05,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%eax
add    $0xd9d4d039,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1c,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%eax
add    $0xe6db99e5,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
shr    $0x15,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%eax
add    $0x1fa27cf8,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x10,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
add    $0xc4ac5665,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
shr    $0x9,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%eax
add    $0xf4292244,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%eax
add    $0x432aff97,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%eax
add    $0xab9423a7,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%eax
add    $0xfc93a039,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%eax
add    $0x655b59c3,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
add    $0x8f0ccc92,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%eax
add    $0xffeff47d,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
add    $0x85845dd1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%eax
add    $0x6fa87e4f,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%eax
add    $0xfe2ce6e0,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%eax
add    $0xa3014314,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%eax
add    $0x4e0811a1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0xf7537e82,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
shr    $0x1a,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%eax
add    $0xbd3af235,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
shr    $0x16,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
add    $0x2ad7d2bb,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x11,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%eax
add    $0xeb86d391,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
shr    $0xb,%ecx
or     %ecx,%eax
add    -0x1c(%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)
pop    %rbp
ret

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

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

LLVM IR (-O2):
define void @seahorse_md5_transform(i32* nocapture %0, i32* nocapture %1) {
%3 = load i32, i32* %0
%4 = getelementptr inbounds i32, i32* %0, i64 1
%5 = load i32, i32* %4
%6 = getelementptr inbounds i32, i32* %0, i64 2
%7 = load i32, i32* %6
%8 = getelementptr inbounds i32, i32* %0, i64 3
%9 = load i32, i32* %8
%10 = xor i32 %9, %7
%11 = and i32 %10, %5
%12 = xor i32 %11, %9
%13 = load i32, i32* %1
%14 = add i32 %3, -680876936
%15 = add i32 %14, %13
%16 = add i32 %15, %12
%17 = tail call i32 @llvm.fshl.i32(i32 %16, i32 %16, i32 7)
%18 = add i32 %17, %5
%19 = xor i32 %7, %5
%20 = and i32 %18, %19
%21 = xor i32 %20, %7
%22 = getelementptr inbounds i32, i32* %1, i64 1
%23 = load i32, i32* %22
%24 = add i32 %9, -389564586
%25 = add i32 %24, %23
%26 = add i32 %25, %21
%27 = tail call i32 @llvm.fshl.i32(i32 %26, i32 %26, i32 12)
%28 = add i32 %27, %18
%29 = xor i32 %18, %5
%30 = and i32 %28, %29
%31 = xor i32 %30, %5
%32 = getelementptr inbounds i32, i32* %1, i64 2
%33 = load i32, i32* %32
%34 = add i32 %7, 606105819
%35 = add i32 %34, %33
%36 = add i32 %35, %31
%37 = tail call i32 @llvm.fshl.i32(i32 %36, i32 %36, i32 17)
%38 = add i32 %37, %28
%39 = xor i32 %28, %18
%40 = and i32 %38, %39
%41 = xor i32 %40, %18
%42 = getelementptr inbounds i32, i32* %1, i64 3
%43 = load i32, i32* %42
%44 = add i32 %5, -1044525330
%45 = add i32 %44, %43
%46 = add i32 %45, %41
%47 = tail call i32 @llvm.fshl.i32(i32 %46, i32 %46, i32 22)
%48 = add i32 %47, %38
%49 = xor i32 %38, %28
%50 = and i32 %48, %49
%51 = xor i32 %50, %28
%52 = getelementptr inbounds i32, i32* %1, i64 4
%53 = load i32, i32* %52
%54 = add i32 %53, -176418897
%55 = add i32 %54, %18
%56 = add i32 %55, %51
%57 = tail call i32 @llvm.fshl.i32(i32 %56, i32 %56, i32 7)
%58 = add i32 %57, %48
%59 = xor i32 %48, %38
%60 = and i32 %58, %59
%61 = xor i32 %60, %38
%62 = getelementptr inbounds i32, i32* %1, i64 5
%63 = load i32, i32* %62
%64 = add i32 %63, 1200080426
%65 = add i32 %64, %28
%66 = add i32 %65, %61
%67 = tail call i32 @llvm.fshl.i32(i32 %66, i32 %66, i32 12)
%68 = add i32 %67, %58
%69 = xor i32 %58, %48
%70 = and i32 %68, %69
%71 = xor i32 %70, %48
%72 = getelementptr inbounds i32, i32* %1, i64 6
%73 = load i32, i32* %72
%74 = add i32 %73, -1473231341
%75 = add i32 %74, %38
%76 = add i32 %75, %71
%77 = tail call i32 @llvm.fshl.i32(i32 %76, i32 %76, i32 17)
%78 = add i32 %77, %68
%79 = xor i32 %68, %58
%80 = and i32 %78, %79
%81 = xor i32 %80, %58
%82 = getelementptr inbounds i32, i32* %1, i64 7
%83 = load i32, i32* %82
%84 = add i32 %83, -45705983
%85 = add i32 %84, %48
%86 = add i32 %85, %81
%87 = tail call i32 @llvm.fshl.i32(i32 %86, i32 %86, i32 22)
%88 = add i32 %87, %78
%89 = xor i32 %78, %68
%90 = and i32 %88, %89
%91 = xor i32 %90, %68
%92 = getelementptr inbounds i32, i32* %1, i64 8
%93 = load i32, i32* %92
%94 = add i32 %93, 1770035416
%95 = add i32 %94, %58
%96 = add i32 %95, %91
%97 = tail call i32 @llvm.fshl.i32(i32 %96, i32 %96, i32 7)
%98 = add i32 %97, %88
%99 = xor i32 %88, %78
%100 = and i32 %98, %99
%101 = xor i32 %100, %78
%102 = getelementptr inbounds i32, i32* %1, i64 9
%103 = load i32, i32* %102
%104 = add i32 %103, -1958414417
%105 = add i32 %104, %68
%106 = add i32 %105, %101
%107 = tail call i32 @llvm.fshl.i32(i32 %106, i32 %106, i32 12)
%108 = add i32 %107, %98
%109 = xor i32 %98, %88
%110 = and i32 %108, %109
%111 = xor i32 %110, %88
%112 = getelementptr inbounds i32, i32* %1, i64 10
%113 = load i32, i32* %112
%114 = add i32 %113, -42063
%115 = add i32 %114, %78
%116 = add i32 %115, %111
%117 = tail call i32 @llvm.fshl.i32(i32 %116, i32 %116, i32 17)
%118 = add i32 %117, %108
%119 = xor i32 %108, %98
%120 = and i32 %118, %119
%121 = xor i32 %120, %98
%122 = getelementptr inbounds i32, i32* %1, i64 11
%123 = load i32, i32* %122
%124 = add i32 %123, -1990404162
%125 = add i32 %124, %88
%126 = add i32 %125, %121
%127 = tail call i32 @llvm.fshl.i32(i32 %126, i32 %126, i32 22)
%128 = add i32 %127, %118
%129 = xor i32 %118, %108
%130 = and i32 %128, %129
%131 = xor i32 %130, %108
%132 = getelementptr inbounds i32, i32* %1, i64 12
%133 = load i32, i32* %132
%134 = add i32 %133, 1804603682
%135 = add i32 %134, %98
%136 = add i32 %135, %131
%137 = tail call i32 @llvm.fshl.i32(i32 %136, i32 %136, i32 7)
%138 = add i32 %137, %128
%139 = xor i32 %128, %118
%140 = and i32 %138, %139
%141 = xor i32 %140, %118
%142 = getelementptr inbounds i32, i32* %1, i64 13
%143 = load i32, i32* %142
%144 = add i32 %143, -40341101
%145 = add i32 %144, %108
%146 = add i32 %145, %141
%147 = tail call i32 @llvm.fshl.i32(i32 %146, i32 %146, i32 12)
%148 = add i32 %147, %138
%149 = xor i32 %138, %128
%150 = and i32 %148, %149
%151 = xor i32 %150, %128
%152 = getelementptr inbounds i32, i32* %1, i64 14
%153 = load i32, i32* %152
%154 = add i32 %153, -1502002290
%155 = add i32 %154, %118
%156 = add i32 %155, %151
%157 = tail call i32 @llvm.fshl.i32(i32 %156, i32 %156, i32 17)
%158 = add i32 %157, %148
%159 = xor i32 %148, %138
%160 = and i32 %158, %159
%161 = xor i32 %160, %138
%162 = getelementptr inbounds i32, i32* %1, i64 15
%163 = load i32, i32* %162
%164 = add i32 %163, 1236535329
%165 = add i32 %164, %128
%166 = add i32 %165, %161
%167 = tail call i32 @llvm.fshl.i32(i32 %166, i32 %166, i32 22)
%168 = add i32 %167, %158
%169 = xor i32 %168, %158
%170 = and i32 %169, %148
%171 = xor i32 %170, %158
%172 = add i32 %23, -165796510
%173 = add i32 %172, %138
%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, %158
%179 = xor i32 %178, %168
%180 = add i32 %73, -1069501632
%181 = add i32 %180, %148
%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 %123, 643717713
%189 = add i32 %188, %158
%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 %13, -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 %63, -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 %113, 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 %163, -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 %53, -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 %103, 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 %153, -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 %43, -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 %93, 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 %143, -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 %33, -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 %83, 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 %133, -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 %63, -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 %93, -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 %123, 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 %153, -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 %23, -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 %53, 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 %83, -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 %113, -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 %143, 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 %13, -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 %43, -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 %73, 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 %103, -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 %133, -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 %163, 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 %33, -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 %13, -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 %83, 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 %153, -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 %63, -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 %133, 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 %43, -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 %113, -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 %23, -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 %93, 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 %163, -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 %73, -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 %143, 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 %53, -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 %123, -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 %33, 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 %103, -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, %3
store i32 %535, i32* %0
%536 = add i32 %527, %5
%537 = add i32 %536, %534
store i32 %537, i32* %4
%538 = add i32 %527, %7
store i32 %538, i32* %6
%539 = add i32 %519, %9
store i32 %539, i32* %8
ret void
}