#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ SHA512_transform(unsigned long long *, unsigned long long *);
void SHA512_finish(unsigned long long H[], unsigned long long W[],
                   unsigned long long FileLen) {
  unsigned long *Buf = (unsigned long *)W;
  int t;
  int Witi = (FileLen % 128) / 8;
  int amari = (FileLen % 8) * 8;
  for (t = 0; t <= Witi; t++)
    W[t] = (unsigned long long)(Buf[t * 2] << 24 | Buf[t * 2] << 8 & 0xFF0000 |
                                Buf[t * 2] >> 8 & 0xFF00 | Buf[t * 2] >> 24)
               << 32 |
           (unsigned long long)(Buf[t * 2 + 1] << 24 |
                                Buf[t * 2 + 1] << 8 & 0xFF0000 |
                                Buf[t * 2 + 1] >> 8 & 0xFF00 |
                                Buf[t * 2 + 1] >> 24);
  if (amari == 0)
    W[Witi] = 0x8000000000000000ULL;
  else
    W[Witi] = W[Witi] & 0xFFFFFFFFFFFFFFFFULL << (64 - amari) |
              0x8000000000000000ULL >> amari;
  Witi++;
  if (Witi >= 15) {
    for (t = Witi; t < 16; t++)
      W[t] = 0;
    for (t = 16; t < 80; t++)
      W[t] = ((((W[t - 2]) >> (19)) | ((W[t - 2]) << (64 - 19))) ^
              (((W[t - 2]) >> (61)) | ((W[t - 2]) << (64 - 61))) ^
              ((W[t - 2]) >> (6))) +
             W[t - 7] +
             ((((W[t - 15]) >> (1)) | ((W[t - 15]) << (64 - 1))) ^
              (((W[t - 15]) >> (8)) | ((W[t - 15]) << (64 - 8))) ^
              ((W[t - 15]) >> (7))) +
             W[t - 16];
    SHA512_transform(H, W);
    Witi = 0;
  }
  for (t = Witi; t < 14; t++)
    W[t] = 0;
  W[14] = FileLen >> 61;
  W[15] = FileLen << 3;
  for (t = 16; t < 80; t++)
    W[t] = ((((W[t - 2]) >> (19)) | ((W[t - 2]) << (64 - 19))) ^
            (((W[t - 2]) >> (61)) | ((W[t - 2]) << (64 - 61))) ^
            ((W[t - 2]) >> (6))) +
           W[t - 7] +
           ((((W[t - 15]) >> (1)) | ((W[t - 15]) << (64 - 1))) ^
            (((W[t - 15]) >> (8)) | ((W[t - 15]) << (64 - 8))) ^
            ((W[t - 15]) >> (7))) +
           W[t - 16];
  SHA512_transform(H, W);
}


