void sha_hash(int *data, int *hash) {
  int W[80];
  unsigned int A = hash[0], B = hash[1], C = hash[2], D = hash[3], E = hash[4];
  unsigned int t, x, TEMP;
  for (t = 0; t < 16; t++) {
    W[t] = data[t];
  }
  for (t = 16; t < 80; t++) {
    x = W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16];
    W[t] = ((x << 1) | ((x >> 31) & 1));
  }
  for (t = 0; t < 20; t++) {
    TEMP = ((A << 5) | ((A >> 27) & 0x1f)) + ((B & C) | ((~B) & D)) + E + W[t] +
           0x5a827999;
    E = D;
    D = C;
    C = ((B << 30) | ((B >> 2) & 0x3fffffff));
    B = A;
    A = TEMP;
  }
  for (; t < 40; t++) {
    TEMP =
        ((A << 5) | ((A >> 27) & 0x1f)) + (B ^ C ^ D) + E + W[t] + 0x6ed9eba1;
    E = D;
    D = C;
    C = ((B << 30) | ((B >> 2) & 0x3fffffff));
    B = A;
    A = TEMP;
  }
  for (; t < 60; t++) {
    TEMP = ((A << 5) | ((A >> 27) & 0x1f)) + ((B & C) | (B & D) | (C & D)) + E +
           W[t] + 0x8f1bbcdc;
    E = D;
    D = C;
    C = ((B << 30) | ((B >> 2) & 0x3fffffff));
    B = A;
    A = TEMP;
  }
  for (; t < 80; t++) {
    TEMP =
        ((A << 5) | ((A >> 27) & 0x1f)) + (B ^ C ^ D) + E + W[t] + 0xca62c1d6;
    E = D;
    D = C;
    C = ((B << 30) | ((B >> 2) & 0x3fffffff));
    B = A;
    A = TEMP;
  }
  hash[0] += A;
  hash[1] += B;
  hash[2] += C;
  hash[3] += D;
  hash[4] += E;
}


