#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 SHA_LONG;
typedef TYPE_1__ SHA256_CTX;

/* Variables and functions */
size_t SHA_CBLOCK;
size_t SHA_LBLOCK;
int /*<<< orphan*/ sha256_block_data_order(TYPE_1__ *, unsigned char const *,
                                           size_t);
int /*<<< orphan*/ sha256_block_host_order(TYPE_1__ *, int *, int);
int SHA256_Update(SHA256_CTX *c, const void *data_, size_t len) {
  const unsigned char *data = data_;
  register SHA_LONG *p;
  register SHA_LONG l;
  size_t sw, sc, ew, ec;
  if (len == 0)
    return 1;
  l = (c->Nl + (((SHA_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) >= SHA_CBLOCK) {
      l = p[sw];
      {
        switch (sc) {
        case 0:
          l = ((unsigned long)(*((data)++))) << 24;
        case 1:
          l |= ((unsigned long)(*((data)++))) << 16;
        case 2:
          l |= ((unsigned long)(*((data)++))) << 8;
        case 3:
          l |= ((unsigned long)(*((data)++)));
        }
      };
      p[sw++] = l;
      for (; sw < SHA_LBLOCK; sw++) {
        ({
          unsigned int r = *((const unsigned int *)(data));
          asm("bswapl %0" : "=r"(r) : "0"(r));
          (data) += 4;
          (l) = r;
        });
        p[sw] = l;
      }
      sha256_block_host_order(c, p, 1);
      len -= (SHA_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)++))) << 24;
            if (--len == 0)
              break;
          case 1:
            l |= ((unsigned long)(*((data)++))) << 16;
            if (--len == 0)
              break;
          case 2:
            l |= ((unsigned long)(*((data)++))) << 8;
          }
        };
        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)++))) << 24;
          case 1:
            l |= ((unsigned long)(*((data)++))) << 16;
          case 2:
            l |= ((unsigned long)(*((data)++))) << 8;
          case 3:
            l |= ((unsigned long)(*((data)++)));
          }
        };
        p[sw++] = l;
        for (; sw < ew; sw++) {
          ({
            unsigned int r = *((const unsigned int *)(data));
            asm("bswapl %0" : "=r"(r) : "0"(r));
            (data) += 4;
            (l) = r;
          });
          p[sw] = l;
        }
        if (ec) {
          {
            l = 0;
            (data) += ec;
            switch (ec) {
            case 3:
              l = ((unsigned long)(*(--(data)))) << 8;
            case 2:
              l |= ((unsigned long)(*(--(data)))) << 16;
            case 1:
              l |= ((unsigned long)(*(--(data)))) << 24;
            }
          };
          p[sw] = l;
        }
      }
      return 1;
    }
  }
  sw = len / SHA_CBLOCK;
  if (sw > 0) {
    {
      sha256_block_data_order(c, data, sw);
      sw *= SHA_CBLOCK;
      data += sw;
      len -= sw;
    }
  }
  if (len != 0) {
    p = c->data;
    c->num = len;
    ew = len >> 2;
    ec = len & 0x03;
    for (; ew; ew--, p++) {
      ({
        unsigned int r = *((const unsigned int *)(data));
        asm("bswapl %0" : "=r"(r) : "0"(r));
        (data) += 4;
        (l) = r;
      });
      *p = l;
    }
    {
      l = 0;
      (data) += ec;
      switch (ec) {
      case 3:
        l = ((unsigned long)(*(--(data)))) << 8;
      case 2:
        l |= ((unsigned long)(*(--(data)))) << 16;
      case 1:
        l |= ((unsigned long)(*(--(data)))) << 24;
      }
    };
    *p = l;
  }
  return 1;
}


