#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*/ clearWBuffert(unsigned int *);
int /*<<< orphan*/ innerHash(unsigned int *, unsigned int *);
void calc(const void *src, const int bytelength, unsigned char *hash) {
  int roundPos;
  int lastBlockBytes;
  int hashByte;
  unsigned int result[5] = {0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476,
                            0xc3d2e1f0};
  const unsigned char *sarray = (const unsigned char *)src;
  unsigned int w[80];
  const int endOfFullBlocks = bytelength - 64;
  int endCurrentBlock;
  int currentBlock = 0;
  while (currentBlock <= endOfFullBlocks) {
    endCurrentBlock = currentBlock + 64;
    for (roundPos = 0; currentBlock < endCurrentBlock; currentBlock += 4) {
      w[roundPos++] = (unsigned int)sarray[currentBlock + 3] |
                      (((unsigned int)sarray[currentBlock + 2]) << 8) |
                      (((unsigned int)sarray[currentBlock + 1]) << 16) |
                      (((unsigned int)sarray[currentBlock]) << 24);
    }
    innerHash(result, w);
  }
  endCurrentBlock = bytelength - currentBlock;
  clearWBuffert(w);
  lastBlockBytes = 0;
  for (; lastBlockBytes < endCurrentBlock; ++lastBlockBytes) {
    w[lastBlockBytes >> 2] |=
        (unsigned int)sarray[lastBlockBytes + currentBlock]
        << ((3 - (lastBlockBytes & 3)) << 3);
  }
  w[lastBlockBytes >> 2] |= 0x80U << ((3 - (lastBlockBytes & 3)) << 3);
  if (endCurrentBlock >= 56) {
    innerHash(result, w);
    clearWBuffert(w);
  }
  w[15] = bytelength << 3;
  innerHash(result, w);
  for (hashByte = 20; --hashByte >= 0;) {
    hash[hashByte] =
        (result[hashByte >> 2] >> (((3 - hashByte) & 0x3) << 3)) & 0xff;
  }
}


