#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 */
typedef int uint8_t;
typedef int /*<<< orphan*/ outerKeyPad;
typedef int /*<<< orphan*/ innerKeyPad;
typedef int /*<<< orphan*/ buffer;

/* Variables and functions */
int /*<<< orphan*/ Sha256_ComputeHash(int *, int const *, int);
int /*<<< orphan*/ memcpy(int *, int const *, int);
int /*<<< orphan*/ memset(int *, int, int);
void HmacSha256_ComputeHash(uint8_t hash[32], const uint8_t *data, int dataLen,
                            const uint8_t *key, int keyLen) {
  uint8_t innerKeyPad[64];
  uint8_t outerKeyPad[64];
  uint8_t keyHash[32];
  uint8_t innerHash[32];
  uint8_t buffer[1024];
  int i;
  if (keyLen > 64) {
    Sha256_ComputeHash(keyHash, key, keyLen);
    key = keyHash;
    keyLen = 32;
  }
  memset(innerKeyPad, 0, sizeof(innerKeyPad));
  memset(outerKeyPad, 0, sizeof(outerKeyPad));
  memcpy(innerKeyPad, key, keyLen);
  memcpy(outerKeyPad, key, keyLen);
  for (i = 0; i < 64; i++) {
    innerKeyPad[i] ^= 0x36;
    outerKeyPad[i] ^= 0x5c;
  }
  memset(buffer, 0x00, sizeof(buffer));
  memcpy(buffer, innerKeyPad, 64);
  memcpy(buffer + 64, data, dataLen);
  Sha256_ComputeHash(innerHash, buffer, 64 + dataLen);
  memset(buffer, 0x00, sizeof(buffer));
  memcpy(buffer, outerKeyPad, 64);
  memcpy(buffer + 64, innerHash, 32);
  Sha256_ComputeHash(hash, buffer, 64 + 32);
}


