#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 unsigned char uint32_t;
typedef int d;
typedef int c;
typedef int b;
typedef int a;
typedef int /*<<< orphan*/ X;
typedef int /*<<< orphan*/ M;

/* Variables and functions */
scalar_t__ F(unsigned char, unsigned char, unsigned char);
scalar_t__ G(unsigned char, unsigned char, unsigned char);
scalar_t__ H(unsigned char, unsigned char, unsigned char);
scalar_t__ I(unsigned char, unsigned char, unsigned char);
scalar_t__ LEFT_ROTATE(int, int);
int /*<<< orphan*/ bzero(unsigned char *, int);
int /*<<< orphan*/ memcpy(void *, unsigned char *, int);
void md5(void *digest, const void *in, size_t len) {
  size_t n = len * 8 / 512 + 1;
  uint32_t M[(n + 1) * 16];
  bzero(M, sizeof(M));
  for (size_t i = 0; i < len; i++) {
    M[i / 4] |= ((unsigned char *)in)[i] << 8 * ((i % 4));
  }
  M[len / 4] |= 0x80 << 8 * ((len % 4));
  M[n * 16 - 2] = len * 8;
  uint32_t state[4] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476};
  for (size_t i = 0; i < n; i++) {
    uint32_t X[16];
    uint32_t a, b, c, d;
    for (int j = 0; j < 16; j++) {
      X[j] = M[i * 16 + j];
    }
    a = state[0];
    b = state[1];
    c = state[2];
    d = state[3];
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + F((b), (c), (d)) + (X[0]) + (0xd76aa478), 7);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + F((a), (b), (c)) + (X[1]) + (0xe8c7b756), 12);
    } while (0);
    do {
      (c) =
          (d) + LEFT_ROTATE((c) + F((d), (a), (b)) + (X[2]) + (0x242070db), 17);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + F((c), (d), (a)) + (X[3]) + (0xc1bdceee), 22);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + F((b), (c), (d)) + (X[4]) + (0xf57c0faf), 7);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + F((a), (b), (c)) + (X[5]) + (0x4787c62a), 12);
    } while (0);
    do {
      (c) =
          (d) + LEFT_ROTATE((c) + F((d), (a), (b)) + (X[6]) + (0xa8304613), 17);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + F((c), (d), (a)) + (X[7]) + (0xfd469501), 22);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + F((b), (c), (d)) + (X[8]) + (0x698098d8), 7);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + F((a), (b), (c)) + (X[9]) + (0x8b44f7af), 12);
    } while (0);
    do {
      (c) = (d) +
            LEFT_ROTATE((c) + F((d), (a), (b)) + (X[10]) + (0xffff5bb1), 17);
    } while (0);
    do {
      (b) = (c) +
            LEFT_ROTATE((b) + F((c), (d), (a)) + (X[11]) + (0x895cd7be), 22);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + F((b), (c), (d)) + (X[12]) + (0x6b901122), 7);
    } while (0);
    do {
      (d) = (a) +
            LEFT_ROTATE((d) + F((a), (b), (c)) + (X[13]) + (0xfd987193), 12);
    } while (0);
    do {
      (c) = (d) +
            LEFT_ROTATE((c) + F((d), (a), (b)) + (X[14]) + (0xa679438e), 17);
    } while (0);
    do {
      (b) = (c) +
            LEFT_ROTATE((b) + F((c), (d), (a)) + (X[15]) + (0x49b40821), 22);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + G((b), (c), (d)) + (X[1]) + (0xf61e2562), 5);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + G((a), (b), (c)) + (X[6]) + (0xc040b340), 9);
    } while (0);
    do {
      (c) = (d) +
            LEFT_ROTATE((c) + G((d), (a), (b)) + (X[11]) + (0x265e5a51), 14);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + G((c), (d), (a)) + (X[0]) + (0xe9b6c7aa), 20);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + G((b), (c), (d)) + (X[5]) + (0xd62f105d), 5);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + G((a), (b), (c)) + (X[10]) + (0x02441453), 9);
    } while (0);
    do {
      (c) = (d) +
            LEFT_ROTATE((c) + G((d), (a), (b)) + (X[15]) + (0xd8a1e681), 14);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + G((c), (d), (a)) + (X[4]) + (0xe7d3fbc8), 20);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + G((b), (c), (d)) + (X[9]) + (0x21e1cde6), 5);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + G((a), (b), (c)) + (X[14]) + (0xc33707d6), 9);
    } while (0);
    do {
      (c) =
          (d) + LEFT_ROTATE((c) + G((d), (a), (b)) + (X[3]) + (0xf4d50d87), 14);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + G((c), (d), (a)) + (X[8]) + (0x455a14ed), 20);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + G((b), (c), (d)) + (X[13]) + (0xa9e3e905), 5);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + G((a), (b), (c)) + (X[2]) + (0xfcefa3f8), 9);
    } while (0);
    do {
      (c) =
          (d) + LEFT_ROTATE((c) + G((d), (a), (b)) + (X[7]) + (0x676f02d9), 14);
    } while (0);
    do {
      (b) = (c) +
            LEFT_ROTATE((b) + G((c), (d), (a)) + (X[12]) + (0x8d2a4c8a), 20);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + H((b), (c), (d)) + (X[5]) + (0xfffa3942), 4);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + H((a), (b), (c)) + (X[8]) + (0x8771f681), 11);
    } while (0);
    do {
      (c) = (d) +
            LEFT_ROTATE((c) + H((d), (a), (b)) + (X[11]) + (0x6d9d6122), 16);
    } while (0);
    do {
      (b) = (c) +
            LEFT_ROTATE((b) + H((c), (d), (a)) + (X[14]) + (0xfde5380c), 23);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + H((b), (c), (d)) + (X[1]) + (0xa4beea44), 4);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + H((a), (b), (c)) + (X[4]) + (0x4bdecfa9), 11);
    } while (0);
    do {
      (c) =
          (d) + LEFT_ROTATE((c) + H((d), (a), (b)) + (X[7]) + (0xf6bb4b60), 16);
    } while (0);
    do {
      (b) = (c) +
            LEFT_ROTATE((b) + H((c), (d), (a)) + (X[10]) + (0xbebfbc70), 23);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + H((b), (c), (d)) + (X[13]) + (0x289b7ec6), 4);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + H((a), (b), (c)) + (X[0]) + (0xeaa127fa), 11);
    } while (0);
    do {
      (c) =
          (d) + LEFT_ROTATE((c) + H((d), (a), (b)) + (X[3]) + (0xd4ef3085), 16);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + H((c), (d), (a)) + (X[6]) + (0x04881d05), 23);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + H((b), (c), (d)) + (X[9]) + (0xd9d4d039), 4);
    } while (0);
    do {
      (d) = (a) +
            LEFT_ROTATE((d) + H((a), (b), (c)) + (X[12]) + (0xe6db99e5), 11);
    } while (0);
    do {
      (c) = (d) +
            LEFT_ROTATE((c) + H((d), (a), (b)) + (X[15]) + (0x1fa27cf8), 16);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + H((c), (d), (a)) + (X[2]) + (0xc4ac5665), 23);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + I((b), (c), (d)) + (X[0]) + (0xf4292244), 6);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + I((a), (b), (c)) + (X[7]) + (0x432aff97), 10);
    } while (0);
    do {
      (c) = (d) +
            LEFT_ROTATE((c) + I((d), (a), (b)) + (X[14]) + (0xab9423a7), 15);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + I((c), (d), (a)) + (X[5]) + (0xfc93a039), 21);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + I((b), (c), (d)) + (X[12]) + (0x655b59c3), 6);
    } while (0);
    do {
      (d) =
          (a) + LEFT_ROTATE((d) + I((a), (b), (c)) + (X[3]) + (0x8f0ccc92), 10);
    } while (0);
    do {
      (c) = (d) +
            LEFT_ROTATE((c) + I((d), (a), (b)) + (X[10]) + (0xffeff47d), 15);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + I((c), (d), (a)) + (X[1]) + (0x85845dd1), 21);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + I((b), (c), (d)) + (X[8]) + (0x6fa87e4f), 6);
    } while (0);
    do {
      (d) = (a) +
            LEFT_ROTATE((d) + I((a), (b), (c)) + (X[15]) + (0xfe2ce6e0), 10);
    } while (0);
    do {
      (c) =
          (d) + LEFT_ROTATE((c) + I((d), (a), (b)) + (X[6]) + (0xa3014314), 15);
    } while (0);
    do {
      (b) = (c) +
            LEFT_ROTATE((b) + I((c), (d), (a)) + (X[13]) + (0x4e0811a1), 21);
    } while (0);
    do {
      (a) =
          (b) + LEFT_ROTATE((a) + I((b), (c), (d)) + (X[4]) + (0xf7537e82), 6);
    } while (0);
    do {
      (d) = (a) +
            LEFT_ROTATE((d) + I((a), (b), (c)) + (X[11]) + (0xbd3af235), 10);
    } while (0);
    do {
      (c) =
          (d) + LEFT_ROTATE((c) + I((d), (a), (b)) + (X[2]) + (0x2ad7d2bb), 15);
    } while (0);
    do {
      (b) =
          (c) + LEFT_ROTATE((b) + I((c), (d), (a)) + (X[9]) + (0xeb86d391), 21);
    } while (0);
    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;
  }
  if (digest != NULL) {
    memcpy(digest, state, sizeof(uint32_t) * 4);
  }
}


