#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__ {
  int Nl;
  int num;
  int *data;
  scalar_t__ Nh;
};
typedef int MD4_LONG;
typedef TYPE_1__ MD4_CTX;

/* Variables and functions */
size_t MD4_CBLOCK;
size_t MD4_LBLOCK;
int /*<<< orphan*/ md4_block_data_order(TYPE_1__ *, unsigned char const *,
                                        size_t);
int /*<<< orphan*/ md4_block_host_order(TYPE_1__ *, int *, int);
int MD4_Update(MD4_CTX *c, const void *data_, size_t len) {
  const unsigned char *data = data_;
  register MD4_LONG *p;
  register MD4_LONG l;
  size_t sw, sc, ew, ec;
  if (len == 0)
    return 1;
  l = (c->Nl + (((MD4_LONG)len) << 3)) & 0xffffffffUL;
  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) = *((const unsigned int *)(data)), (data) += 4, l);
        p[sw] = l;
      }
      md4_block_host_order(c, p, 1);
      len -= (MD4_CBLOCK - c->num);
      c->num = 0;
    } else {
      c->num += (unsigned int)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) = *((const unsigned int *)(data)), (data) += 4, 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) = *((const unsigned int *)(data)), (data) += 4, 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    $0x80,%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    1156 <MD4_Update+0x36>