x86 assembly (clang, -O0):
<SHA512_finish>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7f,%rax
shr    $0x3,%rax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
shl    $0x3,%rax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     125e <SHA512_finish+0x14e>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
shl    $0x18,%rdx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shl    $0x8,%rax
and    $0xff0000,%rax
or     %rax,%rdx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x8,%rax
and    $0xff00,%rax
or     %rax,%rdx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x18,%rax
or     %rax,%rdx
shl    $0x20,%rdx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shl    $0x18,%rax
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shl    $0x8,%rcx
and    $0xff0000,%rcx
or     %rcx,%rax
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shr    $0x8,%rcx
and    $0xff00,%rcx
or     %rcx,%rax
mov    -0x20(%rbp),%rcx
mov    -0x24(%rbp),%esi
shl    $0x1,%esi
add    $0x1,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shr    $0x18,%rcx
or     %rcx,%rax
or     %rax,%rdx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1151 <SHA512_finish+0x41>
cmpl   $0x0,-0x2c(%rbp)
jne    1283 <SHA512_finish+0x173>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movabs $0x8000000000000000,%rdx
mov    %rdx,(%rax,%rcx,8)
jmp    12c9 <SHA512_finish+0x1b9>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    $0x40,%eax
sub    -0x2c(%rbp),%eax
mov    %eax,%eax
mov    %eax,%ecx
mov    $0xffffffffffffffff,%rax
shl    %cl,%rax
and    %rax,%rdx
mov    -0x2c(%rbp),%eax
mov    %eax,%ecx
movabs $0x8000000000000000,%rax
shr    %cl,%rax
or     %rax,%rdx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
cmpl   $0xf,-0x28(%rbp)
jl     1458 <SHA512_finish+0x348>
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    130a <SHA512_finish+0x1fa>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12e2 <SHA512_finish+0x1d2>
movl   $0x10,-0x24(%rbp)
cmpl   $0x50,-0x24(%rbp)
jge    1444 <SHA512_finish+0x334>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
shr    $0x13,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shl    $0x2d,%rax
or     %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x3d,%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shl    $0x3,%rcx
or     %rcx,%rax
xor    %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x6,%rax
xor    %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x7,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0xf,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x1,%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    $0xf,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shl    $0x3f,%rcx
or     %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    $0xf,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shr    $0x8,%rcx
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%edi
sub    $0xf,%edi
movslq %edi,%rdi
mov    (%rsi,%rdi,8),%rsi
shl    $0x38,%rsi
or     %rsi,%rcx
xor    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    $0xf,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shr    $0x7,%rcx
xor    %rcx,%rax
add    %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x10,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1311 <SHA512_finish+0x201>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <SHA512_transform@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    %eax,-0x24(%rbp)
cmpl   $0xe,-0x24(%rbp)
jge    1486 <SHA512_finish+0x376>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    145e <SHA512_finish+0x34e>
mov    -0x18(%rbp),%rcx
shr    $0x3d,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x70(%rax)
mov    -0x18(%rbp),%rcx
shl    $0x3,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x78(%rax)
movl   $0x10,-0x24(%rbp)
cmpl   $0x50,-0x24(%rbp)
jge    15e0 <SHA512_finish+0x4d0>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdx
shr    $0x13,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shl    $0x2d,%rax
or     %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x3d,%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    $0x2,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shl    $0x3,%rcx
or     %rcx,%rax
xor    %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x6,%rax
xor    %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x7,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0xf,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
shr    $0x1,%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    $0xf,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shl    $0x3f,%rcx
or     %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    $0xf,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shr    $0x8,%rcx
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%edi
sub    $0xf,%edi
movslq %edi,%rdi
mov    (%rsi,%rdi,8),%rsi
shl    $0x38,%rsi
or     %rsi,%rcx
xor    %rcx,%rax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%esi
sub    $0xf,%esi
movslq %esi,%rsi
mov    (%rcx,%rsi,8),%rcx
shr    $0x7,%rcx
xor    %rcx,%rax
add    %rax,%rdx
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x10,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,8),%rdx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14ad <SHA512_finish+0x39d>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <SHA512_transform@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SHA512_finish>:
push   %r15
push   %r14
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%r14
mov    %r15d,%r10d
shr    $0x3,%r10d
and    $0xf,%r10d
lea    0x0(,%rdx,8),%r8d
lea    0x1(%r10),%r9d
test   %r10d,%r10d
je     1218 <SHA512_finish+0xf8>
mov    %r9d,%r11d
and    $0xfffffffe,%r11d
xor    %edi,%edi
movdqa 0xe9e(%rip),%xmm0
movdqa 0xea6(%rip),%xmm1
mov    %r11,%rcx
nopl   (%rax)
movdqu (%r12,%rdi,2),%xmm2
movdqu 0x10(%r12,%rdi,2),%xmm4
movdqa %xmm2,%xmm3
punpcklqdq %xmm4,%xmm3
punpckhqdq %xmm4,%xmm2
movdqa %xmm3,%xmm4
psllq  $0x18,%xmm4
movdqa %xmm3,%xmm5
psllq  $0x8,%xmm5
pand   %xmm0,%xmm5
por    %xmm4,%xmm5
movdqa %xmm3,%xmm4
psrlq  $0x8,%xmm4
pand   %xmm1,%xmm4
psrlq  $0x18,%xmm3
por    %xmm4,%xmm3
por    %xmm5,%xmm3
psllq  $0x20,%xmm3
movdqa %xmm2,%xmm4
psllq  $0x18,%xmm4
movdqa %xmm2,%xmm5
psllq  $0x8,%xmm5
pand   %xmm0,%xmm5
por    %xmm4,%xmm5
movdqa %xmm2,%xmm4
psrlq  $0x8,%xmm4
pand   %xmm1,%xmm4
psrlq  $0x18,%xmm2
por    %xmm4,%xmm2
por    %xmm5,%xmm2
por    %xmm3,%xmm2
movdqu %xmm2,(%r12,%rdi,1)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1170 <SHA512_finish+0x50>
cmp    %r9,%r11
jne    121b <SHA512_finish+0xfb>
jmp    129e <SHA512_finish+0x17e>
xor    %r11d,%r11d
mov    %r9,%rdi
sub    %r11,%rdi
shl    $0x3,%r11
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r12,%r11,2),%rcx
mov    0x8(%r12,%r11,2),%rdx
mov    %ecx,%esi
shl    $0x18,%esi
mov    %ecx,%ebx
shl    $0x8,%ebx
and    $0xff0000,%ebx
or     %esi,%ebx
mov    %ecx,%esi
shr    $0x8,%esi
and    $0xff00,%esi
or     %ebx,%esi
shr    $0x18,%rcx
or     %esi,%ecx
shl    $0x20,%rcx
mov    %rdx,%rsi
shl    $0x18,%rsi
mov    %edx,%eax
shl    $0x8,%eax
and    $0xff0000,%eax
or     %rsi,%rax
mov    %rdx,%rsi
shr    $0x8,%rsi
and    $0xff00,%esi
or     %rax,%rsi
shr    $0x18,%rdx
or     %rsi,%rdx
or     %rcx,%rdx
mov    %rdx,(%r12,%r11,1)
add    $0x8,%r11
add    $0xffffffffffffffff,%rdi
jne    1230 <SHA512_finish+0x110>
movabs $0x8000000000000000,%rax
mov    %r10d,%edx
and    $0x38,%r8d
je     12c4 <SHA512_finish+0x1a4>
mov    (%r12,%rdx,8),%rsi
mov    %r8d,%ecx
neg    %cl
shr    %cl,%rsi
mov    %r8d,%ecx
shrd   %cl,%rsi,%rax
mov    %rax,(%r12,%rdx,8)
cmp    $0xe,%r10d
jb     1358 <SHA512_finish+0x238>
jne    12dd <SHA512_finish+0x1bd>
movq   $0x0,0x78(%r12)
mov    (%r12),%r8
mov    $0x10,%eax
cs nopw 0x0(%rax,%rax,1)
mov    -0x10(%r12,%rax,8),%rdx
mov    %rdx,%rsi
rol    $0x2d,%rsi
mov    -0x78(%r12,%rax,8),%r9
mov    %rdx,%rbx
rol    $0x3,%rbx
xor    %rsi,%rbx
shr    $0x6,%rdx
xor    %rbx,%rdx
add    -0x38(%r12,%rax,8),%rdx
mov    %r9,%rsi
mov    %r9,%rdi
mov    %r9,%rcx
ror    %rcx
rol    $0x38,%rsi
add    %r8,%rdx
mov    %r9,%r8
xor    %rcx,%rsi
shr    $0x7,%rdi
xor    %rsi,%rdi
add    %rdx,%rdi
mov    %rdi,(%r12,%rax,8)
add    $0x1,%rax
cmp    $0x50,%rax
jne    12f0 <SHA512_finish+0x1d0>
mov    %r14,%rdi
mov    %r12,%rsi
call   1030 <SHA512_transform@plt>
xor    %r9d,%r9d
jmp    135e <SHA512_finish+0x23e>
cmp    $0xd,%r10d
je     137c <SHA512_finish+0x25c>
mov    %r9d,%eax
lea    (%r12,%rax,8),%rdi
mov    $0xd,%eax
sub    %r9d,%eax
lea    0x8(,%rax,8),%rdx
xor    %esi,%esi
call   1040 <memset@plt>
mov    %r15,%rax
shr    $0x3d,%rax
mov    %rax,0x70(%r12)
shl    $0x3,%r15
mov    %r15,0x78(%r12)
mov    (%r12),%r8
mov    $0x10,%eax
nopw   0x0(%rax,%rax,1)
mov    -0x10(%r12,%rax,8),%rdx
mov    %rdx,%rsi
rol    $0x2d,%rsi
mov    -0x78(%r12,%rax,8),%r9
mov    %rdx,%rbx
rol    $0x3,%rbx
xor    %rsi,%rbx
shr    $0x6,%rdx
xor    %rbx,%rdx
add    -0x38(%r12,%rax,8),%rdx
mov    %r9,%rsi
mov    %r9,%rdi
mov    %r9,%rcx
ror    %rcx
rol    $0x38,%rsi
add    %r8,%rdx
mov    %r9,%r8
xor    %rcx,%rsi
shr    $0x7,%rdi
xor    %rsi,%rdi
add    %rdx,%rdi
mov    %rdi,(%r12,%rax,8)
add    $0x1,%rax
cmp    $0x50,%rax
jne    13a0 <SHA512_finish+0x280>
mov    %r14,%rdi
mov    %r12,%rsi
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
jmp    1030 <SHA512_transform@plt>

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

