#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 */
typedef struct TYPE_5__ TYPE_1__;

/* Type definitions */
struct TYPE_5__ {
  unsigned long Nl;
  int num;
  unsigned long *data;
  scalar_t__ Nh;
};
typedef unsigned long MD4_LONG;
typedef TYPE_1__ MD4_CTX;

/* Variables and functions */
unsigned long MD4_CBLOCK;
int MD4_LBLOCK;
int /*<<< orphan*/ md4_block_data_order(TYPE_1__ *, unsigned char const *, int);
int /*<<< orphan*/ md4_block_host_order(TYPE_1__ *, unsigned long *, int);
int MD4_Update(MD4_CTX *c, const void *data_, unsigned long len) {
  const unsigned char *data = data_;
  register MD4_LONG *p;
  register unsigned long l;
  int sw, sc, ew, ec;
  if (len == 0)
    return 1;
  l = (c->Nl + (len << 3)) & 0xffffffffL;
  if (l < c->Nl)
    c->Nh++;
  c->Nh += (len >> 29);
  c->Nl = l;
  if (c->num != 0) {
    p = c->data;
    sw = c->num >> 2;
    sc = c->num & 0x03;
    if ((c->num + len) >= MD4_CBLOCK) {
      l = p[sw];
      {
        switch (sc) {
        case 0:
          l = ((unsigned long)(*((data)++)));
        case 1:
          l |= ((unsigned long)(*((data)++))) << 8;
        case 2:
          l |= ((unsigned long)(*((data)++))) << 16;
        case 3:
          l |= ((unsigned long)(*((data)++))) << 24;
        }
      };
      p[sw++] = l;
      for (; sw < MD4_LBLOCK; sw++) {
        (l = (((unsigned long)(*((data)++)))),
         l |= (((unsigned long)(*((data)++))) << 8),
         l |= (((unsigned long)(*((data)++))) << 16),
         l |= (((unsigned long)(*((data)++))) << 24), l);
        p[sw] = l;
      }
      md4_block_host_order(c, p, 1);
      len -= (MD4_CBLOCK - c->num);
      c->num = 0;
    } else {
      c->num += len;
      if ((sc + len) < 4) {
        l = p[sw];
        {
          switch (sc) {
          case 0:
            l = ((unsigned long)(*((data)++)));
            if (--len == 0)
              break;
          case 1:
            l |= ((unsigned long)(*((data)++))) << 8;
            if (--len == 0)
              break;
          case 2:
            l |= ((unsigned long)(*((data)++))) << 16;
          }
        };
        p[sw] = l;
      } else {
        ew = (c->num >> 2);
        ec = (c->num & 0x03);
        if (sc)
          l = p[sw];
        {
          switch (sc) {
          case 0:
            l = ((unsigned long)(*((data)++)));
          case 1:
            l |= ((unsigned long)(*((data)++))) << 8;
          case 2:
            l |= ((unsigned long)(*((data)++))) << 16;
          case 3:
            l |= ((unsigned long)(*((data)++))) << 24;
          }
        };
        p[sw++] = l;
        for (; sw < ew; sw++) {
          (l = (((unsigned long)(*((data)++)))),
           l |= (((unsigned long)(*((data)++))) << 8),
           l |= (((unsigned long)(*((data)++))) << 16),
           l |= (((unsigned long)(*((data)++))) << 24), l);
          p[sw] = l;
        }
        if (ec) {
          {
            l = 0;
            (data) += ec;
            switch (ec) {
            case 3:
              l = ((unsigned long)(*(--(data)))) << 16;
            case 2:
              l |= ((unsigned long)(*(--(data)))) << 8;
            case 1:
              l |= ((unsigned long)(*(--(data))));
            }
          };
          p[sw] = l;
        }
      }
      return 1;
    }
  }
  sw = len / MD4_CBLOCK;
  if (sw > 0) {
    {
      md4_block_data_order(c, data, sw);
      sw *= MD4_CBLOCK;
      data += sw;
      len -= sw;
    }
  }
  if (len != 0) {
    p = c->data;
    c->num = len;
    ew = len >> 2;
    ec = len & 0x03;
    for (; ew; ew--, p++) {
      (l = (((unsigned long)(*((data)++)))),
       l |= (((unsigned long)(*((data)++))) << 8),
       l |= (((unsigned long)(*((data)++))) << 16),
       l |= (((unsigned long)(*((data)++))) << 24), l);
      *p = l;
    }
    {
      l = 0;
      (data) += ec;
      switch (ec) {
      case 3:
        l = ((unsigned long)(*(--(data)))) << 16;
      case 2:
        l |= ((unsigned long)(*(--(data)))) << 8;
      case 1:
        l |= ((unsigned long)(*(--(data))));
      }
    };
    *p = l;
  }
  return 1;
}


