#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 int uint32_t;

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


x86 assembly (clang, -O0):
<md5_transform>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%eax
add    $0xd76aa478,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
sar    $0x19,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    116d <md5_transform+0x6d>
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
add    $0xe8c7b756,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
sar    $0x14,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    11a8 <md5_transform+0xa8>
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
add    $0x242070db,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
sar    $0xf,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    11e3 <md5_transform+0xe3>
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
add    $0xc1bdceee,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
sar    $0xa,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    121e <md5_transform+0x11e>
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0xf57c0faf,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
sar    $0x19,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1259 <md5_transform+0x159>
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%eax
add    $0x4787c62a,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
sar    $0x14,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1294 <md5_transform+0x194>
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%eax
add    $0xa8304613,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
sar    $0xf,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    12cf <md5_transform+0x1cf>
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%eax
add    $0xfd469501,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
sar    $0xa,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    130a <md5_transform+0x20a>
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%eax
add    $0x698098d8,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
sar    $0x19,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1345 <md5_transform+0x245>
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%eax
add    $0x8b44f7af,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
sar    $0x14,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1380 <md5_transform+0x280>
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%eax
add    $0xffff5bb1,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
sar    $0xf,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    13bb <md5_transform+0x2bb>
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%eax
add    $0x895cd7be,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
sar    $0xa,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    13f6 <md5_transform+0x2f6>
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%eax
add    $0x6b901122,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x7,%eax
mov    -0x14(%rbp),%ecx
sar    $0x19,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1431 <md5_transform+0x331>
mov    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%eax
add    $0xfd987193,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xc,%eax
mov    -0x20(%rbp),%ecx
sar    $0x14,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    146c <md5_transform+0x36c>
mov    -0x18(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%eax
add    $0xa679438e,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x11,%eax
mov    -0x1c(%rbp),%ecx
sar    $0xf,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    14a7 <md5_transform+0x3a7>
mov    -0x14(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%eax
add    $0x49b40821,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x16,%eax
mov    -0x18(%rbp),%ecx
sar    $0xa,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    14e2 <md5_transform+0x3e2>
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
add    $0xf61e2562,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    151d <md5_transform+0x41d>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%eax
add    $0xc040b340,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
sar    $0x17,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1558 <md5_transform+0x458>
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%eax
add    $0x265e5a51,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x12,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1593 <md5_transform+0x493>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%eax
add    $0xe9b6c7aa,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    15cd <md5_transform+0x4cd>
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%eax
add    $0xd62f105d,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1608 <md5_transform+0x508>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%eax
add    $0x2441453,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
sar    $0x17,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1643 <md5_transform+0x543>
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%eax
add    $0xd8a1e681,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x12,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    167e <md5_transform+0x57e>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0xe7d3fbc8,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    16b9 <md5_transform+0x5b9>
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%eax
add    $0x21e1cde6,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    16f4 <md5_transform+0x5f4>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%eax
add    $0xc33707d6,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
sar    $0x17,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    172f <md5_transform+0x62f>
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
add    $0xf4d50d87,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x12,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    176a <md5_transform+0x66a>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%eax
add    $0x455a14ed,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    17a5 <md5_transform+0x6a5>
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    -0x1c(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%eax
add    $0xa9e3e905,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x5,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    17e0 <md5_transform+0x6e0>
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    -0x18(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
add    $0xfcefa3f8,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x9,%eax
mov    -0x20(%rbp),%ecx
sar    $0x17,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    181b <md5_transform+0x71b>
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    -0x14(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%eax
add    $0x676f02d9,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xe,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x12,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1856 <md5_transform+0x756>
mov    -0x20(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    -0x20(%rbp),%edx
and    %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%eax
add    $0x8d2a4c8a,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x14,%eax
mov    -0x18(%rbp),%ecx
sar    $0xc,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1891 <md5_transform+0x791>
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%eax
add    $0xfffa3942,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    18c5 <md5_transform+0x7c5>
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%eax
add    $0x8771f681,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
sar    $0x15,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    18f9 <md5_transform+0x7f9>
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%eax
add    $0x6d9d6122,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    192d <md5_transform+0x82d>
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%eax
add    $0xfde5380c,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
sar    $0x9,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1961 <md5_transform+0x861>
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
add    $0xa4beea44,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1995 <md5_transform+0x895>
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0x4bdecfa9,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
sar    $0x15,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    19c9 <md5_transform+0x8c9>
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%eax
add    $0xf6bb4b60,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    19fd <md5_transform+0x8fd>
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%eax
add    $0xbebfbc70,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
sar    $0x9,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1a31 <md5_transform+0x931>
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%eax
add    $0x289b7ec6,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1a65 <md5_transform+0x965>
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%eax
add    $0xeaa127fa,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
sar    $0x15,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1a98 <md5_transform+0x998>
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
add    $0xd4ef3085,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1acc <md5_transform+0x9cc>
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%eax
add    $0x4881d05,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
sar    $0x9,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1b00 <md5_transform+0xa00>
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%eax
add    $0xd9d4d039,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x4,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1b34 <md5_transform+0xa34>
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%eax
add    $0xe6db99e5,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xb,%eax
mov    -0x20(%rbp),%ecx
sar    $0x15,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1b68 <md5_transform+0xa68>
mov    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%eax
add    $0x1fa27cf8,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1b9c <md5_transform+0xa9c>
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
add    $0xc4ac5665,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x17,%eax
mov    -0x18(%rbp),%ecx
sar    $0x9,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1bd0 <md5_transform+0xad0>
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    (%rcx),%eax
add    $0xf4292244,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1c0a <md5_transform+0xb0a>
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x1c(%rcx),%eax
add    $0x432aff97,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
sar    $0x16,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1c45 <md5_transform+0xb45>
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x38(%rcx),%eax
add    $0xab9423a7,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x11,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1c80 <md5_transform+0xb80>
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x14(%rcx),%eax
add    $0xfc93a039,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
sar    $0xb,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1cbb <md5_transform+0xbbb>
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x30(%rcx),%eax
add    $0x655b59c3,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1cf6 <md5_transform+0xbf6>
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0xc(%rcx),%eax
add    $0x8f0ccc92,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
sar    $0x16,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1d31 <md5_transform+0xc31>
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x28(%rcx),%eax
add    $0xffeff47d,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x11,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1d6c <md5_transform+0xc6c>
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x4(%rcx),%eax
add    $0x85845dd1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
sar    $0xb,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1da7 <md5_transform+0xca7>
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x20(%rcx),%eax
add    $0x6fa87e4f,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1de2 <md5_transform+0xce2>
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x3c(%rcx),%eax
add    $0xfe2ce6e0,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
sar    $0x16,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1e1d <md5_transform+0xd1d>
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x18(%rcx),%eax
add    $0xa3014314,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x11,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1e58 <md5_transform+0xd58>
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x34(%rcx),%eax
add    $0x4e0811a1,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
sar    $0xb,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    1e93 <md5_transform+0xd93>
mov    -0x1c(%rbp),%eax
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x10(%rcx),%eax
add    $0xf7537e82,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x6,%eax
mov    -0x14(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1ece <md5_transform+0xdce>
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
mov    -0x1c(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x2c(%rcx),%eax
add    $0xbd3af235,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xa,%eax
mov    -0x20(%rbp),%ecx
sar    $0x16,%ecx
or     %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1f09 <md5_transform+0xe09>
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x8(%rcx),%eax
add    $0x2ad7d2bb,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0xf,%eax
mov    -0x1c(%rbp),%ecx
sar    $0x11,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    1f44 <md5_transform+0xe44>
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%edx
xor    $0xffffffff,%edx
or     %edx,%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
add    0x24(%rcx),%eax
add    $0xeb86d391,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x15,%eax
mov    -0x18(%rbp),%ecx
sar    $0xb,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
pop    %rbp
ret

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

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

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