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

/* Forward declarations */

/* Type definitions */
typedef scalar_t__ uint8_t;
typedef int uint32_t;
typedef int d;
typedef int c;
typedef int b;
typedef int a;

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


x86 assembly (clang, -O0):
<_nettle_md5_compress>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x64(%rbp)
cmpl   $0x10,-0x64(%rbp)
jae    116e <_nettle_md5_compress+0x6e>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
mov    %eax,%ecx
shl    $0x18,%ecx
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x8,%eax
or     %eax,%ecx
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
or     %eax,%ecx
mov    -0x64(%rbp),%eax
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
jmp    1113 <_nettle_md5_compress+0x13>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    -0x60(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x50(%rbp),%eax
add    $0xd76aa478,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x7,%eax
mov    -0x54(%rbp),%ecx
sar    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    -0x5c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x4c(%rbp),%eax
add    $0xe8c7b756,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xc,%eax
mov    -0x60(%rbp),%ecx
sar    $0x14,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    -0x58(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x48(%rbp),%eax
add    $0x242070db,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0x11,%eax
mov    -0x5c(%rbp),%ecx
sar    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    -0x54(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x44(%rbp),%eax
add    $0xc1bdceee,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x16,%eax
mov    -0x58(%rbp),%ecx
sar    $0xa,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    -0x60(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x40(%rbp),%eax
add    $0xf57c0faf,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x7,%eax
mov    -0x54(%rbp),%ecx
sar    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    -0x5c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x3c(%rbp),%eax
add    $0x4787c62a,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xc,%eax
mov    -0x60(%rbp),%ecx
sar    $0x14,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    -0x58(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x38(%rbp),%eax
add    $0xa8304613,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0x11,%eax
mov    -0x5c(%rbp),%ecx
sar    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    -0x54(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x34(%rbp),%eax
add    $0xfd469501,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x16,%eax
mov    -0x58(%rbp),%ecx
sar    $0xa,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    -0x60(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x30(%rbp),%eax
add    $0x698098d8,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x7,%eax
mov    -0x54(%rbp),%ecx
sar    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    -0x5c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x2c(%rbp),%eax
add    $0x8b44f7af,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xc,%eax
mov    -0x60(%rbp),%ecx
sar    $0x14,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    -0x58(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x28(%rbp),%eax
add    $0xffff5bb1,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0x11,%eax
mov    -0x5c(%rbp),%ecx
sar    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    -0x54(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x24(%rbp),%eax
add    $0x895cd7be,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x16,%eax
mov    -0x58(%rbp),%ecx
sar    $0xa,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    -0x60(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x20(%rbp),%eax
add    $0x6b901122,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x7,%eax
mov    -0x54(%rbp),%ecx
sar    $0x19,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    -0x5c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x1c(%rbp),%eax
add    $0xfd987193,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xc,%eax
mov    -0x60(%rbp),%ecx
sar    $0x14,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    -0x58(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x18(%rbp),%eax
add    $0xa679438e,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0x11,%eax
mov    -0x5c(%rbp),%ecx
sar    $0xf,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    -0x54(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x14(%rbp),%eax
add    $0x49b40821,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x16,%eax
mov    -0x58(%rbp),%ecx
sar    $0xa,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    -0x5c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x4c(%rbp),%eax
add    $0xf61e2562,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x5,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    -0x58(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x38(%rbp),%eax
add    $0xc040b340,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0x9,%eax
mov    -0x60(%rbp),%ecx
sar    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    -0x54(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x24(%rbp),%eax
add    $0x265e5a51,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0xe,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x12,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    -0x60(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x50(%rbp),%eax
add    $0xe9b6c7aa,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x14,%eax
mov    -0x58(%rbp),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    -0x5c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x3c(%rbp),%eax
add    $0xd62f105d,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x5,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    -0x58(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x28(%rbp),%eax
add    $0x2441453,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0x9,%eax
mov    -0x60(%rbp),%ecx
sar    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    -0x54(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x14(%rbp),%eax
add    $0xd8a1e681,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0xe,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x12,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    -0x60(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x40(%rbp),%eax
add    $0xe7d3fbc8,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x14,%eax
mov    -0x58(%rbp),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    -0x5c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x2c(%rbp),%eax
add    $0x21e1cde6,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x5,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    -0x58(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x18(%rbp),%eax
add    $0xc33707d6,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0x9,%eax
mov    -0x60(%rbp),%ecx
sar    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    -0x54(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x44(%rbp),%eax
add    $0xf4d50d87,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0xe,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x12,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    -0x60(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x30(%rbp),%eax
add    $0x455a14ed,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x14,%eax
mov    -0x58(%rbp),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    -0x5c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x1c(%rbp),%eax
add    $0xa9e3e905,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x5,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    -0x58(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x48(%rbp),%eax
add    $0xfcefa3f8,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0x9,%eax
mov    -0x60(%rbp),%ecx
sar    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    -0x54(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x34(%rbp),%eax
add    $0x676f02d9,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0xe,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x12,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    -0x60(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
add    -0x20(%rbp),%eax
add    $0x8d2a4c8a,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x14,%eax
mov    -0x58(%rbp),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x5c(%rbp),%eax
xor    -0x60(%rbp),%eax
add    -0x3c(%rbp),%eax
add    $0xfffa3942,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x4,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
xor    -0x58(%rbp),%eax
xor    -0x5c(%rbp),%eax
add    -0x30(%rbp),%eax
add    $0x8771f681,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xb,%eax
mov    -0x60(%rbp),%ecx
sar    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
xor    -0x54(%rbp),%eax
xor    -0x58(%rbp),%eax
add    -0x24(%rbp),%eax
add    $0x6d9d6122,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0x10,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
xor    -0x60(%rbp),%eax
xor    -0x54(%rbp),%eax
add    -0x18(%rbp),%eax
add    $0xfde5380c,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x17,%eax
mov    -0x58(%rbp),%ecx
sar    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x5c(%rbp),%eax
xor    -0x60(%rbp),%eax
add    -0x4c(%rbp),%eax
add    $0xa4beea44,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x4,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
xor    -0x58(%rbp),%eax
xor    -0x5c(%rbp),%eax
add    -0x40(%rbp),%eax
add    $0x4bdecfa9,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xb,%eax
mov    -0x60(%rbp),%ecx
sar    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
xor    -0x54(%rbp),%eax
xor    -0x58(%rbp),%eax
add    -0x34(%rbp),%eax
add    $0xf6bb4b60,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0x10,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
xor    -0x60(%rbp),%eax
xor    -0x54(%rbp),%eax
add    -0x28(%rbp),%eax
add    $0xbebfbc70,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x17,%eax
mov    -0x58(%rbp),%ecx
sar    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x5c(%rbp),%eax
xor    -0x60(%rbp),%eax
add    -0x1c(%rbp),%eax
add    $0x289b7ec6,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x4,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
xor    -0x58(%rbp),%eax
xor    -0x5c(%rbp),%eax
add    -0x50(%rbp),%eax
add    $0xeaa127fa,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xb,%eax
mov    -0x60(%rbp),%ecx
sar    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
xor    -0x54(%rbp),%eax
xor    -0x58(%rbp),%eax
add    -0x44(%rbp),%eax
add    $0xd4ef3085,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0x10,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
xor    -0x60(%rbp),%eax
xor    -0x54(%rbp),%eax
add    -0x38(%rbp),%eax
add    $0x4881d05,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x17,%eax
mov    -0x58(%rbp),%ecx
sar    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x5c(%rbp),%eax
xor    -0x60(%rbp),%eax
add    -0x2c(%rbp),%eax
add    $0xd9d4d039,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x4,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
xor    -0x58(%rbp),%eax
xor    -0x5c(%rbp),%eax
add    -0x20(%rbp),%eax
add    $0xe6db99e5,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xb,%eax
mov    -0x60(%rbp),%ecx
sar    $0x15,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
xor    -0x54(%rbp),%eax
xor    -0x58(%rbp),%eax
add    -0x14(%rbp),%eax
add    $0x1fa27cf8,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0x10,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
xor    -0x60(%rbp),%eax
xor    -0x54(%rbp),%eax
add    -0x48(%rbp),%eax
add    $0xc4ac5665,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x17,%eax
mov    -0x58(%rbp),%ecx
sar    $0x9,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x50(%rbp),%eax
add    $0xf4292244,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x6,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x34(%rbp),%eax
add    $0x432aff97,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xa,%eax
mov    -0x60(%rbp),%ecx
sar    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x18(%rbp),%eax
add    $0xab9423a7,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0xf,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x3c(%rbp),%eax
add    $0xfc93a039,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x15,%eax
mov    -0x58(%rbp),%ecx
sar    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x20(%rbp),%eax
add    $0x655b59c3,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x6,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x44(%rbp),%eax
add    $0x8f0ccc92,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xa,%eax
mov    -0x60(%rbp),%ecx
sar    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x28(%rbp),%eax
add    $0xffeff47d,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0xf,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x4c(%rbp),%eax
add    $0x85845dd1,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x15,%eax
mov    -0x58(%rbp),%ecx
sar    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x30(%rbp),%eax
add    $0x6fa87e4f,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x6,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x14(%rbp),%eax
add    $0xfe2ce6e0,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xa,%eax
mov    -0x60(%rbp),%ecx
sar    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x38(%rbp),%eax
add    $0xa3014314,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0xf,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x1c(%rbp),%eax
add    $0x4e0811a1,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x15,%eax
mov    -0x58(%rbp),%ecx
sar    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x58(%rbp),%ecx
mov    -0x60(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x40(%rbp),%eax
add    $0xf7537e82,%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
shl    $0x6,%eax
mov    -0x54(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x54(%rbp),%ecx
mov    -0x5c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x24(%rbp),%eax
add    $0xbd3af235,%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
shl    $0xa,%eax
mov    -0x60(%rbp),%ecx
sar    $0x16,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x54(%rbp),%eax
mov    -0x60(%rbp),%ecx
mov    -0x58(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x48(%rbp),%eax
add    $0x2ad7d2bb,%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
shl    $0xf,%eax
mov    -0x5c(%rbp),%ecx
sar    $0x11,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
add    -0x5c(%rbp),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x60(%rbp),%eax
mov    -0x5c(%rbp),%ecx
mov    -0x54(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
add    -0x2c(%rbp),%eax
add    $0xeb86d391,%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
shl    $0x15,%eax
mov    -0x58(%rbp),%ecx
sar    $0xb,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x5c(%rbp),%eax
add    -0x58(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x54(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x58(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x5c(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x60(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
pop    %rbp
ret

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

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

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