#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*/ bzero(unsigned char *, int);
int /*<<< orphan*/ free(unsigned char *);
unsigned char *malloc(int);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, int);
unsigned char *sha3_pad(unsigned char *, int);
int /*<<< orphan*/ sha3_permute_block(unsigned char *);
int /*<<< orphan*/ strncat(unsigned char *, char *, int);
unsigned char *sha3_512(unsigned char *data, int size) {
  unsigned char *P;
  int i;
  int j;
  if (size % 72 != 0) {
    P = sha3_pad(data, size);
    size += (72 - size % 72);
  }
  int n = (size / 72);
  unsigned char *p[n];
  for (i = 0; i < n; i++) {
    p[i] = malloc(72);
    memcpy(p[i], P + (i * 72), 72);
  }
  unsigned char *S = malloc(200);
  bzero(S, 200);
  int c = 128;
  for (i = 0; i < n; i++) {
    strncat(p[i], "\0", c);
    for (j = 0; j < 200; j++) {
      S[j] ^= p[i][j];
    }
    sha3_permute_block(S);
  }
  unsigned char *Z = malloc(64);
  memcpy(Z, S, 64);
  free(S);
  for (i = 0; i < n; i++) {
    free(p[i]);
  }
  return Z;
}


x86 assembly (clang, -O0):
<sha3_512>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x48,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
je     11bb <sha3_512+0x4b>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1080 <sha3_pad@plt>
mov    %rax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x48,%ecx
cltd
idiv   %ecx
mov    $0x48,%eax
sub    %edx,%eax
add    -0xc(%rbp),%eax
mov    %eax,-0xc(%rbp)
movslq -0xc(%rbp),%rax
imul   $0x38e38e39,%rax,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x24,%rax
add    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1256 <sha3_512+0xe6>
mov    $0x48,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%rsi
imul   $0x48,-0x1c(%rbp),%eax
cltq
add    %rax,%rsi
mov    $0x48,%edx
call   1050 <memcpy@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1204 <sha3_512+0x94>
mov    $0xc8,%edi
call   1060 <malloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rdi
mov    $0xc8,%esi
call   1090 <bzero@plt>
movl   $0x80,-0x44(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1305 <sha3_512+0x195>
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x44(%rbp),%edx
lea    0xd5e(%rip),%rsi
call   1040 <strncat@plt>
movl   $0x0,-0x20(%rbp)
cmpl   $0xc8,-0x20(%rbp)
jge    12ee <sha3_512+0x17e>
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movzbl (%rax,%rcx,1),%edx
xor    %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12ae <sha3_512+0x13e>
mov    -0x40(%rbp),%rdi
call   1070 <sha3_permute_block@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1280 <sha3_512+0x110>
mov    $0x40,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1360 <sha3_512+0x1f0>
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1335 <sha3_512+0x1c5>
mov    -0x50(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sha3_512>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %esi,%ebx
movslq %esi,%r14
imul   $0x38e38e39,%r14,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
sar    $0x24,%rax
add    %ecx,%eax
shl    $0x3,%eax
lea    (%rax,%rax,8),%eax
sub    %eax,%r14d
je     11b7 <sha3_512+0x47>
mov    %ebx,%esi
call   1080 <sha3_pad@plt>
mov    %rax,%r15
sub    %r14d,%ebx
add    $0x48,%ebx
jmp    11b7 <sha3_512+0x47>
mov    %ebx,-0x2c(%rbp)
movslq %ebx,%rax
imul   $0x38e38e39,%rax,%r13
mov    %r13,%rcx
shr    $0x3f,%rcx
sar    $0x24,%r13
add    %ecx,%r13d
lea    0xf(,%r13,8),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%r14
sub    %rcx,%r14
mov    %r14,%rsp
cmp    $0x48,%eax
jl     121b <sha3_512+0xab>
xor    %ebx,%ebx
xchg   %ax,%ax
mov    $0x48,%edi
call   1060 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
mov    %rax,%rdi
mov    %r15,%rsi
mov    $0x48,%edx
call   1050 <memcpy@plt>
add    $0x1,%rbx
add    $0x48,%r15
cmp    %rbx,%r13
jne    11f0 <sha3_512+0x80>
mov    $0xc8,%edi
call   1060 <malloc@plt>
mov    %rax,%r12
mov    %rax,%rdi
mov    $0xc8,%esi
call   1090 <bzero@plt>
cmpl   $0x48,-0x2c(%rbp)
jl     13f4 <sha3_512+0x284>
lea    0xc8(%r12),%rax
mov    %rax,-0x38(%rbp)
xor    %r15d,%r15d
jmp    1385 <sha3_512+0x215>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rbx),%xmm0
movups 0x10(%rbx),%xmm1
movups (%r12),%xmm2
xorps  %xmm0,%xmm2
movups 0x10(%r12),%xmm0
xorps  %xmm1,%xmm0
movups 0x20(%r12),%xmm1
movups 0x30(%r12),%xmm3
movups %xmm2,(%r12)
movups %xmm0,0x10(%r12)
movups 0x20(%rbx),%xmm0
xorps  %xmm1,%xmm0
movups 0x30(%rbx),%xmm1
xorps  %xmm3,%xmm1
movups %xmm0,0x20(%r12)
movups %xmm1,0x30(%r12)
movups 0x40(%rbx),%xmm0
movups 0x50(%rbx),%xmm1
movups 0x40(%r12),%xmm2
xorps  %xmm0,%xmm2
movups 0x50(%r12),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0x40(%r12)
movups %xmm0,0x50(%r12)
movups 0x60(%rbx),%xmm0
movups 0x70(%rbx),%xmm1
movups 0x60(%r12),%xmm2
xorps  %xmm0,%xmm2
movups 0x70(%r12),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0x60(%r12)
movups %xmm0,0x70(%r12)
movups 0x80(%rbx),%xmm0
movups 0x90(%rbx),%xmm1
movups 0x80(%r12),%xmm2
xorps  %xmm0,%xmm2
movups 0x90(%r12),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0x80(%r12)
movups %xmm0,0x90(%r12)
movups 0xa0(%rbx),%xmm0
movups 0xb0(%rbx),%xmm1
movups 0xa0(%r12),%xmm2
xorps  %xmm0,%xmm2
movups 0xb0(%r12),%xmm0
xorps  %xmm1,%xmm0
movups %xmm2,0xa0(%r12)
movups %xmm0,0xb0(%r12)
mov    0xc0(%rbx),%rax
xor    %rax,0xc0(%r12)
mov    %r12,%rdi
call   1070 <sha3_permute_block@plt>
add    $0x1,%r15
cmp    %r13,%r15
je     13f4 <sha3_512+0x284>
mov    (%r14,%r15,8),%rbx
mov    %rbx,%rdi
lea    0xc6d(%rip),%rsi
mov    $0x80,%edx
call   1040 <strncat@plt>
lea    0xc8(%rbx),%rax
cmp    %rax,%r12
jae    1260 <sha3_512+0xf0>
cmp    -0x38(%rbp),%rbx
jae    1260 <sha3_512+0xf0>
mov    $0x3,%eax
nopl   0x0(%rax)
movzbl -0x3(%rbx,%rax,1),%ecx
xor    %cl,-0x3(%r12,%rax,1)
movzbl -0x2(%rbx,%rax,1),%ecx
xor    %cl,-0x2(%r12,%rax,1)
movzbl -0x1(%rbx,%rax,1),%ecx
xor    %cl,-0x1(%r12,%rax,1)
movzbl (%rbx,%rax,1),%ecx
xor    %cl,(%r12,%rax,1)
add    $0x4,%rax
cmp    $0xcb,%rax
jne    13c0 <sha3_512+0x250>
jmp    1374 <sha3_512+0x204>
mov    $0x40,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    %rax,%rdi
mov    %r12,%rsi
mov    $0x40,%edx
call   1050 <memcpy@plt>
mov    %r12,%rdi
call   1030 <free@plt>
cmpl   $0x48,-0x2c(%rbp)
jl     1442 <sha3_512+0x2d2>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%r13
jne    1430 <sha3_512+0x2c0>
mov    %r15,%rax
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [2 x i8] zeroinitializer
define i8* @sha3_512(i8* %0, i32 %1) {
%3 = alloca i8*
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i8*
%10 = alloca i64
%11 = alloca i8*
%12 = alloca i32
%13 = alloca i8*
store i8* %0, i8** %3
store i32 %1, i32* %4
%14 = load i32, i32* %4
%15 = srem i32 %14, 72
%16 = icmp ne i32 %15, 0
br i1 %16, label %17, label %26
17: ; preds = %2
%18 = load i8*, i8** %3
%19 = load i32, i32* %4
%20 = call i8* @sha3_pad(i8* %18, i32 %19)
store i8* %20, i8** %5
%21 = load i32, i32* %4
%22 = srem i32 %21, 72
%23 = sub nsw i32 72, %22
%24 = load i32, i32* %4
%25 = add nsw i32 %24, %23
store i32 %25, i32* %4
br label %26
26: ; preds = %17, %2
%27 = load i32, i32* %4
%28 = sdiv i32 %27, 72
store i32 %28, i32* %8
%29 = load i32, i32* %8
%30 = zext i32 %29 to i64
%31 = call i8* @llvm.stacksave()
store i8* %31, i8** %9
%32 = alloca i8*, i64 %30
store i64 %30, i64* %10
store i32 0, i32* %6
br label %33
33: ; preds = %52, %26
%34 = load i32, i32* %6
%35 = load i32, i32* %8
%36 = icmp slt i32 %34, %35
br i1 %36, label %37, label %55
37: ; preds = %33
%38 = call i8* @malloc(i32 72)
%39 = load i32, i32* %6
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i8*, i8** %32, i64 %40
store i8* %38, i8** %41
%42 = load i32, i32* %6
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8*, i8** %32, i64 %43
%45 = load i8*, i8** %44
%46 = load i8*, i8** %5
%47 = load i32, i32* %6
%48 = mul nsw i32 %47, 72
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %46, i64 %49
%51 = call i32 @memcpy(i8* %45, i8* %50, i32 72)
br label %52
52: ; preds = %37
%53 = load i32, i32* %6
%54 = add nsw i32 %53, 1
store i32 %54, i32* %6
br label %33
55: ; preds = %33
%56 = call i8* @malloc(i32 200)
store i8* %56, i8** %11
%57 = load i8*, i8** %11
%58 = call i32 @bzero(i8* %57, i32 200)
store i32 128, i32* %12
store i32 0, i32* %6
br label %59
59: ; preds = %97, %55
%60 = load i32, i32* %6
%61 = load i32, i32* %8
%62 = icmp slt i32 %60, %61
br i1 %62, label %63, label %100
63: ; preds = %59
%64 = load i32, i32* %6
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8*, i8** %32, i64 %65
%67 = load i8*, i8** %66
%68 = load i32, i32* %12
%69 = call i32 @strncat(i8* %67, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0), i32 %68)
store i32 0, i32* %7
br label %70
70: ; preds = %91, %63
%71 = load i32, i32* %7
%72 = icmp slt i32 %71, 200
br i1 %72, label %73, label %94
73: ; preds = %70
%74 = load i32, i32* %6
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8*, i8** %32, i64 %75
%77 = load i8*, i8** %76
%78 = load i32, i32* %7
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i8, i8* %77, i64 %79
%81 = load i8, i8* %80
%82 = zext i8 %81 to i32
%83 = load i8*, i8** %11
%84 = load i32, i32* %7
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
%87 = load i8, i8* %86
%88 = zext i8 %87 to i32
%89 = xor i32 %88, %82
%90 = trunc i32 %89 to i8
store i8 %90, i8* %86
br label %91
91: ; preds = %73
%92 = load i32, i32* %7
%93 = add nsw i32 %92, 1
store i32 %93, i32* %7
br label %70
94: ; preds = %70
%95 = load i8*, i8** %11
%96 = call i32 @sha3_permute_block(i8* %95)
br label %97
97: ; preds = %94
%98 = load i32, i32* %6
%99 = add nsw i32 %98, 1
store i32 %99, i32* %6
br label %59
100: ; preds = %59
%101 = call i8* @malloc(i32 64)
store i8* %101, i8** %13
%102 = load i8*, i8** %13
%103 = load i8*, i8** %11
%104 = call i32 @memcpy(i8* %102, i8* %103, i32 64)
%105 = load i8*, i8** %11
%106 = call i32 @free(i8* %105)
store i32 0, i32* %6
br label %107
107: ; preds = %117, %100
%108 = load i32, i32* %6
%109 = load i32, i32* %8
%110 = icmp slt i32 %108, %109
br i1 %110, label %111, label %120
111: ; preds = %107
%112 = load i32, i32* %6
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8*, i8** %32, i64 %113
%115 = load i8*, i8** %114
%116 = call i32 @free(i8* %115)
br label %117
117: ; preds = %111
%118 = load i32, i32* %6
%119 = add nsw i32 %118, 1
store i32 %119, i32* %6
br label %107
120: ; preds = %107
%121 = load i8*, i8** %13
%122 = load i8*, i8** %9
ret i8* %121
}

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