#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*/ sha2_chain(unsigned char *, unsigned char *);
int expand_sha2(unsigned char *digest, unsigned n_digest,
                const unsigned char *hash) {
  if ((32) >= n_digest) {
    for (unsigned i = 0; i < n_digest; i++)
      digest[i] = hash[i];
    return 0;
  } else {
    for (unsigned i = 0; i < (32); i++)
      digest[i] = hash[i];
    n_digest -= (32);
  }
  while ((32) <= n_digest) {
    sha2_chain(digest + (32), digest);
    n_digest -= (32);
    digest += (32);
  }
  unsigned char temp[(32)];
  if (n_digest) {
    sha2_chain(temp, digest);
    for (unsigned i = 0; i < n_digest; i++)
      digest[(32) + i] = temp[i];
  }
  return 0;
}


x86 assembly (clang, -O0):
<expand_sha2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    $0x20,%eax
cmp    -0x14(%rbp),%eax
jb     1172 <expand_sha2+0x62>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1166 <expand_sha2+0x56>
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1138 <expand_sha2+0x28>
movl   $0x0,-0x4(%rbp)
jmp    1246 <expand_sha2+0x136>
movl   $0x0,-0x28(%rbp)
cmpl   $0x20,-0x28(%rbp)
jae    11a5 <expand_sha2+0x95>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1179 <expand_sha2+0x69>
mov    -0x14(%rbp),%eax
sub    $0x20,%eax
mov    %eax,-0x14(%rbp)
jmp    11b3 <expand_sha2+0xa3>
mov    $0x20,%eax
cmp    -0x14(%rbp),%eax
ja     11ec <expand_sha2+0xdc>
mov    -0x10(%rbp),%rdi
add    $0x20,%rdi
mov    -0x10(%rbp),%rsi
call   1030 <sha2_chain@plt>
mov    -0x14(%rbp),%eax
sub    $0x20,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x10(%rbp)
jmp    11b3 <expand_sha2+0xa3>
cmpl   $0x0,-0x14(%rbp)
je     123f <expand_sha2+0x12f>
lea    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <sha2_chain@plt>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    123a <expand_sha2+0x12a>
mov    -0x54(%rbp),%eax
mov    -0x50(%rbp,%rax,1),%dl
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
add    $0x20,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    120a <expand_sha2+0xfa>
jmp    123f <expand_sha2+0x12f>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<expand_sha2>:
push   %rbp
push   %r14
push   %rbx
sub    $0x20,%rsp
mov    %esi,%ebp
mov    %rdi,%rbx
cmp    $0x21,%esi
jae    11c0 <expand_sha2+0xb0>
test   %ebp,%ebp
je     135d <expand_sha2+0x24d>
mov    %ebp,%r8d
cmp    $0x8,%ebp
jb     1150 <expand_sha2+0x40>
lea    (%rdx,%r8,1),%rcx
cmp    %rbx,%rcx
jbe    13b3 <expand_sha2+0x2a3>
lea    (%rbx,%r8,1),%rcx
cmp    %rdx,%rcx
jbe    13b3 <expand_sha2+0x2a3>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
add    %r8,%rsi
mov    %r8,%rdi
and    $0x3,%rdi
je     1181 <expand_sha2+0x71>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rdx,%rcx,1),%eax
mov    %al,(%rbx,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1170 <expand_sha2+0x60>
cmp    $0x3,%rsi
jb     135d <expand_sha2+0x24d>
nopl   0x0(%rax,%rax,1)
movzbl (%rdx,%rcx,1),%eax
mov    %al,(%rbx,%rcx,1)
movzbl 0x1(%rdx,%rcx,1),%eax
mov    %al,0x1(%rbx,%rcx,1)
movzbl 0x2(%rdx,%rcx,1),%eax
mov    %al,0x2(%rbx,%rcx,1)
movzbl 0x3(%rdx,%rcx,1),%eax
mov    %al,0x3(%rbx,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1190 <expand_sha2+0x80>
jmp    135d <expand_sha2+0x24d>
mov    (%rdx),%al
mov    %al,(%rbx)
mov    0x1(%rdx),%al
mov    %al,0x1(%rbx)
mov    0x2(%rdx),%al
mov    %al,0x2(%rbx)
mov    0x3(%rdx),%al
mov    %al,0x3(%rbx)
mov    0x4(%rdx),%al
mov    %al,0x4(%rbx)
mov    0x5(%rdx),%al
mov    %al,0x5(%rbx)
mov    0x6(%rdx),%al
mov    %al,0x6(%rbx)
mov    0x7(%rdx),%al
mov    %al,0x7(%rbx)
mov    0x8(%rdx),%al
mov    %al,0x8(%rbx)
mov    0x9(%rdx),%al
mov    %al,0x9(%rbx)
mov    0xa(%rdx),%al
mov    %al,0xa(%rbx)
mov    0xb(%rdx),%al
mov    %al,0xb(%rbx)
mov    0xc(%rdx),%al
mov    %al,0xc(%rbx)
mov    0xd(%rdx),%al
mov    %al,0xd(%rbx)
mov    0xe(%rdx),%al
mov    %al,0xe(%rbx)
mov    0xf(%rdx),%al
mov    %al,0xf(%rbx)
mov    0x10(%rdx),%al
mov    %al,0x10(%rbx)
mov    0x11(%rdx),%al
mov    %al,0x11(%rbx)
mov    0x12(%rdx),%al
mov    %al,0x12(%rbx)
mov    0x13(%rdx),%al
mov    %al,0x13(%rbx)
mov    0x14(%rdx),%al
mov    %al,0x14(%rbx)
mov    0x15(%rdx),%al
mov    %al,0x15(%rbx)
mov    0x16(%rdx),%al
mov    %al,0x16(%rbx)
mov    0x17(%rdx),%al
mov    %al,0x17(%rbx)
mov    0x18(%rdx),%al
mov    %al,0x18(%rbx)
mov    0x19(%rdx),%al
mov    %al,0x19(%rbx)
mov    0x1a(%rdx),%al
mov    %al,0x1a(%rbx)
mov    0x1b(%rdx),%al
mov    %al,0x1b(%rbx)
mov    0x1c(%rdx),%al
mov    %al,0x1c(%rbx)
mov    0x1d(%rdx),%al
mov    %al,0x1d(%rbx)
mov    0x1e(%rdx),%al
mov    %al,0x1e(%rbx)
mov    0x1f(%rdx),%al
mov    %al,0x1f(%rbx)
add    $0xffffffe0,%ebp
cmp    $0x20,%ebp
jb     12af <expand_sha2+0x19f>
cs nopw 0x0(%rax,%rax,1)
mov    %rbx,%rsi
add    $0x20,%rbx
mov    %rbx,%rdi
call   1030 <sha2_chain@plt>
add    $0xffffffe0,%ebp
cmp    $0x1f,%ebp
ja     1290 <expand_sha2+0x180>
test   %ebp,%ebp
je     135d <expand_sha2+0x24d>
mov    %rsp,%r14
mov    %r14,%rdi
mov    %rbx,%rsi
call   1030 <sha2_chain@plt>
mov    %ebp,%r9d
cmp    $0x8,%ebp
jae    1368 <expand_sha2+0x258>
xor    %ecx,%ecx
mov    %rcx,%rsi
not    %rsi
lea    (%rsi,%r9,1),%r8
mov    %r9,%rdi
and    $0x3,%rdi
je     130b <expand_sha2+0x1fb>
add    $0x1,%rsi
lea    0x20(%rcx),%ebp
add    %rbx,%rbp
add    %rsp,%rcx
xor    %edx,%edx
nopl   (%rax)
movzbl (%rcx,%rdx,1),%eax
mov    %al,0x0(%rbp,%rdx,1)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
cmp    %rdx,%rdi
jne    12f0 <expand_sha2+0x1e0>
neg    %rsi
mov    %rsi,%rcx
cmp    $0x3,%r8
jb     135d <expand_sha2+0x24d>
neg    %r9
add    $0x20,%rcx
nopl   0x0(%rax,%rax,1)
movzbl -0x20(%rsp,%rcx,1),%eax
mov    %ecx,%edx
mov    %al,(%rbx,%rdx,1)
movzbl -0x1f(%rsp,%rcx,1),%eax
lea    0x1(%rcx),%edx
mov    %al,(%rbx,%rdx,1)
movzbl -0x1e(%rsp,%rcx,1),%eax
lea    0x2(%rcx),%edx
mov    %al,(%rbx,%rdx,1)
movzbl -0x1d(%rsp,%rcx,1),%eax
lea    0x3(%rcx),%edx
mov    %al,(%rbx,%rdx,1)
lea    (%r9,%rcx,1),%rax
add    $0x4,%rax
add    $0x4,%rcx
cmp    $0x20,%rax
jne    1320 <expand_sha2+0x210>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
lea    -0x1(%r9),%rdx
mov    %edx,%esi
not    %esi
xor    %ecx,%ecx
test   $0xffffffe0,%esi
je     12cb <expand_sha2+0x1bb>
shr    $0x20,%rdx
jne    12cb <expand_sha2+0x1bb>
lea    (%r9,%rbx,1),%rcx
add    $0x20,%rcx
cmp    %rcx,%r14
jae    13a6 <expand_sha2+0x296>
lea    (%rsp,%r9,1),%rcx
lea    0x20(%rbx),%rdx
cmp    %rcx,%rdx
jb     12c9 <expand_sha2+0x1b9>
cmp    $0x20,%r9d
jae    140f <expand_sha2+0x2ff>
xor    %ecx,%ecx
jmp    14af <expand_sha2+0x39f>
cmp    $0x10,%ebp
jae    13bc <expand_sha2+0x2ac>
xor    %ecx,%ecx
jmp    13e5 <expand_sha2+0x2d5>
mov    %r8d,%ecx
and    $0xfffffff0,%ecx
movups (%rdx),%xmm0
movups %xmm0,(%rbx)
cmp    $0x10,%rcx
je     13d6 <expand_sha2+0x2c6>
movups 0x10(%rdx),%xmm0
movups %xmm0,0x10(%rbx)
cmp    %r8,%rcx
je     135d <expand_sha2+0x24d>
test   $0x8,%r8b
je     1152 <expand_sha2+0x42>
mov    %rcx,%rsi
mov    %r8d,%ecx
and    $0xfffffff8,%ecx
xchg   %ax,%ax
mov    (%rdx,%rsi,1),%rdi
mov    %rdi,(%rbx,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    13f0 <expand_sha2+0x2e0>
cmp    %r8,%rcx
je     135d <expand_sha2+0x24d>
jmp    1152 <expand_sha2+0x42>
mov    %r9d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdx
mov    %rdx,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
test   %rdx,%rdx
je     147c <expand_sha2+0x36c>
mov    %rsi,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps (%rsp,%rbp,1),%xmm0
movaps 0x10(%rsp,%rbp,1),%xmm1
mov    %ebp,%edx
and    $0xffffffc0,%edx
movups %xmm0,0x20(%rbx,%rdx,1)
movups %xmm1,0x30(%rbx,%rdx,1)
movaps 0x20(%rsp,%rbp,1),%xmm0
movaps 0x30(%rsp,%rbp,1),%xmm1
add    $0x40,%rbp
mov    %ebp,%edx
and    $0xffffffc0,%edx
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,0x10(%rbx,%rdx,1)
add    $0xfffffffffffffffe,%rdi
jne    1440 <expand_sha2+0x330>
jmp    147e <expand_sha2+0x36e>
xor    %ebp,%ebp
test   $0x1,%sil
je     149c <expand_sha2+0x38c>
movaps (%rsp,%rbp,1),%xmm0
movaps 0x10(%rsp,%rbp,1),%xmm1
add    $0x20,%ebp
and    $0xffffffe0,%ebp
movups %xmm0,(%rbx,%rbp,1)
movups %xmm1,0x10(%rbx,%rbp,1)
cmp    %r9,%rcx
je     135d <expand_sha2+0x24d>
test   $0x18,%r9b
je     12cb <expand_sha2+0x1bb>
mov    %rcx,%rbp
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
add    $0x20,%rbp
mov    %rcx,%rsi
neg    %rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x20(%rsp,%rbp,1),%rdi
mov    %ebp,%edx
and    $0xfffffff8,%edx
mov    %rdi,(%rbx,%rdx,1)
lea    (%rsi,%rbp,1),%rdx
add    $0x8,%rdx
add    $0x8,%rbp
cmp    $0x20,%rdx
jne    14d0 <expand_sha2+0x3c0>
cmp    %r9,%rcx
jne    12cb <expand_sha2+0x1bb>
jmp    135d <expand_sha2+0x24d>

LLVM IR (-O0):
define i32 @expand_sha2(i8* %0, i32 %1, i8* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca [32 x i8]
%11 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i8* %2, i8** %7
%12 = load i32, i32* %6
%13 = icmp uge i32 32, %12
br i1 %13, label %14, label %33
14: ; preds = %3
store i32 0, i32* %8
br label %15
15: ; preds = %29, %14
%16 = load i32, i32* %8
%17 = load i32, i32* %6
%18 = icmp ult i32 %16, %17
br i1 %18, label %19, label %32
19: ; preds = %15
%20 = load i8*, i8** %7
%21 = load i32, i32* %8
%22 = zext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %20, i64 %22
%24 = load i8, i8* %23
%25 = load i8*, i8** %5
%26 = load i32, i32* %8
%27 = zext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %25, i64 %27
store i8 %24, i8* %28
br label %29
29: ; preds = %19
%30 = load i32, i32* %8
%31 = add i32 %30, 1
store i32 %31, i32* %8
br label %15
32: ; preds = %15
store i32 0, i32* %4
br label %92
33: ; preds = %3
store i32 0, i32* %9
br label %34
34: ; preds = %47, %33
%35 = load i32, i32* %9
%36 = icmp ult i32 %35, 32
br i1 %36, label %37, label %50
37: ; preds = %34
%38 = load i8*, i8** %7
%39 = load i32, i32* %9
%40 = zext i32 %39 to i64
%41 = getelementptr inbounds i8, i8* %38, i64 %40
%42 = load i8, i8* %41
%43 = load i8*, i8** %5
%44 = load i32, i32* %9
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %43, i64 %45
store i8 %42, i8* %46
br label %47
47: ; preds = %37
%48 = load i32, i32* %9
%49 = add i32 %48, 1
store i32 %49, i32* %9
br label %34
50: ; preds = %34
%51 = load i32, i32* %6
%52 = sub i32 %51, 32
store i32 %52, i32* %6
br label %53
53: ; preds = %50
br label %54
54: ; preds = %57, %53
%55 = load i32, i32* %6
%56 = icmp ule i32 32, %55
br i1 %56, label %57, label %66
57: ; preds = %54
%58 = load i8*, i8** %5
%59 = getelementptr inbounds i8, i8* %58, i64 32
%60 = load i8*, i8** %5
%61 = call i32 @sha2_chain(i8* %59, i8* %60)
%62 = load i32, i32* %6
%63 = sub i32 %62, 32
store i32 %63, i32* %6
%64 = load i8*, i8** %5
%65 = getelementptr inbounds i8, i8* %64, i64 32
store i8* %65, i8** %5
br label %54
66: ; preds = %54
%67 = load i32, i32* %6
%68 = icmp ne i32 %67, 0
br i1 %68, label %69, label %91
69: ; preds = %66
%70 = getelementptr inbounds [32 x i8], [32 x i8]* %10, i64 0, i64 0
%71 = load i8*, i8** %5
%72 = call i32 @sha2_chain(i8* %70, i8* %71)
store i32 0, i32* %11
br label %73
73: ; preds = %87, %69
%74 = load i32, i32* %11
%75 = load i32, i32* %6
%76 = icmp ult i32 %74, %75
br i1 %76, label %77, label %90
77: ; preds = %73
%78 = load i32, i32* %11
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds [32 x i8], [32 x i8]* %10, i64 0, i64 %79
%81 = load i8, i8* %80
%82 = load i8*, i8** %5
%83 = load i32, i32* %11
%84 = add i32 32, %83
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %82, i64 %85
store i8 %81, i8* %86
br label %87
87: ; preds = %77
%88 = load i32, i32* %11
%89 = add i32 %88, 1
store i32 %89, i32* %11
br label %73
90: ; preds = %73
br label %91
91: ; preds = %90, %66
store i32 0, i32* %4
br label %92
92: ; preds = %91, %32
%93 = load i32, i32* %4
ret i32 %93
}

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