x86 assembly (clang, -O0):
<SHA256_Update>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%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 <SHA256_Update+0x36>
movl   $0x1,-0x4(%rbp)
jmp    187c <SHA256_Update+0x75c>
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 <SHA256_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     16bf <SHA256_Update+0x59f>
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     136c <SHA256_Update+0x24c>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x78(%rbp)
sub    $0x3,%rax
ja     12b8 <SHA256_Update+0x198>
mov    -0x78(%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
shl    $0x18,%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    $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
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    132a <SHA256_Update+0x20a>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
bswap  %eax
mov    %eax,-0x5c(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x5c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    %eax,-0x60(%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 <SHA256_Update+0x1b1>
mov    -0x10(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    $0x1,%edx
call   1030 <sha256_block_host_order@plt>
mov    0x2ca5(%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    16ba <SHA256_Update+0x59a>
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    1488 <SHA256_Update+0x368>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x80(%rbp)
test   %rax,%rax
je     13d8 <SHA256_Update+0x2b8>
jmp    13b2 <SHA256_Update+0x292>
mov    -0x80(%rbp),%rax
sub    $0x1,%rax
je     1411 <SHA256_Update+0x2f1>
jmp    13c5 <SHA256_Update+0x2a5>
mov    -0x80(%rbp),%rax
sub    $0x2,%rax
je     1453 <SHA256_Update+0x333>
jmp    1475 <SHA256_Update+0x355>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
movzbl (%rax),%eax
shl    $0x18,%rax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    140c <SHA256_Update+0x2ec>
jmp    1475 <SHA256_Update+0x355>
jmp    1411 <SHA256_Update+0x2f1>
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    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    144e <SHA256_Update+0x32e>
jmp    1475 <SHA256_Update+0x355>
jmp    1453 <SHA256_Update+0x333>
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    -0x34(%rbp),%edx
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    16ae <SHA256_Update+0x58e>
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     14c1 <SHA256_Update+0x3a1>
mov    -0x30(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x88(%rbp)
sub    $0x3,%rax
ja     1568 <SHA256_Update+0x448>
mov    -0x88(%rbp),%rax
lea    0xb1c(%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
shl    $0x18,%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    $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
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    15d4 <SHA256_Update+0x4b4>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%eax
bswap  %eax
mov    %eax,-0x64(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    %eax,-0x68(%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    1581 <SHA256_Update+0x461>
cmpq   $0x0,-0x58(%rbp)
je     16a9 <SHA256_Update+0x589>
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,-0x90(%rbp)
sub    $0x1,%rax
je     1678 <SHA256_Update+0x558>
jmp    160f <SHA256_Update+0x4ef>
mov    -0x90(%rbp),%rax
sub    $0x2,%rax
je     1655 <SHA256_Update+0x535>
jmp    1625 <SHA256_Update+0x505>
mov    -0x90(%rbp),%rax
sub    $0x3,%rax
jne    169b <SHA256_Update+0x57b>
jmp    163b <SHA256_Update+0x51b>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x8,%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    $0x10,%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
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    %edx,(%rax,%rcx,4)
jmp    16ae <SHA256_Update+0x58e>
movl   $0x1,-0x4(%rbp)
jmp    187c <SHA256_Update+0x75c>
jmp    16bf <SHA256_Update+0x59f>
mov    -0x20(%rbp),%rax
mov    0x291e(%rip),%rcx
xor    %edx,%edx
divq   (%rcx)
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jbe    171d <SHA256_Update+0x5fd>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1040 <sha256_block_data_order@plt>
mov    0x28f2(%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     1875 <SHA256_Update+0x755>
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     17b0 <SHA256_Update+0x690>
mov    -0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
bswap  %eax
mov    %eax,-0x6c(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    %eax,-0x70(%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    1759 <SHA256_Update+0x639>
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,-0x98(%rbp)
sub    $0x1,%rax
je     1849 <SHA256_Update+0x729>
jmp    17e0 <SHA256_Update+0x6c0>
mov    -0x98(%rbp),%rax
sub    $0x2,%rax
je     1826 <SHA256_Update+0x706>
jmp    17f6 <SHA256_Update+0x6d6>
mov    -0x98(%rbp),%rax
sub    $0x3,%rax
jne    186c <SHA256_Update+0x74c>
jmp    180c <SHA256_Update+0x6ec>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
movzbl -0x1(%rax),%eax
shl    $0x8,%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    $0x10,%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
shl    $0x18,%rcx
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    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SHA256_Update>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
test   %rdx,%rdx
je     133d <SHA256_Update+0x21d>
mov    %rdx,%r14
mov    %rsi,%rbx
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),%edi
test   %rdi,%rdi
je     11dd <SHA256_Update+0xbd>
movslq %edi,%rdx
mov    0x8(%r15),%rsi
mov    %edi,%eax
sar    $0x2,%eax
cltq
mov    %edi,%ecx
and    $0x3,%ecx
add    %r14,%rdx
mov    0x2e6c(%rip),%r12
cmp    (%r12),%rdx
jae    11ec <SHA256_Update+0xcc>
add    %r14d,%edi
mov    %edi,0x4(%r15)
lea    (%rcx,%r14,1),%rdx
cmp    $0x3,%rdx
ja     1366 <SHA256_Update+0x246>
mov    (%rsi,%rax,4),%edx
cmp    $0x2,%ecx
je     11cd <SHA256_Update+0xad>
cmp    $0x1,%ecx
je     11b9 <SHA256_Update+0x99>
test   %rcx,%rcx
jne    11d5 <SHA256_Update+0xb5>
movzbl (%rbx),%edx
shl    $0x18,%edx
add    $0xffffffffffffffff,%r14
je     11d5 <SHA256_Update+0xb5>
add    $0x1,%rbx
mov    %edx,%ecx
movzbl (%rbx),%edx
shl    $0x10,%edx
or     %ecx,%edx
cmp    $0x1,%r14
je     11d5 <SHA256_Update+0xb5>
add    $0x1,%rbx
movzbl (%rbx),%ecx
shl    $0x8,%ecx
or     %ecx,%edx
mov    %edx,(%rsi,%rax,4)
jmp    133d <SHA256_Update+0x21d>
mov    0x2e04(%rip),%rax
mov    (%rax),%rcx
jmp    1277 <SHA256_Update+0x157>
mov    (%rsi,%rax,4),%edx
lea    0xe0a(%rip),%rdi
movslq (%rdi,%rcx,4),%rcx
add    %rdi,%rcx
jmp    *%rcx
movzbl (%rbx),%edx
add    $0x1,%rbx
shl    $0x18,%edx
movzbl (%rbx),%ecx
add    $0x1,%rbx
shl    $0x10,%ecx
or     %ecx,%edx
movzbl (%rbx),%ecx
add    $0x1,%rbx
shl    $0x8,%ecx
or     %ecx,%edx
movzbl (%rbx),%ecx
add    $0x1,%rbx
or     %edx,%ecx
mov    %ecx,(%rsi,%rax,4)
mov    0x2da4(%rip),%rcx
mov    (%rcx),%rcx
add    $0x1,%rax
cmp    %rcx,%rax
jae    1254 <SHA256_Update+0x134>
mov    (%rbx),%edx
bswap  %edx
add    $0x4,%rbx
mov    %edx,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1240 <SHA256_Update+0x120>
mov    %r15,%rdi
mov    $0x1,%edx
call   1030 <sha256_block_host_order@plt>
mov    (%r12),%rcx
movslq 0x4(%r15),%rax
sub    %rcx,%r14
add    %rax,%r14
movl   $0x0,0x4(%r15)
mov    %r14,%rax
or     %rcx,%rax
shr    $0x20,%rax
je     134e <SHA256_Update+0x22e>
mov    %r14,%rax
xor    %edx,%edx
div    %rcx
mov    %rax,%r12
cmp    %r14,%rcx
ja     12b6 <SHA256_Update+0x196>
mov    %r15,%rdi
mov    %rbx,%rsi
mov    %r12,%rdx
call   1040 <sha256_block_data_order@plt>
mov    0x2d3c(%rip),%rax
imul   (%rax),%r12
add    %r12,%rbx
sub    %r12,%r14
test   %r14,%r14
je     133d <SHA256_Update+0x21d>
mov    0x8(%r15),%rax
mov    %r14d,0x4(%r15)
mov    %r14d,%ecx
and    $0x3,%ecx
cmp    $0x4,%r14
jb     12fb <SHA256_Update+0x1db>
shr    $0x2,%r14
xor    %edx,%edx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rsi,4),%edi
bswap  %edi
mov    %edi,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xfffffffffffffffc,%rdx
cmp    %rsi,%r14
jne    12e0 <SHA256_Update+0x1c0>
sub    %rdx,%rbx
sub    %rdx,%rax
add    %rcx,%rbx
xor    %edx,%edx
cmp    $0x1,%rcx
je     1332 <SHA256_Update+0x212>
cmp    $0x2,%ecx
je     131c <SHA256_Update+0x1fc>
cmp    $0x3,%ecx
jne    133b <SHA256_Update+0x21b>
movzbl -0x1(%rbx),%edx
add    $0xffffffffffffffff,%rbx
shl    $0x28,%rdx
movzbl -0x1(%rbx),%ecx
add    $0xffffffffffffffff,%rbx
shl    $0x30,%rcx
or     %rdx,%rcx
shr    $0x20,%rcx
mov    %rcx,%rdx
movzbl -0x1(%rbx),%ecx
shl    $0x18,%ecx
or     %ecx,%edx
mov    %edx,(%rax)
mov    $0x1,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
mov    %r14d,%eax
xor    %edx,%edx
div    %ecx
mov    %eax,%r12d
cmp    %r14,%rcx
jbe    1297 <SHA256_Update+0x177>
jmp    12b6 <SHA256_Update+0x196>
mov    %edi,%edx
sar    $0x2,%edx
movslq %edx,%rdx
and    $0x3,%edi
test   %ecx,%ecx
je     1389 <SHA256_Update+0x269>
mov    (%rsi,%rax,4),%r8d
lea    0xc90(%rip),%r9
movslq (%r9,%rcx,4),%rcx
add    %r9,%rcx
jmp    *%rcx
movzbl (%rbx),%r8d
add    $0x1,%rbx
shl    $0x18,%r8d
movzbl (%rbx),%ecx
add    $0x1,%rbx
shl    $0x10,%ecx
or     %ecx,%r8d
movzbl (%rbx),%ecx
add    $0x1,%rbx
shl    $0x8,%ecx
or     %ecx,%r8d
movzbl (%rbx),%ecx
add    $0x1,%rbx
or     %r8d,%ecx
mov    %ecx,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rdx,%rax
jae    13e7 <SHA256_Update+0x2c7>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx),%ecx
bswap  %ecx
add    $0x4,%rbx
mov    %ecx,(%rsi,%rax,4)
add    $0x1,%rax
cmp    %rax,%rdx
jne    13d0 <SHA256_Update+0x2b0>
mov    %rdx,%rax
test   %rdi,%rdi
je     133d <SHA256_Update+0x21d>
add    %rdi,%rbx
xor    %edx,%edx
cmp    $0x1,%rdi
je     1427 <SHA256_Update+0x307>
cmp    $0x2,%edi
je     1411 <SHA256_Update+0x2f1>
cmp    $0x3,%edi
jne    1430 <SHA256_Update+0x310>
movzbl -0x1(%rbx),%edx
add    $0xffffffffffffffff,%rbx
shl    $0x28,%rdx
movzbl -0x1(%rbx),%ecx
add    $0xffffffffffffffff,%rbx
shl    $0x30,%rcx
or     %rdx,%rcx
shr    $0x20,%rcx
mov    %rcx,%rdx
movzbl -0x1(%rbx),%ecx
shl    $0x18,%ecx
or     %ecx,%edx
mov    %edx,(%rsi,%rax,4)
jmp    133d <SHA256_Update+0x21d>

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

LLVM IR (-O2):
%struct.TYPE_5__ = type { i32, i32, i32*, i64 }
@SHA_CBLOCK = global i64 0
@SHA_LBLOCK = global i64 0
define i32 @SHA256_Update(%struct.TYPE_5__* %0, i8* %1, i64 %2) {
%4 = icmp eq i64 %2, 0
br i1 %4, label %268, 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* @SHA_CBLOCK
br label %204
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* @SHA_CBLOCK
%34 = icmp ult i64 %32, %33
br i1 %34, label %88, label %35
35: ; preds = %24
%36 = getelementptr inbounds i32, i32* %26, i64 %28
%37 = load i32, i32* %36
switch i64 %30, label %69 [
i64 0, label %38
i64 1, label %43
i64 2, label %51
i64 3, label %59
]
38: ; preds = %35
%39 = getelementptr inbounds i8, i8* %1, i64 1
%40 = load i8, i8* %1
%41 = zext i8 %40 to i32
%42 = shl nuw i32 %41, 24
br label %43
43: ; preds = %35, %38
%44 = phi i32 [ %37, %35 ], [ %42, %38 ]
%45 = phi i8* [ %1, %35 ], [ %39, %38 ]
%46 = getelementptr inbounds i8, i8* %45, i64 1
%47 = load i8, i8* %45
%48 = zext i8 %47 to i32
%49 = shl nuw nsw i32 %48, 16
%50 = or i32 %49, %44
br label %51
51: ; preds = %35, %43
%52 = phi i32 [ %37, %35 ], [ %50, %43 ]
%53 = phi i8* [ %1, %35 ], [ %46, %43 ]
%54 = getelementptr inbounds i8, i8* %53, i64 1
%55 = load i8, i8* %53
%56 = zext i8 %55 to i32
%57 = shl nuw nsw i32 %56, 8
%58 = or i32 %57, %52
br label %59
59: ; preds = %35, %51
%60 = phi i32 [ %37, %35 ], [ %58, %51 ]
%61 = phi i8* [ %1, %35 ], [ %54, %51 ]
%62 = getelementptr inbounds i8, i8* %61, i64 1
%63 = load i8, i8* %61
%64 = zext i8 %63 to i32
%65 = or i32 %60, %64
store i32 %65, i32* %36
%66 = load i64, i64* @SHA_LBLOCK
%67 = add nsw i64 %28, 1
%68 = icmp ult i64 %67, %66
br i1 %68, label %70, label %80
69: ; preds = %35
unreachable
70: ; preds = %59, %70
%71 = phi i64 [ %78, %70 ], [ %67, %59 ]
%72 = phi i8* [ %76, %70 ], [ %62, %59 ]
%73 = bitcast i8* %72 to i32*
%74 = load i32, i32* %73
%75 = tail call i32 asm "bswapl $0", "=r,0,~{dirflag},~{fpsr},~{flags}"(i32 %74)
%76 = getelementptr inbounds i8, i8* %72, i64 4
%77 = getelementptr inbounds i32, i32* %26, i64 %71
store i32 %75, i32* %77
%78 = add i64 %71, 1
%79 = icmp eq i64 %78, %66
br i1 %79, label %80, label %70
80: ; preds = %70, %59
%81 = phi i8* [ %62, %59 ], [ %76, %70 ]
%82 = tail call i32 @sha256_block_host_order(%struct.TYPE_5__* %0, i32* %26, i32 1)
%83 = load i64, i64* @SHA_CBLOCK
%84 = load i32, i32* %19
%85 = sext i32 %84 to i64
%86 = sub i64 %2, %83
%87 = add i64 %86, %85
store i32 0, i32* %19
br label %204
88: ; preds = %24
%89 = add i32 %20, %8
store i32 %89, i32* %19
%90 = add i64 %30, %2
%91 = icmp ult i64 %90, 4
br i1 %91, label %92, label %121
92: ; preds = %88
%93 = getelementptr inbounds i32, i32* %26, i64 %28
%94 = load i32, i32* %93
switch i64 %30, label %119 [
i64 0, label %95
i64 1, label %102
i64 2, label %112
]
95: ; preds = %92
%96 = getelementptr inbounds i8, i8* %1, i64 1
%97 = load i8, i8* %1
%98 = zext i8 %97 to i32
%99 = shl nuw i32 %98, 24
%100 = add i64 %2, -1
%101 = icmp eq i64 %100, 0
br i1 %101, label %119, label %102
102: ; preds = %95, %92
%103 = phi i32 [ %94, %92 ], [ %99, %95 ]
%104 = phi i8* [ %1, %92 ], [ %96, %95 ]
%105 = phi i64 [ %2, %92 ], [ %100, %95 ]
%106 = getelementptr inbounds i8, i8* %104, i64 1
%107 = load i8, i8* %104
%108 = zext i8 %107 to i32
%109 = shl nuw nsw i32 %108, 16
%110 = or i32 %109, %103
%111 = icmp eq i64 %105, 1
br i1 %111, label %119, label %112
112: ; preds = %102, %92
%113 = phi i32 [ %94, %92 ], [ %110, %102 ]
%114 = phi i8* [ %1, %92 ], [ %106, %102 ]
%115 = load i8, i8* %114
%116 = zext i8 %115 to i32
%117 = shl nuw nsw i32 %116, 8
%118 = or i32 %117, %113
br label %119
119: ; preds = %102, %95, %112, %92
%120 = phi i32 [ %94, %92 ], [ %118, %112 ], [ %110, %102 ], [ %99, %95 ]
store i32 %120, i32* %93
br label %268
121: ; preds = %88
%122 = ashr i32 %89, 2
%123 = sext i32 %122 to i64
%124 = and i32 %89, 3
%125 = zext i32 %124 to i64
%126 = icmp eq i32 %29, 0
br i1 %126, label %130, label %127
127: ; preds = %121
%128 = getelementptr inbounds i32, i32* %26, i64 %28
%129 = load i32, i32* %128
switch i64 %30, label %161 [
i64 0, label %130
i64 1, label %135
i64 2, label %143
i64 3, label %151
]
130: ; preds = %121, %127
%131 = getelementptr inbounds i8, i8* %1, i64 1
%132 = load i8, i8* %1
%133 = zext i8 %132 to i32
%134 = shl nuw i32 %133, 24
br label %135
135: ; preds = %127, %130
%136 = phi i32 [ %129, %127 ], [ %134, %130 ]
%137 = phi i8* [ %1, %127 ], [ %131, %130 ]
%138 = getelementptr inbounds i8, i8* %137, i64 1
%139 = load i8, i8* %137
%140 = zext i8 %139 to i32
%141 = shl nuw nsw i32 %140, 16
%142 = or i32 %141, %136
br label %143
143: ; preds = %127, %135
%144 = phi i32 [ %129, %127 ], [ %142, %135 ]
%145 = phi i8* [ %1, %127 ], [ %138, %135 ]
%146 = getelementptr inbounds i8, i8* %145, i64 1
%147 = load i8, i8* %145
%148 = zext i8 %147 to i32
%149 = shl nuw nsw i32 %148, 8
%150 = or i32 %149, %144
br label %151
151: ; preds = %127, %143
%152 = phi i32 [ %129, %127 ], [ %150, %143 ]
%153 = phi i8* [ %1, %127 ], [ %146, %143 ]
%154 = getelementptr inbounds i8, i8* %153, i64 1
%155 = load i8, i8* %153
%156 = zext i8 %155 to i32
%157 = or i32 %152, %156
%158 = getelementptr inbounds i32, i32* %26, i64 %28
store i32 %157, i32* %158
%159 = add nsw i64 %28, 1
%160 = icmp ult i64 %159, %123
br i1 %160, label %162, label %172
161: ; preds = %127
unreachable
162: ; preds = %151, %162
%163 = phi i64 [ %170, %162 ], [ %159, %151 ]
%164 = phi i8* [ %168, %162 ], [ %154, %151 ]
%165 = bitcast i8* %164 to i32*
%166 = load i32, i32* %165
%167 = tail call i32 asm "bswapl $0", "=r,0,~{dirflag},~{fpsr},~{flags}"(i32 %166)
%168 = getelementptr inbounds i8, i8* %164, i64 4
%169 = getelementptr inbounds i32, i32* %26, i64 %163
store i32 %167, i32* %169
%170 = add i64 %163, 1
%171 = icmp eq i64 %170, %123
br i1 %171, label %172, label %162
172: ; preds = %162, %151
%173 = phi i8* [ %154, %151 ], [ %168, %162 ]
%174 = phi i64 [ %159, %151 ], [ %123, %162 ]
%175 = icmp eq i32 %124, 0
br i1 %175, label %268, label %176
176: ; preds = %172
%177 = getelementptr inbounds i8, i8* %173, i64 %125
switch i64 %125, label %201 [
i64 3, label %178
i64 2, label %183
i64 1, label %192
]
178: ; preds = %176
%179 = getelementptr inbounds i8, i8* %177, i64 -1
%180 = load i8, i8* %179
%181 = zext i8 %180 to i64
%182 = shl nuw nsw i64 %181, 40
br label %183
183: ; preds = %176, %178
%184 = phi i64 [ 0, %176 ], [ %182, %178 ]
%185 = phi i8* [ %177, %176 ], [ %179, %178 ]
%186 = getelementptr inbounds i8, i8* %185, i64 -1
%187 = load i8, i8* %186
%188 = zext i8 %187 to i64
%189 = shl nuw nsw i64 %188, 48
%190 = or i64 %189, %184
%191 = ashr exact i64 %190, 32
br label %192
192: ; preds = %176, %183
%193 = phi i64 [ 0, %176 ], [ %191, %183 ]
%194 = phi i8* [ %177, %176 ], [ %186, %183 ]
%195 = getelementptr inbounds i8, i8* %194, i64 -1
%196 = load i8, i8* %195
%197 = zext i8 %196 to i64
%198 = shl nuw nsw i64 %197, 24
%199 = or i64 %198, %193
%200 = trunc i64 %199 to i32
br label %201
201: ; preds = %192, %176
%202 = phi i32 [ 0, %176 ], [ %200, %192 ]
%203 = getelementptr inbounds i32, i32* %26, i64 %174
store i32 %202, i32* %203
br label %268
204: ; preds = %22, %80
%205 = phi i64 [ %83, %80 ], [ %23, %22 ]
%206 = phi i8* [ %81, %80 ], [ %1, %22 ]
%207 = phi i64 [ %87, %80 ], [ %2, %22 ]
%208 = udiv i64 %207, %205
%209 = icmp ugt i64 %205, %207
br i1 %209, label %216, label %210
210: ; preds = %204
%211 = tail call i32 @sha256_block_data_order(%struct.TYPE_5__* %0, i8* %206, i64 %208)
%212 = load i64, i64* @SHA_CBLOCK
%213 = mul i64 %212, %208
%214 = getelementptr inbounds i8, i8* %206, i64 %213
%215 = sub i64 %207, %213
br label %216
216: ; preds = %210, %204
%217 = phi i8* [ %214, %210 ], [ %206, %204 ]
%218 = phi i64 [ %215, %210 ], [ %207, %204 ]
%219 = icmp eq i64 %218, 0
br i1 %219, label %268, label %220
220: ; preds = %216
%221 = getelementptr inbounds %struct.TYPE_5__, %struct.TYPE_5__* %0, i64 0, i32 2
%222 = load i32*, i32** %221
%223 = trunc i64 %218 to i32
store i32 %223, i32* %19
%224 = and i64 %218, 3
%225 = icmp ult i64 %218, 4
br i1 %225, label %239, label %226
226: ; preds = %220
%227 = lshr i64 %218, 2
br label %228
228: ; preds = %226, %228
%229 = phi i8* [ %235, %228 ], [ %217, %226 ]
%230 = phi i32* [ %237, %228 ], [ %222, %226 ]
%231 = phi i64 [ %236, %228 ], [ %227, %226 ]
%232 = bitcast i8* %229 to i32*
%233 = load i32, i32* %232
%234 = tail call i32 asm "bswapl $0", "=r,0,~{dirflag},~{fpsr},~{flags}"(i32 %233)
%235 = getelementptr inbounds i8, i8* %229, i64 4
store i32 %234, i32* %230
%236 = add nsw i64 %231, -1
%237 = getelementptr inbounds i32, i32* %230, i64 1
%238 = icmp eq i64 %236, 0
br i1 %238, label %239, label %228
239: ; preds = %228, %220
%240 = phi i32* [ %222, %220 ], [ %237, %228 ]
%241 = phi i8* [ %217, %220 ], [ %235, %228 ]
%242 = getelementptr inbounds i8, i8* %241, i64 %224
switch i64 %224, label %266 [
i64 3, label %243
i64 2, label %248
i64 1, label %257
]
243: ; preds = %239
%244 = getelementptr inbounds i8, i8* %242, i64 -1
%245 = load i8, i8* %244
%246 = zext i8 %245 to i64
%247 = shl nuw nsw i64 %246, 40
br label %248
248: ; preds = %239, %243
%249 = phi i64 [ 0, %239 ], [ %247, %243 ]
%250 = phi i8* [ %242, %239 ], [ %244, %243 ]
%251 = getelementptr inbounds i8, i8* %250, i64 -1
%252 = load i8, i8* %251
%253 = zext i8 %252 to i64
%254 = shl nuw nsw i64 %253, 48
%255 = or i64 %254, %249
%256 = ashr exact i64 %255, 32
br label %257
257: ; preds = %239, %248
%258 = phi i64 [ 0, %239 ], [ %256, %248 ]
%259 = phi i8* [ %242, %239 ], [ %251, %248 ]
%260 = getelementptr inbounds i8, i8* %259, i64 -1
%261 = load i8, i8* %260
%262 = zext i8 %261 to i64
%263 = shl nuw nsw i64 %262, 24
%264 = or i64 %263, %258
%265 = trunc i64 %264 to i32
br label %266
266: ; preds = %257, %239
%267 = phi i32 [ 0, %239 ], [ %265, %257 ]
store i32 %267, i32* %240
br label %268
268: ; preds = %216, %266, %119, %201, %172, %3
ret i32 1
}