movl   $0x1,-0x4(%rbp)
jmp    1825 <MD4_Update+0x705>
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    -0x20(%rbp),%rcx
shl    $0x3,%ecx
add    %ecx,%eax
cltq
movabs $0xffffffff,%rcx
and    %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x10(%rbp),%rcx
cmp    (%rcx),%eax
jge    1196 <MD4_Update+0x76>
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rcx
add    $0x1,%rcx
mov    %rcx,0x10(%rax)
mov    -0x20(%rbp),%rcx
shr    $0x1d,%rcx
mov    -0x10(%rbp),%rax
add    0x10(%rax),%rcx
mov    %rcx,0x10(%rax)
mov    -0x34(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x10(%rbp),%rax
cmpl   $0x0,0x4(%rax)
je     1686 <MD4_Update+0x566>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
sar    $0x2,%eax
cltq
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
and    $0x3,%eax
cltq
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq 0x4(%rax),%rax
add    -0x20(%rbp),%rax
mov    0x2de8(%rip),%rcx
cmp    (%rcx),%rax
jb     135b <MD4_Update+0x23b>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x60(%rbp)
sub    $0x3,%rax
ja     12b8 <MD4_Update+0x198>
mov    -0x60(%rbp),%rax
lea    0xddc(%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    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x8,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x10,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x18,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x40(%rbp)
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    0x2cfc(%rip),%rcx
cmp    (%rcx),%rax
jae    1319 <MD4_Update+0x1f9>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    12d1 <MD4_Update+0x1b1>
mov    -0x10(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    $0x1,%edx
call   1040 <md4_block_host_order@plt>
mov    0x2cb6(%rip),%rax
mov    (%rax),%rcx
mov    -0x10(%rbp),%rax
movslq 0x4(%rax),%rax
sub    %rax,%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x0,0x4(%rax)
jmp    1681 <MD4_Update+0x561>
mov    -0x20(%rbp),%rax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x48(%rbp),%rax
add    -0x20(%rbp),%rax
cmp    $0x4,%rax
jae    1473 <MD4_Update+0x353>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x68(%rbp)
test   %rax,%rax
je     13c7 <MD4_Update+0x2a7>
jmp    13a1 <MD4_Update+0x281>
mov    -0x68(%rbp),%rax
sub    $0x1,%rax
je     13fc <MD4_Update+0x2dc>
jmp    13b4 <MD4_Update+0x294>
mov    -0x68(%rbp),%rax
sub    $0x2,%rax
je     143e <MD4_Update+0x31e>
jmp    1460 <MD4_Update+0x340>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    13f7 <MD4_Update+0x2d7>
jmp    1460 <MD4_Update+0x340>
jmp    13fc <MD4_Update+0x2dc>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x8,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    1439 <MD4_Update+0x319>
jmp    1460 <MD4_Update+0x340>
jmp    143e <MD4_Update+0x31e>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x10,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1675 <MD4_Update+0x555>
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
sar    $0x2,%eax
cltq
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
and    $0x3,%eax
cltq
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x48(%rbp)
je     14ac <MD4_Update+0x38c>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x70(%rbp)
sub    $0x3,%rax
ja     154d <MD4_Update+0x42d>
mov    -0x70(%rbp),%rax
lea    0xb37(%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    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x8,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x10,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
mov    %eax,%ecx
shl    $0x18,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x40(%rbp)
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    15a8 <MD4_Update+0x488>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    1566 <MD4_Update+0x446>
cmpq   $0x0,-0x58(%rbp)
je     1670 <MD4_Update+0x550>
movl   $0x0,-0x34(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x28(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x78(%rbp)
sub    $0x1,%rax
je     1643 <MD4_Update+0x523>
jmp    15e0 <MD4_Update+0x4c0>
mov    -0x78(%rbp),%rax
sub    $0x2,%rax
je     1620 <MD4_Update+0x500>
jmp    15f3 <MD4_Update+0x4d3>
mov    -0x78(%rbp),%rax
sub    $0x3,%rax
jne    1662 <MD4_Update+0x542>
jmp    1606 <MD4_Update+0x4e6>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x10,%rax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
mov    %eax,%ecx
shl    $0x8,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
mov    %eax,%ecx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1675 <MD4_Update+0x555>
movl   $0x1,-0x4(%rbp)
jmp    1825 <MD4_Update+0x705>
jmp    1686 <MD4_Update+0x566>
mov    -0x20(%rbp),%rax
mov    0x2957(%rip),%rcx
xor    %edx,%edx
divq   (%rcx)
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jbe    16e4 <MD4_Update+0x5c4>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1030 <md4_block_data_order@plt>
mov    0x292b(%rip),%rax
mov    (%rax),%rax
imul   -0x40(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
je     181e <MD4_Update+0x6fe>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    %eax,%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x20(%rbp),%rax
shr    $0x2,%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
and    $0x3,%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x50(%rbp)
je     1766 <MD4_Update+0x646>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x50(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x50(%rbp)
mov    -0x30(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x30(%rbp)
jmp    1720 <MD4_Update+0x600>
movl   $0x0,-0x34(%rbp)
mov    -0x58(%rbp),%rcx
mov    -0x28(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x80(%rbp)
sub    $0x1,%rax
je     17f6 <MD4_Update+0x6d6>
jmp    1793 <MD4_Update+0x673>
mov    -0x80(%rbp),%rax
sub    $0x2,%rax
je     17d3 <MD4_Update+0x6b3>
jmp    17a6 <MD4_Update+0x686>
mov    -0x80(%rbp),%rax
sub    $0x3,%rax
jne    1815 <MD4_Update+0x6f5>
jmp    17b9 <MD4_Update+0x699>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x10,%rax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
mov    %eax,%ecx
shl    $0x8,%rcx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
mov    %eax,%ecx
movslq -0x34(%rbp),%rax
or     %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<MD4_Update>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
test   %rdx,%rdx
je     174c <MD4_Update+0x62c>
mov    %rdx,%r14
mov    %rsi,%r13
mov    %rdi,%r15
lea    0x0(,%rdx,8),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    0x10(%rdi),%rcx
shr    $0x1d,%rdx
add    %rcx,%rdx
mov    %rdx,0x10(%rdi)
add    %eax,(%rdi)
mov    0x4(%rdi),%ebp
test   %rbp,%rbp
je     11e8 <MD4_Update+0xc8>
movslq %ebp,%rax
mov    0x8(%r15),%rsi
mov    %ebp,%ecx
sar    $0x2,%ecx
movslq %ecx,%rdx
mov    %ebp,%edi
and    $0x3,%edi
add    %r14,%rax
mov    0x2e64(%rip),%r12
cmp    (%r12),%rax
jae    11f7 <MD4_Update+0xd7>
add    %r14d,%ebp
mov    %ebp,0x4(%r15)
lea    (%rdi,%r14,1),%rax
cmp    $0x3,%rax
ja     130a <MD4_Update+0x1ea>
mov    (%rsi,%rdx,4),%eax
cmp    $0x2,%edi
je     11d6 <MD4_Update+0xb6>
cmp    $0x1,%edi
je     11c0 <MD4_Update+0xa0>
test   %rdi,%rdi
jne    11e0 <MD4_Update+0xc0>
movzbl 0x0(%r13),%eax
add    $0xffffffffffffffff,%r14
je     11e0 <MD4_Update+0xc0>
add    $0x1,%r13
mov    %eax,%ecx
movzbl 0x0(%r13),%eax
shl    $0x8,%eax
or     %ecx,%eax
cmp    $0x1,%r14
je     11e0 <MD4_Update+0xc0>
add    $0x1,%r13
movzbl 0x0(%r13),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    %eax,(%rsi,%rdx,4)
jmp    174c <MD4_Update+0x62c>
mov    0x2df9(%rip),%rax
mov    (%rax),%rcx
jmp    14dd <MD4_Update+0x3bd>
mov    (%rsi,%rdx,4),%eax
lea    0xdff(%rip),%rcx
movslq (%rcx,%rdi,4),%rdi
add    %rcx,%rdi
jmp    *%rdi
movzbl 0x0(%r13),%eax
add    $0x1,%r13
movzbl 0x0(%r13),%ecx
add    $0x1,%r13
shl    $0x8,%ecx
or     %ecx,%eax
movzbl 0x0(%r13),%ecx
add    $0x1,%r13
shl    $0x10,%ecx
or     %ecx,%eax
lea    0x1(%r13),%rbx
movzbl 0x0(%r13),%ecx
shl    $0x18,%ecx
or     %eax,%ecx
mov    %ecx,(%rsi,%rdx,4)
mov    0x2d91(%rip),%rax
mov    (%rax),%r11
lea    0x1(%rdx),%rcx
cmp    %r11,%rcx
jae    14b7 <MD4_Update+0x397>
mov    %rdx,%r10
not    %r10
add    %r11,%r10
cmp    $0x8,%r10
jb     145c <MD4_Update+0x33c>
lea    (%rsi,%rcx,4),%rax
lea    0x0(,%r11,4),%rdi
lea    0x0(,%rdx,4),%rbp
sub    %rbp,%rdi
add    %r13,%rdi
add    $0xfffffffffffffffd,%rdi
cmp    %rax,%rdi
jbe    129a <MD4_Update+0x17a>
lea    (%rsi,%r11,4),%rax
cmp    %rax,%rbx
jb     145c <MD4_Update+0x33c>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1432 <MD4_Update+0x312>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
lea    (%rsi,%rdx,4),%rax
add    $0x34,%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups 0x1(%r13,%rdx,4),%xmm0
movups 0x11(%r13,%rdx,4),%xmm1
movups %xmm0,-0x30(%rax,%rdx,4)
movups %xmm1,-0x20(%rax,%rdx,4)
movups 0x21(%r13,%rdx,4),%xmm0
movups 0x31(%r13,%rdx,4),%xmm1
movups %xmm0,-0x10(%rax,%rdx,4)
movups %xmm1,(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    12d0 <MD4_Update+0x1b0>
jmp    1434 <MD4_Update+0x314>
mov    %ebp,%eax
sar    $0x2,%eax
movslq %eax,%r11
and    $0x3,%ebp
test   %edi,%edi
je     132c <MD4_Update+0x20c>
mov    (%rsi,%rdx,4),%eax
lea    0xced(%rip),%rcx
movslq (%rcx,%rdi,4),%rdi
add    %rcx,%rdi
jmp    *%rdi
movzbl 0x0(%r13),%eax
add    $0x1,%r13
movzbl 0x0(%r13),%ecx
add    $0x1,%r13
shl    $0x8,%ecx
or     %ecx,%eax
movzbl 0x0(%r13),%ecx
add    $0x1,%r13
shl    $0x10,%ecx
or     %ecx,%eax
lea    0x1(%r13),%rdi
movzbl 0x0(%r13),%ecx
shl    $0x18,%ecx
or     %eax,%ecx
mov    %ecx,(%rsi,%rdx,4)
lea    0x1(%rdx),%rax
cmp    %r11,%rax
jae    142a <MD4_Update+0x30a>
mov    %rdx,%r8
not    %r8
add    %r11,%r8
cmp    $0x8,%r8
jb     178a <MD4_Update+0x66a>
lea    (%rsi,%rax,4),%r9
lea    0x0(,%r11,4),%rbx
lea    0x0(,%rdx,4),%rcx
sub    %rcx,%rbx
lea    (%rbx,%r13,1),%rcx
add    $0xfffffffffffffffd,%rcx
cmp    %r9,%rcx
jbe    13b3 <MD4_Update+0x293>
lea    (%rsi,%r11,4),%rcx
cmp    %rcx,%rdi
jb     178a <MD4_Update+0x66a>
mov    %r8,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rcx
mov    %rcx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     1760 <MD4_Update+0x640>
mov    %r10,%rbx
and    $0xfffffffffffffffe,%rbx
lea    (%rsi,%rdx,4),%rcx
add    $0x34,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x1(%r13,%rdx,4),%xmm0
movups 0x11(%r13,%rdx,4),%xmm1
movups %xmm0,-0x30(%rcx,%rdx,4)
movups %xmm1,-0x20(%rcx,%rdx,4)
movups 0x21(%r13,%rdx,4),%xmm0
movups 0x31(%r13,%rdx,4),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,4)
movups %xmm1,(%rcx,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rbx
jne    13f0 <MD4_Update+0x2d0>
jmp    1762 <MD4_Update+0x642>
mov    %rax,%r11
jmp    17e7 <MD4_Update+0x6c7>
xor    %edx,%edx
test   $0x1,%r9b
je     1450 <MD4_Update+0x330>
lea    (%rcx,%rdx,1),%rax
movups (%rbx,%rdx,4),%xmm0
movups 0x10(%rbx,%rdx,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
lea    (%rbx,%r8,4),%rbx
cmp    %r8,%r10
je     14b7 <MD4_Update+0x397>
add    %r8,%rcx
mov    %r11d,%edi
sub    %ecx,%edi
mov    %rcx,%rdx
not    %rdx
add    %r11,%rdx
and    $0x3,%rdi
je     1483 <MD4_Update+0x363>
mov    (%rbx),%eax
add    $0x4,%rbx
mov    %eax,(%rsi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1470 <MD4_Update+0x350>
cmp    $0x3,%rdx
jb     14b7 <MD4_Update+0x397>
nopl   0x0(%rax)
mov    (%rbx),%eax
mov    %eax,(%rsi,%rcx,4)
mov    0x4(%rbx),%eax
mov    %eax,0x4(%rsi,%rcx,4)
mov    0x8(%rbx),%eax
mov    %eax,0x8(%rsi,%rcx,4)
mov    0xc(%rbx),%eax
add    $0x10,%rbx
mov    %eax,0xc(%rsi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    1490 <MD4_Update+0x370>
mov    %r15,%rdi
mov    $0x1,%edx
call   1040 <md4_block_host_order@plt>
mov    (%r12),%rcx
movslq 0x4(%r15),%rax
sub    %rcx,%r14
add    %rax,%r14
movl   $0x0,0x4(%r15)
mov    %rbx,%r13
mov    %r14,%rax
or     %rcx,%rax
shr    $0x20,%rax
je     1599 <MD4_Update+0x479>
mov    %r14,%rax
xor    %edx,%edx
div    %rcx
mov    %rax,%r12
cmp    %r14,%rcx
ja     151c <MD4_Update+0x3fc>
mov    %r15,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
call   1030 <md4_block_data_order@plt>
mov    0x2ad6(%rip),%rax
imul   (%rax),%r12
add    %r12,%r13
sub    %r12,%r14
test   %r14,%r14
je     174c <MD4_Update+0x62c>
mov    0x8(%r15),%rax
mov    %r14d,0x4(%r15)
mov    %r14d,%ecx
and    $0x3,%ecx
cmp    $0x4,%r14
jb     170a <MD4_Update+0x5ea>
mov    %r14,%rdx
shr    $0x2,%rdx
cmp    $0x20,%r14
jb     1670 <MD4_Update+0x550>
and    $0xfffffffffffffffc,%r14
add    %r13,%r14
cmp    %rax,%r14
jbe    1567 <MD4_Update+0x447>
lea    (%rax,%rdx,4),%rsi
cmp    %rsi,%r13
jb     1670 <MD4_Update+0x550>
movabs $0x3ffffffffffffffe,%rsi
ff ff 3f
lea    -0x6(%rsi),%r8
and    %rdx,%r8
lea    -0x8(%r8),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rbp
jae    15b1 <MD4_Update+0x491>
xor    %esi,%esi
jmp    1621 <MD4_Update+0x501>
mov    %r14d,%eax
xor    %edx,%edx
div    %ecx
mov    %eax,%r12d
cmp    %r14,%rcx
jbe    14fd <MD4_Update+0x3dd>
jmp    151c <MD4_Update+0x3fc>
add    $0xfffffffffffffffe,%rsi
and    %rsi,%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups 0x0(%r13,%rsi,4),%xmm0
movups 0x10(%r13,%rsi,4),%xmm1
movups %xmm0,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
movups 0x20(%r13,%rsi,4),%xmm0
movups 0x30(%r13,%rsi,4),%xmm1
movups %xmm0,0x20(%rax,%rsi,4)
movups %xmm1,0x30(%rax,%rsi,4)
movups 0x40(%r13,%rsi,4),%xmm0
movups 0x50(%r13,%rsi,4),%xmm1
movups %xmm0,0x40(%rax,%rsi,4)
movups %xmm1,0x50(%rax,%rsi,4)
movups 0x60(%r13,%rsi,4),%xmm0
movups 0x70(%r13,%rsi,4),%xmm1
movups %xmm0,0x60(%rax,%rsi,4)
movups %xmm1,0x70(%rax,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    15c0 <MD4_Update+0x4a0>
test   %rbx,%rbx
je     165b <MD4_Update+0x53b>
lea    0x10(,%rsi,4),%rdi
add    %r13,%rdi
lea    (%rax,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%rbx
xor    %ebp,%ebp
nop
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    1640 <MD4_Update+0x520>
lea    (%rax,%r8,4),%rax
lea    0x0(%r13,%r8,4),%r13
cmp    %r8,%rdx
je     170a <MD4_Update+0x5ea>
and    $0x7,%edx
lea    -0x1(%rdx),%rsi
mov    %rdx,%rdi
and    $0x7,%rdi
je     169a <MD4_Update+0x57a>
xor    %ebx,%ebx
nop
mov    0x0(%r13),%ebp
add    $0x4,%r13
mov    %ebp,(%rax)
add    $0x4,%rax
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1680 <MD4_Update+0x560>
sub    %rbx,%rdx
cmp    $0x7,%rsi
jb     170a <MD4_Update+0x5ea>
xor    %esi,%esi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x0(%r13,%rdi,4),%ebp
mov    %ebp,(%rax,%rdi,4)
mov    0x4(%r13,%rdi,4),%ebp
mov    %ebp,0x4(%rax,%rdi,4)
mov    0x8(%r13,%rdi,4),%ebp
mov    %ebp,0x8(%rax,%rdi,4)
mov    0xc(%r13,%rdi,4),%ebp
mov    %ebp,0xc(%rax,%rdi,4)
mov    0x10(%r13,%rdi,4),%ebp
mov    %ebp,0x10(%rax,%rdi,4)
mov    0x14(%r13,%rdi,4),%ebp
mov    %ebp,0x14(%rax,%rdi,4)
mov    0x18(%r13,%rdi,4),%ebp
mov    %ebp,0x18(%rax,%rdi,4)
mov    0x1c(%r13,%rdi,4),%ebp
mov    %ebp,0x1c(%rax,%rdi,4)
add    $0x8,%rdi
add    $0xffffffffffffffe0,%rsi
cmp    %rdi,%rdx
jne    16b0 <MD4_Update+0x590>
sub    %rsi,%rax
sub    %rsi,%r13
add    %rcx,%r13
xor    %edx,%edx
cmp    $0x1,%rcx
je     1743 <MD4_Update+0x623>
cmp    $0x2,%ecx
je     172c <MD4_Update+0x60c>
cmp    $0x3,%ecx
jne    174a <MD4_Update+0x62a>
movzbl -0x1(%r13),%edx
add    $0xffffffffffffffff,%r13
shl    $0x30,%rdx
movzbl -0x1(%r13),%ecx
add    $0xffffffffffffffff,%r13
shl    $0x28,%rcx
or     %rdx,%rcx
shr    $0x20,%rcx
mov    %rcx,%rdx
movzbl -0x1(%r13),%ecx
or     %ecx,%edx
mov    %edx,(%rax)
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edx,%edx
test   $0x1,%r10b
je     177e <MD4_Update+0x65e>
lea    (%rax,%rdx,1),%rcx
movups (%rdi,%rdx,4),%xmm0
movups 0x10(%rdi,%rdx,4),%xmm1
movups %xmm0,(%rsi,%rcx,4)
movups %xmm1,0x10(%rsi,%rcx,4)
lea    (%rdi,%r9,4),%rdi
cmp    %r9,%r8
je     17e7 <MD4_Update+0x6c7>
add    %r9,%rax
mov    %r11d,%ebx
sub    %eax,%ebx
mov    %rax,%rdx
not    %rdx
add    %r11,%rdx
and    $0x3,%rbx
je     17b3 <MD4_Update+0x693>
xchg   %ax,%ax
mov    (%rdi),%ecx
add    $0x4,%rdi
mov    %ecx,(%rsi,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    17a0 <MD4_Update+0x680>
cmp    $0x3,%rdx
jb     17e7 <MD4_Update+0x6c7>
nopl   0x0(%rax)
mov    (%rdi),%ecx
mov    %ecx,(%rsi,%rax,4)
mov    0x4(%rdi),%ecx
mov    %ecx,0x4(%rsi,%rax,4)
mov    0x8(%rdi),%ecx
mov    %ecx,0x8(%rsi,%rax,4)
mov    0xc(%rdi),%ecx
add    $0x10,%rdi
mov    %ecx,0xc(%rsi,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    17c0 <MD4_Update+0x6a0>
test   %rbp,%rbp
je     174c <MD4_Update+0x62c>
add    %rbp,%rdi
xor    %eax,%eax
cmp    $0x1,%rbp
je     1827 <MD4_Update+0x707>
cmp    $0x2,%ebp
je     1811 <MD4_Update+0x6f1>
cmp    $0x3,%ebp
jne    182d <MD4_Update+0x70d>
movzbl -0x1(%rdi),%eax
add    $0xffffffffffffffff,%rdi
shl    $0x30,%rax
movzbl -0x1(%rdi),%ecx
add    $0xffffffffffffffff,%rdi
shl    $0x28,%rcx
or     %rax,%rcx
shr    $0x20,%rcx
mov    %rcx,%rax
movzbl -0x1(%rdi),%ecx
or     %ecx,%eax
mov    %eax,(%rsi,%r11,4)
jmp    174c <MD4_Update+0x62c>

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

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