x86 assembly (clang, -O0):
<sha_hash>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x154(%rbp)
mov    -0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x158(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x15c(%rbp)
mov    -0x10(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x160(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%eax
mov    %eax,-0x164(%rbp)
movl   $0x0,-0x168(%rbp)
cmpl   $0x10,-0x168(%rbp)
jae    1198 <sha_hash+0x98>
mov    -0x8(%rbp),%rax
mov    -0x168(%rbp),%ecx
mov    (%rax,%rcx,4),%ecx
mov    -0x168(%rbp),%eax
mov    %ecx,-0x150(%rbp,%rax,4)
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    115d <sha_hash+0x5d>
movl   $0x10,-0x168(%rbp)
cmpl   $0x50,-0x168(%rbp)
jae    1235 <sha_hash+0x135>
mov    -0x168(%rbp),%eax
sub    $0x3,%eax
mov    %eax,%eax
mov    -0x150(%rbp,%rax,4),%eax
mov    -0x168(%rbp),%ecx
sub    $0x8,%ecx
mov    %ecx,%ecx
xor    -0x150(%rbp,%rcx,4),%eax
mov    -0x168(%rbp),%ecx
sub    $0xe,%ecx
mov    %ecx,%ecx
xor    -0x150(%rbp,%rcx,4),%eax
mov    -0x168(%rbp),%ecx
sub    $0x10,%ecx
mov    %ecx,%ecx
xor    -0x150(%rbp,%rcx,4),%eax
mov    %eax,-0x16c(%rbp)
mov    -0x16c(%rbp),%ecx
shl    $0x1,%ecx
mov    -0x16c(%rbp),%eax
shr    $0x1f,%eax
and    $0x1,%eax
or     %eax,%ecx
mov    -0x168(%rbp),%eax
mov    %ecx,-0x150(%rbp,%rax,4)
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    11a2 <sha_hash+0xa2>
movl   $0x0,-0x168(%rbp)
cmpl   $0x14,-0x168(%rbp)
jae    1304 <sha_hash+0x204>
mov    -0x154(%rbp),%eax
shl    $0x5,%eax
mov    -0x154(%rbp),%ecx
shr    $0x1b,%ecx
and    $0x1f,%ecx
or     %ecx,%eax
mov    -0x158(%rbp),%ecx
and    -0x15c(%rbp),%ecx
mov    -0x158(%rbp),%edx
xor    $0xffffffff,%edx
and    -0x160(%rbp),%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x164(%rbp),%eax
mov    -0x168(%rbp),%ecx
add    -0x150(%rbp,%rcx,4),%eax
add    $0x5a827999,%eax
mov    %eax,-0x170(%rbp)
mov    -0x160(%rbp),%eax
mov    %eax,-0x164(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x160(%rbp)
mov    -0x158(%rbp),%eax
shl    $0x1e,%eax
mov    -0x158(%rbp),%ecx
shr    $0x2,%ecx
and    $0x3fffffff,%ecx
or     %ecx,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x154(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x170(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    123f <sha_hash+0x13f>
jmp    1309 <sha_hash+0x209>
cmpl   $0x28,-0x168(%rbp)
jae    13c3 <sha_hash+0x2c3>
mov    -0x154(%rbp),%eax
shl    $0x5,%eax
mov    -0x154(%rbp),%ecx
shr    $0x1b,%ecx
and    $0x1f,%ecx
or     %ecx,%eax
mov    -0x158(%rbp),%ecx
xor    -0x15c(%rbp),%ecx
xor    -0x160(%rbp),%ecx
add    %ecx,%eax
add    -0x164(%rbp),%eax
mov    -0x168(%rbp),%ecx
add    -0x150(%rbp,%rcx,4),%eax
add    $0x6ed9eba1,%eax
mov    %eax,-0x170(%rbp)
mov    -0x160(%rbp),%eax
mov    %eax,-0x164(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x160(%rbp)
mov    -0x158(%rbp),%eax
shl    $0x1e,%eax
mov    -0x158(%rbp),%ecx
shr    $0x2,%ecx
and    $0x3fffffff,%ecx
or     %ecx,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x154(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x170(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    1309 <sha_hash+0x209>
jmp    13c8 <sha_hash+0x2c8>
cmpl   $0x3c,-0x168(%rbp)
jae    1498 <sha_hash+0x398>
mov    -0x154(%rbp),%eax
shl    $0x5,%eax
mov    -0x154(%rbp),%ecx
shr    $0x1b,%ecx
and    $0x1f,%ecx
or     %ecx,%eax
mov    -0x158(%rbp),%ecx
and    -0x15c(%rbp),%ecx
mov    -0x158(%rbp),%edx
and    -0x160(%rbp),%edx
or     %edx,%ecx
mov    -0x15c(%rbp),%edx
and    -0x160(%rbp),%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x164(%rbp),%eax
mov    -0x168(%rbp),%ecx
add    -0x150(%rbp,%rcx,4),%eax
add    $0x8f1bbcdc,%eax
mov    %eax,-0x170(%rbp)
mov    -0x160(%rbp),%eax
mov    %eax,-0x164(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x160(%rbp)
mov    -0x158(%rbp),%eax
shl    $0x1e,%eax
mov    -0x158(%rbp),%ecx
shr    $0x2,%ecx
and    $0x3fffffff,%ecx
or     %ecx,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x154(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x170(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    13c8 <sha_hash+0x2c8>
jmp    149d <sha_hash+0x39d>
cmpl   $0x50,-0x168(%rbp)
jae    1557 <sha_hash+0x457>
mov    -0x154(%rbp),%eax
shl    $0x5,%eax
mov    -0x154(%rbp),%ecx
shr    $0x1b,%ecx
and    $0x1f,%ecx
or     %ecx,%eax
mov    -0x158(%rbp),%ecx
xor    -0x15c(%rbp),%ecx
xor    -0x160(%rbp),%ecx
add    %ecx,%eax
add    -0x164(%rbp),%eax
mov    -0x168(%rbp),%ecx
add    -0x150(%rbp,%rcx,4),%eax
add    $0xca62c1d6,%eax
mov    %eax,-0x170(%rbp)
mov    -0x160(%rbp),%eax
mov    %eax,-0x164(%rbp)
mov    -0x15c(%rbp),%eax
mov    %eax,-0x160(%rbp)
mov    -0x158(%rbp),%eax
shl    $0x1e,%eax
mov    -0x158(%rbp),%ecx
shr    $0x2,%ecx
and    $0x3fffffff,%ecx
or     %ecx,%eax
mov    %eax,-0x15c(%rbp)
mov    -0x154(%rbp),%eax
mov    %eax,-0x158(%rbp)
mov    -0x170(%rbp),%eax
mov    %eax,-0x154(%rbp)
mov    -0x168(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x168(%rbp)
jmp    149d <sha_hash+0x39d>
mov    -0x154(%rbp),%ecx
mov    -0x10(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x158(%rbp),%ecx
mov    -0x10(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x15c(%rbp),%ecx
mov    -0x10(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x160(%rbp),%ecx
mov    -0x10(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x164(%rbp),%ecx
mov    -0x10(%rbp),%rax
add    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sha_hash>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    (%rsi),%r14d
mov    0x4(%rsi),%r11d
mov    0x8(%rsi),%r10d
mov    0xc(%rsi),%r9d
mov    0x10(%rsi),%r12d
movups (%rdi),%xmm0
movups 0x10(%rdi),%xmm1
movups 0x20(%rdi),%xmm2
movups 0x30(%rdi),%xmm3
movaps %xmm3,-0x40(%rsp)
movaps %xmm2,-0x50(%rsp)
movaps %xmm1,-0x60(%rsp)
movaps %xmm0,-0x70(%rsp)
xor    %eax,%eax
nopl   0x0(%rax)
mov    -0x50(%rsp,%rax,4),%ecx
xor    -0x3c(%rsp,%rax,4),%ecx
xor    -0x68(%rsp,%rax,4),%ecx
xor    -0x70(%rsp,%rax,4),%ecx
rol    %ecx
mov    %ecx,-0x30(%rsp,%rax,4)
add    $0x1,%rax
cmp    $0x40,%rax
jne    1150 <sha_hash+0x50>
mov    $0x1,%r13d
mov    %r14d,%ebx
mov    %r12d,-0x74(%rsp)
mov    %r9d,%edx
mov    %r10d,%edi
mov    %r11d,%eax
nopw   0x0(%rax,%rax,1)
mov    %edx,%r15d
mov    %eax,%edx
mov    %edi,%ebp
mov    %ebx,%edi
mov    %ebx,%eax
rol    $0x5,%eax
mov    %ebp,%ebx
xor    %r15d,%ebx
and    %edx,%ebx
xor    %r15d,%ebx
add    %r12d,%ebx
add    %eax,%ebx
mov    -0x74(%rsp,%r13,4),%eax
mov    -0x70(%rsp,%r13,4),%r12d
add    %ebx,%eax
add    $0x5a827999,%eax
rol    $0x1e,%edx
mov    %eax,%ebx
rol    $0x5,%ebx
mov    %edx,%ecx
xor    %ebp,%ecx
and    %edi,%ecx
xor    %ebp,%ecx
add    %r15d,%ecx
add    %ebx,%ecx
lea    (%r12,%rcx,1),%ebx
add    $0x5a827999,%ebx
rol    $0x1e,%edi
add    $0x2,%r13
mov    %ebp,%r12d
cmp    $0x15,%r13
jne    1190 <sha_hash+0x90>
xor    %ecx,%ecx
nop
mov    %edx,%r12d
mov    %eax,%edx
mov    %edi,%r15d
mov    %ebx,%edi
mov    %ebx,%eax
rol    $0x5,%eax
mov    %r15d,%ebx
xor    %edx,%ebx
xor    %r12d,%ebx
add    %ebp,%ebx
add    %eax,%ebx
mov    -0x20(%rsp,%rcx,4),%eax
mov    -0x1c(%rsp,%rcx,4),%r13d
rol    $0x1e,%edx
add    %ebx,%eax
add    $0x6ed9eba1,%eax
mov    %eax,%ebx
rol    $0x5,%ebx
mov    %edi,%ebp
xor    %r15d,%ebp
xor    %edx,%ebp
add    %r12d,%ebp
add    %ebx,%ebp
lea    0x6ed9eba1(%r13,%rbp,1),%ebx
6e
rol    $0x1e,%edi
add    $0x2,%rcx
mov    %r15d,%ebp
cmp    $0x14,%rcx
jne    11f0 <sha_hash+0xf0>
xor    %r13d,%r13d
nopw   0x0(%rax,%rax,1)
mov    %eax,%r12d
mov    %edi,%ecx
mov    %edx,%eax
mov    %ebx,%edi
rol    $0x5,%ebx
mov    %r12d,%edx
rol    $0x1e,%edx
mov    %ecx,%ebp
or     %edx,%ebp
and    %edi,%ebp
mov    %ecx,%r8d
and    %edx,%r8d
or     %ebp,%r8d
mov    %eax,%ebp
add    %eax,%r8d
or     %ecx,%eax
and    %r12d,%eax
and    %ecx,%ebp
or     %eax,%ebp
add    %r15d,%ebp
add    %ebx,%ebp
mov    0x30(%rsp,%r13,4),%eax
mov    0x34(%rsp,%r13,4),%ebx
add    %ebp,%eax
add    $0x8f1bbcdc,%eax
mov    %eax,%ebp
rol    $0x5,%ebp
add    %ebp,%r8d
add    %r8d,%ebx
add    $0x8f1bbcdc,%ebx
rol    $0x1e,%edi
add    $0x2,%r13
mov    %ecx,%r15d
cmp    $0x14,%r13
jne    1250 <sha_hash+0x150>
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    %edx,%r8d
mov    %eax,%edx
mov    %edi,%r15d
mov    %ebx,%edi
mov    %ebx,%eax
rol    $0x5,%eax
mov    %r15d,%ebx
xor    %edx,%ebx
xor    %r8d,%ebx
add    %ecx,%ebx
add    %eax,%ebx
mov    0x80(%rsp,%rbp,4),%eax
mov    0x84(%rsp,%rbp,4),%r12d
rol    $0x1e,%edx
add    %ebx,%eax
add    $0xca62c1d6,%eax
mov    %eax,%ebx
rol    $0x5,%ebx
mov    %edi,%ecx
xor    %r15d,%ecx
xor    %edx,%ecx
add    %r8d,%ecx
add    %ebx,%ecx
lea    (%r12,%rcx,1),%ebx
add    $0xca62c1d6,%ebx
rol    $0x1e,%edi
add    $0x2,%rbp
mov    %r15d,%ecx
cmp    $0x14,%rbp
jne    12c0 <sha_hash+0x1c0>
add    %r14d,%ebx
mov    %ebx,(%rsi)
add    %r11d,%eax
mov    %eax,0x4(%rsi)
add    %r10d,%edi
mov    %edi,0x8(%rsi)
add    %r9d,%edx
mov    %edx,0xc(%rsi)
add    -0x74(%rsp),%r15d
mov    %r15d,0x10(%rsi)
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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