LLVM IR (-O2):
define void @SHA512_finish(i64* %0, i64* %1, i64 %2) {
%4 = trunc i64 %2 to i32
%5 = lshr i32 %4, 3
%6 = and i32 %5, 15
%7 = shl i32 %4, 3
%8 = add nuw nsw i32 %6, 1
%9 = zext i32 %8 to i64
%10 = icmp eq i32 %6, 0
br i1 %10, label %47, label %11
11: ; preds = %3
%12 = and i64 %9, 30
br label %13
13: ; preds = %13, %11
%14 = phi i64 [ 0, %11 ], [ %43, %13 ]
%15 = shl nuw nsw i64 %14, 1
%16 = getelementptr inbounds i64, i64* %1, i64 %15
%17 = bitcast i64* %16 to <4 x i64>*
%18 = load <4 x i64>, <4 x i64>* %17
%19 = shufflevector <4 x i64> %18, <4 x i64> poison, <2 x i32> <i32 0, i32 2>
%20 = shufflevector <4 x i64> %18, <4 x i64> poison, <2 x i32> <i32 1, i32 3>
%21 = shl <2 x i64> %19, <i64 24, i64 24>
%22 = shl <2 x i64> %19, <i64 8, i64 8>
%23 = and <2 x i64> %22, <i64 16711680, i64 16711680>
%24 = or <2 x i64> %23, %21
%25 = lshr <2 x i64> %19, <i64 8, i64 8>
%26 = and <2 x i64> %25, <i64 65280, i64 65280>
%27 = or <2 x i64> %24, %26
%28 = lshr <2 x i64> %19, <i64 24, i64 24>
%29 = or <2 x i64> %27, %28
%30 = shl <2 x i64> %29, <i64 32, i64 32>
%31 = shl <2 x i64> %20, <i64 24, i64 24>
%32 = shl <2 x i64> %20, <i64 8, i64 8>
%33 = and <2 x i64> %32, <i64 16711680, i64 16711680>
%34 = or <2 x i64> %33, %31
%35 = lshr <2 x i64> %20, <i64 8, i64 8>
%36 = and <2 x i64> %35, <i64 65280, i64 65280>
%37 = or <2 x i64> %34, %36
%38 = lshr <2 x i64> %20, <i64 24, i64 24>
%39 = or <2 x i64> %37, %38
%40 = or <2 x i64> %39, %30
%41 = getelementptr inbounds i64, i64* %1, i64 %14
%42 = bitcast i64* %41 to <2 x i64>*
store <2 x i64> %40, <2 x i64>* %42
%43 = add nuw i64 %14, 2
%44 = icmp eq i64 %43, %12
br i1 %44, label %45, label %13
45: ; preds = %13
%46 = icmp eq i64 %12, %9
br i1 %46, label %80, label %47
47: ; preds = %3, %45
%48 = phi i64 [ 0, %3 ], [ %12, %45 ]
br label %49
49: ; preds = %47, %49
%50 = phi i64 [ %78, %49 ], [ %48, %47 ]
%51 = shl nuw nsw i64 %50, 1
%52 = getelementptr inbounds i64, i64* %1, i64 %51
%53 = load i64, i64* %52
%54 = shl i64 %53, 24
%55 = shl i64 %53, 8
%56 = and i64 %55, 16711680
%57 = or i64 %56, %54
%58 = lshr i64 %53, 8
%59 = and i64 %58, 65280
%60 = or i64 %57, %59
%61 = lshr i64 %53, 24
%62 = or i64 %60, %61
%63 = shl i64 %62, 32
%64 = or i64 %51, 1
%65 = getelementptr inbounds i64, i64* %1, i64 %64
%66 = load i64, i64* %65
%67 = shl i64 %66, 24
%68 = shl i64 %66, 8
%69 = and i64 %68, 16711680
%70 = or i64 %69, %67
%71 = lshr i64 %66, 8
%72 = and i64 %71, 65280
%73 = or i64 %70, %72
%74 = lshr i64 %66, 24
%75 = or i64 %73, %74
%76 = or i64 %75, %63
%77 = getelementptr inbounds i64, i64* %1, i64 %50
store i64 %76, i64* %77
%78 = add nuw nsw i64 %50, 1
%79 = icmp eq i64 %78, %9
br i1 %79, label %80, label %49
80: ; preds = %49, %45
%81 = and i32 %7, 56
%82 = icmp eq i32 %81, 0
%83 = zext i32 %6 to i64
%84 = getelementptr inbounds i64, i64* %1, i64 %83
br i1 %82, label %94, label %85
85: ; preds = %80
%86 = load i64, i64* %84
%87 = sub nuw nsw i32 64, %81
%88 = zext i32 %87 to i64
%89 = shl nsw i64 -1, %88
%90 = and i64 %86, %89
%91 = zext i32 %81 to i64
%92 = lshr i64 -9223372036854775808, %91
%93 = or i64 %90, %92
br label %94
94: ; preds = %80, %85
%95 = phi i64 [ %93, %85 ], [ -9223372036854775808, %80 ]
store i64 %95, i64* %84
%96 = icmp ugt i32 %6, 13
br i1 %96, label %97, label %133
97: ; preds = %94
%98 = icmp eq i32 %6, 14
br i1 %98, label %99, label %101
99: ; preds = %97
%100 = getelementptr inbounds i64, i64* %1, i64 15
store i64 0, i64* %100
br label %101
101: ; preds = %99, %97
%102 = load i64, i64* %1
br label %103
103: ; preds = %101, %103
%104 = phi i64 [ %102, %101 ], [ %120, %103 ]
%105 = phi i64 [ 16, %101 ], [ %129, %103 ]
%106 = add nsw i64 %105, -2
%107 = getelementptr inbounds i64, i64* %1, i64 %106
%108 = load i64, i64* %107
%109 = tail call i64 @llvm.fshl.i64(i64 %108, i64 %108, i64 45)
%110 = tail call i64 @llvm.fshl.i64(i64 %108, i64 %108, i64 3)
%111 = xor i64 %109, %110
%112 = lshr i64 %108, 6
%113 = xor i64 %111, %112
%114 = add nsw i64 %105, -7
%115 = getelementptr inbounds i64, i64* %1, i64 %114
%116 = load i64, i64* %115
%117 = add i64 %113, %116
%118 = add nsw i64 %105, -15
%119 = getelementptr inbounds i64, i64* %1, i64 %118
%120 = load i64, i64* %119
%121 = tail call i64 @llvm.fshl.i64(i64 %120, i64 %120, i64 63)
%122 = tail call i64 @llvm.fshl.i64(i64 %120, i64 %120, i64 56)
%123 = xor i64 %121, %122
%124 = lshr i64 %120, 7
%125 = xor i64 %123, %124
%126 = add i64 %117, %104
%127 = add i64 %126, %125
%128 = getelementptr inbounds i64, i64* %1, i64 %105
store i64 %127, i64* %128
%129 = add nuw nsw i64 %105, 1
%130 = icmp eq i64 %129, 80
br i1 %130, label %131, label %103
131: ; preds = %103
%132 = tail call i32 @SHA512_transform(i64* %0, i64* %1)
br label %135
133: ; preds = %94
%134 = icmp eq i32 %6, 13
br i1 %134, label %144, label %135
135: ; preds = %131, %133
%136 = phi i32 [ 0, %131 ], [ %8, %133 ]
%137 = zext i32 %136 to i64
%138 = getelementptr i64, i64* %1, i64 %137
%139 = bitcast i64* %138 to i8*
%140 = sub nuw nsw i32 13, %136
%141 = zext i32 %140 to i64
%142 = shl nuw nsw i64 %141, 3
%143 = add nuw nsw i64 %142, 8
br label %144
144: ; preds = %135, %133
%145 = lshr i64 %2, 61
%146 = getelementptr inbounds i64, i64* %1, i64 14
store i64 %145, i64* %146
%147 = shl i64 %2, 3
%148 = getelementptr inbounds i64, i64* %1, i64 15
store i64 %147, i64* %148
%149 = load i64, i64* %1
br label %150
150: ; preds = %150, %144
%151 = phi i64 [ %149, %144 ], [ %167, %150 ]
%152 = phi i64 [ 16, %144 ], [ %176, %150 ]
%153 = add nsw i64 %152, -2
%154 = getelementptr inbounds i64, i64* %1, i64 %153
%155 = load i64, i64* %154
%156 = tail call i64 @llvm.fshl.i64(i64 %155, i64 %155, i64 45)
%157 = tail call i64 @llvm.fshl.i64(i64 %155, i64 %155, i64 3)
%158 = xor i64 %156, %157
%159 = lshr i64 %155, 6
%160 = xor i64 %158, %159
%161 = add nsw i64 %152, -7
%162 = getelementptr inbounds i64, i64* %1, i64 %161
%163 = load i64, i64* %162
%164 = add i64 %160, %163
%165 = add nsw i64 %152, -15
%166 = getelementptr inbounds i64, i64* %1, i64 %165
%167 = load i64, i64* %166
%168 = tail call i64 @llvm.fshl.i64(i64 %167, i64 %167, i64 63)
%169 = tail call i64 @llvm.fshl.i64(i64 %167, i64 %167, i64 56)
%170 = xor i64 %168, %169
%171 = lshr i64 %167, 7
%172 = xor i64 %170, %171
%173 = add i64 %164, %151
%174 = add i64 %173, %172
%175 = getelementptr inbounds i64, i64* %1, i64 %152
store i64 %174, i64* %175
%176 = add nuw nsw i64 %152, 1
%177 = icmp eq i64 %176, 80
br i1 %177, label %178, label %150
178: ; preds = %150
%179 = tail call i32 @SHA512_transform(i64* %0, i64* %1)
ret void
}