x86 assembly (clang, -O0):
<md5>:
push   %rbp
mov    %rsp,%rbp
sub    $0x470,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
shl    $0x3,%rax
shr    $0x9,%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
shl    $0x4,%rax
add    $0x10,%rax
mov    %rsp,%rcx
mov    %rcx,-0x28(%rbp)
mov    %rsp,%rdi
sub    %rax,%rdi
mov    %rdi,-0x70(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x30(%rbp)
mov    %eax,%esi
call   1080 <bzero@plt>
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    121c <md5+0xac>
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x38(%rbp),%rdx
movzbl (%rcx,%rdx,1),%esi
mov    -0x38(%rbp),%rcx
and    $0x3,%rcx
shl    $0x3,%rcx
shl    %cl,%esi
mov    -0x38(%rbp),%rcx
shr    $0x2,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    11ce <md5+0x5e>
mov    -0x70(%rbp),%rax
mov    -0x18(%rbp),%rcx
and    $0x3,%rcx
shl    $0x3,%rcx
mov    $0x80,%esi
shl    %cl,%esi
mov    -0x18(%rbp),%rcx
shr    $0x2,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
mov    %cl,%dl
mov    -0x20(%rbp),%rcx
shl    $0x4,%rcx
sub    $0x2,%rcx
mov    %dl,(%rax,%rcx,1)
mov    0x1d9d(%rip),%eax
mov    %eax,-0x3c(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    2ef9 <md5+0x1d89>
movl   $0x0,-0x68(%rbp)
cmpl   $0x10,-0x68(%rbp)
jge    12b9 <md5+0x149>
mov    -0x70(%rbp),%rax
mov    -0x48(%rbp),%rcx
shl    $0x4,%rcx
movslq -0x68(%rbp),%rdx
add    %rdx,%rcx
mov    (%rax,%rcx,1),%cl
movslq -0x68(%rbp),%rax
mov    %cl,-0x60(%rbp,%rax,1)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1283 <md5+0x113>
mov    -0x3c(%rbp),%al
mov    %al,-0x61(%rbp)
mov    -0x3b(%rbp),%al
mov    %al,-0x62(%rbp)
mov    -0x3a(%rbp),%al
mov    %al,-0x63(%rbp)
mov    -0x39(%rbp),%al
mov    %al,-0x64(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x78(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x80(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x80(%rbp),%rax
add    %rcx,%rax
movzbl -0x60(%rbp),%ecx
add    %rcx,%rax
movabs $0xd76aa478,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x7,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x78(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    1332 <md5+0x1c2>
jmp    1337 <md5+0x1c7>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x88(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x90(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x90(%rbp),%rax
add    %rcx,%rax
movzbl -0x5f(%rbp),%ecx
add    %rcx,%rax
movabs $0xe8c7b756,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xc,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x88(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    13a4 <md5+0x234>
jmp    13a9 <md5+0x239>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x98(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0xa0(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0xa0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5e(%rbp),%ecx
add    %rcx,%rax
add    $0x242070db,%rax
mov    %eax,%edi
mov    $0x11,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x98(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    140f <md5+0x29f>
jmp    1414 <md5+0x2a4>
movzbl -0x63(%rbp),%eax
mov    %rax,-0xa8(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0xb0(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0xb0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5d(%rbp),%ecx
add    %rcx,%rax
movabs $0xc1bdceee,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x16,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0xa8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    1481 <md5+0x311>
jmp    1486 <md5+0x316>
movzbl -0x62(%rbp),%eax
mov    %rax,-0xb8(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0xc0(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0xc0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5c(%rbp),%ecx
add    %rcx,%rax
movabs $0xf57c0faf,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x7,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0xb8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    14f3 <md5+0x383>
jmp    14f8 <md5+0x388>
movzbl -0x61(%rbp),%eax
mov    %rax,-0xc8(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0xd0(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0xd0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5b(%rbp),%ecx
add    %rcx,%rax
add    $0x4787c62a,%rax
mov    %eax,%edi
mov    $0xc,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0xc8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    155e <md5+0x3ee>
jmp    1563 <md5+0x3f3>
movzbl -0x64(%rbp),%eax
mov    %rax,-0xd8(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0xe0(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0xe0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5a(%rbp),%ecx
add    %rcx,%rax
movabs $0xa8304613,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x11,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0xd8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    15d0 <md5+0x460>
jmp    15d5 <md5+0x465>
movzbl -0x63(%rbp),%eax
mov    %rax,-0xe8(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0xf0(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0xf0(%rbp),%rax
add    %rcx,%rax
movzbl -0x59(%rbp),%ecx
add    %rcx,%rax
movabs $0xfd469501,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x16,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0xe8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    1642 <md5+0x4d2>
jmp    1647 <md5+0x4d7>
movzbl -0x62(%rbp),%eax
mov    %rax,-0xf8(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x100(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x100(%rbp),%rax
add    %rcx,%rax
movzbl -0x58(%rbp),%ecx
add    %rcx,%rax
add    $0x698098d8,%rax
mov    %eax,%edi
mov    $0x7,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0xf8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    16ad <md5+0x53d>
jmp    16b2 <md5+0x542>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x108(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x110(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x110(%rbp),%rax
add    %rcx,%rax
movzbl -0x57(%rbp),%ecx
add    %rcx,%rax
movabs $0x8b44f7af,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xc,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x108(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    171f <md5+0x5af>
jmp    1724 <md5+0x5b4>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x118(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x120(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x120(%rbp),%rax
add    %rcx,%rax
movzbl -0x56(%rbp),%ecx
add    %rcx,%rax
movabs $0xffff5bb1,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x11,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x118(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    1791 <md5+0x621>
jmp    1796 <md5+0x626>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x128(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x130(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x130(%rbp),%rax
add    %rcx,%rax
movzbl -0x55(%rbp),%ecx
add    %rcx,%rax
movabs $0x895cd7be,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x16,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x128(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    1803 <md5+0x693>
jmp    1808 <md5+0x698>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x138(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x140(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x140(%rbp),%rax
add    %rcx,%rax
movzbl -0x54(%rbp),%ecx
add    %rcx,%rax
add    $0x6b901122,%rax
mov    %eax,%edi
mov    $0x7,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x138(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    186e <md5+0x6fe>
jmp    1873 <md5+0x703>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x148(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x150(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x150(%rbp),%rax
add    %rcx,%rax
movzbl -0x53(%rbp),%ecx
add    %rcx,%rax
movabs $0xfd987193,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xc,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x148(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    18e0 <md5+0x770>
jmp    18e5 <md5+0x775>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x158(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x160(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x160(%rbp),%rax
add    %rcx,%rax
movzbl -0x52(%rbp),%ecx
add    %rcx,%rax
movabs $0xa679438e,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x11,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x158(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    1952 <md5+0x7e2>
jmp    1957 <md5+0x7e7>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x168(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x170(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1040 <F@plt>
mov    %rax,%rcx
mov    -0x170(%rbp),%rax
add    %rcx,%rax
movzbl -0x51(%rbp),%ecx
add    %rcx,%rax
add    $0x49b40821,%rax
mov    %eax,%edi
mov    $0x16,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x168(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    19bd <md5+0x84d>
jmp    19c2 <md5+0x852>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x178(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x180(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x180(%rbp),%rax
add    %rcx,%rax
movzbl -0x5f(%rbp),%ecx
add    %rcx,%rax
movabs $0xf61e2562,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x5,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x178(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    1a2f <md5+0x8bf>
jmp    1a34 <md5+0x8c4>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x188(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x190(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x190(%rbp),%rax
add    %rcx,%rax
movzbl -0x5a(%rbp),%ecx
add    %rcx,%rax
movabs $0xc040b340,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x9,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x188(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    1aa1 <md5+0x931>
jmp    1aa6 <md5+0x936>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x198(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x1a0(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x1a0(%rbp),%rax
add    %rcx,%rax
movzbl -0x55(%rbp),%ecx
add    %rcx,%rax
add    $0x265e5a51,%rax
mov    %eax,%edi
mov    $0xe,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x198(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    1b0c <md5+0x99c>
jmp    1b11 <md5+0x9a1>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x1a8(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x1b0(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x1b0(%rbp),%rax
add    %rcx,%rax
movzbl -0x60(%rbp),%ecx
add    %rcx,%rax
movabs $0xe9b6c7aa,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x14,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x1a8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    1b7e <md5+0xa0e>
jmp    1b83 <md5+0xa13>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x1b8(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x1c0(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x1c0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5b(%rbp),%ecx
add    %rcx,%rax
movabs $0xd62f105d,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x5,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x1b8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    1bf0 <md5+0xa80>
jmp    1bf5 <md5+0xa85>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x1c8(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x1d0(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x1d0(%rbp),%rax
add    %rcx,%rax
movzbl -0x56(%rbp),%ecx
add    %rcx,%rax
add    $0x2441453,%rax
mov    %eax,%edi
mov    $0x9,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x1c8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    1c5b <md5+0xaeb>
jmp    1c60 <md5+0xaf0>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x1d8(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x1e0(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x1e0(%rbp),%rax
add    %rcx,%rax
movzbl -0x51(%rbp),%ecx
add    %rcx,%rax
movabs $0xd8a1e681,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xe,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x1d8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    1ccd <md5+0xb5d>
jmp    1cd2 <md5+0xb62>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x1e8(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x1f0(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x1f0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5c(%rbp),%ecx
add    %rcx,%rax
movabs $0xe7d3fbc8,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x14,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x1e8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    1d3f <md5+0xbcf>
jmp    1d44 <md5+0xbd4>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x1f8(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x200(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x200(%rbp),%rax
add    %rcx,%rax
movzbl -0x57(%rbp),%ecx
add    %rcx,%rax
add    $0x21e1cde6,%rax
mov    %eax,%edi
mov    $0x5,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x1f8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    1daa <md5+0xc3a>
jmp    1daf <md5+0xc3f>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x208(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x210(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x210(%rbp),%rax
add    %rcx,%rax
movzbl -0x52(%rbp),%ecx
add    %rcx,%rax
movabs $0xc33707d6,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x9,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x208(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    1e1c <md5+0xcac>
jmp    1e21 <md5+0xcb1>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x218(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x220(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x220(%rbp),%rax
add    %rcx,%rax
movzbl -0x5d(%rbp),%ecx
add    %rcx,%rax
movabs $0xf4d50d87,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xe,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x218(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    1e8e <md5+0xd1e>
jmp    1e93 <md5+0xd23>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x228(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x230(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x230(%rbp),%rax
add    %rcx,%rax
movzbl -0x58(%rbp),%ecx
add    %rcx,%rax
add    $0x455a14ed,%rax
mov    %eax,%edi
mov    $0x14,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x228(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    1ef9 <md5+0xd89>
jmp    1efe <md5+0xd8e>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x238(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x240(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x240(%rbp),%rax
add    %rcx,%rax
movzbl -0x53(%rbp),%ecx
add    %rcx,%rax
movabs $0xa9e3e905,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x5,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x238(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    1f6b <md5+0xdfb>
jmp    1f70 <md5+0xe00>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x248(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x250(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x250(%rbp),%rax
add    %rcx,%rax
movzbl -0x5e(%rbp),%ecx
add    %rcx,%rax
movabs $0xfcefa3f8,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x9,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x248(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    1fdd <md5+0xe6d>
jmp    1fe2 <md5+0xe72>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x258(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x260(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x260(%rbp),%rax
add    %rcx,%rax
movzbl -0x59(%rbp),%ecx
add    %rcx,%rax
add    $0x676f02d9,%rax
mov    %eax,%edi
mov    $0xe,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x258(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    2048 <md5+0xed8>
jmp    204d <md5+0xedd>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x268(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x270(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1060 <G@plt>
mov    %rax,%rcx
mov    -0x270(%rbp),%rax
add    %rcx,%rax
movzbl -0x54(%rbp),%ecx
add    %rcx,%rax
movabs $0x8d2a4c8a,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x14,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x268(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    20ba <md5+0xf4a>
jmp    20bf <md5+0xf4f>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x278(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x280(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x280(%rbp),%rax
add    %rcx,%rax
movzbl -0x5b(%rbp),%ecx
add    %rcx,%rax
movabs $0xfffa3942,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x4,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x278(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    212c <md5+0xfbc>
jmp    2131 <md5+0xfc1>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x288(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x290(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x290(%rbp),%rax
add    %rcx,%rax
movzbl -0x58(%rbp),%ecx
add    %rcx,%rax
movabs $0x8771f681,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xb,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x288(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    219e <md5+0x102e>
jmp    21a3 <md5+0x1033>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x298(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x2a0(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x2a0(%rbp),%rax
add    %rcx,%rax
movzbl -0x55(%rbp),%ecx
add    %rcx,%rax
add    $0x6d9d6122,%rax
mov    %eax,%edi
mov    $0x10,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x298(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    2209 <md5+0x1099>
jmp    220e <md5+0x109e>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x2a8(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x2b0(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x2b0(%rbp),%rax
add    %rcx,%rax
movzbl -0x52(%rbp),%ecx
add    %rcx,%rax
movabs $0xfde5380c,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x17,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x2a8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    227b <md5+0x110b>
jmp    2280 <md5+0x1110>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x2b8(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x2c0(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x2c0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5f(%rbp),%ecx
add    %rcx,%rax
movabs $0xa4beea44,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x4,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x2b8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    22ed <md5+0x117d>
jmp    22f2 <md5+0x1182>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x2c8(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x2d0(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x2d0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5c(%rbp),%ecx
add    %rcx,%rax
add    $0x4bdecfa9,%rax
mov    %eax,%edi
mov    $0xb,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x2c8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    2358 <md5+0x11e8>
jmp    235d <md5+0x11ed>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x2d8(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x2e0(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x2e0(%rbp),%rax
add    %rcx,%rax
movzbl -0x59(%rbp),%ecx
add    %rcx,%rax
movabs $0xf6bb4b60,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x10,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x2d8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    23ca <md5+0x125a>
jmp    23cf <md5+0x125f>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x2e8(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x2f0(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x2f0(%rbp),%rax
add    %rcx,%rax
movzbl -0x56(%rbp),%ecx
add    %rcx,%rax
movabs $0xbebfbc70,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x17,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x2e8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    243c <md5+0x12cc>
jmp    2441 <md5+0x12d1>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x2f8(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x300(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x300(%rbp),%rax
add    %rcx,%rax
movzbl -0x53(%rbp),%ecx
add    %rcx,%rax
add    $0x289b7ec6,%rax
mov    %eax,%edi
mov    $0x4,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x2f8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    24a7 <md5+0x1337>
jmp    24ac <md5+0x133c>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x308(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x310(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x310(%rbp),%rax
add    %rcx,%rax
movzbl -0x60(%rbp),%ecx
add    %rcx,%rax
movabs $0xeaa127fa,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xb,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x308(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    2519 <md5+0x13a9>
jmp    251e <md5+0x13ae>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x318(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x320(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x320(%rbp),%rax
add    %rcx,%rax
movzbl -0x5d(%rbp),%ecx
add    %rcx,%rax
movabs $0xd4ef3085,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x10,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x318(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    258b <md5+0x141b>
jmp    2590 <md5+0x1420>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x328(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x330(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x330(%rbp),%rax
add    %rcx,%rax
movzbl -0x5a(%rbp),%ecx
add    %rcx,%rax
add    $0x4881d05,%rax
mov    %eax,%edi
mov    $0x17,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x328(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    25f6 <md5+0x1486>
jmp    25fb <md5+0x148b>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x338(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x340(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x340(%rbp),%rax
add    %rcx,%rax
movzbl -0x57(%rbp),%ecx
add    %rcx,%rax
movabs $0xd9d4d039,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x4,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x338(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    2668 <md5+0x14f8>
jmp    266d <md5+0x14fd>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x348(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x350(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x350(%rbp),%rax
add    %rcx,%rax
movzbl -0x54(%rbp),%ecx
add    %rcx,%rax
movabs $0xe6db99e5,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xb,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x348(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    26da <md5+0x156a>
jmp    26df <md5+0x156f>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x358(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x360(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x360(%rbp),%rax
add    %rcx,%rax
movzbl -0x51(%rbp),%ecx
add    %rcx,%rax
add    $0x1fa27cf8,%rax
mov    %eax,%edi
mov    $0x10,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x358(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    2745 <md5+0x15d5>
jmp    274a <md5+0x15da>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x368(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x370(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1030 <H@plt>
mov    %rax,%rcx
mov    -0x370(%rbp),%rax
add    %rcx,%rax
movzbl -0x5e(%rbp),%ecx
add    %rcx,%rax
movabs $0xc4ac5665,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x17,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x368(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    27b7 <md5+0x1647>
jmp    27bc <md5+0x164c>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x378(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x380(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x380(%rbp),%rax
add    %rcx,%rax
movzbl -0x60(%rbp),%ecx
add    %rcx,%rax
movabs $0xf4292244,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x6,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x378(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    2829 <md5+0x16b9>
jmp    282e <md5+0x16be>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x388(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x390(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x390(%rbp),%rax
add    %rcx,%rax
movzbl -0x59(%rbp),%ecx
add    %rcx,%rax
add    $0x432aff97,%rax
mov    %eax,%edi
mov    $0xa,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x388(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    2894 <md5+0x1724>
jmp    2899 <md5+0x1729>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x398(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x3a0(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x3a0(%rbp),%rax
add    %rcx,%rax
movzbl -0x52(%rbp),%ecx
add    %rcx,%rax
movabs $0xab9423a7,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xf,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x398(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    2906 <md5+0x1796>
jmp    290b <md5+0x179b>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x3a8(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x3b0(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x3b0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5b(%rbp),%ecx
add    %rcx,%rax
movabs $0xfc93a039,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x15,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x3a8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    2978 <md5+0x1808>
jmp    297d <md5+0x180d>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x3b8(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x3c0(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x3c0(%rbp),%rax
add    %rcx,%rax
movzbl -0x54(%rbp),%ecx
add    %rcx,%rax
add    $0x655b59c3,%rax
mov    %eax,%edi
mov    $0x6,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x3b8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    29e3 <md5+0x1873>
jmp    29e8 <md5+0x1878>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x3c8(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x3d0(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x3d0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5d(%rbp),%ecx
add    %rcx,%rax
movabs $0x8f0ccc92,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xa,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x3c8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    2a55 <md5+0x18e5>
jmp    2a5a <md5+0x18ea>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x3d8(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x3e0(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x3e0(%rbp),%rax
add    %rcx,%rax
movzbl -0x56(%rbp),%ecx
add    %rcx,%rax
movabs $0xffeff47d,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xf,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x3d8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    2ac7 <md5+0x1957>
jmp    2acc <md5+0x195c>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x3e8(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x3f0(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x3f0(%rbp),%rax
add    %rcx,%rax
movzbl -0x5f(%rbp),%ecx
add    %rcx,%rax
movabs $0x85845dd1,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x15,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x3e8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    2b39 <md5+0x19c9>
jmp    2b3e <md5+0x19ce>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x3f8(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x400(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x400(%rbp),%rax
add    %rcx,%rax
movzbl -0x58(%rbp),%ecx
add    %rcx,%rax
add    $0x6fa87e4f,%rax
mov    %eax,%edi
mov    $0x6,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x3f8(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    2ba4 <md5+0x1a34>
jmp    2ba9 <md5+0x1a39>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x408(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x410(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x410(%rbp),%rax
add    %rcx,%rax
movzbl -0x51(%rbp),%ecx
add    %rcx,%rax
movabs $0xfe2ce6e0,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xa,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x408(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    2c16 <md5+0x1aa6>
jmp    2c1b <md5+0x1aab>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x418(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x420(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x420(%rbp),%rax
add    %rcx,%rax
movzbl -0x5a(%rbp),%ecx
add    %rcx,%rax
movabs $0xa3014314,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xf,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x418(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    2c88 <md5+0x1b18>
jmp    2c8d <md5+0x1b1d>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x428(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x430(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x430(%rbp),%rax
add    %rcx,%rax
movzbl -0x53(%rbp),%ecx
add    %rcx,%rax
add    $0x4e0811a1,%rax
mov    %eax,%edi
mov    $0x15,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x428(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    2cf3 <md5+0x1b83>
jmp    2cf8 <md5+0x1b88>
movzbl -0x62(%rbp),%eax
mov    %rax,-0x438(%rbp)
movzbl -0x61(%rbp),%eax
mov    %rax,-0x440(%rbp)
mov    -0x62(%rbp),%cl
mov    -0x63(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x64(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x440(%rbp),%rax
add    %rcx,%rax
movzbl -0x5c(%rbp),%ecx
add    %rcx,%rax
movabs $0xf7537e82,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x6,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x438(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x61(%rbp)
jmp    2d65 <md5+0x1bf5>
jmp    2d6a <md5+0x1bfa>
movzbl -0x61(%rbp),%eax
mov    %rax,-0x448(%rbp)
movzbl -0x64(%rbp),%eax
mov    %rax,-0x450(%rbp)
mov    -0x61(%rbp),%cl
mov    -0x62(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x63(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x450(%rbp),%rax
add    %rcx,%rax
movzbl -0x55(%rbp),%ecx
add    %rcx,%rax
movabs $0xbd3af235,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0xa,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x448(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x64(%rbp)
jmp    2dd7 <md5+0x1c67>
jmp    2ddc <md5+0x1c6c>
movzbl -0x64(%rbp),%eax
mov    %rax,-0x458(%rbp)
movzbl -0x63(%rbp),%eax
mov    %rax,-0x460(%rbp)
mov    -0x64(%rbp),%cl
mov    -0x61(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x62(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x460(%rbp),%rax
add    %rcx,%rax
movzbl -0x5e(%rbp),%ecx
add    %rcx,%rax
add    $0x2ad7d2bb,%rax
mov    %eax,%edi
mov    $0xf,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x458(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x63(%rbp)
jmp    2e42 <md5+0x1cd2>
jmp    2e47 <md5+0x1cd7>
movzbl -0x63(%rbp),%eax
mov    %rax,-0x468(%rbp)
movzbl -0x62(%rbp),%eax
mov    %rax,-0x470(%rbp)
mov    -0x63(%rbp),%cl
mov    -0x64(%rbp),%al
movzbl %cl,%edi
movzbl %al,%esi
movzbl -0x61(%rbp),%edx
call   1070 <I@plt>
mov    %rax,%rcx
mov    -0x470(%rbp),%rax
add    %rcx,%rax
movzbl -0x57(%rbp),%ecx
add    %rcx,%rax
movabs $0xeb86d391,%rcx
add    %rcx,%rax
mov    %eax,%edi
mov    $0x15,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %rax,%rcx
mov    -0x468(%rbp),%rax
add    %rcx,%rax
mov    %al,-0x62(%rbp)
jmp    2eb4 <md5+0x1d44>
movzbl -0x61(%rbp),%ecx
movzbl -0x3c(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x3c(%rbp)
movzbl -0x62(%rbp),%ecx
movzbl -0x3b(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x3b(%rbp)
movzbl -0x63(%rbp),%ecx
movzbl -0x3a(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x3a(%rbp)
movzbl -0x64(%rbp),%ecx
movzbl -0x39(%rbp),%eax
add    %ecx,%eax
mov    %al,-0x39(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    126e <md5+0xfe>
cmpq   $0x0,-0x8(%rbp)
je     2f16 <md5+0x1da6>
mov    -0x8(%rbp),%rdi
lea    -0x3c(%rbp),%rsi
mov    $0x4,%edx
call   1050 <memcpy@plt>
mov    -0x28(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<md5>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,-0xc8(%rbp)
lea    0x0(,%rdx,8),%r14
mov    %r14,%r12
shr    $0x9,%r12
shl    $0x4,%r12
lea    0x20(%r12),%rsi
mov    %rsp,%r13
sub    %rsi,%r13
mov    %r13,%rsp
mov    %r13,%rdi
call   1080 <bzero@plt>
test   %r15,%r15
je     121f <md5+0xaf>
xor    %edx,%edx
cmp    $0x1,%r15
jne    11cb <md5+0x5b>
xor    %eax,%eax
jmp    1203 <md5+0x93>
mov    %r15,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rbx,%rax,1),%edi
mov    %edx,%ecx
and    $0x10,%cl
shl    %cl,%edi
mov    %rax,%rcx
shr    $0x2,%rcx
or     %dil,0x0(%r13,%rcx,1)
add    $0x2,%rax
add    $0x10,%edx
cmp    %rax,%rsi
jne    11e0 <md5+0x70>
test   $0x1,%r15b
je     121f <md5+0xaf>
movzbl (%rbx,%rax,1),%edx
lea    0x0(,%rax,8),%ecx
shl    %cl,%edx
shr    $0x2,%rax
or     %dl,0x0(%r13,%rax,1)
lea    0x0(,%r15,8),%ecx
mov    $0x80,%eax
shl    %cl,%eax
shr    $0x2,%r15
or     %al,0x0(%r13,%r15,1)
mov    %r12,%rax
or     $0xe,%rax
mov    %r14b,0x0(%r13,%rax,1)
movl   $0x76fe8901,-0x2c(%rbp)
add    $0x10,%r12
mov    $0x76,%cl
mov    $0xfe,%sil
mov    $0x89,%al
mov    $0x1,%bl
xor    %edx,%edx
mov    %r12,-0xd8(%rbp)
mov    %r13,-0xd0(%rbp)
nopw   0x0(%rax,%rax,1)
mov    %rdx,-0xe0(%rbp)
movzbl 0x0(%r13,%rdx,1),%r15d
mov    %r15,-0xb0(%rbp)
movzbl 0x1(%r13,%rdx,1),%r12d
mov    %r12,-0xb8(%rbp)
movzbl 0x2(%r13,%rdx,1),%edi
mov    %rdi,-0x98(%rbp)
movzbl 0x3(%r13,%rdx,1),%edi
mov    %rdi,-0x88(%rbp)
movzbl 0x4(%r13,%rdx,1),%edi
mov    %rdi,-0x58(%rbp)
movzbl 0x5(%r13,%rdx,1),%edi
mov    %rdi,-0x80(%rbp)
movzbl 0x6(%r13,%rdx,1),%edi
mov    %rdi,-0x60(%rbp)
movzbl 0x7(%r13,%rdx,1),%edi
mov    %rdi,-0x70(%rbp)
movzbl 0x8(%r13,%rdx,1),%edi
mov    %rdi,-0xa0(%rbp)
movzbl 0x9(%r13,%rdx,1),%edi
mov    %rdi,-0x40(%rbp)
movzbl 0xa(%r13,%rdx,1),%edi
mov    %rdi,-0x90(%rbp)
movzbl 0xb(%r13,%rdx,1),%edi
mov    %rdi,-0x48(%rbp)
movzbl 0xc(%r13,%rdx,1),%edi
mov    %rdi,-0xa8(%rbp)
movzbl 0xd(%r13,%rdx,1),%edi
mov    %rdi,-0x50(%rbp)
movzbl 0xe(%r13,%rdx,1),%edi
mov    %rdi,-0x78(%rbp)
movzbl 0xf(%r13,%rdx,1),%edx
mov    %rdx,-0x68(%rbp)
movzbl %al,%r14d
movzbl %sil,%esi
mov    %esi,-0x30(%rbp)
movzbl %cl,%ecx
mov    %ecx,-0x34(%rbp)
mov    %r14d,%edi
mov    -0x34(%rbp),%edx
call   1040 <F@plt>
movzbl %bl,%ebx
mov    %ebx,-0xc0(%rbp)
add    %ebx,%eax
lea    (%r15,%rax,1),%edi
add    $0xd76aa478,%edi
mov    $0x7,%esi
call   1090 <LEFT_ROTATE@plt>
mov    %r14d,%ebx
add    %bl,%al
movzbl %al,%r13d
mov    %r13d,%edi
mov    %r14d,%esi
mov    -0x30(%rbp),%edx
call   1040 <F@plt>
add    -0x34(%rbp),%eax
lea    (%r12,%rax,1),%edi
add    $0xe8c7b756,%edi
mov    $0xc,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r13b,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %r13d,%esi
mov    %ebx,%edx
mov    %ebx,-0xbc(%rbp)
call   1040 <F@plt>
add    -0x30(%rbp),%eax
mov    -0x98(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0x242070db,%edi
mov    $0x11,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %r13d,%edx
call   1040 <F@plt>
add    %ebx,%eax
mov    -0x88(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0xc1bdceee,%edi
mov    $0x16,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1040 <F@plt>
add    %r13d,%eax
mov    -0x58(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0xf57c0faf,%edi
mov    $0x7,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1040 <F@plt>
add    %r14d,%eax
mov    -0x80(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0x4787c62a,%edi
mov    $0xc,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1040 <F@plt>
add    %r15d,%eax
mov    -0x60(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0xa8304613,%edi
mov    $0x11,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1040 <F@plt>
add    %r12d,%eax
mov    -0x70(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0xfd469501,%edi
mov    $0x16,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1040 <F@plt>
add    %ebx,%eax
mov    -0xa0(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0x698098d8,%edi
mov    $0x7,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1040 <F@plt>
add    %r14d,%eax
mov    -0x40(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0x8b44f7af,%edi
mov    $0xc,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r13d
mov    %r13d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1040 <F@plt>
add    %r15d,%eax
mov    -0x90(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0xffff5bb1,%edi
mov    $0x11,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r13b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %ebx,%edx
call   1040 <F@plt>
add    %r12d,%eax
mov    -0x48(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0x895cd7be,%edi
mov    $0x16,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
call   1040 <F@plt>
add    %ebx,%eax
mov    -0xa8(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0x6b901122,%edi
mov    $0x7,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1040 <F@plt>
add    %r13d,%eax
mov    -0x50(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0xfd987193,%edi
mov    $0xc,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r13d
mov    %r13d,%edi
mov    %r14d,%esi
mov    %r12d,%edx
call   1040 <F@plt>
add    %r15d,%eax
mov    -0x78(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0xa679438e,%edi
mov    $0x11,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r13b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r13d,%esi
mov    %r14d,%edx
call   1040 <F@plt>
add    %r12d,%eax
mov    -0x68(%rbp),%rcx
lea    (%rcx,%rax,1),%edi
add    $0x49b40821,%edi
mov    $0x16,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r13d,%edx
call   1060 <G@plt>
add    -0xb8(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0xf61e2562,%edi
mov    $0x5,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1060 <G@plt>
add    -0x60(%rbp),%r13d
lea    (%rax,%r13,1),%edi
add    $0xc040b340,%edi
mov    $0x9,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1060 <G@plt>
add    -0x48(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0x265e5a51,%edi
mov    $0xe,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1060 <G@plt>
add    -0xb0(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0xe9b6c7aa,%edi
mov    $0x14,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1060 <G@plt>
add    -0x80(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0xd62f105d,%edi
mov    $0x5,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1060 <G@plt>
add    -0x90(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0x2441453,%edi
mov    $0x9,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1060 <G@plt>
add    -0x68(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0xd8a1e681,%edi
mov    $0xe,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1060 <G@plt>
add    -0x58(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0xe7d3fbc8,%edi
mov    $0x14,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1060 <G@plt>
add    -0x40(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0x21e1cde6,%edi
mov    $0x5,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1060 <G@plt>
add    -0x78(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0xc33707d6,%edi
mov    $0x9,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1060 <G@plt>
add    -0x88(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0xf4d50d87,%edi
mov    $0xe,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1060 <G@plt>
mov    -0xa0(%rbp),%r13
add    %r13d,%r12d
lea    (%rax,%r12,1),%edi
add    $0x455a14ed,%edi
mov    $0x14,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1060 <G@plt>
add    -0x50(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0xa9e3e905,%edi
mov    $0x5,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1060 <G@plt>
add    -0x98(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0xfcefa3f8,%edi
mov    $0x9,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1060 <G@plt>
add    -0x70(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0x676f02d9,%edi
mov    $0xe,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1060 <G@plt>
add    -0xa8(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0x8d2a4c8a,%edi
mov    $0x14,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1030 <H@plt>
add    -0x80(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0xfffa3942,%edi
mov    $0x4,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1030 <H@plt>
add    %r13d,%r14d
lea    (%rax,%r14,1),%edi
add    $0x8771f681,%edi
mov    $0xb,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1030 <H@plt>
add    -0x48(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0x6d9d6122,%edi
mov    $0x10,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1030 <H@plt>
add    -0x78(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0xfde5380c,%edi
mov    $0x17,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1030 <H@plt>
add    -0xb8(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0xa4beea44,%edi
mov    $0x4,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1030 <H@plt>
add    -0x58(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0x4bdecfa9,%edi
mov    $0xb,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1030 <H@plt>
add    -0x70(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0xf6bb4b60,%edi
mov    $0x10,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1030 <H@plt>
add    -0x90(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0xbebfbc70,%edi
mov    $0x17,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1030 <H@plt>
add    -0x50(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0x289b7ec6,%edi
mov    $0x4,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1030 <H@plt>
add    -0xb0(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0xeaa127fa,%edi
mov    $0xb,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1030 <H@plt>
add    -0x88(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0xd4ef3085,%edi
mov    $0x10,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1030 <H@plt>
add    -0x60(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0x4881d05,%edi
mov    $0x17,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1030 <H@plt>
add    -0x40(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0xd9d4d039,%edi
mov    $0x4,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1030 <H@plt>
mov    -0xa8(%rbp),%r13
add    %r13d,%r14d
lea    (%rax,%r14,1),%edi
add    $0xe6db99e5,%edi
mov    $0xb,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1030 <H@plt>
add    -0x68(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0x1fa27cf8,%edi
mov    $0x10,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1030 <H@plt>
add    -0x98(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0xc4ac5665,%edi
mov    $0x17,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1070 <I@plt>
add    -0xb0(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0xf4292244,%edi
mov    $0x6,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1070 <I@plt>
add    -0x70(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0x432aff97,%edi
mov    $0xa,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1070 <I@plt>
add    -0x78(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0xab9423a7,%edi
mov    $0xf,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1070 <I@plt>
add    -0x80(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0xfc93a039,%edi
mov    $0x15,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1070 <I@plt>
add    %r13d,%ebx
lea    (%rax,%rbx,1),%edi
add    $0x655b59c3,%edi
mov    $0x6,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1070 <I@plt>
add    -0x88(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0x8f0ccc92,%edi
mov    $0xa,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1070 <I@plt>
add    -0x90(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0xffeff47d,%edi
mov    $0xf,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1070 <I@plt>
add    -0xb8(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0x85845dd1,%edi
mov    $0x15,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1070 <I@plt>
add    -0xa0(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0x6fa87e4f,%edi
mov    $0x6,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%ebx
mov    %ebx,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1070 <I@plt>
add    -0x68(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0xfe2ce6e0,%edi
mov    $0xa,%esi
call   1090 <LEFT_ROTATE@plt>
add    %bl,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %ebx,%esi
mov    %r12d,%edx
call   1070 <I@plt>
add    -0x60(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0xa3014314,%edi
mov    $0xf,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %ebx,%edx
call   1070 <I@plt>
add    -0x50(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0x4e0811a1,%edi
mov    $0x15,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r15b,%al
movzbl %al,%r12d
mov    %r12d,%edi
mov    %r15d,%esi
mov    %r14d,%edx
call   1070 <I@plt>
add    -0x58(%rbp),%ebx
lea    (%rax,%rbx,1),%edi
add    $0xf7537e82,%edi
mov    $0x6,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r12b,%al
movzbl %al,%r13d
mov    %r13d,%edi
mov    %r12d,%esi
mov    %r15d,%edx
call   1070 <I@plt>
add    -0x48(%rbp),%r14d
lea    (%rax,%r14,1),%edi
add    $0xbd3af235,%edi
mov    $0xa,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r13b,%al
movzbl %al,%r14d
mov    %r14d,%edi
mov    %r13d,%esi
mov    %r12d,%edx
call   1070 <I@plt>
add    -0x98(%rbp),%r15d
lea    (%rax,%r15,1),%edi
add    $0x2ad7d2bb,%edi
mov    -0xc0(%rbp),%ebx
mov    $0xf,%esi
call   1090 <LEFT_ROTATE@plt>
add    %r14b,%al
movzbl %al,%r15d
mov    %r15d,%edi
mov    %r14d,%esi
mov    %r13d,%edx
call   1070 <I@plt>
add    -0x40(%rbp),%r12d
lea    (%rax,%r12,1),%edi
add    $0xeb86d391,%edi
mov    -0xd8(%rbp),%r12
mov    $0x15,%esi
call   1090 <LEFT_ROTATE@plt>
mov    -0xe0(%rbp),%rdx
mov    -0x30(%rbp),%esi
mov    -0x34(%rbp),%ecx
add    %r15b,%al
add    %r13b,%bl
mov    -0xd0(%rbp),%r13
add    -0xbc(%rbp),%al
add    %r15b,%sil
add    %r14b,%cl
add    $0x10,%rdx
cmp    %rdx,%r12
jne    1270 <md5+0x100>
mov    %bl,-0x2c(%rbp)
mov    %al,-0x2b(%rbp)
mov    %sil,-0x2a(%rbp)
mov    %cl,-0x29(%rbp)
mov    -0xc8(%rbp),%rdi
test   %rdi,%rdi
je     1ef6 <md5+0xd86>
lea    -0x2c(%rbp),%rsi
mov    $0x4,%edx
call   1050 <memcpy@plt>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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