#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*/ crypto_hash_sha512(unsigned char *, unsigned char *,
                                      unsigned long long);
void get_hram(unsigned char *hram, const unsigned char *sm,
              const unsigned char *pk, unsigned char *playground,
              unsigned long long smlen) {
  unsigned long long i;
  for (i = 0; i < 32; ++i)
    playground[i] = sm[i];
  for (i = 32; i < 64; ++i)
    playground[i] = pk[i - 32];
  for (i = 64; i < smlen; ++i)
    playground[i] = sm[i];
  crypto_hash_sha512(hram, playground, smlen);
}


x86 assembly (clang, -O0):
<get_hram>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movq   $0x0,-0x30(%rbp)
cmpq   $0x20,-0x30(%rbp)
jae    1166 <get_hram+0x56>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    1134 <get_hram+0x24>
movq   $0x20,-0x30(%rbp)
cmpq   $0x40,-0x30(%rbp)
jae    11a4 <get_hram+0x94>
mov    -0x18(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    $0x20,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    116e <get_hram+0x5e>
movq   $0x40,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    11e1 <get_hram+0xd1>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11ac <get_hram+0x9c>
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
call   1030 <crypto_hash_sha512@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<get_hram>:
push   %rbx
mov    (%rsi),%al
mov    %al,(%rcx)
mov    0x1(%rsi),%al
mov    %al,0x1(%rcx)
mov    0x2(%rsi),%al
mov    %al,0x2(%rcx)
mov    0x3(%rsi),%al
mov    %al,0x3(%rcx)
mov    0x4(%rsi),%al
mov    %al,0x4(%rcx)
mov    0x5(%rsi),%al
mov    %al,0x5(%rcx)
mov    0x6(%rsi),%al
mov    %al,0x6(%rcx)
mov    0x7(%rsi),%al
mov    %al,0x7(%rcx)
mov    0x8(%rsi),%al
mov    %al,0x8(%rcx)
mov    0x9(%rsi),%al
mov    %al,0x9(%rcx)
mov    0xa(%rsi),%al
mov    %al,0xa(%rcx)
mov    0xb(%rsi),%al
mov    %al,0xb(%rcx)
mov    0xc(%rsi),%al
mov    %al,0xc(%rcx)
mov    0xd(%rsi),%al
mov    %al,0xd(%rcx)
mov    0xe(%rsi),%al
mov    %al,0xe(%rcx)
mov    0xf(%rsi),%al
mov    %al,0xf(%rcx)
mov    0x10(%rsi),%al
mov    %al,0x10(%rcx)
mov    0x11(%rsi),%al
mov    %al,0x11(%rcx)
mov    0x12(%rsi),%al
mov    %al,0x12(%rcx)
mov    0x13(%rsi),%al
mov    %al,0x13(%rcx)
mov    0x14(%rsi),%al
mov    %al,0x14(%rcx)
mov    0x15(%rsi),%al
mov    %al,0x15(%rcx)
mov    0x16(%rsi),%al
mov    %al,0x16(%rcx)
mov    0x17(%rsi),%al
mov    %al,0x17(%rcx)
mov    0x18(%rsi),%al
mov    %al,0x18(%rcx)
mov    0x19(%rsi),%al
mov    %al,0x19(%rcx)
mov    0x1a(%rsi),%al
mov    %al,0x1a(%rcx)
mov    0x1b(%rsi),%al
mov    %al,0x1b(%rcx)
mov    0x1c(%rsi),%al
mov    %al,0x1c(%rcx)
mov    0x1d(%rsi),%al
mov    %al,0x1d(%rcx)
mov    0x1e(%rsi),%al
mov    %al,0x1e(%rcx)
mov    0x1f(%rsi),%al
mov    %al,0x1f(%rcx)
lea    0x40(%rcx),%r10
cmp    %rdx,%rcx
jae    1218 <get_hram+0x108>
cmp    %rdx,%r10
jbe    1218 <get_hram+0x108>
xor    %eax,%eax
nop
movzbl (%rdx,%rax,1),%ebx
mov    %bl,0x20(%rcx,%rax,1)
movzbl 0x1(%rdx,%rax,1),%ebx
mov    %bl,0x21(%rcx,%rax,1)
movzbl 0x2(%rdx,%rax,1),%ebx
mov    %bl,0x22(%rcx,%rax,1)
movzbl 0x3(%rdx,%rax,1),%ebx
mov    %bl,0x23(%rcx,%rax,1)
add    $0x4,%rax
cmp    $0x20,%rax
jne    11e0 <get_hram+0xd0>
cmp    $0x41,%r8
jae    1231 <get_hram+0x121>
jmp    13fb <get_hram+0x2eb>
movups (%rdx),%xmm0
movups %xmm0,0x20(%rcx)
movups 0x10(%rdx),%xmm0
movups %xmm0,0x30(%rcx)
cmp    $0x41,%r8
jb     13fb <get_hram+0x2eb>
lea    -0x40(%r8),%r9
mov    $0x40,%edx
cmp    $0x8,%r9
jb     1391 <get_hram+0x281>
lea    (%rsi,%r8,1),%rax
cmp    %rax,%r10
jae    125e <get_hram+0x14e>
lea    (%rcx,%r8,1),%rax
lea    0x40(%rsi),%rbx
cmp    %rax,%rbx
jb     1391 <get_hram+0x281>
cmp    $0x20,%r9
jae    126b <get_hram+0x15b>
xor    %eax,%eax
jmp    135c <get_hram+0x24c>
mov    %r9,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rdx
mov    %rdx,%r11
shr    $0x5,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x60,%rdx
jae    1295 <get_hram+0x185>
xor    %edx,%edx
jmp    1312 <get_hram+0x202>
and    $0xfffffffffffffffc,%r11
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups 0x40(%rsi,%rdx,1),%xmm0
movups 0x50(%rsi,%rdx,1),%xmm1
movups %xmm0,0x40(%rcx,%rdx,1)
movups %xmm1,0x50(%rcx,%rdx,1)
movups 0x60(%rsi,%rdx,1),%xmm0
movups 0x70(%rsi,%rdx,1),%xmm1
movups %xmm0,0x60(%rcx,%rdx,1)
movups %xmm1,0x70(%rcx,%rdx,1)
movups 0x80(%rsi,%rdx,1),%xmm0
movups 0x90(%rsi,%rdx,1),%xmm1
movups %xmm0,0x80(%rcx,%rdx,1)
movups %xmm1,0x90(%rcx,%rdx,1)
movups 0xa0(%rsi,%rdx,1),%xmm0
movups 0xb0(%rsi,%rdx,1),%xmm1
movups %xmm0,0xa0(%rcx,%rdx,1)
movups %xmm1,0xb0(%rcx,%rdx,1)
sub    $0xffffffffffffff80,%rdx
add    $0xfffffffffffffffc,%r11
jne    12a0 <get_hram+0x190>
test   %r10,%r10
je     134d <get_hram+0x23d>
lea    (%rcx,%rdx,1),%r11
add    $0x50,%r11
add    %rsi,%rdx
add    $0x50,%rdx
shl    $0x5,%r10
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movups %xmm0,-0x10(%r11,%rbx,1)
movups %xmm1,(%r11,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1330 <get_hram+0x220>
cmp    %rax,%r9
je     13fb <get_hram+0x2eb>
test   $0x18,%r8b
je     138a <get_hram+0x27a>
mov    %r9,%r10
and    $0xfffffffffffffff8,%r10
lea    0x40(%r10),%rdx
nopw   0x0(%rax,%rax,1)
mov    0x40(%rsi,%rax,1),%rbx
mov    %rbx,0x40(%rcx,%rax,1)
add    $0x8,%rax
cmp    %rax,%r10
jne    1370 <get_hram+0x260>
cmp    %r10,%r9
jne    1391 <get_hram+0x281>
jmp    13fb <get_hram+0x2eb>
add    $0x40,%rax
mov    %rax,%rdx
mov    %r8d,%eax
sub    %edx,%eax
mov    %rdx,%r9
not    %r9
add    %r8,%r9
and    $0x3,%rax
je     13c1 <get_hram+0x2b1>
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rsi,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    13b0 <get_hram+0x2a0>
cmp    $0x3,%r9
jb     13fb <get_hram+0x2eb>
nopw   0x0(%rax,%rax,1)
movzbl (%rsi,%rdx,1),%eax
mov    %al,(%rcx,%rdx,1)
movzbl 0x1(%rsi,%rdx,1),%eax
mov    %al,0x1(%rcx,%rdx,1)
movzbl 0x2(%rsi,%rdx,1),%eax
mov    %al,0x2(%rcx,%rdx,1)
movzbl 0x3(%rsi,%rdx,1),%eax
mov    %al,0x3(%rcx,%rdx,1)
add    $0x4,%rdx
cmp    %rdx,%r8
jne    13d0 <get_hram+0x2c0>
mov    %rcx,%rsi
mov    %r8,%rdx
pop    %rbx
jmp    1030 <crypto_hash_sha512@plt>

LLVM IR (-O0):
define void @get_hram(i8* %0, i8* %1, i8* %2, i8* %3, i64 %4) {
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i64
%11 = alloca i64
store i8* %0, i8** %6
store i8* %1, i8** %7
store i8* %2, i8** %8
store i8* %3, i8** %9
store i64 %4, i64* %10
store i64 0, i64* %11
br label %12
12: ; preds = %23, %5
%13 = load i64, i64* %11
%14 = icmp ult i64 %13, 32
br i1 %14, label %15, label %26
15: ; preds = %12
%16 = load i8*, i8** %7
%17 = load i64, i64* %11
%18 = getelementptr inbounds i8, i8* %16, i64 %17
%19 = load i8, i8* %18
%20 = load i8*, i8** %9
%21 = load i64, i64* %11
%22 = getelementptr inbounds i8, i8* %20, i64 %21
store i8 %19, i8* %22
br label %23
23: ; preds = %15
%24 = load i64, i64* %11
%25 = add i64 %24, 1
store i64 %25, i64* %11
br label %12
26: ; preds = %12
store i64 32, i64* %11
br label %27
27: ; preds = %39, %26
%28 = load i64, i64* %11
%29 = icmp ult i64 %28, 64
br i1 %29, label %30, label %42
30: ; preds = %27
%31 = load i8*, i8** %8
%32 = load i64, i64* %11
%33 = sub i64 %32, 32
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = load i8*, i8** %9
%37 = load i64, i64* %11
%38 = getelementptr inbounds i8, i8* %36, i64 %37
store i8 %35, i8* %38
br label %39
39: ; preds = %30
%40 = load i64, i64* %11
%41 = add i64 %40, 1
store i64 %41, i64* %11
br label %27
42: ; preds = %27
store i64 64, i64* %11
br label %43
43: ; preds = %55, %42
%44 = load i64, i64* %11
%45 = load i64, i64* %10
%46 = icmp ult i64 %44, %45
br i1 %46, label %47, label %58
47: ; preds = %43
%48 = load i8*, i8** %7
%49 = load i64, i64* %11
%50 = getelementptr inbounds i8, i8* %48, i64 %49
%51 = load i8, i8* %50
%52 = load i8*, i8** %9
%53 = load i64, i64* %11
%54 = getelementptr inbounds i8, i8* %52, i64 %53
store i8 %51, i8* %54
br label %55
55: ; preds = %47
%56 = load i64, i64* %11
%57 = add i64 %56, 1
store i64 %57, i64* %11
br label %43
58: ; preds = %43
%59 = load i8*, i8** %6
%60 = load i8*, i8** %9
%61 = load i64, i64* %10
%62 = call i32 @crypto_hash_sha512(i8* %59, i8* %60, i64 %61)
ret void
}

LLVM IR (-O2):
define void @get_hram(i8* %0, i8* nocapture %1, i8* nocapture %2, i8* %3, i64 %4) {
%6 = load i8, i8* %1
store i8 %6, i8* %3
%7 = getelementptr inbounds i8, i8* %1, i64 1
%8 = load i8, i8* %7
%9 = getelementptr inbounds i8, i8* %3, i64 1
store i8 %8, i8* %9
%10 = getelementptr inbounds i8, i8* %1, i64 2
%11 = load i8, i8* %10
%12 = getelementptr inbounds i8, i8* %3, i64 2
store i8 %11, i8* %12
%13 = getelementptr inbounds i8, i8* %1, i64 3
%14 = load i8, i8* %13
%15 = getelementptr inbounds i8, i8* %3, i64 3
store i8 %14, i8* %15
%16 = getelementptr inbounds i8, i8* %1, i64 4
%17 = load i8, i8* %16
%18 = getelementptr inbounds i8, i8* %3, i64 4
store i8 %17, i8* %18
%19 = getelementptr inbounds i8, i8* %1, i64 5
%20 = load i8, i8* %19
%21 = getelementptr inbounds i8, i8* %3, i64 5
store i8 %20, i8* %21
%22 = getelementptr inbounds i8, i8* %1, i64 6
%23 = load i8, i8* %22
%24 = getelementptr inbounds i8, i8* %3, i64 6
store i8 %23, i8* %24
%25 = getelementptr inbounds i8, i8* %1, i64 7
%26 = load i8, i8* %25
%27 = getelementptr inbounds i8, i8* %3, i64 7
store i8 %26, i8* %27
%28 = getelementptr inbounds i8, i8* %1, i64 8
%29 = load i8, i8* %28
%30 = getelementptr inbounds i8, i8* %3, i64 8
store i8 %29, i8* %30
%31 = getelementptr inbounds i8, i8* %1, i64 9
%32 = load i8, i8* %31
%33 = getelementptr inbounds i8, i8* %3, i64 9
store i8 %32, i8* %33
%34 = getelementptr inbounds i8, i8* %1, i64 10
%35 = load i8, i8* %34
%36 = getelementptr inbounds i8, i8* %3, i64 10
store i8 %35, i8* %36
%37 = getelementptr inbounds i8, i8* %1, i64 11
%38 = load i8, i8* %37
%39 = getelementptr inbounds i8, i8* %3, i64 11
store i8 %38, i8* %39
%40 = getelementptr inbounds i8, i8* %1, i64 12
%41 = load i8, i8* %40
%42 = getelementptr inbounds i8, i8* %3, i64 12
store i8 %41, i8* %42
%43 = getelementptr inbounds i8, i8* %1, i64 13
%44 = load i8, i8* %43
%45 = getelementptr inbounds i8, i8* %3, i64 13
store i8 %44, i8* %45
%46 = getelementptr inbounds i8, i8* %1, i64 14
%47 = load i8, i8* %46
%48 = getelementptr inbounds i8, i8* %3, i64 14
store i8 %47, i8* %48
%49 = getelementptr inbounds i8, i8* %1, i64 15
%50 = load i8, i8* %49
%51 = getelementptr inbounds i8, i8* %3, i64 15
store i8 %50, i8* %51
%52 = getelementptr inbounds i8, i8* %1, i64 16
%53 = load i8, i8* %52
%54 = getelementptr inbounds i8, i8* %3, i64 16
store i8 %53, i8* %54
%55 = getelementptr inbounds i8, i8* %1, i64 17
%56 = load i8, i8* %55
%57 = getelementptr inbounds i8, i8* %3, i64 17
store i8 %56, i8* %57
%58 = getelementptr inbounds i8, i8* %1, i64 18
%59 = load i8, i8* %58
%60 = getelementptr inbounds i8, i8* %3, i64 18
store i8 %59, i8* %60
%61 = getelementptr inbounds i8, i8* %1, i64 19
%62 = load i8, i8* %61
%63 = getelementptr inbounds i8, i8* %3, i64 19
store i8 %62, i8* %63
%64 = getelementptr inbounds i8, i8* %1, i64 20
%65 = load i8, i8* %64
%66 = getelementptr inbounds i8, i8* %3, i64 20
store i8 %65, i8* %66
%67 = getelementptr inbounds i8, i8* %1, i64 21
%68 = load i8, i8* %67
%69 = getelementptr inbounds i8, i8* %3, i64 21
store i8 %68, i8* %69
%70 = getelementptr inbounds i8, i8* %1, i64 22
%71 = load i8, i8* %70
%72 = getelementptr inbounds i8, i8* %3, i64 22
store i8 %71, i8* %72
%73 = getelementptr inbounds i8, i8* %1, i64 23
%74 = load i8, i8* %73
%75 = getelementptr inbounds i8, i8* %3, i64 23
store i8 %74, i8* %75
%76 = getelementptr inbounds i8, i8* %1, i64 24
%77 = load i8, i8* %76
%78 = getelementptr inbounds i8, i8* %3, i64 24
store i8 %77, i8* %78
%79 = getelementptr inbounds i8, i8* %1, i64 25
%80 = load i8, i8* %79
%81 = getelementptr inbounds i8, i8* %3, i64 25
store i8 %80, i8* %81
%82 = getelementptr inbounds i8, i8* %1, i64 26
%83 = load i8, i8* %82
%84 = getelementptr inbounds i8, i8* %3, i64 26
store i8 %83, i8* %84
%85 = getelementptr inbounds i8, i8* %1, i64 27
%86 = load i8, i8* %85
%87 = getelementptr inbounds i8, i8* %3, i64 27
store i8 %86, i8* %87
%88 = getelementptr inbounds i8, i8* %1, i64 28
%89 = load i8, i8* %88
%90 = getelementptr inbounds i8, i8* %3, i64 28
store i8 %89, i8* %90
%91 = getelementptr inbounds i8, i8* %1, i64 29
%92 = load i8, i8* %91
%93 = getelementptr inbounds i8, i8* %3, i64 29
store i8 %92, i8* %93
%94 = getelementptr inbounds i8, i8* %1, i64 30
%95 = load i8, i8* %94
%96 = getelementptr inbounds i8, i8* %3, i64 30
store i8 %95, i8* %96
%97 = getelementptr inbounds i8, i8* %1, i64 31
%98 = load i8, i8* %97
%99 = getelementptr inbounds i8, i8* %3, i64 31
store i8 %98, i8* %99
%100 = getelementptr i8, i8* %3, i64 64
%101 = icmp ult i8* %3, %2
%102 = icmp ugt i8* %100, %2
%103 = and i1 %101, %102
br i1 %103, label %250, label %104
104: ; preds = %5
%105 = bitcast i8* %2 to <16 x i8>*
%106 = load <16 x i8>, <16 x i8>* %105
%107 = getelementptr inbounds i8, i8* %3, i64 32
%108 = bitcast i8* %107 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %108
%109 = getelementptr inbounds i8, i8* %2, i64 16
%110 = bitcast i8* %109 to <16 x i8>*
%111 = load <16 x i8>, <16 x i8>* %110
%112 = getelementptr inbounds i8, i8* %3, i64 48
%113 = bitcast i8* %112 to <16 x i8>*
store <16 x i8> %111, <16 x i8>* %113
br label %114
114: ; preds = %250, %104
%115 = icmp ugt i64 %4, 64
br i1 %115, label %116, label %292
116: ; preds = %114
%117 = add i64 %4, -64
%118 = icmp ult i64 %117, 8
br i1 %118, label %231, label %119
119: ; preds = %116
%120 = getelementptr i8, i8* %3, i64 64
%121 = getelementptr i8, i8* %3, i64 %4
%122 = getelementptr i8, i8* %1, i64 64
%123 = getelementptr i8, i8* %1, i64 %4
%124 = icmp ult i8* %120, %123
%125 = icmp ult i8* %122, %121
%126 = and i1 %124, %125
br i1 %126, label %231, label %127
127: ; preds = %119
%128 = icmp ult i64 %117, 32
br i1 %128, label %214, label %129
129: ; preds = %127
%130 = and i64 %117, -32
%131 = add i64 %130, -32
%132 = lshr exact i64 %131, 5
%133 = add nuw nsw i64 %132, 1
%134 = and i64 %133, 3
%135 = icmp ult i64 %131, 96
br i1 %135, label %188, label %136
136: ; preds = %129
%137 = and i64 %133, 1152921504606846972
br label %138
138: ; preds = %138, %136
%139 = phi i64 [ 0, %136 ], [ %185, %138 ]
%140 = phi i64 [ 0, %136 ], [ %186, %138 ]
%141 = or i64 %139, 64
%142 = getelementptr inbounds i8, i8* %1, i64 %141
%143 = bitcast i8* %142 to <16 x i8>*
%144 = load <16 x i8>, <16 x i8>* %143
%145 = getelementptr inbounds i8, i8* %142, i64 16
%146 = bitcast i8* %145 to <16 x i8>*
%147 = load <16 x i8>, <16 x i8>* %146
%148 = getelementptr inbounds i8, i8* %3, i64 %141
%149 = bitcast i8* %148 to <16 x i8>*
store <16 x i8> %144, <16 x i8>* %149
%150 = getelementptr inbounds i8, i8* %148, i64 16
%151 = bitcast i8* %150 to <16 x i8>*
store <16 x i8> %147, <16 x i8>* %151
%152 = or i64 %139, 96
%153 = getelementptr inbounds i8, i8* %1, i64 %152
%154 = bitcast i8* %153 to <16 x i8>*
%155 = load <16 x i8>, <16 x i8>* %154
%156 = getelementptr inbounds i8, i8* %153, i64 16
%157 = bitcast i8* %156 to <16 x i8>*
%158 = load <16 x i8>, <16 x i8>* %157
%159 = getelementptr inbounds i8, i8* %3, i64 %152
%160 = bitcast i8* %159 to <16 x i8>*
store <16 x i8> %155, <16 x i8>* %160
%161 = getelementptr inbounds i8, i8* %159, i64 16
%162 = bitcast i8* %161 to <16 x i8>*
store <16 x i8> %158, <16 x i8>* %162
%163 = add i64 %139, 128
%164 = getelementptr inbounds i8, i8* %1, i64 %163
%165 = bitcast i8* %164 to <16 x i8>*
%166 = load <16 x i8>, <16 x i8>* %165
%167 = getelementptr inbounds i8, i8* %164, i64 16
%168 = bitcast i8* %167 to <16 x i8>*
%169 = load <16 x i8>, <16 x i8>* %168
%170 = getelementptr inbounds i8, i8* %3, i64 %163
%171 = bitcast i8* %170 to <16 x i8>*
store <16 x i8> %166, <16 x i8>* %171
%172 = getelementptr inbounds i8, i8* %170, i64 16
%173 = bitcast i8* %172 to <16 x i8>*
store <16 x i8> %169, <16 x i8>* %173
%174 = add i64 %139, 160
%175 = getelementptr inbounds i8, i8* %1, i64 %174
%176 = bitcast i8* %175 to <16 x i8>*
%177 = load <16 x i8>, <16 x i8>* %176
%178 = getelementptr inbounds i8, i8* %175, i64 16
%179 = bitcast i8* %178 to <16 x i8>*
%180 = load <16 x i8>, <16 x i8>* %179
%181 = getelementptr inbounds i8, i8* %3, i64 %174
%182 = bitcast i8* %181 to <16 x i8>*
store <16 x i8> %177, <16 x i8>* %182
%183 = getelementptr inbounds i8, i8* %181, i64 16
%184 = bitcast i8* %183 to <16 x i8>*
store <16 x i8> %180, <16 x i8>* %184
%185 = add nuw i64 %139, 128
%186 = add i64 %140, 4
%187 = icmp eq i64 %186, %137
br i1 %187, label %188, label %138
188: ; preds = %138, %129
%189 = phi i64 [ 0, %129 ], [ %185, %138 ]
%190 = icmp eq i64 %134, 0
br i1 %190, label %208, label %191
191: ; preds = %188, %191
%192 = phi i64 [ %205, %191 ], [ %189, %188 ]
%193 = phi i64 [ %206, %191 ], [ 0, %188 ]
%194 = add i64 %192, 64
%195 = getelementptr inbounds i8, i8* %1, i64 %194
%196 = bitcast i8* %195 to <16 x i8>*
%197 = load <16 x i8>, <16 x i8>* %196
%198 = getelementptr inbounds i8, i8* %195, i64 16
%199 = bitcast i8* %198 to <16 x i8>*
%200 = load <16 x i8>, <16 x i8>* %199
%201 = getelementptr inbounds i8, i8* %3, i64 %194
%202 = bitcast i8* %201 to <16 x i8>*
store <16 x i8> %197, <16 x i8>* %202
%203 = getelementptr inbounds i8, i8* %201, i64 16
%204 = bitcast i8* %203 to <16 x i8>*
store <16 x i8> %200, <16 x i8>* %204
%205 = add nuw i64 %192, 32
%206 = add i64 %193, 1
%207 = icmp eq i64 %206, %134
br i1 %207, label %208, label %191
208: ; preds = %191, %188
%209 = icmp eq i64 %117, %130
br i1 %209, label %292, label %210
210: ; preds = %208
%211 = add i64 %130, 64
%212 = and i64 %4, 24
%213 = icmp eq i64 %212, 0
br i1 %213, label %231, label %214
214: ; preds = %127, %210
%215 = phi i64 [ %130, %210 ], [ 0, %127 ]
%216 = add i64 %4, -64
%217 = and i64 %216, -8
%218 = add i64 %217, 64
br label %219
219: ; preds = %219, %214
%220 = phi i64 [ %215, %214 ], [ %227, %219 ]
%221 = add i64 %220, 64
%222 = getelementptr inbounds i8, i8* %1, i64 %221
%223 = bitcast i8* %222 to <8 x i8>*
%224 = load <8 x i8>, <8 x i8>* %223
%225 = getelementptr inbounds i8, i8* %3, i64 %221
%226 = bitcast i8* %225 to <8 x i8>*
store <8 x i8> %224, <8 x i8>* %226
%227 = add nuw i64 %220, 8
%228 = icmp eq i64 %227, %217
br i1 %228, label %229, label %219
229: ; preds = %219
%230 = icmp eq i64 %216, %217
br i1 %230, label %292, label %231
231: ; preds = %119, %116, %210, %229
%232 = phi i64 [ 64, %116 ], [ 64, %119 ], [ %211, %210 ], [ %218, %229 ]
%233 = sub i64 %4, %232
%234 = xor i64 %232, -1
%235 = add i64 %234, %4
%236 = and i64 %233, 3
%237 = icmp eq i64 %236, 0
br i1 %237, label %247, label %238
238: ; preds = %231, %238
%239 = phi i64 [ %244, %238 ], [ %232, %231 ]
%240 = phi i64 [ %245, %238 ], [ 0, %231 ]
%241 = getelementptr inbounds i8, i8* %1, i64 %239
%242 = load i8, i8* %241
%243 = getelementptr inbounds i8, i8* %3, i64 %239
store i8 %242, i8* %243
%244 = add nuw i64 %239, 1
%245 = add i64 %240, 1
%246 = icmp eq i64 %245, %236
br i1 %246, label %247, label %238
247: ; preds = %238, %231
%248 = phi i64 [ %232, %231 ], [ %244, %238 ]
%249 = icmp ult i64 %235, 3
br i1 %249, label %292, label %273
250: ; preds = %5, %250
%251 = phi i64 [ %271, %250 ], [ 32, %5 ]
%252 = add nsw i64 %251, -32
%253 = getelementptr inbounds i8, i8* %2, i64 %252
%254 = load i8, i8* %253
%255 = getelementptr inbounds i8, i8* %3, i64 %251
store i8 %254, i8* %255
%256 = or i64 %251, 1
%257 = add nsw i64 %251, -31
%258 = getelementptr inbounds i8, i8* %2, i64 %257
%259 = load i8, i8* %258
%260 = getelementptr inbounds i8, i8* %3, i64 %256
store i8 %259, i8* %260
%261 = or i64 %251, 2
%262 = add nsw i64 %251, -30
%263 = getelementptr inbounds i8, i8* %2, i64 %262
%264 = load i8, i8* %263
%265 = getelementptr inbounds i8, i8* %3, i64 %261
store i8 %264, i8* %265
%266 = or i64 %251, 3
%267 = add nsw i64 %251, -29
%268 = getelementptr inbounds i8, i8* %2, i64 %267
%269 = load i8, i8* %268
%270 = getelementptr inbounds i8, i8* %3, i64 %266
store i8 %269, i8* %270
%271 = add nuw nsw i64 %251, 4
%272 = icmp eq i64 %271, 64
br i1 %272, label %114, label %250
273: ; preds = %247, %273
%274 = phi i64 [ %290, %273 ], [ %248, %247 ]
%275 = getelementptr inbounds i8, i8* %1, i64 %274
%276 = load i8, i8* %275
%277 = getelementptr inbounds i8, i8* %3, i64 %274
store i8 %276, i8* %277
%278 = add nuw i64 %274, 1
%279 = getelementptr inbounds i8, i8* %1, i64 %278
%280 = load i8, i8* %279
%281 = getelementptr inbounds i8, i8* %3, i64 %278
store i8 %280, i8* %281
%282 = add nuw i64 %274, 2
%283 = getelementptr inbounds i8, i8* %1, i64 %282
%284 = load i8, i8* %283
%285 = getelementptr inbounds i8, i8* %3, i64 %282
store i8 %284, i8* %285
%286 = add nuw i64 %274, 3
%287 = getelementptr inbounds i8, i8* %1, i64 %286
%288 = load i8, i8* %287
%289 = getelementptr inbounds i8, i8* %3, i64 %286
store i8 %288, i8* %289
%290 = add nuw i64 %274, 4
%291 = icmp eq i64 %290, %4
br i1 %291, label %292, label %273
292: ; preds = %247, %273, %208, %229, %114
%293 = tail call i32 @crypto_hash_sha512(i8* %0, i8* %3, i64 %4)
ret void
}