x86 assembly (clang, -O0):
<calc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    0xec3(%rip),%rax
mov    %rax,-0x40(%rbp)
mov    0xec0(%rip),%rax
mov    %rax,-0x38(%rbp)
mov    0xebe(%rip),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x40,%eax
mov    %eax,-0x194(%rbp)
movl   $0x0,-0x19c(%rbp)
mov    -0x19c(%rbp),%eax
cmp    -0x194(%rbp),%eax
jg     1244 <calc+0x124>
mov    -0x19c(%rbp),%eax
add    $0x40,%eax
mov    %eax,-0x198(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x19c(%rbp),%eax
cmp    -0x198(%rbp),%eax
jge    122f <calc+0x10f>
mov    -0x48(%rbp),%rax
mov    -0x19c(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x48(%rbp),%rax
mov    -0x19c(%rbp),%edx
add    $0x2,%edx
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
shl    $0x8,%eax
or     %eax,%ecx
mov    -0x48(%rbp),%rax
mov    -0x19c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
shl    $0x10,%eax
or     %eax,%ecx
mov    -0x48(%rbp),%rax
movslq -0x19c(%rbp),%rdx
movzbl (%rax,%rdx,1),%eax
shl    $0x18,%eax
or     %eax,%ecx
mov    -0x1c(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
cltq
mov    %ecx,-0x190(%rbp,%rax,4)
mov    -0x19c(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x19c(%rbp)
jmp    119b <calc+0x7b>
lea    -0x40(%rbp),%rdi
lea    -0x190(%rbp),%rsi
call   1030 <innerHash@plt>
jmp    1173 <calc+0x53>
mov    -0xc(%rbp),%eax
sub    -0x19c(%rbp),%eax
mov    %eax,-0x198(%rbp)
lea    -0x190(%rbp),%rdi
call   1040 <clearWBuffert@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x198(%rbp),%eax
jge    12c1 <calc+0x1a1>
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x19c(%rbp),%ecx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x20(%rbp),%edx
and    $0x3,%edx
mov    $0x3,%ecx
sub    %edx,%ecx
shl    $0x3,%ecx
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x20(%rbp),%eax
sar    $0x2,%eax
cltq
or     -0x190(%rbp,%rax,4),%ecx
mov    %ecx,-0x190(%rbp,%rax,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1266 <calc+0x146>
mov    -0x20(%rbp),%eax
and    $0x3,%eax
mov    $0x3,%ecx
sub    %eax,%ecx
shl    $0x3,%ecx
mov    $0x80,%eax
shl    %cl,%eax
mov    %eax,%ecx
mov    -0x20(%rbp),%eax
sar    $0x2,%eax
cltq
or     -0x190(%rbp,%rax,4),%ecx
mov    %ecx,-0x190(%rbp,%rax,4)
cmpl   $0x38,-0x198(%rbp)
jl     1319 <calc+0x1f9>
lea    -0x40(%rbp),%rdi
lea    -0x190(%rbp),%rsi
call   1030 <innerHash@plt>
lea    -0x190(%rbp),%rdi
call   1040 <clearWBuffert@plt>
mov    -0xc(%rbp),%eax
shl    $0x3,%eax
mov    %eax,-0x154(%rbp)
lea    -0x40(%rbp),%rdi
lea    -0x190(%rbp),%rsi
call   1030 <innerHash@plt>
movl   $0x14,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
jl     1381 <calc+0x261>
mov    -0x24(%rbp),%eax
sar    $0x2,%eax
cltq
mov    -0x40(%rbp,%rax,4),%eax
mov    $0x3,%ecx
sub    -0x24(%rbp),%ecx
and    $0x3,%ecx
shl    $0x3,%ecx
shr    %cl,%eax
and    $0xff,%eax
mov    %al,%dl
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    133c <calc+0x21c>
add    $0x1a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %rdx,%r15
mov    %rdi,%rbx
mov    0xed3(%rip),%eax
mov    %eax,0x20(%rsp)
movaps 0xeb8(%rip),%xmm0
movaps %xmm0,0x10(%rsp)
mov    $0x0,%ebp
mov    %rsi,0x8(%rsp)
cmp    $0x40,%esi
jl     11b8 <calc+0x98>
mov    0x8(%rsp),%rax
lea    -0x40(%rax),%r14d
xor    %ebp,%ebp
lea    0x30(%rsp),%r12
lea    0x10(%rsp),%r13
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ebp,%rax
lea    0x3c(%rax),%ecx
movslq %ecx,%rcx
add    $0xfffffffffffffffc,%rax
mov    %r12,%rdx
mov    0x4(%rbx,%rax,1),%esi
bswap  %esi
mov    %esi,(%rdx)
add    $0x4,%rdx
add    $0x4,%rax
add    $0x4,%ebp
cmp    %rcx,%rax
jl     1190 <calc+0x70>
mov    %r13,%rdi
mov    %r12,%rsi
call   1030 <innerHash@plt>
cmp    %ebp,%r14d
jge    1180 <calc+0x60>
mov    0x8(%rsp),%r13
mov    %r13d,%r12d
sub    %ebp,%r12d
lea    0x30(%rsp),%rdi
call   1040 <clearWBuffert@plt>
test   %r12d,%r12d
mov    $0x0,%esi
jle    1266 <calc+0x146>
movslq %ebp,%r9
mov    %r12d,%r8d
xor    %r14d,%r14d
cmp    $0x1,%r12d
jne    11ee <calc+0xce>
xor    %edx,%edx
jmp    123d <calc+0x11d>
mov    %r8d,%r10d
and    $0xfffffffe,%r10d
lea    (%r9,%rbx,1),%r11
add    $0x1,%r11
xor    %edx,%edx
nop
movzbl -0x1(%r11,%rdx,1),%edi
mov    %r14d,%eax
and    $0x10,%al
mov    %eax,%ecx
xor    $0x18,%cl
shl    %cl,%edi
mov    %edx,%esi
and    $0xfffffffc,%esi
or     0x30(%rsp,%rsi,1),%edi
mov    %edi,0x30(%rsp,%rsi,1)
movzbl (%r11,%rdx,1),%ebp
xor    $0x10,%al
mov    %eax,%ecx
shl    %cl,%ebp
or     %edi,%ebp
mov    %ebp,0x30(%rsp,%rsi,1)
add    $0x2,%rdx
add    $0x10,%r14d
cmp    %rdx,%r10
jne    1200 <calc+0xe0>
mov    %r12d,%esi
test   $0x1,%r8b
je     1266 <calc+0x146>
add    %rdx,%r9
movzbl (%rbx,%r9,1),%eax
lea    0x0(,%rdx,8),%ecx
not    %cl
and    $0x18,%cl
shl    %cl,%eax
and    $0xfffffffc,%edx
or     %eax,0x30(%rsp,%rdx,1)
mov    %r12d,%esi
lea    0x0(,%rsi,8),%ecx
not    %cl
and    $0x18,%cl
mov    $0x80,%eax
shl    %cl,%eax
and    $0xfffffffc,%esi
or     %eax,0x30(%rsp,%rsi,1)
cmp    $0x38,%r12d
jl     12a0 <calc+0x180>
lea    0x10(%rsp),%rdi
lea    0x30(%rsp),%rbx
mov    %rbx,%rsi
call   1030 <innerHash@plt>
mov    %rbx,%rdi
call   1040 <clearWBuffert@plt>
shl    $0x3,%r13d
mov    %r13d,0x6c(%rsp)
lea    0x10(%rsp),%rdi
lea    0x30(%rsp),%rsi
call   1030 <innerHash@plt>
mov    $0x12,%eax
mov    $0xffffff60,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x1(%rax),%ecx
and    $0xfffffffc,%ecx
mov    0x10(%rsp,%rcx,1),%esi
mov    %edx,%ecx
and    $0x18,%cl
shr    %cl,%esi
mov    %sil,0x1(%r15,%rax,1)
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    0x10(%rsp,%rcx,1),%esi
lea    0x8(%rdx),%ecx
and    $0x18,%cl
shr    %cl,%esi
mov    %sil,(%r15,%rax,1)
add    $0xfffffffffffffffe,%rax
add    $0x10,%edx
cmp    $0xfffffffffffffffe,%rax
jne    12d0 <calc+0x1b0>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.calc.result = [5 x i32] [i32 1732584193, i32 -271733879, i32 -1732584194, i32 271733878, i32 -1009589776]
define void @calc(i8* %0, i32 %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca [5 x i32]
%11 = alloca i8*
%12 = alloca [80 x i32]
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i8* %2, i8** %6
%16 = bitcast [5 x i32]* %10 to i8*
%17 = load i8*, i8** %4
store i8* %17, i8** %11
%18 = load i32, i32* %5
%19 = sub nsw i32 %18, 64
store i32 %19, i32* %13
store i32 0, i32* %15
br label %20
20: ; preds = %72, %3
%21 = load i32, i32* %15
%22 = load i32, i32* %13
%23 = icmp sle i32 %21, %22
br i1 %23, label %24, label %76
24: ; preds = %20
%25 = load i32, i32* %15
%26 = add nsw i32 %25, 64
store i32 %26, i32* %14
store i32 0, i32* %7
br label %27
27: ; preds = %69, %24
%28 = load i32, i32* %15
%29 = load i32, i32* %14
%30 = icmp slt i32 %28, %29
br i1 %30, label %31, label %72
31: ; preds = %27
%32 = load i8*, i8** %11
%33 = load i32, i32* %15
%34 = add nsw i32 %33, 3
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i8, i8* %32, i64 %35
%37 = load i8, i8* %36
%38 = zext i8 %37 to i32
%39 = load i8*, i8** %11
%40 = load i32, i32* %15
%41 = add nsw i32 %40, 2
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %39, i64 %42
%44 = load i8, i8* %43
%45 = zext i8 %44 to i32
%46 = shl i32 %45, 8
%47 = or i32 %38, %46
%48 = load i8*, i8** %11
%49 = load i32, i32* %15
%50 = add nsw i32 %49, 1
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i8, i8* %48, i64 %51
%53 = load i8, i8* %52
%54 = zext i8 %53 to i32
%55 = shl i32 %54, 16
%56 = or i32 %47, %55
%57 = load i8*, i8** %11
%58 = load i32, i32* %15
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8, i8* %57, i64 %59
%61 = load i8, i8* %60
%62 = zext i8 %61 to i32
%63 = shl i32 %62, 24
%64 = or i32 %56, %63
%65 = load i32, i32* %7
%66 = add nsw i32 %65, 1
store i32 %66, i32* %7
%67 = sext i32 %65 to i64
%68 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 %67
store i32 %64, i32* %68
br label %69
69: ; preds = %31
%70 = load i32, i32* %15
%71 = add nsw i32 %70, 4
store i32 %71, i32* %15
br label %27
72: ; preds = %27
%73 = getelementptr inbounds [5 x i32], [5 x i32]* %10, i64 0, i64 0
%74 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 0
%75 = call i32 @innerHash(i32* %73, i32* %74)
br label %20
76: ; preds = %20
%77 = load i32, i32* %5
%78 = load i32, i32* %15
%79 = sub nsw i32 %77, %78
store i32 %79, i32* %14
%80 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 0
%81 = call i32 @clearWBuffert(i32* %80)
store i32 0, i32* %8
br label %82
82: ; preds = %106, %76
%83 = load i32, i32* %8
%84 = load i32, i32* %14
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %109
86: ; preds = %82
%87 = load i8*, i8** %11
%88 = load i32, i32* %8
%89 = load i32, i32* %15
%90 = add nsw i32 %88, %89
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %87, i64 %91
%93 = load i8, i8* %92
%94 = zext i8 %93 to i32
%95 = load i32, i32* %8
%96 = and i32 %95, 3
%97 = sub nsw i32 3, %96
%98 = shl i32 %97, 3
%99 = shl i32 %94, %98
%100 = load i32, i32* %8
%101 = ashr i32 %100, 2
%102 = sext i32 %101 to i64
%103 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 %102
%104 = load i32, i32* %103
%105 = or i32 %104, %99
store i32 %105, i32* %103
br label %106
106: ; preds = %86
%107 = load i32, i32* %8
%108 = add nsw i32 %107, 1
store i32 %108, i32* %8
br label %82
109: ; preds = %82
%110 = load i32, i32* %8
%111 = and i32 %110, 3
%112 = sub nsw i32 3, %111
%113 = shl i32 %112, 3
%114 = shl i32 128, %113
%115 = load i32, i32* %8
%116 = ashr i32 %115, 2
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 %117
%119 = load i32, i32* %118
%120 = or i32 %119, %114
store i32 %120, i32* %118
%121 = load i32, i32* %14
%122 = icmp sge i32 %121, 56
br i1 %122, label %123, label %129
123: ; preds = %109
%124 = getelementptr inbounds [5 x i32], [5 x i32]* %10, i64 0, i64 0
%125 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 0
%126 = call i32 @innerHash(i32* %124, i32* %125)
%127 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 0
%128 = call i32 @clearWBuffert(i32* %127)
br label %129
129: ; preds = %123, %109
%130 = load i32, i32* %5
%131 = shl i32 %130, 3
%132 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 15
store i32 %131, i32* %132
%133 = getelementptr inbounds [5 x i32], [5 x i32]* %10, i64 0, i64 0
%134 = getelementptr inbounds [80 x i32], [80 x i32]* %12, i64 0, i64 0
%135 = call i32 @innerHash(i32* %133, i32* %134)
store i32 20, i32* %9
br label %136
136: ; preds = %140, %129
%137 = load i32, i32* %9
%138 = add nsw i32 %137, -1
store i32 %138, i32* %9
%139 = icmp sge i32 %138, 0
br i1 %139, label %140, label %157
140: ; preds = %136
%141 = load i32, i32* %9
%142 = ashr i32 %141, 2
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [5 x i32], [5 x i32]* %10, i64 0, i64 %143
%145 = load i32, i32* %144
%146 = load i32, i32* %9
%147 = sub nsw i32 3, %146
%148 = and i32 %147, 3
%149 = shl i32 %148, 3
%150 = lshr i32 %145, %149
%151 = and i32 %150, 255
%152 = trunc i32 %151 to i8
%153 = load i8*, i8** %6
%154 = load i32, i32* %9
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i8, i8* %153, i64 %155
store i8 %152, i8* %156
br label %136
157: ; preds = %136
ret void
}

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