x86 assembly (clang, -O0):
<HmacSha256_ComputeHash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1340,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
cmpl   $0x40,-0x24(%rbp)
jle    117d <HmacSha256_ComputeHash+0x4d>
lea    -0x2b0(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x24(%rbp),%edx
call   1050 <Sha256_ComputeHash@plt>
lea    -0x2b0(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x20,-0x24(%rbp)
lea    -0x130(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
lea    -0x230(%rbp),%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
lea    -0x130(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x24(%rbp),%edx
call   1040 <memcpy@plt>
lea    -0x230(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x24(%rbp),%edx
call   1040 <memcpy@plt>
movl   $0x0,-0x1334(%rbp)
cmpl   $0x40,-0x1334(%rbp)
jge    1224 <HmacSha256_ComputeHash+0xf4>
movslq -0x1334(%rbp),%rax
mov    -0x130(%rbp,%rax,4),%ecx
xor    $0x36,%ecx
mov    %ecx,-0x130(%rbp,%rax,4)
movslq -0x1334(%rbp),%rax
mov    -0x230(%rbp,%rax,4),%ecx
xor    $0x5c,%ecx
mov    %ecx,-0x230(%rbp,%rax,4)
mov    -0x1334(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1334(%rbp)
jmp    11d3 <HmacSha256_ComputeHash+0xa3>
lea    -0x1330(%rbp),%rdi
xor    %esi,%esi
mov    $0x1000,%edx
call   1030 <memset@plt>
lea    -0x1330(%rbp),%rdi
lea    -0x130(%rbp),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
lea    -0x1330(%rbp),%rdi
add    $0x100,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%edx
call   1040 <memcpy@plt>
lea    -0x330(%rbp),%rdi
lea    -0x1330(%rbp),%rsi
mov    -0x14(%rbp),%edx
add    $0x40,%edx
call   1050 <Sha256_ComputeHash@plt>
lea    -0x1330(%rbp),%rdi
xor    %esi,%esi
mov    $0x1000,%edx
call   1030 <memset@plt>
lea    -0x1330(%rbp),%rdi
lea    -0x230(%rbp),%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
lea    -0x1330(%rbp),%rdi
add    $0x100,%rdi
lea    -0x330(%rbp),%rsi
mov    $0x20,%edx
call   1040 <memcpy@plt>
mov    -0x8(%rbp),%rdi
lea    -0x1330(%rbp),%rsi
mov    $0x60,%edx
call   1050 <Sha256_ComputeHash@plt>
add    $0x1340,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<HmacSha256_ComputeHash>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1318,%rsp
mov    %r8d,%ebx
mov    %rcx,%r14
mov    %edx,%r15d
mov    %rsi,%rbp
mov    %rdi,0x8(%rsp)
cmp    $0x41,%r8d
jl     1175 <HmacSha256_ComputeHash+0x45>
lea    0x290(%rsp),%r12
mov    %r12,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
call   1050 <Sha256_ComputeHash@plt>
mov    $0x20,%ebx
mov    %r12,%r14
lea    0x110(%rsp),%r13
mov    %r13,%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
lea    0x10(%rsp),%r12
mov    %r12,%rdi
xor    %esi,%esi
mov    $0x100,%edx
call   1030 <memset@plt>
mov    %r13,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
call   1040 <memcpy@plt>
mov    %r12,%rdi
mov    %r14,%rsi
mov    %ebx,%edx
call   1040 <memcpy@plt>
movaps 0xe3f(%rip),%xmm0
movaps 0x110(%rsp),%xmm1
xorps  %xmm0,%xmm1
movaps %xmm1,0x110(%rsp)
movaps 0xe35(%rip),%xmm1
movaps 0x10(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x10(%rsp)
movaps 0x120(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x120(%rsp)
movaps 0x20(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x20(%rsp)
movaps 0x130(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x130(%rsp)
movaps 0x30(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x30(%rsp)
movaps 0x140(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x140(%rsp)
movaps 0x40(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x40(%rsp)
movaps 0x150(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x150(%rsp)
movaps 0x50(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x50(%rsp)
movaps 0x160(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x160(%rsp)
movaps 0x60(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x60(%rsp)
movaps 0x170(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x170(%rsp)
movaps 0x70(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x70(%rsp)
movaps 0x180(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x180(%rsp)
movaps 0x80(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x80(%rsp)
movaps 0x190(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x190(%rsp)
movaps 0x90(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0x90(%rsp)
movaps 0x1a0(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x1a0(%rsp)
movaps 0xa0(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0xa0(%rsp)
movaps 0x1b0(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x1b0(%rsp)
movaps 0xb0(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0xb0(%rsp)
movaps 0x1c0(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x1c0(%rsp)
movaps 0xc0(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0xc0(%rsp)
movaps 0x1d0(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x1d0(%rsp)
movaps 0xd0(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0xd0(%rsp)
movaps 0x1e0(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x1e0(%rsp)
movaps 0xe0(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0xe0(%rsp)
movaps 0x1f0(%rsp),%xmm2
xorps  %xmm0,%xmm2
movaps %xmm2,0x1f0(%rsp)
movaps 0xf0(%rsp),%xmm2
xorps  %xmm1,%xmm2
movaps %xmm2,0xf0(%rsp)
xorps  0x200(%rsp),%xmm0
movaps %xmm0,0x200(%rsp)
xorps  0x100(%rsp),%xmm1
movaps %xmm1,0x100(%rsp)
lea    0x310(%rsp),%rbx
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x1000,%edx
call   1030 <memset@plt>
mov    %rbx,%rdi
mov    %r13,%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
lea    0x410(%rsp),%r14
mov    %r14,%rdi
mov    %rbp,%rsi
mov    %r15d,%edx
call   1040 <memcpy@plt>
add    $0x40,%r15d
lea    0x210(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r15d,%edx
call   1050 <Sha256_ComputeHash@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x1000,%edx
call   1030 <memset@plt>
mov    %rbx,%rdi
mov    %r12,%rsi
mov    $0x40,%edx
call   1040 <memcpy@plt>
mov    %r14,%rdi
mov    %rbp,%rsi
mov    $0x20,%edx
call   1040 <memcpy@plt>
mov    0x8(%rsp),%rdi
mov    %rbx,%rsi
mov    $0x60,%edx
call   1050 <Sha256_ComputeHash@plt>
add    $0x1318,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @HmacSha256_ComputeHash(i32* %0, i32* %1, i32 %2, i32* %3, i32 %4) {
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32
%11 = alloca [64 x i32]
%12 = alloca [64 x i32]
%13 = alloca [32 x i32]
%14 = alloca [32 x i32]
%15 = alloca [1024 x i32]
%16 = alloca i32
store i32* %0, i32** %6
store i32* %1, i32** %7
store i32 %2, i32* %8
store i32* %3, i32** %9
store i32 %4, i32* %10
%17 = load i32, i32* %10
%18 = icmp sgt i32 %17, 64
br i1 %18, label %19, label %25
19: ; preds = %5
%20 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 0
%21 = load i32*, i32** %9
%22 = load i32, i32* %10
%23 = call i32 @Sha256_ComputeHash(i32* %20, i32* %21, i32 %22)
%24 = getelementptr inbounds [32 x i32], [32 x i32]* %13, i64 0, i64 0
store i32* %24, i32** %9
store i32 32, i32* %10
br label %25
25: ; preds = %19, %5
%26 = getelementptr inbounds [64 x i32], [64 x i32]* %11, i64 0, i64 0
%27 = call i32 @memset(i32* %26, i32 0, i32 256)
%28 = getelementptr inbounds [64 x i32], [64 x i32]* %12, i64 0, i64 0
%29 = call i32 @memset(i32* %28, i32 0, i32 256)
%30 = getelementptr inbounds [64 x i32], [64 x i32]* %11, i64 0, i64 0
%31 = load i32*, i32** %9
%32 = load i32, i32* %10
%33 = call i32 @memcpy(i32* %30, i32* %31, i32 %32)
%34 = getelementptr inbounds [64 x i32], [64 x i32]* %12, i64 0, i64 0
%35 = load i32*, i32** %9
%36 = load i32, i32* %10
%37 = call i32 @memcpy(i32* %34, i32* %35, i32 %36)
store i32 0, i32* %16
br label %38
38: ; preds = %52, %25
%39 = load i32, i32* %16
%40 = icmp slt i32 %39, 64
br i1 %40, label %41, label %55
41: ; preds = %38
%42 = load i32, i32* %16
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds [64 x i32], [64 x i32]* %11, i64 0, i64 %43
%45 = load i32, i32* %44
%46 = xor i32 %45, 54
store i32 %46, i32* %44
%47 = load i32, i32* %16
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [64 x i32], [64 x i32]* %12, i64 0, i64 %48
%50 = load i32, i32* %49
%51 = xor i32 %50, 92
store i32 %51, i32* %49
br label %52
52: ; preds = %41
%53 = load i32, i32* %16
%54 = add nsw i32 %53, 1
store i32 %54, i32* %16
br label %38
55: ; preds = %38
%56 = getelementptr inbounds [1024 x i32], [1024 x i32]* %15, i64 0, i64 0
%57 = call i32 @memset(i32* %56, i32 0, i32 4096)
%58 = getelementptr inbounds [1024 x i32], [1024 x i32]* %15, i64 0, i64 0
%59 = getelementptr inbounds [64 x i32], [64 x i32]* %11, i64 0, i64 0
%60 = call i32 @memcpy(i32* %58, i32* %59, i32 64)
%61 = getelementptr inbounds [1024 x i32], [1024 x i32]* %15, i64 0, i64 0
%62 = getelementptr inbounds i32, i32* %61, i64 64
%63 = load i32*, i32** %7
%64 = load i32, i32* %8
%65 = call i32 @memcpy(i32* %62, i32* %63, i32 %64)
%66 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 0
%67 = getelementptr inbounds [1024 x i32], [1024 x i32]* %15, i64 0, i64 0
%68 = load i32, i32* %8
%69 = add nsw i32 64, %68
%70 = call i32 @Sha256_ComputeHash(i32* %66, i32* %67, i32 %69)
%71 = getelementptr inbounds [1024 x i32], [1024 x i32]* %15, i64 0, i64 0
%72 = call i32 @memset(i32* %71, i32 0, i32 4096)
%73 = getelementptr inbounds [1024 x i32], [1024 x i32]* %15, i64 0, i64 0
%74 = getelementptr inbounds [64 x i32], [64 x i32]* %12, i64 0, i64 0
%75 = call i32 @memcpy(i32* %73, i32* %74, i32 64)
%76 = getelementptr inbounds [1024 x i32], [1024 x i32]* %15, i64 0, i64 0
%77 = getelementptr inbounds i32, i32* %76, i64 64
%78 = getelementptr inbounds [32 x i32], [32 x i32]* %14, i64 0, i64 0
%79 = call i32 @memcpy(i32* %77, i32* %78, i32 32)
%80 = load i32*, i32** %6
%81 = getelementptr inbounds [1024 x i32], [1024 x i32]* %15, i64 0, i64 0
%82 = call i32 @Sha256_ComputeHash(i32* %80, i32* %81, i32 96)
ret void
}

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