x86 assembly (clang, -O0):
<MD4_Update>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    1153 <MD4_Update+0x33>
movl   $0x1,-0x4(%rbp)
jmp    18f5 <MD4_Update+0x7d5>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movabs $0xffffffff,%rcx
and    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%rax
jae    1197 <MD4_Update+0x77>
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rcx
add    $0x1,%rcx
mov    %rcx,0x18(%rax)
mov    -0x20(%rbp),%rcx
shr    $0x1d,%rcx
mov    -0x10(%rbp),%rax
add    0x18(%rax),%rcx
mov    %rcx,0x18(%rax)
mov    -0x38(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
cmpl   $0x0,0x8(%rax)
je     1706 <MD4_Update+0x5e6>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%eax
sar    $0x2,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%eax
and    $0x3,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq 0x8(%rax),%rax
add    -0x20(%rbp),%rax
mov    0x2deb(%rip),%rcx
cmp    (%rcx),%rax
jb     13a7 <MD4_Update+0x287>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
mov    %rax,-0x50(%rbp)
sub    $0x3,%rax
ja     12ab <MD4_Update+0x18b>
mov    -0x50(%rbp),%rax
lea    0xdde(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
mov    0x2d09(%rip),%rcx
cmp    (%rcx),%eax
jge    1365 <MD4_Update+0x245>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12c5 <MD4_Update+0x1a5>
mov    -0x10(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    $0x1,%edx
call   1040 <md4_block_host_order@plt>
mov    0x2c6a(%rip),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
movslq 0x8(%rax),%rax
sub    %rax,%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x0,0x8(%rax)
jmp    1701 <MD4_Update+0x5e1>
mov    -0x20(%rbp),%rdx
mov    -0x10(%rbp),%rax
movslq 0x8(%rax),%rcx
add    %rdx,%rcx
mov    %ecx,0x8(%rax)
movslq -0x40(%rbp),%rax
add    -0x20(%rbp),%rax
cmp    $0x4,%rax
jae    14b7 <MD4_Update+0x397>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x54(%rbp)
test   %eax,%eax
je     1410 <MD4_Update+0x2f0>
jmp    13ee <MD4_Update+0x2ce>
mov    -0x54(%rbp),%eax
sub    $0x1,%eax
je     1446 <MD4_Update+0x326>
jmp    13ff <MD4_Update+0x2df>
mov    -0x54(%rbp),%eax
sub    $0x2,%eax
je     1484 <MD4_Update+0x364>
jmp    14a2 <MD4_Update+0x382>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    1441 <MD4_Update+0x321>
jmp    14a2 <MD4_Update+0x382>
jmp    1446 <MD4_Update+0x326>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    147f <MD4_Update+0x35f>
jmp    14a2 <MD4_Update+0x382>
jmp    1484 <MD4_Update+0x364>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    16f5 <MD4_Update+0x5d5>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%eax
sar    $0x2,%eax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%eax
and    $0x3,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     14eb <MD4_Update+0x3cb>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
mov    %rax,-0x60(%rbp)
sub    $0x3,%rax
ja     1580 <MD4_Update+0x460>
mov    -0x60(%rbp),%rax
lea    0xaf9(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x30(%rbp),%rax
mov    -0x3c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x3c(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1634 <MD4_Update+0x514>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    159a <MD4_Update+0x47a>
cmpl   $0x0,-0x48(%rbp)
je     16f0 <MD4_Update+0x5d0>
movq   $0x0,-0x38(%rbp)
movslq -0x48(%rbp),%rcx
mov    -0x28(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x64(%rbp)
sub    $0x1,%eax
je     16c5 <MD4_Update+0x5a5>
jmp    1669 <MD4_Update+0x549>
mov    -0x64(%rbp),%eax
sub    $0x2,%eax
je     16a6 <MD4_Update+0x586>
jmp    167a <MD4_Update+0x55a>
mov    -0x64(%rbp),%eax
sub    $0x3,%eax
jne    16e0 <MD4_Update+0x5c0>
jmp    168b <MD4_Update+0x56b>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x10,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rdx
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    16f5 <MD4_Update+0x5d5>
movl   $0x1,-0x4(%rbp)
jmp    18f5 <MD4_Update+0x7d5>
jmp    1706 <MD4_Update+0x5e6>
mov    -0x20(%rbp),%rax
mov    0x28d7(%rip),%rcx
xor    %edx,%edx
divq   (%rcx)
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jle    1768 <MD4_Update+0x648>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x3c(%rbp),%edx
call   1030 <md4_block_data_order@plt>
mov    0x28ae(%rip),%rax
mov    (%rax),%rcx
movslq -0x3c(%rbp),%rax
imul   %rcx,%rax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
movslq -0x3c(%rbp),%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     18ee <MD4_Update+0x7ce>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x8(%rax)
mov    -0x20(%rbp),%rax
shr    $0x2,%rax
mov    %eax,-0x44(%rbp)
mov    -0x20(%rbp),%rax
and    $0x3,%rax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x44(%rbp)
je     1841 <MD4_Update+0x721>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x10,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x44(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x44(%rbp)
mov    -0x30(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x30(%rbp)
jmp    17a2 <MD4_Update+0x682>
movq   $0x0,-0x38(%rbp)
movslq -0x48(%rbp),%rcx
mov    -0x28(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x68(%rbp)
sub    $0x1,%eax
je     18c8 <MD4_Update+0x7a8>
jmp    186c <MD4_Update+0x74c>
mov    -0x68(%rbp),%eax
sub    $0x2,%eax
je     18a9 <MD4_Update+0x789>
jmp    187d <MD4_Update+0x75d>
mov    -0x68(%rbp),%eax
sub    $0x3,%eax
jne    18e3 <MD4_Update+0x7c3>
jmp    188e <MD4_Update+0x76e>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x10,%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x8,%rax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
or     -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x30(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MD4_Update>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
test   %rdx,%rdx
je     13e8 <MD4_Update+0x2c8>
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%r15
mov    (%rdi),%rax
mov    0x18(%rdi),%rcx
lea    (%rax,%rdx,8),%edx
cmp    %rax,%rdx
adc    $0x0,%rcx
mov    %r14,%rax
shr    $0x1d,%rax
add    %rcx,%rax
mov    %rax,0x18(%rdi)
mov    %rdx,(%rdi)
movslq 0x8(%rdi),%rcx
test   %rcx,%rcx
je     11e3 <MD4_Update+0xc3>
mov    %ecx,%eax
mov    0x10(%r15),%rsi
mov    %ecx,%edx
sar    $0x2,%edx
and    $0x3,%eax
add    %r14,%rcx
mov    0x2e6b(%rip),%r12
cmp    (%r12),%rcx
jae    11f2 <MD4_Update+0xd2>
mov    %ecx,0x8(%r15)
mov    %rax,%rdi
add    %r14,%rdi
cmp    $0x3,%rdi
ja     126a <MD4_Update+0x14a>
movslq %edx,%rdx
mov    (%rsi,%rdx,8),%rcx
cmp    $0x2,%eax
je     11d0 <MD4_Update+0xb0>
cmp    $0x1,%eax
je     11b9 <MD4_Update+0x99>
test   %eax,%eax
jne    11da <MD4_Update+0xba>
movzbl (%rbx),%ecx
add    $0xffffffffffffffff,%r14
je     11da <MD4_Update+0xba>
add    $0x1,%rbx
mov    %rcx,%rax
movzbl (%rbx),%ecx
shl    $0x8,%rcx
or     %rax,%rcx
cmp    $0x1,%r14
je     11da <MD4_Update+0xba>
add    $0x1,%rbx
movzbl (%rbx),%eax
shl    $0x10,%rax
or     %rax,%rcx
mov    %rcx,(%rsi,%rdx,8)
jmp    13e8 <MD4_Update+0x2c8>
mov    0x2dfe(%rip),%rax
mov    (%rax),%rcx
jmp    12f1 <MD4_Update+0x1d1>
movslq %edx,%r8
mov    (%rsi,%r8,8),%rdi
mov    %eax,%eax
lea    0xdfe(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
movzbl (%rbx),%edi
add    $0x1,%rbx
movzbl (%rbx),%eax
add    $0x1,%rbx
shl    $0x8,%rax
or     %rax,%rdi
movzbl (%rbx),%eax
add    $0x1,%rbx
shl    $0x10,%rax
or     %rax,%rdi
lea    0x1(%rbx),%rcx
movzbl (%rbx),%eax
shl    $0x18,%rax
or     %rdi,%rax
mov    %rax,(%rsi,%r8,8)
mov    0x2d91(%rip),%rax
movslq (%rax),%rdi
lea    0x1(%r8),%eax
cmp    %edi,%eax
jge    12cb <MD4_Update+0x1ab>
not    %edx
lea    (%rdi,%rdx,1),%eax
lea    -0x2(%rdi),%rdx
test   $0x1,%al
jne    1297 <MD4_Update+0x177>
lea    0x1(%r8),%rax
cmp    %r8,%rdx
jne    12b0 <MD4_Update+0x190>
jmp    12ce <MD4_Update+0x1ae>
mov    %ecx,%r8d
sar    $0x2,%r8d
test   %eax,%eax
je     13f9 <MD4_Update+0x2d9>
movslq %edx,%r9
mov    (%rsi,%r9,8),%r10
cmp    $0x1,%eax
je     1404 <MD4_Update+0x2e4>
cmp    $0x2,%eax
je     1412 <MD4_Update+0x2f2>
jmp    1420 <MD4_Update+0x300>
mov    0x1(%rbx),%eax
add    $0x5,%rbx
mov    %rax,0x8(%rsi,%r8,8)
lea    0x2(%r8),%rax
mov    %rbx,%rcx
cmp    %r8,%rdx
je     12ce <MD4_Update+0x1ae>
nop
mov    (%rcx),%edx
mov    %rdx,(%rsi,%rax,8)
mov    0x4(%rcx),%edx
add    $0x8,%rcx
mov    %rdx,0x8(%rsi,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdi
jne    12b0 <MD4_Update+0x190>
mov    %rcx,%rbx
mov    %r15,%rdi
mov    $0x1,%edx
call   1040 <md4_block_host_order@plt>
mov    (%r12),%rcx
movslq 0x8(%r15),%rax
sub    %rcx,%r14
add    %rax,%r14
movl   $0x0,0x8(%r15)
mov    %r14,%rax
or     %rcx,%rax
shr    $0x20,%rax
je     135d <MD4_Update+0x23d>
mov    %r14,%rax
xor    %edx,%edx
div    %rcx
mov    %rax,%r12
test   %r12d,%r12d
jle    132f <MD4_Update+0x20f>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r12d,%edx
call   1030 <md4_block_data_order@plt>
mov    0x2cc6(%rip),%rax
imul   (%rax),%r12d
movslq %r12d,%rax
add    %rax,%rbx
sub    %rax,%r14
test   %r14,%r14
je     13e8 <MD4_Update+0x2c8>
mov    0x10(%r15),%rax
mov    %r14d,0x8(%r15)
mov    %r14,%rdx
shr    $0x2,%rdx
and    $0x3,%r14d
test   %edx,%edx
je     13a9 <MD4_Update+0x289>
test   $0x1,%dl
jne    136e <MD4_Update+0x24e>
mov    %edx,%ecx
cmp    $0x1,%edx
jne    1390 <MD4_Update+0x270>
jmp    13a9 <MD4_Update+0x289>
mov    %r14d,%eax
xor    %edx,%edx
div    %ecx
mov    %eax,%r12d
test   %r12d,%r12d
jg     130d <MD4_Update+0x1ed>
jmp    132f <MD4_Update+0x20f>
mov    (%rbx),%ecx
add    $0x4,%rbx
mov    %rcx,(%rax)
lea    -0x1(%rdx),%ecx
add    $0x8,%rax
cmp    $0x1,%edx
je     13a9 <MD4_Update+0x289>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx),%edx
mov    %rdx,(%rax)
mov    0x4(%rbx),%edx
add    $0x8,%rbx
mov    %rdx,0x8(%rax)
add    $0x10,%rax
add    $0xfffffffe,%ecx
jne    1390 <MD4_Update+0x270>
mov    %r14d,%edx
add    %rbx,%rdx
xor    %ecx,%ecx
cmp    $0x1,%r14d
je     13de <MD4_Update+0x2be>
cmp    $0x2,%r14d
je     13cf <MD4_Update+0x2af>
cmp    $0x3,%r14d
jne    13e5 <MD4_Update+0x2c5>
movzbl -0x1(%rdx),%ecx
add    $0xffffffffffffffff,%rdx
shl    $0x10,%rcx
movzbl -0x1(%rdx),%esi
add    $0xffffffffffffffff,%rdx
shl    $0x8,%rsi
or     %rsi,%rcx
movzbl -0x1(%rdx),%edx
or     %rdx,%rcx
mov    %rcx,(%rax)
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
movzbl (%rbx),%r10d
add    $0x1,%rbx
movslq %edx,%r9
movzbl (%rbx),%eax
add    $0x1,%rbx
shl    $0x8,%rax
or     %rax,%r10
movzbl (%rbx),%eax
add    $0x1,%rbx
shl    $0x10,%rax
or     %rax,%r10
and    $0x3,%ecx
lea    0x1(%rbx),%rdi
movzbl (%rbx),%eax
shl    $0x18,%rax
or     %r10,%rax
mov    %rax,(%rsi,%r9,8)
add    $0x1,%edx
cmp    %r8d,%edx
jge    1457 <MD4_Update+0x337>
movslq %r8d,%rax
mov    %r9d,%edx
not    %edx
add    %r8d,%edx
lea    -0x2(%rax),%r10
test   $0x1,%dl
jne    145c <MD4_Update+0x33c>
lea    0x1(%r9),%rdx
jmp    146f <MD4_Update+0x34f>
mov    %edx,%r8d
jmp    149b <MD4_Update+0x37b>
mov    0x1(%rbx),%edx
add    $0x5,%rbx
mov    %rdx,0x8(%rsi,%r9,8)
lea    0x2(%r9),%rdx
mov    %rbx,%rdi
cmp    %r9,%r10
je     149b <MD4_Update+0x37b>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rdi),%ebx
mov    %rbx,(%rsi,%rdx,8)
mov    0x4(%rdi),%ebx
add    $0x8,%rdi
mov    %rbx,0x8(%rsi,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rax
jne    1480 <MD4_Update+0x360>
test   %ecx,%ecx
je     13e8 <MD4_Update+0x2c8>
mov    %ecx,%eax
add    %rax,%rdi
xor    %eax,%eax
cmp    $0x1,%ecx
je     14d4 <MD4_Update+0x3b4>
cmp    $0x2,%ecx
je     14c5 <MD4_Update+0x3a5>
cmp    $0x3,%ecx
jne    14db <MD4_Update+0x3bb>
movzbl -0x1(%rdi),%eax
add    $0xffffffffffffffff,%rdi
shl    $0x10,%rax
movzbl -0x1(%rdi),%ecx
add    $0xffffffffffffffff,%rdi
shl    $0x8,%rcx
or     %rcx,%rax
movzbl -0x1(%rdi),%ecx
or     %rcx,%rax
movslq %r8d,%rcx
mov    %rax,(%rsi,%rcx,8)
jmp    13e8 <MD4_Update+0x2c8>

LLVM IR (-O0):
%struct.TYPE_5__ = type { i64, i32, i64*, i64 }
@MD4_CBLOCK = global i64 0
@MD4_LBLOCK = global i32 0
define i32 @MD4_Update(%struct.TYPE_5__* %0, i8* %1, i64 %2) {
%4 = alloca i32
%5 = alloca %struct.TYPE_5__*
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i8*
%9 = alloca i64*
%10 = alloca i64
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
store %struct.TYPE_5__* %0, %struct.TYPE_5__** %5
store i8* %1, i8** %6
store i64 %2, i64* %7
%15 = load i8*, i8** %6
store i8* %15, i8** %8
%16 = load i64, i64* %7
%17 = icmp eq i64 %16, 0
br i1 %17, label %18, label %19
18: ; preds = %3
store i32 1, i32* %4
br label %467
19: ; preds = %3
%20 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%21 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %20, i32 0, i32 0
%22 = load i64, i64* %21
%23 = load i64, i64* %7
%24 = shl i64 %23, 3
%25 = add i64 %22, %24
%26 = and i64 %25, 4294967295
store i64 %26, i64* %10
%27 = load i64, i64* %10
%28 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%29 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %28, i32 0, i32 0
%30 = load i64, i64* %29
%31 = icmp ult i64 %27, %30
br i1 %31, label %32, label %37
32: ; preds = %19
%33 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%34 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %33, i32 0, i32 3
%35 = load i64, i64* %34
%36 = add nsw i64 %35, 1
store i64 %36, i64* %34
br label %37
37: ; preds = %32, %19
%38 = load i64, i64* %7
%39 = lshr i64 %38, 29
%40 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%41 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %40, i32 0, i32 3
%42 = load i64, i64* %41
%43 = add i64 %42, %39
store i64 %43, i64* %41
%44 = load i64, i64* %10
%45 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%46 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %45, i32 0, i32 0
store i64 %44, i64* %46
%47 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%48 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %47, i32 0, i32 1
%49 = load i32, i32* %48
%50 = icmp ne i32 %49, 0
br i1 %50, label %51, label %357
51: ; preds = %37
%52 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%53 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %52, i32 0, i32 2
%54 = load i64*, i64** %53
store i64* %54, i64** %9
%55 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%56 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %55, i32 0, i32 1
%57 = load i32, i32* %56
%58 = ashr i32 %57, 2
store i32 %58, i32* %11
%59 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%60 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %59, i32 0, i32 1
%61 = load i32, i32* %60
%62 = and i32 %61, 3
store i32 %62, i32* %12
%63 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%64 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %63, i32 0, i32 1
%65 = load i32, i32* %64
%66 = sext i32 %65 to i64
%67 = load i64, i64* %7
%68 = add i64 %66, %67
%69 = load i64, i64* @MD4_CBLOCK
%70 = icmp uge i64 %68, %69
br i1 %70, label %71, label %167
71: ; preds = %51
%72 = load i64*, i64** %9
%73 = load i32, i32* %11
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i64, i64* %72, i64 %74
%76 = load i64, i64* %75
store i64 %76, i64* %10
%77 = load i32, i32* %12
switch i32 %77, label %107 [
i32 0, label %78
i32 1, label %83
i32 2, label %91
i32 3, label %99
]
78: ; preds = %71
%79 = load i8*, i8** %8
%80 = getelementptr inbounds i8, i8* %79, i32 1
store i8* %80, i8** %8
%81 = load i8, i8* %79
%82 = zext i8 %81 to i64
store i64 %82, i64* %10
br label %83
83: ; preds = %71, %78
%84 = load i8*, i8** %8
%85 = getelementptr inbounds i8, i8* %84, i32 1
store i8* %85, i8** %8
%86 = load i8, i8* %84
%87 = zext i8 %86 to i64
%88 = shl i64 %87, 8
%89 = load i64, i64* %10
%90 = or i64 %89, %88
store i64 %90, i64* %10
br label %91
91: ; preds = %71, %83
%92 = load i8*, i8** %8
%93 = getelementptr inbounds i8, i8* %92, i32 1
store i8* %93, i8** %8
%94 = load i8, i8* %92
%95 = zext i8 %94 to i64
%96 = shl i64 %95, 16
%97 = load i64, i64* %10
%98 = or i64 %97, %96
store i64 %98, i64* %10
br label %99
99: ; preds = %71, %91
%100 = load i8*, i8** %8
%101 = getelementptr inbounds i8, i8* %100, i32 1
store i8* %101, i8** %8
%102 = load i8, i8* %100
%103 = zext i8 %102 to i64
%104 = shl i64 %103, 24
%105 = load i64, i64* %10
%106 = or i64 %105, %104
store i64 %106, i64* %10
br label %107
107: ; preds = %99, %71
%108 = load i64, i64* %10
%109 = load i64*, i64** %9
%110 = load i32, i32* %11
%111 = add nsw i32 %110, 1
store i32 %111, i32* %11
%112 = sext i32 %110 to i64
%113 = getelementptr inbounds i64, i64* %109, i64 %112
store i64 %108, i64* %113
br label %114
114: ; preds = %150, %107
%115 = load i32, i32* %11
%116 = load i32, i32* @MD4_LBLOCK
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %153
118: ; preds = %114
%119 = load i8*, i8** %8
%120 = getelementptr inbounds i8, i8* %119, i32 1
store i8* %120, i8** %8
%121 = load i8, i8* %119
%122 = zext i8 %121 to i64
store i64 %122, i64* %10
%123 = load i8*, i8** %8
%124 = getelementptr inbounds i8, i8* %123, i32 1
store i8* %124, i8** %8
%125 = load i8, i8* %123
%126 = zext i8 %125 to i64
%127 = shl i64 %126, 8
%128 = load i64, i64* %10
%129 = or i64 %128, %127
store i64 %129, i64* %10
%130 = load i8*, i8** %8
%131 = getelementptr inbounds i8, i8* %130, i32 1
store i8* %131, i8** %8
%132 = load i8, i8* %130
%133 = zext i8 %132 to i64
%134 = shl i64 %133, 16
%135 = load i64, i64* %10
%136 = or i64 %135, %134
store i64 %136, i64* %10
%137 = load i8*, i8** %8
%138 = getelementptr inbounds i8, i8* %137, i32 1
store i8* %138, i8** %8
%139 = load i8, i8* %137
%140 = zext i8 %139 to i64
%141 = shl i64 %140, 24
%142 = load i64, i64* %10
%143 = or i64 %142, %141
store i64 %143, i64* %10
%144 = load i64, i64* %10
%145 = load i64, i64* %10
%146 = load i64*, i64** %9
%147 = load i32, i32* %11
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds i64, i64* %146, i64 %148
store i64 %145, i64* %149
br label %150
150: ; preds = %118
%151 = load i32, i32* %11
%152 = add nsw i32 %151, 1
store i32 %152, i32* %11
br label %114
153: ; preds = %114
%154 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%155 = load i64*, i64** %9
%156 = call i32 @md4_block_host_order(%struct.TYPE_5__* %154, i64* %155, i32 1)
%157 = load i64, i64* @MD4_CBLOCK
%158 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%159 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %158, i32 0, i32 1
%160 = load i32, i32* %159
%161 = sext i32 %160 to i64
%162 = sub i64 %157, %161
%163 = load i64, i64* %7
%164 = sub i64 %163, %162
store i64 %164, i64* %7
%165 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%166 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %165, i32 0, i32 1
store i32 0, i32* %166
br label %356
167: ; preds = %51
%168 = load i64, i64* %7
%169 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%170 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %169, i32 0, i32 1
%171 = load i32, i32* %170
%172 = sext i32 %171 to i64
%173 = add i64 %172, %168
%174 = trunc i64 %173 to i32
store i32 %174, i32* %170
%175 = load i32, i32* %12
%176 = sext i32 %175 to i64
%177 = load i64, i64* %7
%178 = add i64 %176, %177
%179 = icmp ult i64 %178, 4
br i1 %179, label %180, label %224
180: ; preds = %167
%181 = load i64*, i64** %9
%182 = load i32, i32* %11
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i64, i64* %181, i64 %183
%185 = load i64, i64* %184
store i64 %185, i64* %10
%186 = load i32, i32* %12
switch i32 %186, label %218 [
i32 0, label %187
i32 1, label %197
i32 2, label %210
]
187: ; preds = %180
%188 = load i8*, i8** %8
%189 = getelementptr inbounds i8, i8* %188, i32 1
store i8* %189, i8** %8
%190 = load i8, i8* %188
%191 = zext i8 %190 to i64
store i64 %191, i64* %10
%192 = load i64, i64* %7
%193 = add i64 %192, -1
store i64 %193, i64* %7
%194 = icmp eq i64 %193, 0
br i1 %194, label %195, label %196
195: ; preds = %187
br label %218
196: ; preds = %187
br label %197
197: ; preds = %180, %196
%198 = load i8*, i8** %8
%199 = getelementptr inbounds i8, i8* %198, i32 1
store i8* %199, i8** %8
%200 = load i8, i8* %198
%201 = zext i8 %200 to i64
%202 = shl i64 %201, 8
%203 = load i64, i64* %10
%204 = or i64 %203, %202
store i64 %204, i64* %10
%205 = load i64, i64* %7
%206 = add i64 %205, -1
store i64 %206, i64* %7
%207 = icmp eq i64 %206, 0
br i1 %207, label %208, label %209
208: ; preds = %197
br label %218
209: ; preds = %197
br label %210
210: ; preds = %180, %209
%211 = load i8*, i8** %8
%212 = getelementptr inbounds i8, i8* %211, i32 1
store i8* %212, i8** %8
%213 = load i8, i8* %211
%214 = zext i8 %213 to i64
%215 = shl i64 %214, 16
%216 = load i64, i64* %10
%217 = or i64 %216, %215
store i64 %217, i64* %10
br label %218
218: ; preds = %210, %180, %208, %195
%219 = load i64, i64* %10
%220 = load i64*, i64** %9
%221 = load i32, i32* %11
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i64, i64* %220, i64 %222
store i64 %219, i64* %223
br label %355
224: ; preds = %167
%225 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%226 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %225, i32 0, i32 1
%227 = load i32, i32* %226
%228 = ashr i32 %227, 2
store i32 %228, i32* %13
%229 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%230 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %229, i32 0, i32 1
%231 = load i32, i32* %230
%232 = and i32 %231, 3
store i32 %232, i32* %14
%233 = load i32, i32* %12
%234 = icmp ne i32 %233, 0
br i1 %234, label %235, label %241
235: ; preds = %224
%236 = load i64*, i64** %9
%237 = load i32, i32* %11
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i64, i64* %236, i64 %238
%240 = load i64, i64* %239
store i64 %240, i64* %10
br label %241
241: ; preds = %235, %224
%242 = load i32, i32* %12
switch i32 %242, label %272 [
i32 0, label %243
i32 1, label %248
i32 2, label %256
i32 3, label %264
]
243: ; preds = %241
%244 = load i8*, i8** %8
%245 = getelementptr inbounds i8, i8* %244, i32 1
store i8* %245, i8** %8
%246 = load i8, i8* %244
%247 = zext i8 %246 to i64
store i64 %247, i64* %10
br label %248
248: ; preds = %241, %243
%249 = load i8*, i8** %8
%250 = getelementptr inbounds i8, i8* %249, i32 1
store i8* %250, i8** %8
%251 = load i8, i8* %249
%252 = zext i8 %251 to i64
%253 = shl i64 %252, 8
%254 = load i64, i64* %10
%255 = or i64 %254, %253
store i64 %255, i64* %10
br label %256
256: ; preds = %241, %248
%257 = load i8*, i8** %8
%258 = getelementptr inbounds i8, i8* %257, i32 1
store i8* %258, i8** %8
%259 = load i8, i8* %257
%260 = zext i8 %259 to i64
%261 = shl i64 %260, 16
%262 = load i64, i64* %10
%263 = or i64 %262, %261
store i64 %263, i64* %10
br label %264
264: ; preds = %241, %256
%265 = load i8*, i8** %8
%266 = getelementptr inbounds i8, i8* %265, i32 1
store i8* %266, i8** %8
%267 = load i8, i8* %265
%268 = zext i8 %267 to i64
%269 = shl i64 %268, 24
%270 = load i64, i64* %10
%271 = or i64 %270, %269
store i64 %271, i64* %10
br label %272
272: ; preds = %264, %241
%273 = load i64, i64* %10
%274 = load i64*, i64** %9
%275 = load i32, i32* %11
%276 = add nsw i32 %275, 1
store i32 %276, i32* %11
%277 = sext i32 %275 to i64
%278 = getelementptr inbounds i64, i64* %274, i64 %277
store i64 %273, i64* %278
br label %279
279: ; preds = %315, %272
%280 = load i32, i32* %11
%281 = load i32, i32* %13
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %318
283: ; preds = %279
%284 = load i8*, i8** %8
%285 = getelementptr inbounds i8, i8* %284, i32 1
store i8* %285, i8** %8
%286 = load i8, i8* %284
%287 = zext i8 %286 to i64
store i64 %287, i64* %10
%288 = load i8*, i8** %8
%289 = getelementptr inbounds i8, i8* %288, i32 1
store i8* %289, i8** %8
%290 = load i8, i8* %288
%291 = zext i8 %290 to i64
%292 = shl i64 %291, 8
%293 = load i64, i64* %10
%294 = or i64 %293, %292
store i64 %294, i64* %10
%295 = load i8*, i8** %8
%296 = getelementptr inbounds i8, i8* %295, i32 1
store i8* %296, i8** %8
%297 = load i8, i8* %295
%298 = zext i8 %297 to i64
%299 = shl i64 %298, 16
%300 = load i64, i64* %10
%301 = or i64 %300, %299
store i64 %301, i64* %10
%302 = load i8*, i8** %8
%303 = getelementptr inbounds i8, i8* %302, i32 1
store i8* %303, i8** %8
%304 = load i8, i8* %302
%305 = zext i8 %304 to i64
%306 = shl i64 %305, 24
%307 = load i64, i64* %10
%308 = or i64 %307, %306
store i64 %308, i64* %10
%309 = load i64, i64* %10
%310 = load i64, i64* %10
%311 = load i64*, i64** %9
%312 = load i32, i32* %11
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds i64, i64* %311, i64 %313
store i64 %310, i64* %314
br label %315
315: ; preds = %283
%316 = load i32, i32* %11
%317 = add nsw i32 %316, 1
store i32 %317, i32* %11
br label %279
318: ; preds = %279
%319 = load i32, i32* %14
%320 = icmp ne i32 %319, 0
br i1 %320, label %321, label %354
321: ; preds = %318
store i64 0, i64* %10
%322 = load i32, i32* %14
%323 = load i8*, i8** %8
%324 = sext i32 %322 to i64
%325 = getelementptr inbounds i8, i8* %323, i64 %324
store i8* %325, i8** %8
%326 = load i32, i32* %14
switch i32 %326, label %348 [
i32 3, label %327
i32 2, label %333
i32 1, label %341
]
327: ; preds = %321
%328 = load i8*, i8** %8
%329 = getelementptr inbounds i8, i8* %328, i32 -1
store i8* %329, i8** %8
%330 = load i8, i8* %329
%331 = zext i8 %330 to i64
%332 = shl i64 %331, 16
store i64 %332, i64* %10
br label %333
333: ; preds = %321, %327
%334 = load i8*, i8** %8
%335 = getelementptr inbounds i8, i8* %334, i32 -1
store i8* %335, i8** %8
%336 = load i8, i8* %335
%337 = zext i8 %336 to i64
%338 = shl i64 %337, 8
%339 = load i64, i64* %10
%340 = or i64 %339, %338
store i64 %340, i64* %10
br label %341
341: ; preds = %321, %333
%342 = load i8*, i8** %8
%343 = getelementptr inbounds i8, i8* %342, i32 -1
store i8* %343, i8** %8
%344 = load i8, i8* %343
%345 = zext i8 %344 to i64
%346 = load i64, i64* %10
%347 = or i64 %346, %345
store i64 %347, i64* %10
br label %348
348: ; preds = %341, %321
%349 = load i64, i64* %10
%350 = load i64*, i64** %9
%351 = load i32, i32* %11
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds i64, i64* %350, i64 %352
store i64 %349, i64* %353
br label %354
354: ; preds = %348, %318
br label %355
355: ; preds = %354, %218
store i32 1, i32* %4
br label %467
356: ; preds = %153
br label %357
357: ; preds = %356, %37
%358 = load i64, i64* %7
%359 = load i64, i64* @MD4_CBLOCK
%360 = udiv i64 %358, %359
%361 = trunc i64 %360 to i32
store i32 %361, i32* %11
%362 = load i32, i32* %11
%363 = icmp sgt i32 %362, 0
br i1 %363, label %364, label %382
364: ; preds = %357
%365 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%366 = load i8*, i8** %8
%367 = load i32, i32* %11
%368 = call i32 @md4_block_data_order(%struct.TYPE_5__* %365, i8* %366, i32 %367)
%369 = load i64, i64* @MD4_CBLOCK
%370 = load i32, i32* %11
%371 = sext i32 %370 to i64
%372 = mul i64 %371, %369
%373 = trunc i64 %372 to i32
store i32 %373, i32* %11
%374 = load i32, i32* %11
%375 = load i8*, i8** %8
%376 = sext i32 %374 to i64
%377 = getelementptr inbounds i8, i8* %375, i64 %376
store i8* %377, i8** %8
%378 = load i32, i32* %11
%379 = sext i32 %378 to i64
%380 = load i64, i64* %7
%381 = sub i64 %380, %379
store i64 %381, i64* %7
br label %382
382: ; preds = %364, %357
%383 = load i64, i64* %7
%384 = icmp ne i64 %383, 0
br i1 %384, label %385, label %466
385: ; preds = %382
%386 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%387 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %386, i32 0, i32 2
%388 = load i64*, i64** %387
store i64* %388, i64** %9
%389 = load i64, i64* %7
%390 = trunc i64 %389 to i32
%391 = load %struct.TYPE_5__*, %struct.TYPE_5__** %5
%392 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %391, i32 0, i32 1
store i32 %390, i32* %392
%393 = load i64, i64* %7
%394 = lshr i64 %393, 2
%395 = trunc i64 %394 to i32
store i32 %395, i32* %13
%396 = load i64, i64* %7
%397 = and i64 %396, 3
%398 = trunc i64 %397 to i32
store i32 %398, i32* %14
br label %399
399: ; preds = %431, %385
%400 = load i32, i32* %13
%401 = icmp ne i32 %400, 0
br i1 %401, label %402, label %436
402: ; preds = %399
%403 = load i8*, i8** %8
%404 = getelementptr inbounds i8, i8* %403, i32 1
store i8* %404, i8** %8
%405 = load i8, i8* %403
%406 = zext i8 %405 to i64
store i64 %406, i64* %10
%407 = load i8*, i8** %8
%408 = getelementptr inbounds i8, i8* %407, i32 1
store i8* %408, i8** %8
%409 = load i8, i8* %407
%410 = zext i8 %409 to i64
%411 = shl i64 %410, 8
%412 = load i64, i64* %10
%413 = or i64 %412, %411
store i64 %413, i64* %10
%414 = load i8*, i8** %8
%415 = getelementptr inbounds i8, i8* %414, i32 1
store i8* %415, i8** %8
%416 = load i8, i8* %414
%417 = zext i8 %416 to i64
%418 = shl i64 %417, 16
%419 = load i64, i64* %10
%420 = or i64 %419, %418
store i64 %420, i64* %10
%421 = load i8*, i8** %8
%422 = getelementptr inbounds i8, i8* %421, i32 1
store i8* %422, i8** %8
%423 = load i8, i8* %421
%424 = zext i8 %423 to i64
%425 = shl i64 %424, 24
%426 = load i64, i64* %10
%427 = or i64 %426, %425
store i64 %427, i64* %10
%428 = load i64, i64* %10
%429 = load i64, i64* %10
%430 = load i64*, i64** %9
store i64 %429, i64* %430
br label %431
431: ; preds = %402
%432 = load i32, i32* %13
%433 = add nsw i32 %432, -1
store i32 %433, i32* %13
%434 = load i64*, i64** %9
%435 = getelementptr inbounds i64, i64* %434, i32 1
store i64* %435, i64** %9
br label %399
436: ; preds = %399
store i64 0, i64* %10
%437 = load i32, i32* %14
%438 = load i8*, i8** %8
%439 = sext i32 %437 to i64
%440 = getelementptr inbounds i8, i8* %438, i64 %439
store i8* %440, i8** %8
%441 = load i32, i32* %14
switch i32 %441, label %463 [
i32 3, label %442
i32 2, label %448
i32 1, label %456
]
442: ; preds = %436
%443 = load i8*, i8** %8
%444 = getelementptr inbounds i8, i8* %443, i32 -1
store i8* %444, i8** %8
%445 = load i8, i8* %444
%446 = zext i8 %445 to i64
%447 = shl i64 %446, 16
store i64 %447, i64* %10
br label %448
448: ; preds = %436, %442
%449 = load i8*, i8** %8
%450 = getelementptr inbounds i8, i8* %449, i32 -1
store i8* %450, i8** %8
%451 = load i8, i8* %450
%452 = zext i8 %451 to i64
%453 = shl i64 %452, 8
%454 = load i64, i64* %10
%455 = or i64 %454, %453
store i64 %455, i64* %10
br label %456
456: ; preds = %436, %448
%457 = load i8*, i8** %8
%458 = getelementptr inbounds i8, i8* %457, i32 -1
store i8* %458, i8** %8
%459 = load i8, i8* %458
%460 = zext i8 %459 to i64
%461 = load i64, i64* %10
%462 = or i64 %461, %460
store i64 %462, i64* %10
br label %463
463: ; preds = %456, %436
%464 = load i64, i64* %10
%465 = load i64*, i64** %9
store i64 %464, i64* %465
br label %466
466: ; preds = %463, %382
store i32 1, i32* %4
br label %467
467: ; preds = %466, %355, %18
%468 = load i32, i32* %4
ret i32 %468
}

LLVM IR (-O2):
%struct.TYPE_5__ = type { i64, i32, i64*, i64 }
@MD4_CBLOCK = global i64 0
@MD4_LBLOCK = global i32 0
define i32 @MD4_Update(%struct.TYPE_5__* %0, i8* %1, i64 %2) {
%4 = icmp eq i64 %2, 0
br i1 %4, label %471, label %5
5: ; preds = %3
%6 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %0, i64 0, i32 0
%7 = load i64, i64* %6
%8 = shl i64 %2, 3
%9 = add i64 %7, %8
%10 = and i64 %9, 4294967295
%11 = icmp ult i64 %10, %7
%12 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %0, i64 0, i32 3
%13 = load i64, i64* %12
%14 = zext i1 %11 to i64
%15 = add nsw i64 %13, %14
%16 = lshr i64 %2, 29
%17 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %0, i64 0, i32 3
%18 = add i64 %15, %16
store i64 %18, i64* %17
store i64 %10, i64* %6
%19 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %0, i64 0, i32 1
%20 = load i32, i32* %19
%21 = icmp eq i32 %20, 0
br i1 %21, label %22, label %24
22: ; preds = %5
%23 = load i64, i64* @MD4_CBLOCK
br label %342
24: ; preds = %5
%25 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %0, i64 0, i32 2
%26 = load i64*, i64** %25
%27 = ashr i32 %20, 2
%28 = and i32 %20, 3
%29 = sext i32 %20 to i64
%30 = add i64 %29, %2
%31 = load i64, i64* @MD4_CBLOCK
%32 = icmp ult i64 %30, %31
br i1 %32, label %155, label %33
33: ; preds = %24
%34 = sext i32 %27 to i64
%35 = getelementptr inbounds i64, i64* %26, i64 %34
%36 = load i64, i64* %35
switch i32 %28, label %102 [
i32 0, label %37
i32 1, label %41
i32 2, label %49
i32 3, label %57
]
37: ; preds = %33
%38 = getelementptr inbounds i8, i8* %1, i64 1
%39 = load i8, i8* %1
%40 = zext i8 %39 to i64
br label %41
41: ; preds = %33, %37
%42 = phi i8* [ %1, %33 ], [ %38, %37 ]
%43 = phi i64 [ %36, %33 ], [ %40, %37 ]
%44 = getelementptr inbounds i8, i8* %42, i64 1
%45 = load i8, i8* %42
%46 = zext i8 %45 to i64
%47 = shl nuw nsw i64 %46, 8
%48 = or i64 %47, %43
br label %49
49: ; preds = %33, %41
%50 = phi i8* [ %1, %33 ], [ %44, %41 ]
%51 = phi i64 [ %36, %33 ], [ %48, %41 ]
%52 = getelementptr inbounds i8, i8* %50, i64 1
%53 = load i8, i8* %50
%54 = zext i8 %53 to i64
%55 = shl nuw nsw i64 %54, 16
%56 = or i64 %55, %51
br label %57
57: ; preds = %33, %49
%58 = phi i8* [ %1, %33 ], [ %52, %49 ]
%59 = phi i64 [ %36, %33 ], [ %56, %49 ]
%60 = getelementptr inbounds i8, i8* %58, i64 1
%61 = load i8, i8* %58
%62 = zext i8 %61 to i64
%63 = shl nuw nsw i64 %62, 24
%64 = or i64 %63, %59
store i64 %64, i64* %35
%65 = load i32, i32* @MD4_LBLOCK
%66 = add nsw i32 %27, 1
%67 = icmp slt i32 %66, %65
br i1 %67, label %68, label %147
68: ; preds = %57
%69 = add nsw i64 %34, 1
%70 = sext i32 %65 to i64
%71 = xor i64 %34, -1
%72 = add nsw i64 %71, %70
%73 = add nsw i64 %70, -2
%74 = and i64 %72, 1
%75 = icmp eq i64 %74, 0
br i1 %75, label %97, label %76
76: ; preds = %68
%77 = getelementptr inbounds i8, i8* %58, i64 2
%78 = load i8, i8* %60
%79 = zext i8 %78 to i64
%80 = getelementptr inbounds i8, i8* %58, i64 3
%81 = load i8, i8* %77
%82 = zext i8 %81 to i64
%83 = shl nuw nsw i64 %82, 8
%84 = or i64 %83, %79
%85 = getelementptr inbounds i8, i8* %58, i64 4
%86 = load i8, i8* %80
%87 = zext i8 %86 to i64
%88 = shl nuw nsw i64 %87, 16
%89 = or i64 %84, %88
%90 = getelementptr inbounds i8, i8* %58, i64 5
%91 = load i8, i8* %85
%92 = zext i8 %91 to i64
%93 = shl nuw nsw i64 %92, 24
%94 = or i64 %89, %93
%95 = getelementptr inbounds i64, i64* %26, i64 %69
store i64 %94, i64* %95
%96 = add nsw i64 %34, 2
br label %97
97: ; preds = %76, %68
%98 = phi i8* [ undef, %68 ], [ %90, %76 ]
%99 = phi i64 [ %69, %68 ], [ %96, %76 ]
%100 = phi i8* [ %60, %68 ], [ %90, %76 ]
%101 = icmp eq i64 %73, %34
br i1 %101, label %147, label %103
102: ; preds = %33
unreachable
103: ; preds = %97, %103
%104 = phi i64 [ %145, %103 ], [ %99, %97 ]
%105 = phi i8* [ %139, %103 ], [ %100, %97 ]
%106 = getelementptr inbounds i8, i8* %105, i64 1
%107 = load i8, i8* %105
%108 = zext i8 %107 to i64
%109 = getelementptr inbounds i8, i8* %105, i64 2
%110 = load i8, i8* %106
%111 = zext i8 %110 to i64
%112 = shl nuw nsw i64 %111, 8
%113 = or i64 %112, %108
%114 = getelementptr inbounds i8, i8* %105, i64 3
%115 = load i8, i8* %109
%116 = zext i8 %115 to i64
%117 = shl nuw nsw i64 %116, 16
%118 = or i64 %113, %117
%119 = getelementptr inbounds i8, i8* %105, i64 4
%120 = load i8, i8* %114
%121 = zext i8 %120 to i64
%122 = shl nuw nsw i64 %121, 24
%123 = or i64 %118, %122
%124 = getelementptr inbounds i64, i64* %26, i64 %104
store i64 %123, i64* %124
%125 = add nsw i64 %104, 1
%126 = getelementptr inbounds i8, i8* %105, i64 5
%127 = load i8, i8* %119
%128 = zext i8 %127 to i64
%129 = getelementptr inbounds i8, i8* %105, i64 6
%130 = load i8, i8* %126
%131 = zext i8 %130 to i64
%132 = shl nuw nsw i64 %131, 8
%133 = or i64 %132, %128
%134 = getelementptr inbounds i8, i8* %105, i64 7
%135 = load i8, i8* %129
%136 = zext i8 %135 to i64
%137 = shl nuw nsw i64 %136, 16
%138 = or i64 %133, %137
%139 = getelementptr inbounds i8, i8* %105, i64 8
%140 = load i8, i8* %134
%141 = zext i8 %140 to i64
%142 = shl nuw nsw i64 %141, 24
%143 = or i64 %138, %142
%144 = getelementptr inbounds i64, i64* %26, i64 %125
store i64 %143, i64* %144
%145 = add nsw i64 %104, 2
%146 = icmp eq i64 %145, %70
br i1 %146, label %147, label %103
147: ; preds = %97, %103, %57
%148 = phi i8* [ %60, %57 ], [ %98, %97 ], [ %139, %103 ]
%149 = tail call i32 @md4_block_host_order(%struct.TYPE_5__* %0, i64* %26, i32 1)
%150 = load i64, i64* @MD4_CBLOCK
%151 = load i32, i32* %19
%152 = sext i32 %151 to i64
%153 = sub i64 %2, %150
%154 = add i64 %153, %152
store i32 0, i32* %19
br label %342
155: ; preds = %24
%156 = trunc i64 %30 to i32
store i32 %156, i32* %19
%157 = zext i32 %28 to i64
%158 = add i64 %157, %2
%159 = icmp ult i64 %158, 4
br i1 %159, label %160, label %189
160: ; preds = %155
%161 = sext i32 %27 to i64
%162 = getelementptr inbounds i64, i64* %26, i64 %161
%163 = load i64, i64* %162
switch i32 %28, label %187 [
i32 0, label %164
i32 1, label %170
i32 2, label %180
]
164: ; preds = %160
%165 = getelementptr inbounds i8, i8* %1, i64 1
%166 = load i8, i8* %1
%167 = zext i8 %166 to i64
%168 = add i64 %2, -1
%169 = icmp eq i64 %168, 0
br i1 %169, label %187, label %170
170: ; preds = %164, %160
%171 = phi i64 [ %2, %160 ], [ %168, %164 ]
%172 = phi i8* [ %1, %160 ], [ %165, %164 ]
%173 = phi i64 [ %163, %160 ], [ %167, %164 ]
%174 = getelementptr inbounds i8, i8* %172, i64 1
%175 = load i8, i8* %172
%176 = zext i8 %175 to i64
%177 = shl nuw nsw i64 %176, 8
%178 = or i64 %177, %173
%179 = icmp eq i64 %171, 1
br i1 %179, label %187, label %180
180: ; preds = %170, %160
%181 = phi i8* [ %1, %160 ], [ %174, %170 ]
%182 = phi i64 [ %163, %160 ], [ %178, %170 ]
%183 = load i8, i8* %181
%184 = zext i8 %183 to i64
%185 = shl nuw nsw i64 %184, 16
%186 = or i64 %185, %182
br label %187
187: ; preds = %170, %164, %180, %160
%188 = phi i64 [ %163, %160 ], [ %186, %180 ], [ %178, %170 ], [ %167, %164 ]
store i64 %188, i64* %162
br label %471
189: ; preds = %155
%190 = ashr i32 %156, 2
%191 = and i32 %156, 3
%192 = icmp eq i32 %28, 0
br i1 %192, label %197, label %193
193: ; preds = %189
%194 = sext i32 %27 to i64
%195 = getelementptr inbounds i64, i64* %26, i64 %194
%196 = load i64, i64* %195
switch i32 %28, label %266 [
i32 3, label %220
i32 1, label %202
i32 2, label %211
]
197: ; preds = %189
%198 = getelementptr inbounds i8, i8* %1, i64 1
%199 = load i8, i8* %1
%200 = zext i8 %199 to i64
%201 = sext i32 %27 to i64
br label %202
202: ; preds = %193, %197
%203 = phi i64 [ %194, %193 ], [ %201, %197 ]
%204 = phi i8* [ %1, %193 ], [ %198, %197 ]
%205 = phi i64 [ %196, %193 ], [ %200, %197 ]
%206 = getelementptr inbounds i8, i8* %204, i64 1
%207 = load i8, i8* %204
%208 = zext i8 %207 to i64
%209 = shl nuw nsw i64 %208, 8
%210 = or i64 %209, %205
br label %211
211: ; preds = %193, %202
%212 = phi i64 [ %194, %193 ], [ %203, %202 ]
%213 = phi i8* [ %1, %193 ], [ %206, %202 ]
%214 = phi i64 [ %196, %193 ], [ %210, %202 ]
%215 = getelementptr inbounds i8, i8* %213, i64 1
%216 = load i8, i8* %213
%217 = zext i8 %216 to i64
%218 = shl nuw nsw i64 %217, 16
%219 = or i64 %218, %214
br label %220
220: ; preds = %193, %211
%221 = phi i64 [ %194, %193 ], [ %212, %211 ]
%222 = phi i8* [ %1, %193 ], [ %215, %211 ]
%223 = phi i64 [ %196, %193 ], [ %219, %211 ]
%224 = getelementptr inbounds i8, i8* %222, i64 1
%225 = load i8, i8* %222
%226 = zext i8 %225 to i64
%227 = shl nuw nsw i64 %226, 24
%228 = or i64 %227, %223
%229 = getelementptr inbounds i64, i64* %26, i64 %221
store i64 %228, i64* %229
%230 = add nsw i32 %27, 1
%231 = icmp slt i32 %230, %190
br i1 %231, label %232, label %311
232: ; preds = %220
%233 = add nsw i64 %221, 1
%234 = sext i32 %190 to i64
%235 = xor i64 %221, -1
%236 = add nsw i64 %235, %234
%237 = add nsw i64 %234, -2
%238 = and i64 %236, 1
%239 = icmp eq i64 %238, 0
br i1 %239, label %261, label %240
240: ; preds = %232
%241 = getelementptr inbounds i8, i8* %222, i64 2
%242 = load i8, i8* %224
%243 = zext i8 %242 to i64
%244 = getelementptr inbounds i8, i8* %222, i64 3
%245 = load i8, i8* %241
%246 = zext i8 %245 to i64
%247 = shl nuw nsw i64 %246, 8
%248 = or i64 %247, %243
%249 = getelementptr inbounds i8, i8* %222, i64 4
%250 = load i8, i8* %244
%251 = zext i8 %250 to i64
%252 = shl nuw nsw i64 %251, 16
%253 = or i64 %248, %252
%254 = getelementptr inbounds i8, i8* %222, i64 5
%255 = load i8, i8* %249
%256 = zext i8 %255 to i64
%257 = shl nuw nsw i64 %256, 24
%258 = or i64 %253, %257
%259 = getelementptr inbounds i64, i64* %26, i64 %233
store i64 %258, i64* %259
%260 = add nsw i64 %221, 2
br label %261
261: ; preds = %240, %232
%262 = phi i8* [ undef, %232 ], [ %254, %240 ]
%263 = phi i64 [ %233, %232 ], [ %260, %240 ]
%264 = phi i8* [ %224, %232 ], [ %254, %240 ]
%265 = icmp eq i64 %237, %221
br i1 %265, label %311, label %267
266: ; preds = %193
unreachable
267: ; preds = %261, %267
%268 = phi i64 [ %309, %267 ], [ %263, %261 ]
%269 = phi i8* [ %303, %267 ], [ %264, %261 ]
%270 = getelementptr inbounds i8, i8* %269, i64 1
%271 = load i8, i8* %269
%272 = zext i8 %271 to i64
%273 = getelementptr inbounds i8, i8* %269, i64 2
%274 = load i8, i8* %270
%275 = zext i8 %274 to i64
%276 = shl nuw nsw i64 %275, 8
%277 = or i64 %276, %272
%278 = getelementptr inbounds i8, i8* %269, i64 3
%279 = load i8, i8* %273
%280 = zext i8 %279 to i64
%281 = shl nuw nsw i64 %280, 16
%282 = or i64 %277, %281
%283 = getelementptr inbounds i8, i8* %269, i64 4
%284 = load i8, i8* %278
%285 = zext i8 %284 to i64
%286 = shl nuw nsw i64 %285, 24
%287 = or i64 %282, %286
%288 = getelementptr inbounds i64, i64* %26, i64 %268
store i64 %287, i64* %288
%289 = add nsw i64 %268, 1
%290 = getelementptr inbounds i8, i8* %269, i64 5
%291 = load i8, i8* %283
%292 = zext i8 %291 to i64
%293 = getelementptr inbounds i8, i8* %269, i64 6
%294 = load i8, i8* %290
%295 = zext i8 %294 to i64
%296 = shl nuw nsw i64 %295, 8
%297 = or i64 %296, %292
%298 = getelementptr inbounds i8, i8* %269, i64 7
%299 = load i8, i8* %293
%300 = zext i8 %299 to i64
%301 = shl nuw nsw i64 %300, 16
%302 = or i64 %297, %301
%303 = getelementptr inbounds i8, i8* %269, i64 8
%304 = load i8, i8* %298
%305 = zext i8 %304 to i64
%306 = shl nuw nsw i64 %305, 24
%307 = or i64 %302, %306
%308 = getelementptr inbounds i64, i64* %26, i64 %289
store i64 %307, i64* %308
%309 = add nsw i64 %268, 2
%310 = icmp eq i64 %309, %234
br i1 %310, label %311, label %267
311: ; preds = %261, %267, %220
%312 = phi i8* [ %224, %220 ], [ %262, %261 ], [ %303, %267 ]
%313 = phi i32 [ %230, %220 ], [ %190, %267 ], [ %190, %261 ]
%314 = icmp eq i32 %191, 0
br i1 %314, label %471, label %315
315: ; preds = %311
%316 = zext i32 %191 to i64
%317 = getelementptr inbounds i8, i8* %312, i64 %316
switch i32 %191, label %338 [
i32 3, label %318
i32 2, label %323
i32 1, label %331
]
318: ; preds = %315
%319 = getelementptr inbounds i8, i8* %317, i64 -1
%320 = load i8, i8* %319
%321 = zext i8 %320 to i64
%322 = shl nuw nsw i64 %321, 16
br label %323
323: ; preds = %315, %318
%324 = phi i8* [ %317, %315 ], [ %319, %318 ]
%325 = phi i64 [ 0, %315 ], [ %322, %318 ]
%326 = getelementptr inbounds i8, i8* %324, i64 -1
%327 = load i8, i8* %326
%328 = zext i8 %327 to i64
%329 = shl nuw nsw i64 %328, 8
%330 = or i64 %329, %325
br label %331
331: ; preds = %315, %323
%332 = phi i8* [ %317, %315 ], [ %326, %323 ]
%333 = phi i64 [ 0, %315 ], [ %330, %323 ]
%334 = getelementptr inbounds i8, i8* %332, i64 -1
%335 = load i8, i8* %334
%336 = zext i8 %335 to i64
%337 = or i64 %333, %336
br label %338
338: ; preds = %331, %315
%339 = phi i64 [ 0, %315 ], [ %337, %331 ]
%340 = sext i32 %313 to i64
%341 = getelementptr inbounds i64, i64* %26, i64 %340
store i64 %339, i64* %341
br label %471
342: ; preds = %22, %147
%343 = phi i64 [ %150, %147 ], [ %23, %22 ]
%344 = phi i64 [ %154, %147 ], [ %2, %22 ]
%345 = phi i8* [ %148, %147 ], [ %1, %22 ]
%346 = udiv i64 %344, %343
%347 = trunc i64 %346 to i32
%348 = icmp sgt i32 %347, 0
br i1 %348, label %349, label %357
349: ; preds = %342
%350 = tail call i32 @md4_block_data_order(%struct.TYPE_5__* %0, i8* %345, i32 %347)
%351 = load i64, i64* @MD4_CBLOCK
%352 = shl i64 %346, 32
%353 = mul i64 %352, %351
%354 = ashr exact i64 %353, 32
%355 = getelementptr inbounds i8, i8* %345, i64 %354
%356 = sub i64 %344, %354
br label %357
357: ; preds = %349, %342
%358 = phi i64 [ %356, %349 ], [ %344, %342 ]
%359 = phi i8* [ %355, %349 ], [ %345, %342 ]
%360 = icmp eq i64 %358, 0
br i1 %360, label %471, label %361
361: ; preds = %357
%362 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %0, i64 0, i32 2
%363 = load i64*, i64** %362
%364 = trunc i64 %358 to i32
store i32 %364, i32* %19
%365 = lshr i64 %358, 2
%366 = trunc i64 %365 to i32
%367 = and i32 %364, 3
%368 = icmp eq i32 %366, 0
br i1 %368, label %444, label %369
369: ; preds = %361
%370 = and i32 %366, 1
%371 = icmp eq i32 %370, 0
br i1 %371, label %393, label %372
372: ; preds = %369
%373 = getelementptr inbounds i8, i8* %359, i64 1
%374 = load i8, i8* %359
%375 = zext i8 %374 to i64
%376 = getelementptr inbounds i8, i8* %359, i64 2
%377 = load i8, i8* %373
%378 = zext i8 %377 to i64
%379 = shl nuw nsw i64 %378, 8
%380 = or i64 %379, %375
%381 = getelementptr inbounds i8, i8* %359, i64 3
%382 = load i8, i8* %376
%383 = zext i8 %382 to i64
%384 = shl nuw nsw i64 %383, 16
%385 = or i64 %380, %384
%386 = getelementptr inbounds i8, i8* %359, i64 4
%387 = load i8, i8* %381
%388 = zext i8 %387 to i64
%389 = shl nuw nsw i64 %388, 24
%390 = or i64 %385, %389
store i64 %390, i64* %363
%391 = add nsw i32 %366, -1
%392 = getelementptr inbounds i64, i64* %363, i64 1
br label %393
393: ; preds = %372, %369
%394 = phi i8* [ undef, %369 ], [ %386, %372 ]
%395 = phi i64* [ undef, %369 ], [ %392, %372 ]
%396 = phi i32 [ %366, %369 ], [ %391, %372 ]
%397 = phi i64* [ %363, %369 ], [ %392, %372 ]
%398 = phi i8* [ %359, %369 ], [ %386, %372 ]
%399 = icmp eq i32 %366, 1
br i1 %399, label %444, label %400
400: ; preds = %393, %400
%401 = phi i32 [ %441, %400 ], [ %396, %393 ]
%402 = phi i64* [ %442, %400 ], [ %397, %393 ]
%403 = phi i8* [ %436, %400 ], [ %398, %393 ]
%404 = getelementptr inbounds i8, i8* %403, i64 1
%405 = load i8, i8* %403
%406 = zext i8 %405 to i64
%407 = getelementptr inbounds i8, i8* %403, i64 2
%408 = load i8, i8* %404
%409 = zext i8 %408 to i64
%410 = shl nuw nsw i64 %409, 8
%411 = or i64 %410, %406
%412 = getelementptr inbounds i8, i8* %403, i64 3
%413 = load i8, i8* %407
%414 = zext i8 %413 to i64
%415 = shl nuw nsw i64 %414, 16
%416 = or i64 %411, %415
%417 = getelementptr inbounds i8, i8* %403, i64 4
%418 = load i8, i8* %412
%419 = zext i8 %418 to i64
%420 = shl nuw nsw i64 %419, 24
%421 = or i64 %416, %420
store i64 %421, i64* %402
%422 = getelementptr inbounds i64, i64* %402, i64 1
%423 = getelementptr inbounds i8, i8* %403, i64 5
%424 = load i8, i8* %417
%425 = zext i8 %424 to i64
%426 = getelementptr inbounds i8, i8* %403, i64 6
%427 = load i8, i8* %423
%428 = zext i8 %427 to i64
%429 = shl nuw nsw i64 %428, 8
%430 = or i64 %429, %425
%431 = getelementptr inbounds i8, i8* %403, i64 7
%432 = load i8, i8* %426
%433 = zext i8 %432 to i64
%434 = shl nuw nsw i64 %433, 16
%435 = or i64 %430, %434
%436 = getelementptr inbounds i8, i8* %403, i64 8
%437 = load i8, i8* %431
%438 = zext i8 %437 to i64
%439 = shl nuw nsw i64 %438, 24
%440 = or i64 %435, %439
store i64 %440, i64* %422
%441 = add nsw i32 %401, -2
%442 = getelementptr inbounds i64, i64* %402, i64 2
%443 = icmp eq i32 %441, 0
br i1 %443, label %444, label %400
444: ; preds = %393, %400, %361
%445 = phi i8* [ %359, %361 ], [ %394, %393 ], [ %436, %400 ]
%446 = phi i64* [ %363, %361 ], [ %395, %393 ], [ %442, %400 ]
%447 = zext i32 %367 to i64
%448 = getelementptr inbounds i8, i8* %445, i64 %447
switch i32 %367, label %469 [
i32 3, label %449
i32 2, label %454
i32 1, label %462
]
449: ; preds = %444
%450 = getelementptr inbounds i8, i8* %448, i64 -1
%451 = load i8, i8* %450
%452 = zext i8 %451 to i64
%453 = shl nuw nsw i64 %452, 16
br label %454
454: ; preds = %444, %449
%455 = phi i8* [ %448, %444 ], [ %450, %449 ]
%456 = phi i64 [ 0, %444 ], [ %453, %449 ]
%457 = getelementptr inbounds i8, i8* %455, i64 -1
%458 = load i8, i8* %457
%459 = zext i8 %458 to i64
%460 = shl nuw nsw i64 %459, 8
%461 = or i64 %460, %456
br label %462
462: ; preds = %444, %454
%463 = phi i8* [ %448, %444 ], [ %457, %454 ]
%464 = phi i64 [ 0, %444 ], [ %461, %454 ]
%465 = getelementptr inbounds i8, i8* %463, i64 -1
%466 = load i8, i8* %465
%467 = zext i8 %466 to i64
%468 = or i64 %464, %467
br label %469
469: ; preds = %462, %444
%470 = phi i64 [ 0, %444 ], [ %468, %462 ]
store i64 %470, i64* %446
br label %471
471: ; preds = %357, %469, %187, %338, %311, %3
ret i32 1
}