void has160_process_block(unsigned *hash, const unsigned *block) {
  unsigned X[32];
  {
    unsigned j;
    for (j = 0; j < 16; j++) {
      X[j] = (block[j]);
    }
    X[16] = X[0] ^ X[1] ^ X[2] ^ X[3];
    X[17] = X[4] ^ X[5] ^ X[6] ^ X[7];
    X[18] = X[8] ^ X[9] ^ X[10] ^ X[11];
    X[19] = X[12] ^ X[13] ^ X[14] ^ X[15];
    X[20] = X[3] ^ X[6] ^ X[9] ^ X[12];
    X[21] = X[2] ^ X[5] ^ X[8] ^ X[15];
    X[22] = X[1] ^ X[4] ^ X[11] ^ X[14];
    X[23] = X[0] ^ X[7] ^ X[10] ^ X[13];
    X[24] = X[5] ^ X[7] ^ X[12] ^ X[14];
    X[25] = X[0] ^ X[2] ^ X[9] ^ X[11];
    X[26] = X[4] ^ X[6] ^ X[13] ^ X[15];
    X[27] = X[1] ^ X[3] ^ X[8] ^ X[10];
    X[28] = X[2] ^ X[7] ^ X[8] ^ X[13];
    X[29] = X[3] ^ X[4] ^ X[9] ^ X[14];
    X[30] = X[0] ^ X[5] ^ X[10] ^ X[15];
    X[31] = X[1] ^ X[6] ^ X[11] ^ X[12];
  }
  {
    unsigned A, B, C, D, E;
    A = hash[0];
    B = hash[1];
    C = hash[2];
    D = hash[3];
    E = hash[4];
    E += ((A) << (5) ^ ((A) >> (32 - (5)))) + (D ^ (B & (C ^ D))) + X[18];
    B = ((B) << (10) ^ ((B) >> (32 - (10))));
    ;
    D += ((E) << (11) ^ ((E) >> (32 - (11)))) + (C ^ (A & (B ^ C))) + X[0];
    A = ((A) << (10) ^ ((A) >> (32 - (10))));
    ;
    C += ((D) << (7) ^ ((D) >> (32 - (7)))) + (B ^ (E & (A ^ B))) + X[1];
    E = ((E) << (10) ^ ((E) >> (32 - (10))));
    ;
    B += ((C) << (15) ^ ((C) >> (32 - (15)))) + (A ^ (D & (E ^ A))) + X[2];
    D = ((D) << (10) ^ ((D) >> (32 - (10))));
    ;
    A += ((B) << (6) ^ ((B) >> (32 - (6)))) + (E ^ (C & (D ^ E))) + X[3];
    C = ((C) << (10) ^ ((C) >> (32 - (10))));
    ;
    E += ((A) << (13) ^ ((A) >> (32 - (13)))) + (D ^ (B & (C ^ D))) + X[19];
    B = ((B) << (10) ^ ((B) >> (32 - (10))));
    ;
    D += ((E) << (8) ^ ((E) >> (32 - (8)))) + (C ^ (A & (B ^ C))) + X[4];
    A = ((A) << (10) ^ ((A) >> (32 - (10))));
    ;
    C += ((D) << (14) ^ ((D) >> (32 - (14)))) + (B ^ (E & (A ^ B))) + X[5];
    E = ((E) << (10) ^ ((E) >> (32 - (10))));
    ;
    B += ((C) << (7) ^ ((C) >> (32 - (7)))) + (A ^ (D & (E ^ A))) + X[6];
    D = ((D) << (10) ^ ((D) >> (32 - (10))));
    ;
    A += ((B) << (12) ^ ((B) >> (32 - (12)))) + (E ^ (C & (D ^ E))) + X[7];
    C = ((C) << (10) ^ ((C) >> (32 - (10))));
    ;
    E += ((A) << (9) ^ ((A) >> (32 - (9)))) + (D ^ (B & (C ^ D))) + X[16];
    B = ((B) << (10) ^ ((B) >> (32 - (10))));
    ;
    D += ((E) << (11) ^ ((E) >> (32 - (11)))) + (C ^ (A & (B ^ C))) + X[8];
    A = ((A) << (10) ^ ((A) >> (32 - (10))));
    ;
    C += ((D) << (8) ^ ((D) >> (32 - (8)))) + (B ^ (E & (A ^ B))) + X[9];
    E = ((E) << (10) ^ ((E) >> (32 - (10))));
    ;
    B += ((C) << (15) ^ ((C) >> (32 - (15)))) + (A ^ (D & (E ^ A))) + X[10];
    D = ((D) << (10) ^ ((D) >> (32 - (10))));
    ;
    A += ((B) << (6) ^ ((B) >> (32 - (6)))) + (E ^ (C & (D ^ E))) + X[11];
    C = ((C) << (10) ^ ((C) >> (32 - (10))));
    ;
    E += ((A) << (12) ^ ((A) >> (32 - (12)))) + (D ^ (B & (C ^ D))) + X[17];
    B = ((B) << (10) ^ ((B) >> (32 - (10))));
    ;
    D += ((E) << (9) ^ ((E) >> (32 - (9)))) + (C ^ (A & (B ^ C))) + X[12];
    A = ((A) << (10) ^ ((A) >> (32 - (10))));
    ;
    C += ((D) << (14) ^ ((D) >> (32 - (14)))) + (B ^ (E & (A ^ B))) + X[13];
    E = ((E) << (10) ^ ((E) >> (32 - (10))));
    ;
    B += ((C) << (5) ^ ((C) >> (32 - (5)))) + (A ^ (D & (E ^ A))) + X[14];
    D = ((D) << (10) ^ ((D) >> (32 - (10))));
    ;
    A += ((B) << (13) ^ ((B) >> (32 - (13)))) + (E ^ (C & (D ^ E))) + X[15];
    C = ((C) << (10) ^ ((C) >> (32 - (10))));
    ;
    E += ((A) << (5) ^ ((A) >> (32 - (5)))) + (B ^ C ^ D) + X[22] + 0x5A827999;
    B = ((B) << (17) ^ ((B) >> (32 - (17))));
    ;
    D += ((E) << (11) ^ ((E) >> (32 - (11)))) + (A ^ B ^ C) + X[3] + 0x5A827999;
    A = ((A) << (17) ^ ((A) >> (32 - (17))));
    ;
    C += ((D) << (7) ^ ((D) >> (32 - (7)))) + (E ^ A ^ B) + X[6] + 0x5A827999;
    E = ((E) << (17) ^ ((E) >> (32 - (17))));
    ;
    B += ((C) << (15) ^ ((C) >> (32 - (15)))) + (D ^ E ^ A) + X[9] + 0x5A827999;
    D = ((D) << (17) ^ ((D) >> (32 - (17))));
    ;
    A += ((B) << (6) ^ ((B) >> (32 - (6)))) + (C ^ D ^ E) + X[12] + 0x5A827999;
    C = ((C) << (17) ^ ((C) >> (32 - (17))));
    ;
    E +=
        ((A) << (13) ^ ((A) >> (32 - (13)))) + (B ^ C ^ D) + X[23] + 0x5A827999;
    B = ((B) << (17) ^ ((B) >> (32 - (17))));
    ;
    D += ((E) << (8) ^ ((E) >> (32 - (8)))) + (A ^ B ^ C) + X[15] + 0x5A827999;
    A = ((A) << (17) ^ ((A) >> (32 - (17))));
    ;
    C += ((D) << (14) ^ ((D) >> (32 - (14)))) + (E ^ A ^ B) + X[2] + 0x5A827999;
    E = ((E) << (17) ^ ((E) >> (32 - (17))));
    ;
    B += ((C) << (7) ^ ((C) >> (32 - (7)))) + (D ^ E ^ A) + X[5] + 0x5A827999;
    D = ((D) << (17) ^ ((D) >> (32 - (17))));
    ;
    A += ((B) << (12) ^ ((B) >> (32 - (12)))) + (C ^ D ^ E) + X[8] + 0x5A827999;
    C = ((C) << (17) ^ ((C) >> (32 - (17))));
    ;
    E += ((A) << (9) ^ ((A) >> (32 - (9)))) + (B ^ C ^ D) + X[20] + 0x5A827999;
    B = ((B) << (17) ^ ((B) >> (32 - (17))));
    ;
    D +=
        ((E) << (11) ^ ((E) >> (32 - (11)))) + (A ^ B ^ C) + X[11] + 0x5A827999;
    A = ((A) << (17) ^ ((A) >> (32 - (17))));
    ;
    C += ((D) << (8) ^ ((D) >> (32 - (8)))) + (E ^ A ^ B) + X[14] + 0x5A827999;
    E = ((E) << (17) ^ ((E) >> (32 - (17))));
    ;
    B += ((C) << (15) ^ ((C) >> (32 - (15)))) + (D ^ E ^ A) + X[1] + 0x5A827999;
    D = ((D) << (17) ^ ((D) >> (32 - (17))));
    ;
    A += ((B) << (6) ^ ((B) >> (32 - (6)))) + (C ^ D ^ E) + X[4] + 0x5A827999;
    C = ((C) << (17) ^ ((C) >> (32 - (17))));
    ;
    E +=
        ((A) << (12) ^ ((A) >> (32 - (12)))) + (B ^ C ^ D) + X[21] + 0x5A827999;
    B = ((B) << (17) ^ ((B) >> (32 - (17))));
    ;
    D += ((E) << (9) ^ ((E) >> (32 - (9)))) + (A ^ B ^ C) + X[7] + 0x5A827999;
    A = ((A) << (17) ^ ((A) >> (32 - (17))));
    ;
    C +=
        ((D) << (14) ^ ((D) >> (32 - (14)))) + (E ^ A ^ B) + X[10] + 0x5A827999;
    E = ((E) << (17) ^ ((E) >> (32 - (17))));
    ;
    B += ((C) << (5) ^ ((C) >> (32 - (5)))) + (D ^ E ^ A) + X[13] + 0x5A827999;
    D = ((D) << (17) ^ ((D) >> (32 - (17))));
    ;
    A += ((B) << (13) ^ ((B) >> (32 - (13)))) + (C ^ D ^ E) + X[0] + 0x5A827999;
    C = ((C) << (17) ^ ((C) >> (32 - (17))));
    ;
    E += ((A) << (5) ^ ((A) >> (32 - (5)))) + (C ^ (B | ~D)) + X[26] +
         0x6ED9EBA1;
    B = ((B) << (25) ^ ((B) >> (32 - (25))));
    ;
    D += ((E) << (11) ^ ((E) >> (32 - (11)))) + (B ^ (A | ~C)) + X[12] +
         0x6ED9EBA1;
    A = ((A) << (25) ^ ((A) >> (32 - (25))));
    ;
    C +=
        ((D) << (7) ^ ((D) >> (32 - (7)))) + (A ^ (E | ~B)) + X[5] + 0x6ED9EBA1;
    E = ((E) << (25) ^ ((E) >> (32 - (25))));
    ;
    B += ((C) << (15) ^ ((C) >> (32 - (15)))) + (E ^ (D | ~A)) + X[14] +
         0x6ED9EBA1;
    D = ((D) << (25) ^ ((D) >> (32 - (25))));
    ;
    A +=
        ((B) << (6) ^ ((B) >> (32 - (6)))) + (D ^ (C | ~E)) + X[7] + 0x6ED9EBA1;
    C = ((C) << (25) ^ ((C) >> (32 - (25))));
    ;
    E += ((A) << (13) ^ ((A) >> (32 - (13)))) + (C ^ (B | ~D)) + X[27] +
         0x6ED9EBA1;
    B = ((B) << (25) ^ ((B) >> (32 - (25))));
    ;
    D +=
        ((E) << (8) ^ ((E) >> (32 - (8)))) + (B ^ (A | ~C)) + X[0] + 0x6ED9EBA1;
    A = ((A) << (25) ^ ((A) >> (32 - (25))));
    ;
    C += ((D) << (14) ^ ((D) >> (32 - (14)))) + (A ^ (E | ~B)) + X[9] +
         0x6ED9EBA1;
    E = ((E) << (25) ^ ((E) >> (32 - (25))));
    ;
    B +=
        ((C) << (7) ^ ((C) >> (32 - (7)))) + (E ^ (D | ~A)) + X[2] + 0x6ED9EBA1;
    D = ((D) << (25) ^ ((D) >> (32 - (25))));
    ;
    A += ((B) << (12) ^ ((B) >> (32 - (12)))) + (D ^ (C | ~E)) + X[11] +
         0x6ED9EBA1;
    C = ((C) << (25) ^ ((C) >> (32 - (25))));
    ;
    E += ((A) << (9) ^ ((A) >> (32 - (9)))) + (C ^ (B | ~D)) + X[24] +
         0x6ED9EBA1;
    B = ((B) << (25) ^ ((B) >> (32 - (25))));
    ;
    D += ((E) << (11) ^ ((E) >> (32 - (11)))) + (B ^ (A | ~C)) + X[4] +
         0x6ED9EBA1;
    A = ((A) << (25) ^ ((A) >> (32 - (25))));
    ;
    C += ((D) << (8) ^ ((D) >> (32 - (8)))) + (A ^ (E | ~B)) + X[13] +
         0x6ED9EBA1;
    E = ((E) << (25) ^ ((E) >> (32 - (25))));
    ;
    B += ((C) << (15) ^ ((C) >> (32 - (15)))) + (E ^ (D | ~A)) + X[6] +
         0x6ED9EBA1;
    D = ((D) << (25) ^ ((D) >> (32 - (25))));
    ;
    A += ((B) << (6) ^ ((B) >> (32 - (6)))) + (D ^ (C | ~E)) + X[15] +
         0x6ED9EBA1;
    C = ((C) << (25) ^ ((C) >> (32 - (25))));
    ;
    E += ((A) << (12) ^ ((A) >> (32 - (12)))) + (C ^ (B | ~D)) + X[25] +
         0x6ED9EBA1;
    B = ((B) << (25) ^ ((B) >> (32 - (25))));
    ;
    D +=
        ((E) << (9) ^ ((E) >> (32 - (9)))) + (B ^ (A | ~C)) + X[8] + 0x6ED9EBA1;
    A = ((A) << (25) ^ ((A) >> (32 - (25))));
    ;
    C += ((D) << (14) ^ ((D) >> (32 - (14)))) + (A ^ (E | ~B)) + X[1] +
         0x6ED9EBA1;
    E = ((E) << (25) ^ ((E) >> (32 - (25))));
    ;
    B += ((C) << (5) ^ ((C) >> (32 - (5)))) + (E ^ (D | ~A)) + X[10] +
         0x6ED9EBA1;
    D = ((D) << (25) ^ ((D) >> (32 - (25))));
    ;
    A += ((B) << (13) ^ ((B) >> (32 - (13)))) + (D ^ (C | ~E)) + X[3] +
         0x6ED9EBA1;
    C = ((C) << (25) ^ ((C) >> (32 - (25))));
    ;
    E += ((A) << (5) ^ ((A) >> (32 - (5)))) + (B ^ C ^ D) + X[30] + 0x8F1BBCDC;
    B = ((B) << (30) ^ ((B) >> (32 - (30))));
    ;
    D += ((E) << (11) ^ ((E) >> (32 - (11)))) + (A ^ B ^ C) + X[7] + 0x8F1BBCDC;
    A = ((A) << (30) ^ ((A) >> (32 - (30))));
    ;
    C += ((D) << (7) ^ ((D) >> (32 - (7)))) + (E ^ A ^ B) + X[2] + 0x8F1BBCDC;
    E = ((E) << (30) ^ ((E) >> (32 - (30))));
    ;
    B +=
        ((C) << (15) ^ ((C) >> (32 - (15)))) + (D ^ E ^ A) + X[13] + 0x8F1BBCDC;
    D = ((D) << (30) ^ ((D) >> (32 - (30))));
    ;
    A += ((B) << (6) ^ ((B) >> (32 - (6)))) + (C ^ D ^ E) + X[8] + 0x8F1BBCDC;
    C = ((C) << (30) ^ ((C) >> (32 - (30))));
    ;
    E +=
        ((A) << (13) ^ ((A) >> (32 - (13)))) + (B ^ C ^ D) + X[31] + 0x8F1BBCDC;
    B = ((B) << (30) ^ ((B) >> (32 - (30))));
    ;
    D += ((E) << (8) ^ ((E) >> (32 - (8)))) + (A ^ B ^ C) + X[3] + 0x8F1BBCDC;
    A = ((A) << (30) ^ ((A) >> (32 - (30))));
    ;
    C +=
        ((D) << (14) ^ ((D) >> (32 - (14)))) + (E ^ A ^ B) + X[14] + 0x8F1BBCDC;
    E = ((E) << (30) ^ ((E) >> (32 - (30))));
    ;
    B += ((C) << (7) ^ ((C) >> (32 - (7)))) + (D ^ E ^ A) + X[9] + 0x8F1BBCDC;
    D = ((D) << (30) ^ ((D) >> (32 - (30))));
    ;
    A += ((B) << (12) ^ ((B) >> (32 - (12)))) + (C ^ D ^ E) + X[4] + 0x8F1BBCDC;
    C = ((C) << (30) ^ ((C) >> (32 - (30))));
    ;
    E += ((A) << (9) ^ ((A) >> (32 - (9)))) + (B ^ C ^ D) + X[28] + 0x8F1BBCDC;
    B = ((B) << (30) ^ ((B) >> (32 - (30))));
    ;
    D +=
        ((E) << (11) ^ ((E) >> (32 - (11)))) + (A ^ B ^ C) + X[15] + 0x8F1BBCDC;
    A = ((A) << (30) ^ ((A) >> (32 - (30))));
    ;
    C += ((D) << (8) ^ ((D) >> (32 - (8)))) + (E ^ A ^ B) + X[10] + 0x8F1BBCDC;
    E = ((E) << (30) ^ ((E) >> (32 - (30))));
    ;
    B += ((C) << (15) ^ ((C) >> (32 - (15)))) + (D ^ E ^ A) + X[5] + 0x8F1BBCDC;
    D = ((D) << (30) ^ ((D) >> (32 - (30))));
    ;
    A += ((B) << (6) ^ ((B) >> (32 - (6)))) + (C ^ D ^ E) + X[0] + 0x8F1BBCDC;
    C = ((C) << (30) ^ ((C) >> (32 - (30))));
    ;
    E +=
        ((A) << (12) ^ ((A) >> (32 - (12)))) + (B ^ C ^ D) + X[29] + 0x8F1BBCDC;
    B = ((B) << (30) ^ ((B) >> (32 - (30))));
    ;
    D += ((E) << (9) ^ ((E) >> (32 - (9)))) + (A ^ B ^ C) + X[11] + 0x8F1BBCDC;
    A = ((A) << (30) ^ ((A) >> (32 - (30))));
    ;
    C += ((D) << (14) ^ ((D) >> (32 - (14)))) + (E ^ A ^ B) + X[6] + 0x8F1BBCDC;
    E = ((E) << (30) ^ ((E) >> (32 - (30))));
    ;
    B += ((C) << (5) ^ ((C) >> (32 - (5)))) + (D ^ E ^ A) + X[1] + 0x8F1BBCDC;
    D = ((D) << (30) ^ ((D) >> (32 - (30))));
    ;
    A +=
        ((B) << (13) ^ ((B) >> (32 - (13)))) + (C ^ D ^ E) + X[12] + 0x8F1BBCDC;
    C = ((C) << (30) ^ ((C) >> (32 - (30))));
    ;
    hash[0] += A;
    hash[1] += B;
    hash[2] += C;
    hash[3] += D;
    hash[4] += E;
  }
}


x86 assembly (clang, -O0):
<has160_process_block>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0x0,-0x94(%rbp)
cmpl   $0x10,-0x94(%rbp)
jae    1155 <has160_process_block+0x55>
mov    -0x10(%rbp),%rax
mov    -0x94(%rbp),%ecx
mov    (%rax,%rcx,4),%ecx
mov    -0x94(%rbp),%eax
mov    %ecx,-0x90(%rbp,%rax,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    111a <has160_process_block+0x1a>
mov    -0x90(%rbp),%eax
xor    -0x8c(%rbp),%eax
xor    -0x88(%rbp),%eax
xor    -0x84(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x80(%rbp),%eax
xor    -0x7c(%rbp),%eax
xor    -0x78(%rbp),%eax
xor    -0x74(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x70(%rbp),%eax
xor    -0x6c(%rbp),%eax
xor    -0x68(%rbp),%eax
xor    -0x64(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x60(%rbp),%eax
xor    -0x5c(%rbp),%eax
xor    -0x58(%rbp),%eax
xor    -0x54(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x84(%rbp),%eax
xor    -0x78(%rbp),%eax
xor    -0x6c(%rbp),%eax
xor    -0x60(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x88(%rbp),%eax
xor    -0x7c(%rbp),%eax
xor    -0x70(%rbp),%eax
xor    -0x54(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8c(%rbp),%eax
xor    -0x80(%rbp),%eax
xor    -0x64(%rbp),%eax
xor    -0x58(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x90(%rbp),%eax
xor    -0x74(%rbp),%eax
xor    -0x68(%rbp),%eax
xor    -0x5c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x7c(%rbp),%eax
xor    -0x74(%rbp),%eax
xor    -0x60(%rbp),%eax
xor    -0x58(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x90(%rbp),%eax
xor    -0x88(%rbp),%eax
xor    -0x6c(%rbp),%eax
xor    -0x64(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x80(%rbp),%eax
xor    -0x78(%rbp),%eax
xor    -0x5c(%rbp),%eax
xor    -0x54(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x8c(%rbp),%eax
xor    -0x84(%rbp),%eax
xor    -0x70(%rbp),%eax
xor    -0x68(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x88(%rbp),%eax
xor    -0x74(%rbp),%eax
xor    -0x70(%rbp),%eax
xor    -0x5c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x84(%rbp),%eax
xor    -0x80(%rbp),%eax
xor    -0x6c(%rbp),%eax
xor    -0x58(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x90(%rbp),%eax
xor    -0x7c(%rbp),%eax
xor    -0x68(%rbp),%eax
xor    -0x54(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8c(%rbp),%eax
xor    -0x78(%rbp),%eax
xor    -0x64(%rbp),%eax
xor    -0x60(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x9c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0xa0(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x5,%eax
mov    -0x98(%rbp),%ecx
shr    $0x1b,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%esi
xor    -0xa4(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x48(%rbp),%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xa,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xb,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x15,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
mov    -0x98(%rbp),%edx
mov    -0x9c(%rbp),%esi
xor    -0xa0(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x90(%rbp),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xa,%eax
mov    -0x98(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x7,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x19,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
mov    -0xa8(%rbp),%edx
mov    -0x98(%rbp),%esi
xor    -0x9c(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x8c(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xa,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xf,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x11,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
mov    -0xa4(%rbp),%edx
mov    -0xa8(%rbp),%esi
xor    -0x98(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x88(%rbp),%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xa,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x6,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x1a,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
mov    -0xa0(%rbp),%edx
mov    -0xa4(%rbp),%esi
xor    -0xa8(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x84(%rbp),%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xa,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xd,%eax
mov    -0x98(%rbp),%ecx
shr    $0x13,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%esi
xor    -0xa4(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x44(%rbp),%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xa,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x8,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x18,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
mov    -0x98(%rbp),%edx
mov    -0x9c(%rbp),%esi
xor    -0xa0(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x80(%rbp),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xa,%eax
mov    -0x98(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xe,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x12,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
mov    -0xa8(%rbp),%edx
mov    -0x98(%rbp),%esi
xor    -0x9c(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x7c(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xa,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x7,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x19,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
mov    -0xa4(%rbp),%edx
mov    -0xa8(%rbp),%esi
xor    -0x98(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x78(%rbp),%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xa,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xc,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x14,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
mov    -0xa0(%rbp),%edx
mov    -0xa4(%rbp),%esi
xor    -0xa8(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x74(%rbp),%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xa,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x9,%eax
mov    -0x98(%rbp),%ecx
shr    $0x17,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%esi
xor    -0xa4(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x50(%rbp),%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xa,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xb,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x15,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
mov    -0x98(%rbp),%edx
mov    -0x9c(%rbp),%esi
xor    -0xa0(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x70(%rbp),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xa,%eax
mov    -0x98(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x8,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x18,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
mov    -0xa8(%rbp),%edx
mov    -0x98(%rbp),%esi
xor    -0x9c(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x6c(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xa,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xf,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x11,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
mov    -0xa4(%rbp),%edx
mov    -0xa8(%rbp),%esi
xor    -0x98(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x68(%rbp),%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xa,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x6,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x1a,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
mov    -0xa0(%rbp),%edx
mov    -0xa4(%rbp),%esi
xor    -0xa8(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x64(%rbp),%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xa,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xc,%eax
mov    -0x98(%rbp),%ecx
shr    $0x14,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
mov    -0x9c(%rbp),%edx
mov    -0xa0(%rbp),%esi
xor    -0xa4(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x4c(%rbp),%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xa,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x9,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x17,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
mov    -0x98(%rbp),%edx
mov    -0x9c(%rbp),%esi
xor    -0xa0(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x60(%rbp),%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xa,%eax
mov    -0x98(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xe,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x12,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
mov    -0xa8(%rbp),%edx
mov    -0x98(%rbp),%esi
xor    -0x9c(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x5c(%rbp),%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xa,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x5,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x1b,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
mov    -0xa4(%rbp),%edx
mov    -0xa8(%rbp),%esi
xor    -0x98(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x58(%rbp),%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xa,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xd,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x13,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
mov    -0xa0(%rbp),%edx
mov    -0xa4(%rbp),%esi
xor    -0xa8(%rbp),%esi
and    %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x54(%rbp),%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xa,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x16,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x5,%eax
mov    -0x98(%rbp),%ecx
shr    $0x1b,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
add    %ecx,%eax
add    -0x38(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x11,%eax
mov    -0x9c(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xb,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x15,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
add    %ecx,%eax
add    -0x84(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x11,%eax
mov    -0x98(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x7,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x19,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
add    %ecx,%eax
add    -0x78(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x11,%eax
mov    -0xa8(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xf,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x11,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
add    %ecx,%eax
add    -0x6c(%rbp),%eax
add    $0x5a827999,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x11,%eax
mov    -0xa4(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x6,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x1a,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
add    %ecx,%eax
add    -0x60(%rbp),%eax
add    $0x5a827999,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x11,%eax
mov    -0xa0(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xd,%eax
mov    -0x98(%rbp),%ecx
shr    $0x13,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
add    %ecx,%eax
add    -0x34(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x11,%eax
mov    -0x9c(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x8,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x18,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
add    %ecx,%eax
add    -0x54(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x11,%eax
mov    -0x98(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xe,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x12,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
add    %ecx,%eax
add    -0x88(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x11,%eax
mov    -0xa8(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x7,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x19,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
add    %ecx,%eax
add    -0x7c(%rbp),%eax
add    $0x5a827999,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x11,%eax
mov    -0xa4(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xc,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x14,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
add    %ecx,%eax
add    -0x70(%rbp),%eax
add    $0x5a827999,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x11,%eax
mov    -0xa0(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x9,%eax
mov    -0x98(%rbp),%ecx
shr    $0x17,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
add    %ecx,%eax
add    -0x40(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x11,%eax
mov    -0x9c(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xb,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x15,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
add    %ecx,%eax
add    -0x64(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x11,%eax
mov    -0x98(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x8,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x18,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
add    %ecx,%eax
add    -0x58(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x11,%eax
mov    -0xa8(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xf,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x11,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
add    %ecx,%eax
add    -0x8c(%rbp),%eax
add    $0x5a827999,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x11,%eax
mov    -0xa4(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x6,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x1a,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
add    %ecx,%eax
add    -0x80(%rbp),%eax
add    $0x5a827999,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x11,%eax
mov    -0xa0(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xc,%eax
mov    -0x98(%rbp),%ecx
shr    $0x14,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
add    %ecx,%eax
add    -0x3c(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x11,%eax
mov    -0x9c(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x9,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x17,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
add    %ecx,%eax
add    -0x74(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x11,%eax
mov    -0x98(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xe,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x12,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
add    %ecx,%eax
add    -0x68(%rbp),%eax
add    $0x5a827999,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x11,%eax
mov    -0xa8(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x5,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x1b,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
add    %ecx,%eax
add    -0x5c(%rbp),%eax
add    $0x5a827999,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x11,%eax
mov    -0xa4(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xd,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x13,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
add    %ecx,%eax
add    -0x90(%rbp),%eax
add    $0x5a827999,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x11,%eax
mov    -0xa0(%rbp),%ecx
shr    $0xf,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x5,%eax
mov    -0x98(%rbp),%ecx
shr    $0x1b,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
mov    -0x9c(%rbp),%edx
mov    -0xa4(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x28(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x19,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xb,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x15,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
mov    -0x98(%rbp),%edx
mov    -0xa0(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x60(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x19,%eax
mov    -0x98(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x7,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x19,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
mov    -0xa8(%rbp),%edx
mov    -0x9c(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x7c(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x19,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xf,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x11,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%edx
mov    -0x98(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x58(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x19,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x6,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x1a,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
mov    -0xa0(%rbp),%edx
mov    -0xa8(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x74(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x19,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xd,%eax
mov    -0x98(%rbp),%ecx
shr    $0x13,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
mov    -0x9c(%rbp),%edx
mov    -0xa4(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x19,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x8,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x18,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
mov    -0x98(%rbp),%edx
mov    -0xa0(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x90(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x19,%eax
mov    -0x98(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xe,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x12,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
mov    -0xa8(%rbp),%edx
mov    -0x9c(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x6c(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x19,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x7,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x19,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%edx
mov    -0x98(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x88(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x19,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xc,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x14,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
mov    -0xa0(%rbp),%edx
mov    -0xa8(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x64(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x19,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x9,%eax
mov    -0x98(%rbp),%ecx
shr    $0x17,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
mov    -0x9c(%rbp),%edx
mov    -0xa4(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x30(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x19,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xb,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x15,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
mov    -0x98(%rbp),%edx
mov    -0xa0(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x80(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x19,%eax
mov    -0x98(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x8,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x18,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
mov    -0xa8(%rbp),%edx
mov    -0x9c(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x5c(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x19,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xf,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x11,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%edx
mov    -0x98(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x78(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x19,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x6,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x1a,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
mov    -0xa0(%rbp),%edx
mov    -0xa8(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x54(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x19,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xc,%eax
mov    -0x98(%rbp),%ecx
shr    $0x14,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
mov    -0x9c(%rbp),%edx
mov    -0xa4(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x2c(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x19,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x9,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x17,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
mov    -0x98(%rbp),%edx
mov    -0xa0(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x70(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x19,%eax
mov    -0x98(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xe,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x12,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
mov    -0xa8(%rbp),%edx
mov    -0x9c(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x8c(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x19,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x5,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x1b,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
mov    -0xa4(%rbp),%edx
mov    -0x98(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x68(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x19,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xd,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x13,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
mov    -0xa0(%rbp),%edx
mov    -0xa8(%rbp),%esi
xor    $0xffffffff,%esi
or     %esi,%edx
xor    %edx,%ecx
add    %ecx,%eax
add    -0x84(%rbp),%eax
add    $0x6ed9eba1,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x19,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x7,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x5,%eax
mov    -0x98(%rbp),%ecx
shr    $0x1b,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xb,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x15,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
add    %ecx,%eax
add    -0x74(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x1e,%eax
mov    -0x98(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x7,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x19,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
add    %ecx,%eax
add    -0x88(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xf,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x11,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
add    %ecx,%eax
add    -0x5c(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x6,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x1a,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
add    %ecx,%eax
add    -0x70(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xd,%eax
mov    -0x98(%rbp),%ecx
shr    $0x13,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x8,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x18,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
add    %ecx,%eax
add    -0x84(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x1e,%eax
mov    -0x98(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xe,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x12,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
add    %ecx,%eax
add    -0x58(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x7,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x19,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
add    %ecx,%eax
add    -0x6c(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xc,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x14,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
add    %ecx,%eax
add    -0x80(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x9,%eax
mov    -0x98(%rbp),%ecx
shr    $0x17,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0xb,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x15,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
add    %ecx,%eax
add    -0x54(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x1e,%eax
mov    -0x98(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x8,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x18,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
add    %ecx,%eax
add    -0x68(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0xf,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x11,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
add    %ecx,%eax
add    -0x7c(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x6,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x1a,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
add    %ecx,%eax
add    -0x90(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%eax
shl    $0xc,%eax
mov    -0x98(%rbp),%ecx
shr    $0x14,%ecx
xor    %ecx,%eax
mov    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa8(%rbp),%eax
mov    %eax,-0xa8(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x9,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x17,%ecx
xor    %ecx,%eax
mov    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
xor    -0xa0(%rbp),%ecx
add    %ecx,%eax
add    -0x64(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa4(%rbp),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x98(%rbp),%eax
shl    $0x1e,%eax
mov    -0x98(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0xe,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x12,%ecx
xor    %ecx,%eax
mov    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
xor    -0x9c(%rbp),%ecx
add    %ecx,%eax
add    -0x78(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0xa0(%rbp),%eax
mov    %eax,-0xa0(%rbp)
mov    -0xa8(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa8(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa8(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x5,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x1b,%ecx
xor    %ecx,%eax
mov    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
xor    -0x98(%rbp),%ecx
add    %ecx,%eax
add    -0x8c(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0x9c(%rbp),%eax
mov    %eax,-0x9c(%rbp)
mov    -0xa4(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa4(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa4(%rbp)
mov    -0x9c(%rbp),%eax
shl    $0xd,%eax
mov    -0x9c(%rbp),%ecx
shr    $0x13,%ecx
xor    %ecx,%eax
mov    -0xa0(%rbp),%ecx
xor    -0xa4(%rbp),%ecx
xor    -0xa8(%rbp),%ecx
add    %ecx,%eax
add    -0x60(%rbp),%eax
add    $0x8f1bbcdc,%eax
add    -0x98(%rbp),%eax
mov    %eax,-0x98(%rbp)
mov    -0xa0(%rbp),%eax
shl    $0x1e,%eax
mov    -0xa0(%rbp),%ecx
shr    $0x2,%ecx
xor    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x98(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x9c(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0xa0(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0xa4(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0xa8(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<has160_process_block>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    0x20(%rsi),%ecx
mov    %ecx,-0x64(%rsp)
mov    0x24(%rsi),%ebp
mov    %ebp,-0x74(%rsp)
mov    0x28(%rsi),%edx
mov    %edx,-0x7c(%rsp)
mov    0x2c(%rsi),%eax
mov    %eax,-0x78(%rsp)
mov    %edx,%r11d
xor    %ecx,%r11d
mov    %r11d,-0x14(%rsp)
xor    %eax,%ebp
mov    %ebp,-0x38(%rsp)
xor    %ebp,%r11d
mov    %rdi,0x10(%rsp)
mov    (%rdi),%r9d
mov    0x4(%rdi),%r8d
mov    0x8(%rdi),%ebx
mov    0xc(%rdi),%edx
mov    %r9d,%eax
rol    $0x5,%eax
mov    0x10(%rdi),%ebp
mov    %ebp,-0xc(%rsp)
add    %r11d,%eax
mov    %edx,%ecx
xor    %ebx,%ecx
mov    %r8,%r13
mov    %r8,0x8(%rsp)
and    %r13d,%ecx
xor    %edx,%ecx
mov    %rdx,%rdi
mov    %rdx,(%rsp)
add    %ebp,%eax
rol    $0xa,%r13d
add    %ecx,%eax
mov    %eax,%ecx
rol    $0xb,%ecx
mov    %r13d,%edx
xor    %ebx,%edx
mov    %r9d,-0x10(%rsp)
and    %r9d,%edx
xor    %ebx,%edx
mov    %rbx,-0x8(%rsp)
mov    (%rsi),%r14d
add    %r14d,%edi
mov    %r14,-0x20(%rsp)
add    %edi,%edx
add    %ecx,%edx
mov    %r9d,%ecx
rol    $0xa,%ecx
mov    %r13d,%edi
xor    %ecx,%edi
and    %eax,%edi
xor    %r13d,%edi
mov    0x4(%rsi),%r10d
add    %r10d,%ebx
mov    %r10,-0x28(%rsp)
add    %ebx,%edi
mov    %edx,%ebx
rol    $0x7,%ebx
add    %ebx,%edi
rol    $0xa,%eax
mov    %eax,%ebx
xor    %ecx,%ebx
and    %edx,%ebx
xor    %ecx,%ebx
mov    0x8(%rsi),%ebp
add    %ebp,%r13d
mov    %ebp,%r12d
mov    %ebp,-0x5c(%rsp)
add    %ebx,%r13d
mov    %edi,%ebx
rol    $0xf,%ebx
add    %ebx,%r13d
rol    $0xa,%edx
mov    %edx,%ebx
xor    %eax,%ebx
and    %edi,%ebx
xor    %eax,%ebx
mov    0xc(%rsi),%ebp
add    %ebp,%ecx
mov    %ebp,%r15d
mov    %ebp,-0x58(%rsp)
add    %ebx,%ecx
mov    %r13d,%ebx
rol    $0x6,%ebx
add    %ebx,%ecx
mov    0x30(%rsi),%r8d
mov    %r8,-0x30(%rsp)
mov    0x38(%rsi),%ebp
mov    %ebp,-0x6c(%rsp)
xor    %r8d,%ebp
mov    %ebp,-0x44(%rsp)
mov    0x34(%rsi),%ebx
mov    %ebx,-0x60(%rsp)
mov    0x3c(%rsi),%r8d
mov    %r8d,-0x80(%rsp)
xor    %r8d,%ebx
mov    %ebx,-0x50(%rsp)
xor    %ebx,%ebp
rol    $0xa,%edi
add    %ebp,%eax
mov    %edi,%ebx
xor    %edx,%ebx
and    %r13d,%ebx
xor    %edx,%ebx
add    %ebx,%eax
mov    %ecx,%ebx
rol    $0xd,%ebx
add    %ebx,%eax
rol    $0xa,%r13d
mov    %r13d,%ebx
xor    %edi,%ebx
and    %ecx,%ebx
xor    %edi,%ebx
mov    0x10(%rsi),%ebp
mov    %ebp,-0x68(%rsp)
add    %ebp,%edx
add    %ebx,%edx
mov    %eax,%ebx
rol    $0x8,%ebx
rol    $0xa,%ecx
add    %ebx,%edx
mov    %edx,%r9d
rol    $0xe,%r9d
mov    %ecx,%ebp
xor    %r13d,%ebp
and    %eax,%ebp
xor    %r13d,%ebp
mov    0x14(%rsi),%r11d
add    %r11d,%edi
mov    %r11d,-0x54(%rsp)
add    %ebp,%edi
add    %r9d,%edi
rol    $0xa,%eax
mov    %eax,%ebp
xor    %ecx,%ebp
and    %edx,%ebp
xor    %ecx,%ebp
mov    0x18(%rsi),%ebx
add    %ebx,%r13d
mov    %ebx,%r9d
add    %ebp,%r13d
mov    %edi,%ebp
rol    $0x7,%ebp
add    %ebp,%r13d
mov    0x1c(%rsi),%r8d
rol    $0xa,%edx
mov    %edx,%esi
xor    %eax,%esi
and    %edi,%esi
xor    %eax,%esi
add    %r8d,%ecx
mov    %r8d,-0x70(%rsp)
add    %esi,%ecx
mov    %r13d,%esi
rol    $0xc,%esi
add    %esi,%ecx
mov    %r12d,%esi
xor    %r14d,%esi
mov    %r10d,%ebx
xor    %r15d,%ebx
mov    %ebx,-0x18(%rsp)
xor    %esi,-0x38(%rsp)
xor    %ebx,%esi
rol    $0xa,%edi
mov    %ecx,%ebp
rol    $0x9,%ebp
add    %esi,%eax
mov    %edi,%esi
xor    %edx,%esi
and    %r13d,%esi
xor    %edx,%esi
add    %esi,%eax
add    %ebp,%eax
rol    $0xa,%r13d
mov    %r13d,%esi
xor    %edi,%esi
and    %ecx,%esi
xor    %edi,%esi
add    -0x64(%rsp),%edx
add    %esi,%edx
mov    %eax,%esi
rol    $0xb,%esi
add    %esi,%edx
rol    $0xa,%ecx
mov    %edx,%esi
rol    $0x8,%esi
mov    %ecx,%ebp
xor    %r13d,%ebp
and    %eax,%ebp
xor    %r13d,%ebp
add    -0x74(%rsp),%edi
add    %ebp,%edi
add    %esi,%edi
rol    $0xa,%eax
mov    %eax,%esi
xor    %ecx,%esi
and    %edx,%esi
xor    %ecx,%esi
add    -0x7c(%rsp),%r13d
add    %esi,%r13d
mov    %edi,%esi
rol    $0xf,%esi
add    %esi,%r13d
rol    $0xa,%edx
mov    %r13d,%esi
rol    $0x6,%esi
mov    %edx,%ebp
xor    %eax,%ebp
and    %edi,%ebp
xor    %eax,%ebp
mov    -0x78(%rsp),%ebx
add    %ebx,%ecx
add    %ebp,%ecx
add    %esi,%ecx
mov    %r9d,%ebp
mov    %r9d,%r15d
mov    -0x68(%rsp),%r9d
xor    %r9d,%ebp
xor    %r8d,%r11d
mov    %ebp,%esi
xor    %r11d,%esi
add    %esi,%eax
rol    $0xa,%edi
mov    %edi,%esi
xor    %edx,%esi
and    %r13d,%esi
xor    %edx,%esi
add    %esi,%eax
mov    %ecx,%esi
rol    $0xc,%esi
rol    $0xa,%r13d
add    %esi,%eax
mov    %r13d,%esi
xor    %edi,%esi
and    %ecx,%esi
xor    %edi,%esi
add    -0x30(%rsp),%edx
add    %esi,%edx
mov    %eax,%esi
rol    $0x9,%esi
add    %esi,%edx
rol    $0xa,%ecx
mov    %ecx,%esi
xor    %r13d,%esi
and    %eax,%esi
xor    %r13d,%esi
mov    -0x60(%rsp),%r14d
add    %r14d,%edi
add    %esi,%edi
mov    %edx,%esi
rol    $0xe,%esi
rol    $0xa,%eax
add    %esi,%edi
mov    %eax,%esi
xor    %ecx,%esi
and    %edx,%esi
xor    %ecx,%esi
mov    -0x6c(%rsp),%r8d
add    %r8d,%r13d
add    %esi,%r13d
mov    %edi,%esi
rol    $0x5,%esi
add    %esi,%r13d
rol    $0xa,%edx
mov    %edx,%esi
xor    %eax,%esi
and    %edi,%esi
xor    %eax,%esi
mov    -0x80(%rsp),%r10d
add    %r10d,%ecx
add    %esi,%ecx
mov    %r13d,%esi
rol    $0xd,%esi
add    %esi,%ecx
mov    %ebx,%esi
xor    -0x28(%rsp),%esi
mov    %esi,-0x40(%rsp)
mov    %r9d,%ebx
xor    %r8d,%ebx
mov    %ebx,-0x34(%rsp)
xor    %ebx,%esi
rol    $0xa,%edi
add    %esi,%eax
mov    %edi,%esi
xor    %edx,%esi
xor    %r13d,%esi
add    %esi,%eax
mov    %ecx,%esi
rol    $0x5,%esi
rol    $0x11,%r13d
add    %esi,%eax
add    $0x5a827999,%eax
mov    %r13d,%esi
xor    %edi,%esi
xor    %ecx,%esi
mov    -0x58(%rsp),%ebx
add    %ebx,%edx
add    %esi,%edx
mov    %eax,%esi
rol    $0xb,%esi
lea    (%rsi,%rdx,1),%r8d
add    $0x5a827999,%r8d
rol    $0x11,%ecx
mov    %r8d,%edx
rol    $0x7,%edx
xor    %ebp,-0x50(%rsp)
mov    %ecx,%esi
xor    %r13d,%esi
xor    %eax,%esi
mov    %r15d,-0x48(%rsp)
add    %r15d,%edi
add    %esi,%edi
lea    (%rdx,%rdi,1),%r9d
add    $0x5a827999,%r9d
rol    $0x11,%eax
mov    %eax,%edx
xor    %ecx,%edx
xor    %r8d,%edx
mov    -0x74(%rsp),%ebp
add    %ebp,%r13d
add    %edx,%r13d
mov    %r9d,%edx
rol    $0xf,%edx
rol    $0x11,%r8d
add    %r13d,%edx
add    $0x5a827999,%edx
mov    %r8d,%esi
xor    %eax,%esi
xor    %r9d,%esi
mov    -0x30(%rsp),%r13
add    %r13d,%ecx
add    %esi,%ecx
mov    %edx,%esi
rol    $0x6,%esi
add    %ecx,%esi
add    $0x5a827999,%esi
mov    -0x7c(%rsp),%ecx
xor    -0x20(%rsp),%ecx
mov    %ecx,-0x4c(%rsp)
mov    -0x70(%rsp),%edi
xor    %r14d,%edi
mov    %edi,-0x3c(%rsp)
xor    %edi,%ecx
add    %ecx,%eax
rol    $0x11,%r9d
mov    %r9d,%ecx
xor    %r8d,%ecx
xor    %edx,%ecx
add    %ecx,%eax
mov    %esi,%ecx
rol    $0xd,%ecx
lea    (%rcx,%rax,1),%edi
add    $0x5a827999,%edi
rol    $0x11,%edx
mov    %edi,%eax
rol    $0x8,%eax
xor    %r11d,-0x44(%rsp)
mov    %edx,%ecx
xor    %r9d,%ecx
xor    %esi,%ecx
add    %r10d,%r8d
add    %ecx,%r8d
add    %eax,%r8d
add    $0x5a827999,%r8d
rol    $0x11,%esi
mov    %esi,%eax
xor    %edx,%eax
xor    %edi,%eax
mov    -0x5c(%rsp),%r12d
add    %r12d,%r9d
add    %eax,%r9d
mov    %r8d,%eax
rol    $0xe,%eax
rol    $0x11,%edi
lea    (%rax,%r9,1),%ecx
add    $0x5a827999,%ecx
mov    %edi,%eax
xor    %esi,%eax
xor    %r8d,%eax
mov    -0x54(%rsp),%r11d
add    %r11d,%edx
add    %eax,%edx
mov    %ecx,%eax
rol    $0x7,%eax
lea    (%rax,%rdx,1),%r9d
add    $0x5a827999,%r9d
rol    $0x11,%r8d
mov    %r8d,%edx
xor    %edi,%edx
xor    %ecx,%edx
mov    -0x64(%rsp),%r10d
add    %r10d,%esi
add    %edx,%esi
mov    %r9d,%edx
rol    $0xc,%edx
add    %edx,%esi
add    $0x5a827999,%esi
mov    %ebp,%edx
xor    %ebx,%edx
mov    %r15d,%r14d
xor    %r13d,%r14d
xor    %edx,-0x34(%rsp)
xor    %r14d,%edx
add    %edx,%edi
rol    $0x11,%ecx
mov    %esi,%edx
rol    $0x9,%edx
mov    %ecx,%ebp
xor    %r8d,%ebp
xor    %r9d,%ebp
add    %ebp,%edi
add    %edx,%edi
add    $0x5a827999,%edi
rol    $0x11,%r9d
mov    %r9d,%edx
xor    %ecx,%edx
xor    %esi,%edx
add    -0x78(%rsp),%r8d
add    %edx,%r8d
mov    %edi,%edx
rol    $0xb,%edx
rol    $0x11,%esi
lea    (%rdx,%r8,1),%eax
add    $0x5a827999,%eax
mov    %esi,%ebp
xor    %r9d,%ebp
xor    %edi,%ebp
mov    -0x6c(%rsp),%r15d
add    %r15d,%ecx
add    %ebp,%ecx
mov    %eax,%edx
rol    $0x8,%edx
lea    (%rdx,%rcx,1),%r8d
add    $0x5a827999,%r8d
rol    $0x11,%edi
mov    %r8d,%edx
rol    $0xf,%edx
mov    -0x14(%rsp),%r13d
xor    -0x18(%rsp),%r13d
mov    %edi,%ebp
xor    %esi,%ebp
xor    %eax,%ebp
add    -0x28(%rsp),%r9d
add    %ebp,%r9d
lea    (%rdx,%r9,1),%ecx
add    $0x5a827999,%ecx
rol    $0x11,%eax
mov    %eax,%ebp
xor    %edi,%ebp
xor    %r8d,%ebp
add    -0x68(%rsp),%esi
add    %ebp,%esi
mov    %ecx,%edx
rol    $0x6,%edx
add    %edx,%esi
add    $0x5a827999,%esi
mov    %r10d,%edx
xor    %r12d,%edx
mov    %r11d,%r10d
mov    %r11d,%ebp
xor    -0x80(%rsp),%ebp
xor    %edx,-0x3c(%rsp)
xor    %ebp,%edx
add    %edx,%edi
rol    $0x11,%r8d
mov    %r8d,%edx
xor    %eax,%edx
xor    %ecx,%edx
add    %edx,%edi
mov    %esi,%edx
rol    $0xc,%edx
add    %edx,%edi
add    $0x5a827999,%edi
rol    $0x11,%ecx
mov    %edi,%edx
rol    $0x9,%edx
xor    %ebp,-0x4c(%rsp)
mov    %ecx,%ebp
xor    %r8d,%ebp
xor    %esi,%ebp
mov    -0x70(%rsp),%r12d
add    %r12d,%eax
add    %ebp,%eax
lea    (%rdx,%rax,1),%r9d
add    $0x5a827999,%r9d
rol    $0x11,%esi
mov    %esi,%eax
xor    %ecx,%eax
xor    %edi,%eax
add    -0x7c(%rsp),%r8d
add    %eax,%r8d
mov    %r9d,%eax
rol    $0xe,%eax
rol    $0x11,%edi
lea    (%rax,%r8,1),%ebp
add    $0x5a827999,%ebp
mov    %edi,%eax
xor    %esi,%eax
xor    %r9d,%eax
mov    -0x60(%rsp),%r8d
add    %r8d,%ecx
add    %eax,%ecx
mov    %ebp,%eax
rol    $0x5,%eax
add    %ecx,%eax
add    $0x5a827999,%eax
rol    $0x11,%r9d
mov    %eax,%ecx
rol    $0xd,%ecx
xor    %r14d,-0x40(%rsp)
mov    %r9d,%edx
xor    %edi,%edx
xor    %ebp,%edx
mov    -0x20(%rsp),%rbx
add    %ebx,%esi
add    %edx,%esi
lea    (%rcx,%rsi,1),%edx
add    $0x5a827999,%edx
rol    $0x11,%ebp
add    -0x50(%rsp),%edi
mov    %r9d,%ecx
not    %ecx
or     %eax,%ecx
xor    %ebp,%ecx
add    %ecx,%edi
mov    %edx,%ecx
rol    $0x5,%ecx
lea    (%rcx,%rdi,1),%r11d
add    $0x6ed9eba1,%r11d
rol    $0x19,%eax
mov    %r11d,%ecx
rol    $0xb,%ecx
mov    %ebp,%esi
not    %esi
or     %edx,%esi
xor    %eax,%esi
add    -0x30(%rsp),%r9d
add    %esi,%r9d
lea    (%rcx,%r9,1),%edi
add    $0x6ed9eba1,%edi
rol    $0x19,%edx
mov    %eax,%ecx
not    %ecx
or     %r11d,%ecx
xor    %edx,%ecx
add    %r10d,%ebp
add    %ecx,%ebp
mov    %edi,%ecx
rol    $0x7,%ecx
lea    (%rcx,%rbp,1),%r10d
add    $0x6ed9eba1,%r10d
rol    $0x19,%r11d
mov    %r10d,%ecx
rol    $0xf,%ecx
mov    %edx,%esi
not    %esi
or     %edi,%esi
xor    %r11d,%esi
add    %r15d,%eax
add    %esi,%eax
lea    (%rcx,%rax,1),%r9d
add    $0x6ed9eba1,%r9d
rol    $0x19,%edi
mov    %r11d,%eax
not    %eax
or     %r10d,%eax
xor    %edi,%eax
add    %r12d,%edx
add    %eax,%edx
mov    %r9d,%eax
rol    $0x6,%eax
add    %eax,%edx
add    $0x6ed9eba1,%edx
rol    $0x19,%r10d
mov    %edx,%eax
rol    $0xd,%eax
add    %r13d,%r11d
mov    %edi,%ecx
not    %ecx
or     %r9d,%ecx
xor    %r10d,%ecx
add    %ecx,%r11d
lea    (%rax,%r11,1),%esi
add    $0x6ed9eba1,%esi
rol    $0x19,%r9d
mov    %r10d,%eax
not    %eax
or     %edx,%eax
xor    %r9d,%eax
add    %ebx,%edi
add    %eax,%edi
mov    %esi,%eax
rol    $0x8,%eax
add    %eax,%edi
add    $0x6ed9eba1,%edi
rol    $0x19,%edx
mov    %edi,%eax
rol    $0xe,%eax
mov    %r9d,%ecx
not    %ecx
or     %esi,%ecx
xor    %edx,%ecx
add    -0x74(%rsp),%r10d
add    %ecx,%r10d
lea    (%rax,%r10,1),%ecx
add    $0x6ed9eba1,%ecx
rol    $0x19,%esi
mov    %edx,%eax
not    %eax
or     %edi,%eax
xor    %esi,%eax
mov    -0x5c(%rsp),%r12d
add    %r12d,%r9d
add    %eax,%r9d
mov    %ecx,%eax
rol    $0x7,%eax
add    %eax,%r9d
add    $0x6ed9eba1,%r9d
rol    $0x19,%edi
mov    %r9d,%eax
rol    $0xc,%eax
mov    %esi,%ebp
not    %ebp
or     %ecx,%ebp
xor    %edi,%ebp
add    -0x78(%rsp),%edx
add    %ebp,%edx
add    %eax,%edx
add    $0x6ed9eba1,%edx
rol    $0x19,%ecx
add    -0x44(%rsp),%esi
mov    %edi,%eax
not    %eax
or     %r9d,%eax
xor    %ecx,%eax
add    %eax,%esi
mov    %edx,%eax
rol    $0x9,%eax
add    %eax,%esi
add    $0x6ed9eba1,%esi
rol    $0x19,%r9d
mov    %esi,%eax
rol    $0xb,%eax
mov    %ecx,%ebp
not    %ebp
or     %edx,%ebp
xor    %r9d,%ebp
mov    -0x68(%rsp),%r13d
add    %r13d,%edi
add    %ebp,%edi
add    %eax,%edi
add    $0x6ed9eba1,%edi
rol    $0x19,%edx
mov    %r9d,%eax
not    %eax
or     %esi,%eax
xor    %edx,%eax
mov    %r8d,%ebx
add    %r8d,%ecx
add    %eax,%ecx
mov    %edi,%eax
rol    $0x8,%eax
add    %eax,%ecx
add    $0x6ed9eba1,%ecx
rol    $0x19,%esi
mov    %ecx,%eax
rol    $0xf,%eax
mov    %edx,%ebp
not    %ebp
or     %edi,%ebp
xor    %esi,%ebp
add    -0x48(%rsp),%r9d
add    %ebp,%r9d
add    %eax,%r9d
add    $0x6ed9eba1,%r9d
rol    $0x19,%edi
mov    %esi,%eax
not    %eax
or     %ecx,%eax
xor    %edi,%eax
add    -0x80(%rsp),%edx
add    %eax,%edx
mov    %r9d,%eax
rol    $0x6,%eax
lea    (%rax,%rdx,1),%r10d
add    $0x6ed9eba1,%r10d
rol    $0x19,%ecx
mov    %r10d,%eax
rol    $0xc,%eax
add    -0x38(%rsp),%esi
mov    %edi,%edx
not    %edx
or     %r9d,%edx
xor    %ecx,%edx
add    %edx,%esi
add    %eax,%esi
add    $0x6ed9eba1,%esi
rol    $0x19,%r9d
mov    %ecx,%eax
not    %eax
or     %r10d,%eax
xor    %r9d,%eax
mov    -0x64(%rsp),%r11d
add    %r11d,%edi
add    %eax,%edi
mov    %esi,%eax
rol    $0x9,%eax
add    %eax,%edi
add    $0x6ed9eba1,%edi
rol    $0x19,%r10d
mov    %edi,%eax
rol    $0xe,%eax
mov    %r9d,%edx
not    %edx
or     %esi,%edx
xor    %r10d,%edx
mov    -0x28(%rsp),%r15
add    %r15d,%ecx
add    %edx,%ecx
add    %eax,%ecx
add    $0x6ed9eba1,%ecx
rol    $0x19,%esi
mov    %r10d,%eax
not    %eax
or     %edi,%eax
xor    %esi,%eax
mov    -0x7c(%rsp),%r14d
add    %r14d,%r9d
add    %eax,%r9d
mov    %ecx,%eax
rol    $0x5,%eax
lea    (%rax,%r9,1),%edx
add    $0x6ed9eba1,%edx
rol    $0x19,%edi
mov    %edx,%eax
rol    $0xd,%eax
mov    %esi,%ebp
not    %ebp
or     %ecx,%ebp
xor    %edi,%ebp
mov    -0x58(%rsp),%r9d
add    %r9d,%r10d
add    %ebp,%r10d
lea    (%rax,%r10,1),%r8d
add    $0x6ed9eba1,%r8d
rol    $0x19,%ecx
add    -0x4c(%rsp),%esi
mov    %ecx,%ebp
xor    %edi,%ebp
xor    %edx,%ebp
add    %ebp,%esi
mov    %r8d,%eax
rol    $0x5,%eax
add    %eax,%esi
add    $0x8f1bbcdc,%esi
add    -0x70(%rsp),%edi
rol    $0x1e,%edx
mov    %edx,%eax
xor    %ecx,%eax
xor    %r8d,%eax
add    %eax,%edi
mov    %esi,%eax
rol    $0xb,%eax
add    %eax,%edi
add    $0x8f1bbcdc,%edi
add    %r12d,%ecx
rol    $0x1e,%r8d
mov    %r8d,%eax
xor    %edx,%eax
xor    %esi,%eax
add    %eax,%ecx
mov    %edi,%eax
rol    $0x7,%eax
add    %eax,%ecx
add    $0x8f1bbcdc,%ecx
add    %ebx,%edx
rol    $0x1e,%esi
mov    %ecx,%eax
rol    $0xf,%eax
mov    %esi,%ebp
xor    %r8d,%ebp
xor    %edi,%ebp
add    %ebp,%edx
add    %eax,%edx
add    $0x8f1bbcdc,%edx
rol    $0x1e,%edi
add    %r11d,%r8d
mov    %edi,%eax
xor    %esi,%eax
xor    %ecx,%eax
add    %eax,%r8d
mov    %edx,%eax
rol    $0x6,%eax
lea    (%rax,%r8,1),%ebx
add    $0x8f1bbcdc,%ebx
add    -0x40(%rsp),%esi
rol    $0x1e,%ecx
mov    %ecx,%ebp
xor    %edi,%ebp
xor    %edx,%ebp
add    %ebp,%esi
mov    %ebx,%eax
rol    $0xd,%eax
add    %eax,%esi
add    $0x8f1bbcdc,%esi
add    %r9d,%edi
rol    $0x1e,%edx
mov    %edx,%eax
xor    %ecx,%eax
xor    %ebx,%eax
add    %eax,%edi
mov    %esi,%eax
rol    $0x8,%eax
add    %eax,%edi
add    $0x8f1bbcdc,%edi
add    -0x6c(%rsp),%ecx
rol    $0x1e,%ebx
mov    %edi,%eax
rol    $0xe,%eax
mov    %ebx,%ebp
xor    %edx,%ebp
xor    %esi,%ebp
add    %ebp,%ecx
lea    (%rax,%rcx,1),%ebp
add    $0x8f1bbcdc,%ebp
rol    $0x1e,%esi
add    -0x74(%rsp),%edx
mov    %esi,%eax
xor    %ebx,%eax
xor    %edi,%eax
add    %eax,%edx
mov    %ebp,%eax
rol    $0x7,%eax
add    %eax,%edx
add    $0x8f1bbcdc,%edx
add    %r13d,%ebx
rol    $0x1e,%edi
mov    %edi,%eax
xor    %esi,%eax
xor    %ebp,%eax
add    %eax,%ebx
mov    %edx,%eax
rol    $0xc,%eax
add    %ebx,%eax
add    $0x8f1bbcdc,%eax
add    -0x3c(%rsp),%esi
rol    $0x1e,%ebp
mov    %ebp,%ecx
xor    %edi,%ecx
xor    %edx,%ecx
add    %ecx,%esi
mov    %eax,%ecx
rol    $0x9,%ecx
add    %ecx,%esi
add    $0x8f1bbcdc,%esi
add    -0x80(%rsp),%edi
rol    $0x1e,%edx
mov    %esi,%ecx
rol    $0xb,%ecx
mov    %edx,%ebx
xor    %ebp,%ebx
xor    %eax,%ebx
add    %ebx,%edi
add    %edi,%ecx
add    $0x8f1bbcdc,%ecx
rol    $0x1e,%eax
add    %r14d,%ebp
mov    %eax,%edi
xor    %edx,%edi
xor    %esi,%edi
add    %edi,%ebp
mov    %ecx,%edi
rol    $0x8,%edi
add    %edi,%ebp
add    $0x8f1bbcdc,%ebp
add    -0x54(%rsp),%edx
rol    $0x1e,%esi
mov    %esi,%edi
xor    %eax,%edi
xor    %ecx,%edi
add    %edi,%edx
mov    %ebp,%edi
rol    $0xf,%edi
add    %edi,%edx
add    $0x8f1bbcdc,%edx
add    -0x20(%rsp),%eax
rol    $0x1e,%ecx
mov    %ecx,%edi
xor    %esi,%edi
xor    %ebp,%edi
add    %edi,%eax
mov    %edx,%edi
rol    $0x6,%edi
add    %eax,%edi
add    $0x8f1bbcdc,%edi
add    -0x34(%rsp),%esi
rol    $0x1e,%ebp
mov    %edi,%eax
rol    $0xc,%eax
mov    %ebp,%ebx
xor    %ecx,%ebx
xor    %edx,%ebx
add    %ebx,%esi
lea    (%rax,%rsi,1),%ebx
add    $0x8f1bbcdc,%ebx
rol    $0x1e,%edx
add    -0x78(%rsp),%ecx
mov    %edx,%esi
xor    %ebp,%esi
xor    %edi,%esi
add    %esi,%ecx
mov    %ebx,%esi
rol    $0x9,%esi
rol    $0x1e,%edi
add    %esi,%ecx
add    $0x8f1bbcdc,%ecx
add    -0x48(%rsp),%ebp
mov    %edi,%esi
xor    %edx,%esi
xor    %ebx,%esi
add    %esi,%ebp
mov    %ecx,%esi
rol    $0xe,%esi
add    %ebp,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%ebx
mov    %esi,%ebp
rol    $0x5,%ebp
add    %r15d,%edx
mov    %ebx,%eax
xor    %edi,%eax
xor    %ecx,%eax
add    %eax,%edx
lea    (%rdx,%rbp,1),%eax
add    $0x8f1bbcdc,%eax
add    %ebp,%edx
mov    -0x30(%rsp),%rbp
add    -0x10(%rsp),%ebp
rol    $0x1e,%ecx
add    %edi,%ebp
mov    %ecx,%edi
xor    %ebx,%edi
xor    %esi,%edi
add    %edi,%ebp
rol    $0xd,%eax
add    %ebp,%eax
add    $0x8f1bbcdc,%eax
mov    0x10(%rsp),%rdi
mov    %eax,(%rdi)
mov    0x8(%rsp),%rax
add    %edx,%eax
add    $0x8f1bbcdc,%eax
mov    %eax,0x4(%rdi)
rol    $0x1e,%esi
add    -0x8(%rsp),%esi
mov    %esi,0x8(%rdi)
add    (%rsp),%ecx
mov    %ecx,0xc(%rdi)
add    -0xc(%rsp),%ebx
mov    %ebx,0x10(%rdi)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @has160_process_block(i32* %0, i32* %1) {
%3 = alloca i32*
%4 = alloca i32*
%5 = alloca [32 x i32]
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store i32* %0, i32** %3
store i32* %1, i32** %4
store i32 0, i32* %6
br label %12
12: ; preds = %24, %2
%13 = load i32, i32* %6
%14 = icmp ult i32 %13, 16
br i1 %14, label %15, label %27
15: ; preds = %12
%16 = load i32*, i32** %4
%17 = load i32, i32* %6
%18 = zext i32 %17 to i64
%19 = getelementptr inbounds i32, i32* %16, i64 %18
%20 = load i32, i32* %19
%21 = load i32, i32* %6
%22 = zext i32 %21 to i64
%23 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 %22
store i32 %20, i32* %23
br label %24
24: ; preds = %15
%25 = load i32, i32* %6
%26 = add i32 %25, 1
store i32 %26, i32* %6
br label %12
27: ; preds = %12
%28 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%29 = load i32, i32* %28
%30 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%31 = load i32, i32* %30
%32 = xor i32 %29, %31
%33 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 2
%34 = load i32, i32* %33
%35 = xor i32 %32, %34
%36 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 3
%37 = load i32, i32* %36
%38 = xor i32 %35, %37
%39 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 16
store i32 %38, i32* %39
%40 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 4
%41 = load i32, i32* %40
%42 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 5
%43 = load i32, i32* %42
%44 = xor i32 %41, %43
%45 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 6
%46 = load i32, i32* %45
%47 = xor i32 %44, %46
%48 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 7
%49 = load i32, i32* %48
%50 = xor i32 %47, %49
%51 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 17
store i32 %50, i32* %51
%52 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 8
%53 = load i32, i32* %52
%54 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 9
%55 = load i32, i32* %54
%56 = xor i32 %53, %55
%57 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 10
%58 = load i32, i32* %57
%59 = xor i32 %56, %58
%60 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 11
%61 = load i32, i32* %60
%62 = xor i32 %59, %61
%63 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 18
store i32 %62, i32* %63
%64 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 12
%65 = load i32, i32* %64
%66 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 13
%67 = load i32, i32* %66
%68 = xor i32 %65, %67
%69 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 14
%70 = load i32, i32* %69
%71 = xor i32 %68, %70
%72 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 15
%73 = load i32, i32* %72
%74 = xor i32 %71, %73
%75 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 19
store i32 %74, i32* %75
%76 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 3
%77 = load i32, i32* %76
%78 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 6
%79 = load i32, i32* %78
%80 = xor i32 %77, %79
%81 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 9
%82 = load i32, i32* %81
%83 = xor i32 %80, %82
%84 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 12
%85 = load i32, i32* %84
%86 = xor i32 %83, %85
%87 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 20
store i32 %86, i32* %87
%88 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 2
%89 = load i32, i32* %88
%90 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 5
%91 = load i32, i32* %90
%92 = xor i32 %89, %91
%93 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 8
%94 = load i32, i32* %93
%95 = xor i32 %92, %94
%96 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 15
%97 = load i32, i32* %96
%98 = xor i32 %95, %97
%99 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 21
store i32 %98, i32* %99
%100 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%101 = load i32, i32* %100
%102 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 4
%103 = load i32, i32* %102
%104 = xor i32 %101, %103
%105 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 11
%106 = load i32, i32* %105
%107 = xor i32 %104, %106
%108 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 14
%109 = load i32, i32* %108
%110 = xor i32 %107, %109
%111 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 22
store i32 %110, i32* %111
%112 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%113 = load i32, i32* %112
%114 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 7
%115 = load i32, i32* %114
%116 = xor i32 %113, %115
%117 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 10
%118 = load i32, i32* %117
%119 = xor i32 %116, %118
%120 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 13
%121 = load i32, i32* %120
%122 = xor i32 %119, %121
%123 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 23
store i32 %122, i32* %123
%124 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 5
%125 = load i32, i32* %124
%126 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 7
%127 = load i32, i32* %126
%128 = xor i32 %125, %127
%129 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 12
%130 = load i32, i32* %129
%131 = xor i32 %128, %130
%132 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 14
%133 = load i32, i32* %132
%134 = xor i32 %131, %133
%135 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 24
store i32 %134, i32* %135
%136 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%137 = load i32, i32* %136
%138 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 2
%139 = load i32, i32* %138
%140 = xor i32 %137, %139
%141 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 9
%142 = load i32, i32* %141
%143 = xor i32 %140, %142
%144 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 11
%145 = load i32, i32* %144
%146 = xor i32 %143, %145
%147 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 25
store i32 %146, i32* %147
%148 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 4
%149 = load i32, i32* %148
%150 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 6
%151 = load i32, i32* %150
%152 = xor i32 %149, %151
%153 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 13
%154 = load i32, i32* %153
%155 = xor i32 %152, %154
%156 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 15
%157 = load i32, i32* %156
%158 = xor i32 %155, %157
%159 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 26
store i32 %158, i32* %159
%160 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%161 = load i32, i32* %160
%162 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 3
%163 = load i32, i32* %162
%164 = xor i32 %161, %163
%165 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 8
%166 = load i32, i32* %165
%167 = xor i32 %164, %166
%168 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 10
%169 = load i32, i32* %168
%170 = xor i32 %167, %169
%171 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 27
store i32 %170, i32* %171
%172 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 2
%173 = load i32, i32* %172
%174 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 7
%175 = load i32, i32* %174
%176 = xor i32 %173, %175
%177 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 8
%178 = load i32, i32* %177
%179 = xor i32 %176, %178
%180 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 13
%181 = load i32, i32* %180
%182 = xor i32 %179, %181
%183 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 28
store i32 %182, i32* %183
%184 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 3
%185 = load i32, i32* %184
%186 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 4
%187 = load i32, i32* %186
%188 = xor i32 %185, %187
%189 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 9
%190 = load i32, i32* %189
%191 = xor i32 %188, %190
%192 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 14
%193 = load i32, i32* %192
%194 = xor i32 %191, %193
%195 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 29
store i32 %194, i32* %195
%196 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%197 = load i32, i32* %196
%198 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 5
%199 = load i32, i32* %198
%200 = xor i32 %197, %199
%201 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 10
%202 = load i32, i32* %201
%203 = xor i32 %200, %202
%204 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 15
%205 = load i32, i32* %204
%206 = xor i32 %203, %205
%207 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 30
store i32 %206, i32* %207
%208 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%209 = load i32, i32* %208
%210 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 6
%211 = load i32, i32* %210
%212 = xor i32 %209, %211
%213 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 11
%214 = load i32, i32* %213
%215 = xor i32 %212, %214
%216 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 12
%217 = load i32, i32* %216
%218 = xor i32 %215, %217
%219 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 31
store i32 %218, i32* %219
%220 = load i32*, i32** %3
%221 = getelementptr inbounds i32, i32* %220, i64 0
%222 = load i32, i32* %221
store i32 %222, i32* %7
%223 = load i32*, i32** %3
%224 = getelementptr inbounds i32, i32* %223, i64 1
%225 = load i32, i32* %224
store i32 %225, i32* %8
%226 = load i32*, i32** %3
%227 = getelementptr inbounds i32, i32* %226, i64 2
%228 = load i32, i32* %227
store i32 %228, i32* %9
%229 = load i32*, i32** %3
%230 = getelementptr inbounds i32, i32* %229, i64 3
%231 = load i32, i32* %230
store i32 %231, i32* %10
%232 = load i32*, i32** %3
%233 = getelementptr inbounds i32, i32* %232, i64 4
%234 = load i32, i32* %233
store i32 %234, i32* %11
%235 = load i32, i32* %7
%236 = shl i32 %235, 5
%237 = load i32, i32* %7
%238 = lshr i32 %237, 27
%239 = xor i32 %236, %238
%240 = load i32, i32* %10
%241 = load i32, i32* %8
%242 = load i32, i32* %9
%243 = load i32, i32* %10
%244 = xor i32 %242, %243
%245 = and i32 %241, %244
%246 = xor i32 %240, %245
%247 = add i32 %239, %246
%248 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 18
%249 = load i32, i32* %248
%250 = add i32 %247, %249
%251 = load i32, i32* %11
%252 = add i32 %251, %250
store i32 %252, i32* %11
%253 = load i32, i32* %8
%254 = shl i32 %253, 10
%255 = load i32, i32* %8
%256 = lshr i32 %255, 22
%257 = xor i32 %254, %256
store i32 %257, i32* %8
%258 = load i32, i32* %11
%259 = shl i32 %258, 11
%260 = load i32, i32* %11
%261 = lshr i32 %260, 21
%262 = xor i32 %259, %261
%263 = load i32, i32* %9
%264 = load i32, i32* %7
%265 = load i32, i32* %8
%266 = load i32, i32* %9
%267 = xor i32 %265, %266
%268 = and i32 %264, %267
%269 = xor i32 %263, %268
%270 = add i32 %262, %269
%271 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%272 = load i32, i32* %271
%273 = add i32 %270, %272
%274 = load i32, i32* %10
%275 = add i32 %274, %273
store i32 %275, i32* %10
%276 = load i32, i32* %7
%277 = shl i32 %276, 10
%278 = load i32, i32* %7
%279 = lshr i32 %278, 22
%280 = xor i32 %277, %279
store i32 %280, i32* %7
%281 = load i32, i32* %10
%282 = shl i32 %281, 7
%283 = load i32, i32* %10
%284 = lshr i32 %283, 25
%285 = xor i32 %282, %284
%286 = load i32, i32* %8
%287 = load i32, i32* %11
%288 = load i32, i32* %7
%289 = load i32, i32* %8
%290 = xor i32 %288, %289
%291 = and i32 %287, %290
%292 = xor i32 %286, %291
%293 = add i32 %285, %292
%294 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%295 = load i32, i32* %294
%296 = add i32 %293, %295
%297 = load i32, i32* %9
%298 = add i32 %297, %296
store i32 %298, i32* %9
%299 = load i32, i32* %11
%300 = shl i32 %299, 10
%301 = load i32, i32* %11
%302 = lshr i32 %301, 22
%303 = xor i32 %300, %302
store i32 %303, i32* %11
%304 = load i32, i32* %9
%305 = shl i32 %304, 15
%306 = load i32, i32* %9
%307 = lshr i32 %306, 17
%308 = xor i32 %305, %307
%309 = load i32, i32* %7
%310 = load i32, i32* %10
%311 = load i32, i32* %11
%312 = load i32, i32* %7
%313 = xor i32 %311, %312
%314 = and i32 %310, %313
%315 = xor i32 %309, %314
%316 = add i32 %308, %315
%317 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 2
%318 = load i32, i32* %317
%319 = add i32 %316, %318
%320 = load i32, i32* %8
%321 = add i32 %320, %319
store i32 %321, i32* %8
%322 = load i32, i32* %10
%323 = shl i32 %322, 10
%324 = load i32, i32* %10
%325 = lshr i32 %324, 22
%326 = xor i32 %323, %325
store i32 %326, i32* %10
%327 = load i32, i32* %8
%328 = shl i32 %327, 6
%329 = load i32, i32* %8
%330 = lshr i32 %329, 26
%331 = xor i32 %328, %330
%332 = load i32, i32* %11
%333 = load i32, i32* %9
%334 = load i32, i32* %10
%335 = load i32, i32* %11
%336 = xor i32 %334, %335
%337 = and i32 %333, %336
%338 = xor i32 %332, %337
%339 = add i32 %331, %338
%340 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 3
%341 = load i32, i32* %340
%342 = add i32 %339, %341
%343 = load i32, i32* %7
%344 = add i32 %343, %342
store i32 %344, i32* %7
%345 = load i32, i32* %9
%346 = shl i32 %345, 10
%347 = load i32, i32* %9
%348 = lshr i32 %347, 22
%349 = xor i32 %346, %348
store i32 %349, i32* %9
%350 = load i32, i32* %7
%351 = shl i32 %350, 13
%352 = load i32, i32* %7
%353 = lshr i32 %352, 19
%354 = xor i32 %351, %353
%355 = load i32, i32* %10
%356 = load i32, i32* %8
%357 = load i32, i32* %9
%358 = load i32, i32* %10
%359 = xor i32 %357, %358
%360 = and i32 %356, %359
%361 = xor i32 %355, %360
%362 = add i32 %354, %361
%363 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 19
%364 = load i32, i32* %363
%365 = add i32 %362, %364
%366 = load i32, i32* %11
%367 = add i32 %366, %365
store i32 %367, i32* %11
%368 = load i32, i32* %8
%369 = shl i32 %368, 10
%370 = load i32, i32* %8
%371 = lshr i32 %370, 22
%372 = xor i32 %369, %371
store i32 %372, i32* %8
%373 = load i32, i32* %11
%374 = shl i32 %373, 8
%375 = load i32, i32* %11
%376 = lshr i32 %375, 24
%377 = xor i32 %374, %376
%378 = load i32, i32* %9
%379 = load i32, i32* %7
%380 = load i32, i32* %8
%381 = load i32, i32* %9
%382 = xor i32 %380, %381
%383 = and i32 %379, %382
%384 = xor i32 %378, %383
%385 = add i32 %377, %384
%386 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 4
%387 = load i32, i32* %386
%388 = add i32 %385, %387
%389 = load i32, i32* %10
%390 = add i32 %389, %388
store i32 %390, i32* %10
%391 = load i32, i32* %7
%392 = shl i32 %391, 10
%393 = load i32, i32* %7
%394 = lshr i32 %393, 22
%395 = xor i32 %392, %394
store i32 %395, i32* %7
%396 = load i32, i32* %10
%397 = shl i32 %396, 14
%398 = load i32, i32* %10
%399 = lshr i32 %398, 18
%400 = xor i32 %397, %399
%401 = load i32, i32* %8
%402 = load i32, i32* %11
%403 = load i32, i32* %7
%404 = load i32, i32* %8
%405 = xor i32 %403, %404
%406 = and i32 %402, %405
%407 = xor i32 %401, %406
%408 = add i32 %400, %407
%409 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 5
%410 = load i32, i32* %409
%411 = add i32 %408, %410
%412 = load i32, i32* %9
%413 = add i32 %412, %411
store i32 %413, i32* %9
%414 = load i32, i32* %11
%415 = shl i32 %414, 10
%416 = load i32, i32* %11
%417 = lshr i32 %416, 22
%418 = xor i32 %415, %417
store i32 %418, i32* %11
%419 = load i32, i32* %9
%420 = shl i32 %419, 7
%421 = load i32, i32* %9
%422 = lshr i32 %421, 25
%423 = xor i32 %420, %422
%424 = load i32, i32* %7
%425 = load i32, i32* %10
%426 = load i32, i32* %11
%427 = load i32, i32* %7
%428 = xor i32 %426, %427
%429 = and i32 %425, %428
%430 = xor i32 %424, %429
%431 = add i32 %423, %430
%432 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 6
%433 = load i32, i32* %432
%434 = add i32 %431, %433
%435 = load i32, i32* %8
%436 = add i32 %435, %434
store i32 %436, i32* %8
%437 = load i32, i32* %10
%438 = shl i32 %437, 10
%439 = load i32, i32* %10
%440 = lshr i32 %439, 22
%441 = xor i32 %438, %440
store i32 %441, i32* %10
%442 = load i32, i32* %8
%443 = shl i32 %442, 12
%444 = load i32, i32* %8
%445 = lshr i32 %444, 20
%446 = xor i32 %443, %445
%447 = load i32, i32* %11
%448 = load i32, i32* %9
%449 = load i32, i32* %10
%450 = load i32, i32* %11
%451 = xor i32 %449, %450
%452 = and i32 %448, %451
%453 = xor i32 %447, %452
%454 = add i32 %446, %453
%455 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 7
%456 = load i32, i32* %455
%457 = add i32 %454, %456
%458 = load i32, i32* %7
%459 = add i32 %458, %457
store i32 %459, i32* %7
%460 = load i32, i32* %9
%461 = shl i32 %460, 10
%462 = load i32, i32* %9
%463 = lshr i32 %462, 22
%464 = xor i32 %461, %463
store i32 %464, i32* %9
%465 = load i32, i32* %7
%466 = shl i32 %465, 9
%467 = load i32, i32* %7
%468 = lshr i32 %467, 23
%469 = xor i32 %466, %468
%470 = load i32, i32* %10
%471 = load i32, i32* %8
%472 = load i32, i32* %9
%473 = load i32, i32* %10
%474 = xor i32 %472, %473
%475 = and i32 %471, %474
%476 = xor i32 %470, %475
%477 = add i32 %469, %476
%478 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 16
%479 = load i32, i32* %478
%480 = add i32 %477, %479
%481 = load i32, i32* %11
%482 = add i32 %481, %480
store i32 %482, i32* %11
%483 = load i32, i32* %8
%484 = shl i32 %483, 10
%485 = load i32, i32* %8
%486 = lshr i32 %485, 22
%487 = xor i32 %484, %486
store i32 %487, i32* %8
%488 = load i32, i32* %11
%489 = shl i32 %488, 11
%490 = load i32, i32* %11
%491 = lshr i32 %490, 21
%492 = xor i32 %489, %491
%493 = load i32, i32* %9
%494 = load i32, i32* %7
%495 = load i32, i32* %8
%496 = load i32, i32* %9
%497 = xor i32 %495, %496
%498 = and i32 %494, %497
%499 = xor i32 %493, %498
%500 = add i32 %492, %499
%501 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 8
%502 = load i32, i32* %501
%503 = add i32 %500, %502
%504 = load i32, i32* %10
%505 = add i32 %504, %503
store i32 %505, i32* %10
%506 = load i32, i32* %7
%507 = shl i32 %506, 10
%508 = load i32, i32* %7
%509 = lshr i32 %508, 22
%510 = xor i32 %507, %509
store i32 %510, i32* %7
%511 = load i32, i32* %10
%512 = shl i32 %511, 8
%513 = load i32, i32* %10
%514 = lshr i32 %513, 24
%515 = xor i32 %512, %514
%516 = load i32, i32* %8
%517 = load i32, i32* %11
%518 = load i32, i32* %7
%519 = load i32, i32* %8
%520 = xor i32 %518, %519
%521 = and i32 %517, %520
%522 = xor i32 %516, %521
%523 = add i32 %515, %522
%524 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 9
%525 = load i32, i32* %524
%526 = add i32 %523, %525
%527 = load i32, i32* %9
%528 = add i32 %527, %526
store i32 %528, i32* %9
%529 = load i32, i32* %11
%530 = shl i32 %529, 10
%531 = load i32, i32* %11
%532 = lshr i32 %531, 22
%533 = xor i32 %530, %532
store i32 %533, i32* %11
%534 = load i32, i32* %9
%535 = shl i32 %534, 15
%536 = load i32, i32* %9
%537 = lshr i32 %536, 17
%538 = xor i32 %535, %537
%539 = load i32, i32* %7
%540 = load i32, i32* %10
%541 = load i32, i32* %11
%542 = load i32, i32* %7
%543 = xor i32 %541, %542
%544 = and i32 %540, %543
%545 = xor i32 %539, %544
%546 = add i32 %538, %545
%547 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 10
%548 = load i32, i32* %547
%549 = add i32 %546, %548
%550 = load i32, i32* %8
%551 = add i32 %550, %549
store i32 %551, i32* %8
%552 = load i32, i32* %10
%553 = shl i32 %552, 10
%554 = load i32, i32* %10
%555 = lshr i32 %554, 22
%556 = xor i32 %553, %555
store i32 %556, i32* %10
%557 = load i32, i32* %8
%558 = shl i32 %557, 6
%559 = load i32, i32* %8
%560 = lshr i32 %559, 26
%561 = xor i32 %558, %560
%562 = load i32, i32* %11
%563 = load i32, i32* %9
%564 = load i32, i32* %10
%565 = load i32, i32* %11
%566 = xor i32 %564, %565
%567 = and i32 %563, %566
%568 = xor i32 %562, %567
%569 = add i32 %561, %568
%570 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 11
%571 = load i32, i32* %570
%572 = add i32 %569, %571
%573 = load i32, i32* %7
%574 = add i32 %573, %572
store i32 %574, i32* %7
%575 = load i32, i32* %9
%576 = shl i32 %575, 10
%577 = load i32, i32* %9
%578 = lshr i32 %577, 22
%579 = xor i32 %576, %578
store i32 %579, i32* %9
%580 = load i32, i32* %7
%581 = shl i32 %580, 12
%582 = load i32, i32* %7
%583 = lshr i32 %582, 20
%584 = xor i32 %581, %583
%585 = load i32, i32* %10
%586 = load i32, i32* %8
%587 = load i32, i32* %9
%588 = load i32, i32* %10
%589 = xor i32 %587, %588
%590 = and i32 %586, %589
%591 = xor i32 %585, %590
%592 = add i32 %584, %591
%593 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 17
%594 = load i32, i32* %593
%595 = add i32 %592, %594
%596 = load i32, i32* %11
%597 = add i32 %596, %595
store i32 %597, i32* %11
%598 = load i32, i32* %8
%599 = shl i32 %598, 10
%600 = load i32, i32* %8
%601 = lshr i32 %600, 22
%602 = xor i32 %599, %601
store i32 %602, i32* %8
%603 = load i32, i32* %11
%604 = shl i32 %603, 9
%605 = load i32, i32* %11
%606 = lshr i32 %605, 23
%607 = xor i32 %604, %606
%608 = load i32, i32* %9
%609 = load i32, i32* %7
%610 = load i32, i32* %8
%611 = load i32, i32* %9
%612 = xor i32 %610, %611
%613 = and i32 %609, %612
%614 = xor i32 %608, %613
%615 = add i32 %607, %614
%616 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 12
%617 = load i32, i32* %616
%618 = add i32 %615, %617
%619 = load i32, i32* %10
%620 = add i32 %619, %618
store i32 %620, i32* %10
%621 = load i32, i32* %7
%622 = shl i32 %621, 10
%623 = load i32, i32* %7
%624 = lshr i32 %623, 22
%625 = xor i32 %622, %624
store i32 %625, i32* %7
%626 = load i32, i32* %10
%627 = shl i32 %626, 14
%628 = load i32, i32* %10
%629 = lshr i32 %628, 18
%630 = xor i32 %627, %629
%631 = load i32, i32* %8
%632 = load i32, i32* %11
%633 = load i32, i32* %7
%634 = load i32, i32* %8
%635 = xor i32 %633, %634
%636 = and i32 %632, %635
%637 = xor i32 %631, %636
%638 = add i32 %630, %637
%639 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 13
%640 = load i32, i32* %639
%641 = add i32 %638, %640
%642 = load i32, i32* %9
%643 = add i32 %642, %641
store i32 %643, i32* %9
%644 = load i32, i32* %11
%645 = shl i32 %644, 10
%646 = load i32, i32* %11
%647 = lshr i32 %646, 22
%648 = xor i32 %645, %647
store i32 %648, i32* %11
%649 = load i32, i32* %9
%650 = shl i32 %649, 5
%651 = load i32, i32* %9
%652 = lshr i32 %651, 27
%653 = xor i32 %650, %652
%654 = load i32, i32* %7
%655 = load i32, i32* %10
%656 = load i32, i32* %11
%657 = load i32, i32* %7
%658 = xor i32 %656, %657
%659 = and i32 %655, %658
%660 = xor i32 %654, %659
%661 = add i32 %653, %660
%662 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 14
%663 = load i32, i32* %662
%664 = add i32 %661, %663
%665 = load i32, i32* %8
%666 = add i32 %665, %664
store i32 %666, i32* %8
%667 = load i32, i32* %10
%668 = shl i32 %667, 10
%669 = load i32, i32* %10
%670 = lshr i32 %669, 22
%671 = xor i32 %668, %670
store i32 %671, i32* %10
%672 = load i32, i32* %8
%673 = shl i32 %672, 13
%674 = load i32, i32* %8
%675 = lshr i32 %674, 19
%676 = xor i32 %673, %675
%677 = load i32, i32* %11
%678 = load i32, i32* %9
%679 = load i32, i32* %10
%680 = load i32, i32* %11
%681 = xor i32 %679, %680
%682 = and i32 %678, %681
%683 = xor i32 %677, %682
%684 = add i32 %676, %683
%685 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 15
%686 = load i32, i32* %685
%687 = add i32 %684, %686
%688 = load i32, i32* %7
%689 = add i32 %688, %687
store i32 %689, i32* %7
%690 = load i32, i32* %9
%691 = shl i32 %690, 10
%692 = load i32, i32* %9
%693 = lshr i32 %692, 22
%694 = xor i32 %691, %693
store i32 %694, i32* %9
%695 = load i32, i32* %7
%696 = shl i32 %695, 5
%697 = load i32, i32* %7
%698 = lshr i32 %697, 27
%699 = xor i32 %696, %698
%700 = load i32, i32* %8
%701 = load i32, i32* %9
%702 = xor i32 %700, %701
%703 = load i32, i32* %10
%704 = xor i32 %702, %703
%705 = add i32 %699, %704
%706 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 22
%707 = load i32, i32* %706
%708 = add i32 %705, %707
%709 = add i32 %708, 1518500249
%710 = load i32, i32* %11
%711 = add i32 %710, %709
store i32 %711, i32* %11
%712 = load i32, i32* %8
%713 = shl i32 %712, 17
%714 = load i32, i32* %8
%715 = lshr i32 %714, 15
%716 = xor i32 %713, %715
store i32 %716, i32* %8
%717 = load i32, i32* %11
%718 = shl i32 %717, 11
%719 = load i32, i32* %11
%720 = lshr i32 %719, 21
%721 = xor i32 %718, %720
%722 = load i32, i32* %7
%723 = load i32, i32* %8
%724 = xor i32 %722, %723
%725 = load i32, i32* %9
%726 = xor i32 %724, %725
%727 = add i32 %721, %726
%728 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 3
%729 = load i32, i32* %728
%730 = add i32 %727, %729
%731 = add i32 %730, 1518500249
%732 = load i32, i32* %10
%733 = add i32 %732, %731
store i32 %733, i32* %10
%734 = load i32, i32* %7
%735 = shl i32 %734, 17
%736 = load i32, i32* %7
%737 = lshr i32 %736, 15
%738 = xor i32 %735, %737
store i32 %738, i32* %7
%739 = load i32, i32* %10
%740 = shl i32 %739, 7
%741 = load i32, i32* %10
%742 = lshr i32 %741, 25
%743 = xor i32 %740, %742
%744 = load i32, i32* %11
%745 = load i32, i32* %7
%746 = xor i32 %744, %745
%747 = load i32, i32* %8
%748 = xor i32 %746, %747
%749 = add i32 %743, %748
%750 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 6
%751 = load i32, i32* %750
%752 = add i32 %749, %751
%753 = add i32 %752, 1518500249
%754 = load i32, i32* %9
%755 = add i32 %754, %753
store i32 %755, i32* %9
%756 = load i32, i32* %11
%757 = shl i32 %756, 17
%758 = load i32, i32* %11
%759 = lshr i32 %758, 15
%760 = xor i32 %757, %759
store i32 %760, i32* %11
%761 = load i32, i32* %9
%762 = shl i32 %761, 15
%763 = load i32, i32* %9
%764 = lshr i32 %763, 17
%765 = xor i32 %762, %764
%766 = load i32, i32* %10
%767 = load i32, i32* %11
%768 = xor i32 %766, %767
%769 = load i32, i32* %7
%770 = xor i32 %768, %769
%771 = add i32 %765, %770
%772 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 9
%773 = load i32, i32* %772
%774 = add i32 %771, %773
%775 = add i32 %774, 1518500249
%776 = load i32, i32* %8
%777 = add i32 %776, %775
store i32 %777, i32* %8
%778 = load i32, i32* %10
%779 = shl i32 %778, 17
%780 = load i32, i32* %10
%781 = lshr i32 %780, 15
%782 = xor i32 %779, %781
store i32 %782, i32* %10
%783 = load i32, i32* %8
%784 = shl i32 %783, 6
%785 = load i32, i32* %8
%786 = lshr i32 %785, 26
%787 = xor i32 %784, %786
%788 = load i32, i32* %9
%789 = load i32, i32* %10
%790 = xor i32 %788, %789
%791 = load i32, i32* %11
%792 = xor i32 %790, %791
%793 = add i32 %787, %792
%794 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 12
%795 = load i32, i32* %794
%796 = add i32 %793, %795
%797 = add i32 %796, 1518500249
%798 = load i32, i32* %7
%799 = add i32 %798, %797
store i32 %799, i32* %7
%800 = load i32, i32* %9
%801 = shl i32 %800, 17
%802 = load i32, i32* %9
%803 = lshr i32 %802, 15
%804 = xor i32 %801, %803
store i32 %804, i32* %9
%805 = load i32, i32* %7
%806 = shl i32 %805, 13
%807 = load i32, i32* %7
%808 = lshr i32 %807, 19
%809 = xor i32 %806, %808
%810 = load i32, i32* %8
%811 = load i32, i32* %9
%812 = xor i32 %810, %811
%813 = load i32, i32* %10
%814 = xor i32 %812, %813
%815 = add i32 %809, %814
%816 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 23
%817 = load i32, i32* %816
%818 = add i32 %815, %817
%819 = add i32 %818, 1518500249
%820 = load i32, i32* %11
%821 = add i32 %820, %819
store i32 %821, i32* %11
%822 = load i32, i32* %8
%823 = shl i32 %822, 17
%824 = load i32, i32* %8
%825 = lshr i32 %824, 15
%826 = xor i32 %823, %825
store i32 %826, i32* %8
%827 = load i32, i32* %11
%828 = shl i32 %827, 8
%829 = load i32, i32* %11
%830 = lshr i32 %829, 24
%831 = xor i32 %828, %830
%832 = load i32, i32* %7
%833 = load i32, i32* %8
%834 = xor i32 %832, %833
%835 = load i32, i32* %9
%836 = xor i32 %834, %835
%837 = add i32 %831, %836
%838 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 15
%839 = load i32, i32* %838
%840 = add i32 %837, %839
%841 = add i32 %840, 1518500249
%842 = load i32, i32* %10
%843 = add i32 %842, %841
store i32 %843, i32* %10
%844 = load i32, i32* %7
%845 = shl i32 %844, 17
%846 = load i32, i32* %7
%847 = lshr i32 %846, 15
%848 = xor i32 %845, %847
store i32 %848, i32* %7
%849 = load i32, i32* %10
%850 = shl i32 %849, 14
%851 = load i32, i32* %10
%852 = lshr i32 %851, 18
%853 = xor i32 %850, %852
%854 = load i32, i32* %11
%855 = load i32, i32* %7
%856 = xor i32 %854, %855
%857 = load i32, i32* %8
%858 = xor i32 %856, %857
%859 = add i32 %853, %858
%860 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 2
%861 = load i32, i32* %860
%862 = add i32 %859, %861
%863 = add i32 %862, 1518500249
%864 = load i32, i32* %9
%865 = add i32 %864, %863
store i32 %865, i32* %9
%866 = load i32, i32* %11
%867 = shl i32 %866, 17
%868 = load i32, i32* %11
%869 = lshr i32 %868, 15
%870 = xor i32 %867, %869
store i32 %870, i32* %11
%871 = load i32, i32* %9
%872 = shl i32 %871, 7
%873 = load i32, i32* %9
%874 = lshr i32 %873, 25
%875 = xor i32 %872, %874
%876 = load i32, i32* %10
%877 = load i32, i32* %11
%878 = xor i32 %876, %877
%879 = load i32, i32* %7
%880 = xor i32 %878, %879
%881 = add i32 %875, %880
%882 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 5
%883 = load i32, i32* %882
%884 = add i32 %881, %883
%885 = add i32 %884, 1518500249
%886 = load i32, i32* %8
%887 = add i32 %886, %885
store i32 %887, i32* %8
%888 = load i32, i32* %10
%889 = shl i32 %888, 17
%890 = load i32, i32* %10
%891 = lshr i32 %890, 15
%892 = xor i32 %889, %891
store i32 %892, i32* %10
%893 = load i32, i32* %8
%894 = shl i32 %893, 12
%895 = load i32, i32* %8
%896 = lshr i32 %895, 20
%897 = xor i32 %894, %896
%898 = load i32, i32* %9
%899 = load i32, i32* %10
%900 = xor i32 %898, %899
%901 = load i32, i32* %11
%902 = xor i32 %900, %901
%903 = add i32 %897, %902
%904 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 8
%905 = load i32, i32* %904
%906 = add i32 %903, %905
%907 = add i32 %906, 1518500249
%908 = load i32, i32* %7
%909 = add i32 %908, %907
store i32 %909, i32* %7
%910 = load i32, i32* %9
%911 = shl i32 %910, 17
%912 = load i32, i32* %9
%913 = lshr i32 %912, 15
%914 = xor i32 %911, %913
store i32 %914, i32* %9
%915 = load i32, i32* %7
%916 = shl i32 %915, 9
%917 = load i32, i32* %7
%918 = lshr i32 %917, 23
%919 = xor i32 %916, %918
%920 = load i32, i32* %8
%921 = load i32, i32* %9
%922 = xor i32 %920, %921
%923 = load i32, i32* %10
%924 = xor i32 %922, %923
%925 = add i32 %919, %924
%926 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 20
%927 = load i32, i32* %926
%928 = add i32 %925, %927
%929 = add i32 %928, 1518500249
%930 = load i32, i32* %11
%931 = add i32 %930, %929
store i32 %931, i32* %11
%932 = load i32, i32* %8
%933 = shl i32 %932, 17
%934 = load i32, i32* %8
%935 = lshr i32 %934, 15
%936 = xor i32 %933, %935
store i32 %936, i32* %8
%937 = load i32, i32* %11
%938 = shl i32 %937, 11
%939 = load i32, i32* %11
%940 = lshr i32 %939, 21
%941 = xor i32 %938, %940
%942 = load i32, i32* %7
%943 = load i32, i32* %8
%944 = xor i32 %942, %943
%945 = load i32, i32* %9
%946 = xor i32 %944, %945
%947 = add i32 %941, %946
%948 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 11
%949 = load i32, i32* %948
%950 = add i32 %947, %949
%951 = add i32 %950, 1518500249
%952 = load i32, i32* %10
%953 = add i32 %952, %951
store i32 %953, i32* %10
%954 = load i32, i32* %7
%955 = shl i32 %954, 17
%956 = load i32, i32* %7
%957 = lshr i32 %956, 15
%958 = xor i32 %955, %957
store i32 %958, i32* %7
%959 = load i32, i32* %10
%960 = shl i32 %959, 8
%961 = load i32, i32* %10
%962 = lshr i32 %961, 24
%963 = xor i32 %960, %962
%964 = load i32, i32* %11
%965 = load i32, i32* %7
%966 = xor i32 %964, %965
%967 = load i32, i32* %8
%968 = xor i32 %966, %967
%969 = add i32 %963, %968
%970 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 14
%971 = load i32, i32* %970
%972 = add i32 %969, %971
%973 = add i32 %972, 1518500249
%974 = load i32, i32* %9
%975 = add i32 %974, %973
store i32 %975, i32* %9
%976 = load i32, i32* %11
%977 = shl i32 %976, 17
%978 = load i32, i32* %11
%979 = lshr i32 %978, 15
%980 = xor i32 %977, %979
store i32 %980, i32* %11
%981 = load i32, i32* %9
%982 = shl i32 %981, 15
%983 = load i32, i32* %9
%984 = lshr i32 %983, 17
%985 = xor i32 %982, %984
%986 = load i32, i32* %10
%987 = load i32, i32* %11
%988 = xor i32 %986, %987
%989 = load i32, i32* %7
%990 = xor i32 %988, %989
%991 = add i32 %985, %990
%992 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%993 = load i32, i32* %992
%994 = add i32 %991, %993
%995 = add i32 %994, 1518500249
%996 = load i32, i32* %8
%997 = add i32 %996, %995
store i32 %997, i32* %8
%998 = load i32, i32* %10
%999 = shl i32 %998, 17
%1000 = load i32, i32* %10
%1001 = lshr i32 %1000, 15
%1002 = xor i32 %999, %1001
store i32 %1002, i32* %10
%1003 = load i32, i32* %8
%1004 = shl i32 %1003, 6
%1005 = load i32, i32* %8
%1006 = lshr i32 %1005, 26
%1007 = xor i32 %1004, %1006
%1008 = load i32, i32* %9
%1009 = load i32, i32* %10
%1010 = xor i32 %1008, %1009
%1011 = load i32, i32* %11
%1012 = xor i32 %1010, %1011
%1013 = add i32 %1007, %1012
%1014 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 4
%1015 = load i32, i32* %1014
%1016 = add i32 %1013, %1015
%1017 = add i32 %1016, 1518500249
%1018 = load i32, i32* %7
%1019 = add i32 %1018, %1017
store i32 %1019, i32* %7
%1020 = load i32, i32* %9
%1021 = shl i32 %1020, 17
%1022 = load i32, i32* %9
%1023 = lshr i32 %1022, 15
%1024 = xor i32 %1021, %1023
store i32 %1024, i32* %9
%1025 = load i32, i32* %7
%1026 = shl i32 %1025, 12
%1027 = load i32, i32* %7
%1028 = lshr i32 %1027, 20
%1029 = xor i32 %1026, %1028
%1030 = load i32, i32* %8
%1031 = load i32, i32* %9
%1032 = xor i32 %1030, %1031
%1033 = load i32, i32* %10
%1034 = xor i32 %1032, %1033
%1035 = add i32 %1029, %1034
%1036 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 21
%1037 = load i32, i32* %1036
%1038 = add i32 %1035, %1037
%1039 = add i32 %1038, 1518500249
%1040 = load i32, i32* %11
%1041 = add i32 %1040, %1039
store i32 %1041, i32* %11
%1042 = load i32, i32* %8
%1043 = shl i32 %1042, 17
%1044 = load i32, i32* %8
%1045 = lshr i32 %1044, 15
%1046 = xor i32 %1043, %1045
store i32 %1046, i32* %8
%1047 = load i32, i32* %11
%1048 = shl i32 %1047, 9
%1049 = load i32, i32* %11
%1050 = lshr i32 %1049, 23
%1051 = xor i32 %1048, %1050
%1052 = load i32, i32* %7
%1053 = load i32, i32* %8
%1054 = xor i32 %1052, %1053
%1055 = load i32, i32* %9
%1056 = xor i32 %1054, %1055
%1057 = add i32 %1051, %1056
%1058 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 7
%1059 = load i32, i32* %1058
%1060 = add i32 %1057, %1059
%1061 = add i32 %1060, 1518500249
%1062 = load i32, i32* %10
%1063 = add i32 %1062, %1061
store i32 %1063, i32* %10
%1064 = load i32, i32* %7
%1065 = shl i32 %1064, 17
%1066 = load i32, i32* %7
%1067 = lshr i32 %1066, 15
%1068 = xor i32 %1065, %1067
store i32 %1068, i32* %7
%1069 = load i32, i32* %10
%1070 = shl i32 %1069, 14
%1071 = load i32, i32* %10
%1072 = lshr i32 %1071, 18
%1073 = xor i32 %1070, %1072
%1074 = load i32, i32* %11
%1075 = load i32, i32* %7
%1076 = xor i32 %1074, %1075
%1077 = load i32, i32* %8
%1078 = xor i32 %1076, %1077
%1079 = add i32 %1073, %1078
%1080 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 10
%1081 = load i32, i32* %1080
%1082 = add i32 %1079, %1081
%1083 = add i32 %1082, 1518500249
%1084 = load i32, i32* %9
%1085 = add i32 %1084, %1083
store i32 %1085, i32* %9
%1086 = load i32, i32* %11
%1087 = shl i32 %1086, 17
%1088 = load i32, i32* %11
%1089 = lshr i32 %1088, 15
%1090 = xor i32 %1087, %1089
store i32 %1090, i32* %11
%1091 = load i32, i32* %9
%1092 = shl i32 %1091, 5
%1093 = load i32, i32* %9
%1094 = lshr i32 %1093, 27
%1095 = xor i32 %1092, %1094
%1096 = load i32, i32* %10
%1097 = load i32, i32* %11
%1098 = xor i32 %1096, %1097
%1099 = load i32, i32* %7
%1100 = xor i32 %1098, %1099
%1101 = add i32 %1095, %1100
%1102 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 13
%1103 = load i32, i32* %1102
%1104 = add i32 %1101, %1103
%1105 = add i32 %1104, 1518500249
%1106 = load i32, i32* %8
%1107 = add i32 %1106, %1105
store i32 %1107, i32* %8
%1108 = load i32, i32* %10
%1109 = shl i32 %1108, 17
%1110 = load i32, i32* %10
%1111 = lshr i32 %1110, 15
%1112 = xor i32 %1109, %1111
store i32 %1112, i32* %10
%1113 = load i32, i32* %8
%1114 = shl i32 %1113, 13
%1115 = load i32, i32* %8
%1116 = lshr i32 %1115, 19
%1117 = xor i32 %1114, %1116
%1118 = load i32, i32* %9
%1119 = load i32, i32* %10
%1120 = xor i32 %1118, %1119
%1121 = load i32, i32* %11
%1122 = xor i32 %1120, %1121
%1123 = add i32 %1117, %1122
%1124 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%1125 = load i32, i32* %1124
%1126 = add i32 %1123, %1125
%1127 = add i32 %1126, 1518500249
%1128 = load i32, i32* %7
%1129 = add i32 %1128, %1127
store i32 %1129, i32* %7
%1130 = load i32, i32* %9
%1131 = shl i32 %1130, 17
%1132 = load i32, i32* %9
%1133 = lshr i32 %1132, 15
%1134 = xor i32 %1131, %1133
store i32 %1134, i32* %9
%1135 = load i32, i32* %7
%1136 = shl i32 %1135, 5
%1137 = load i32, i32* %7
%1138 = lshr i32 %1137, 27
%1139 = xor i32 %1136, %1138
%1140 = load i32, i32* %9
%1141 = load i32, i32* %8
%1142 = load i32, i32* %10
%1143 = xor i32 %1142, -1
%1144 = or i32 %1141, %1143
%1145 = xor i32 %1140, %1144
%1146 = add i32 %1139, %1145
%1147 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 26
%1148 = load i32, i32* %1147
%1149 = add i32 %1146, %1148
%1150 = add i32 %1149, 1859775393
%1151 = load i32, i32* %11
%1152 = add i32 %1151, %1150
store i32 %1152, i32* %11
%1153 = load i32, i32* %8
%1154 = shl i32 %1153, 25
%1155 = load i32, i32* %8
%1156 = lshr i32 %1155, 7
%1157 = xor i32 %1154, %1156
store i32 %1157, i32* %8
%1158 = load i32, i32* %11
%1159 = shl i32 %1158, 11
%1160 = load i32, i32* %11
%1161 = lshr i32 %1160, 21
%1162 = xor i32 %1159, %1161
%1163 = load i32, i32* %8
%1164 = load i32, i32* %7
%1165 = load i32, i32* %9
%1166 = xor i32 %1165, -1
%1167 = or i32 %1164, %1166
%1168 = xor i32 %1163, %1167
%1169 = add i32 %1162, %1168
%1170 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 12
%1171 = load i32, i32* %1170
%1172 = add i32 %1169, %1171
%1173 = add i32 %1172, 1859775393
%1174 = load i32, i32* %10
%1175 = add i32 %1174, %1173
store i32 %1175, i32* %10
%1176 = load i32, i32* %7
%1177 = shl i32 %1176, 25
%1178 = load i32, i32* %7
%1179 = lshr i32 %1178, 7
%1180 = xor i32 %1177, %1179
store i32 %1180, i32* %7
%1181 = load i32, i32* %10
%1182 = shl i32 %1181, 7
%1183 = load i32, i32* %10
%1184 = lshr i32 %1183, 25
%1185 = xor i32 %1182, %1184
%1186 = load i32, i32* %7
%1187 = load i32, i32* %11
%1188 = load i32, i32* %8
%1189 = xor i32 %1188, -1
%1190 = or i32 %1187, %1189
%1191 = xor i32 %1186, %1190
%1192 = add i32 %1185, %1191
%1193 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 5
%1194 = load i32, i32* %1193
%1195 = add i32 %1192, %1194
%1196 = add i32 %1195, 1859775393
%1197 = load i32, i32* %9
%1198 = add i32 %1197, %1196
store i32 %1198, i32* %9
%1199 = load i32, i32* %11
%1200 = shl i32 %1199, 25
%1201 = load i32, i32* %11
%1202 = lshr i32 %1201, 7
%1203 = xor i32 %1200, %1202
store i32 %1203, i32* %11
%1204 = load i32, i32* %9
%1205 = shl i32 %1204, 15
%1206 = load i32, i32* %9
%1207 = lshr i32 %1206, 17
%1208 = xor i32 %1205, %1207
%1209 = load i32, i32* %11
%1210 = load i32, i32* %10
%1211 = load i32, i32* %7
%1212 = xor i32 %1211, -1
%1213 = or i32 %1210, %1212
%1214 = xor i32 %1209, %1213
%1215 = add i32 %1208, %1214
%1216 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 14
%1217 = load i32, i32* %1216
%1218 = add i32 %1215, %1217
%1219 = add i32 %1218, 1859775393
%1220 = load i32, i32* %8
%1221 = add i32 %1220, %1219
store i32 %1221, i32* %8
%1222 = load i32, i32* %10
%1223 = shl i32 %1222, 25
%1224 = load i32, i32* %10
%1225 = lshr i32 %1224, 7
%1226 = xor i32 %1223, %1225
store i32 %1226, i32* %10
%1227 = load i32, i32* %8
%1228 = shl i32 %1227, 6
%1229 = load i32, i32* %8
%1230 = lshr i32 %1229, 26
%1231 = xor i32 %1228, %1230
%1232 = load i32, i32* %10
%1233 = load i32, i32* %9
%1234 = load i32, i32* %11
%1235 = xor i32 %1234, -1
%1236 = or i32 %1233, %1235
%1237 = xor i32 %1232, %1236
%1238 = add i32 %1231, %1237
%1239 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 7
%1240 = load i32, i32* %1239
%1241 = add i32 %1238, %1240
%1242 = add i32 %1241, 1859775393
%1243 = load i32, i32* %7
%1244 = add i32 %1243, %1242
store i32 %1244, i32* %7
%1245 = load i32, i32* %9
%1246 = shl i32 %1245, 25
%1247 = load i32, i32* %9
%1248 = lshr i32 %1247, 7
%1249 = xor i32 %1246, %1248
store i32 %1249, i32* %9
%1250 = load i32, i32* %7
%1251 = shl i32 %1250, 13
%1252 = load i32, i32* %7
%1253 = lshr i32 %1252, 19
%1254 = xor i32 %1251, %1253
%1255 = load i32, i32* %9
%1256 = load i32, i32* %8
%1257 = load i32, i32* %10
%1258 = xor i32 %1257, -1
%1259 = or i32 %1256, %1258
%1260 = xor i32 %1255, %1259
%1261 = add i32 %1254, %1260
%1262 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 27
%1263 = load i32, i32* %1262
%1264 = add i32 %1261, %1263
%1265 = add i32 %1264, 1859775393
%1266 = load i32, i32* %11
%1267 = add i32 %1266, %1265
store i32 %1267, i32* %11
%1268 = load i32, i32* %8
%1269 = shl i32 %1268, 25
%1270 = load i32, i32* %8
%1271 = lshr i32 %1270, 7
%1272 = xor i32 %1269, %1271
store i32 %1272, i32* %8
%1273 = load i32, i32* %11
%1274 = shl i32 %1273, 8
%1275 = load i32, i32* %11
%1276 = lshr i32 %1275, 24
%1277 = xor i32 %1274, %1276
%1278 = load i32, i32* %8
%1279 = load i32, i32* %7
%1280 = load i32, i32* %9
%1281 = xor i32 %1280, -1
%1282 = or i32 %1279, %1281
%1283 = xor i32 %1278, %1282
%1284 = add i32 %1277, %1283
%1285 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%1286 = load i32, i32* %1285
%1287 = add i32 %1284, %1286
%1288 = add i32 %1287, 1859775393
%1289 = load i32, i32* %10
%1290 = add i32 %1289, %1288
store i32 %1290, i32* %10
%1291 = load i32, i32* %7
%1292 = shl i32 %1291, 25
%1293 = load i32, i32* %7
%1294 = lshr i32 %1293, 7
%1295 = xor i32 %1292, %1294
store i32 %1295, i32* %7
%1296 = load i32, i32* %10
%1297 = shl i32 %1296, 14
%1298 = load i32, i32* %10
%1299 = lshr i32 %1298, 18
%1300 = xor i32 %1297, %1299
%1301 = load i32, i32* %7
%1302 = load i32, i32* %11
%1303 = load i32, i32* %8
%1304 = xor i32 %1303, -1
%1305 = or i32 %1302, %1304
%1306 = xor i32 %1301, %1305
%1307 = add i32 %1300, %1306
%1308 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 9
%1309 = load i32, i32* %1308
%1310 = add i32 %1307, %1309
%1311 = add i32 %1310, 1859775393
%1312 = load i32, i32* %9
%1313 = add i32 %1312, %1311
store i32 %1313, i32* %9
%1314 = load i32, i32* %11
%1315 = shl i32 %1314, 25
%1316 = load i32, i32* %11
%1317 = lshr i32 %1316, 7
%1318 = xor i32 %1315, %1317
store i32 %1318, i32* %11
%1319 = load i32, i32* %9
%1320 = shl i32 %1319, 7
%1321 = load i32, i32* %9
%1322 = lshr i32 %1321, 25
%1323 = xor i32 %1320, %1322
%1324 = load i32, i32* %11
%1325 = load i32, i32* %10
%1326 = load i32, i32* %7
%1327 = xor i32 %1326, -1
%1328 = or i32 %1325, %1327
%1329 = xor i32 %1324, %1328
%1330 = add i32 %1323, %1329
%1331 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 2
%1332 = load i32, i32* %1331
%1333 = add i32 %1330, %1332
%1334 = add i32 %1333, 1859775393
%1335 = load i32, i32* %8
%1336 = add i32 %1335, %1334
store i32 %1336, i32* %8
%1337 = load i32, i32* %10
%1338 = shl i32 %1337, 25
%1339 = load i32, i32* %10
%1340 = lshr i32 %1339, 7
%1341 = xor i32 %1338, %1340
store i32 %1341, i32* %10
%1342 = load i32, i32* %8
%1343 = shl i32 %1342, 12
%1344 = load i32, i32* %8
%1345 = lshr i32 %1344, 20
%1346 = xor i32 %1343, %1345
%1347 = load i32, i32* %10
%1348 = load i32, i32* %9
%1349 = load i32, i32* %11
%1350 = xor i32 %1349, -1
%1351 = or i32 %1348, %1350
%1352 = xor i32 %1347, %1351
%1353 = add i32 %1346, %1352
%1354 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 11
%1355 = load i32, i32* %1354
%1356 = add i32 %1353, %1355
%1357 = add i32 %1356, 1859775393
%1358 = load i32, i32* %7
%1359 = add i32 %1358, %1357
store i32 %1359, i32* %7
%1360 = load i32, i32* %9
%1361 = shl i32 %1360, 25
%1362 = load i32, i32* %9
%1363 = lshr i32 %1362, 7
%1364 = xor i32 %1361, %1363
store i32 %1364, i32* %9
%1365 = load i32, i32* %7
%1366 = shl i32 %1365, 9
%1367 = load i32, i32* %7
%1368 = lshr i32 %1367, 23
%1369 = xor i32 %1366, %1368
%1370 = load i32, i32* %9
%1371 = load i32, i32* %8
%1372 = load i32, i32* %10
%1373 = xor i32 %1372, -1
%1374 = or i32 %1371, %1373
%1375 = xor i32 %1370, %1374
%1376 = add i32 %1369, %1375
%1377 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 24
%1378 = load i32, i32* %1377
%1379 = add i32 %1376, %1378
%1380 = add i32 %1379, 1859775393
%1381 = load i32, i32* %11
%1382 = add i32 %1381, %1380
store i32 %1382, i32* %11
%1383 = load i32, i32* %8
%1384 = shl i32 %1383, 25
%1385 = load i32, i32* %8
%1386 = lshr i32 %1385, 7
%1387 = xor i32 %1384, %1386
store i32 %1387, i32* %8
%1388 = load i32, i32* %11
%1389 = shl i32 %1388, 11
%1390 = load i32, i32* %11
%1391 = lshr i32 %1390, 21
%1392 = xor i32 %1389, %1391
%1393 = load i32, i32* %8
%1394 = load i32, i32* %7
%1395 = load i32, i32* %9
%1396 = xor i32 %1395, -1
%1397 = or i32 %1394, %1396
%1398 = xor i32 %1393, %1397
%1399 = add i32 %1392, %1398
%1400 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 4
%1401 = load i32, i32* %1400
%1402 = add i32 %1399, %1401
%1403 = add i32 %1402, 1859775393
%1404 = load i32, i32* %10
%1405 = add i32 %1404, %1403
store i32 %1405, i32* %10
%1406 = load i32, i32* %7
%1407 = shl i32 %1406, 25
%1408 = load i32, i32* %7
%1409 = lshr i32 %1408, 7
%1410 = xor i32 %1407, %1409
store i32 %1410, i32* %7
%1411 = load i32, i32* %10
%1412 = shl i32 %1411, 8
%1413 = load i32, i32* %10
%1414 = lshr i32 %1413, 24
%1415 = xor i32 %1412, %1414
%1416 = load i32, i32* %7
%1417 = load i32, i32* %11
%1418 = load i32, i32* %8
%1419 = xor i32 %1418, -1
%1420 = or i32 %1417, %1419
%1421 = xor i32 %1416, %1420
%1422 = add i32 %1415, %1421
%1423 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 13
%1424 = load i32, i32* %1423
%1425 = add i32 %1422, %1424
%1426 = add i32 %1425, 1859775393
%1427 = load i32, i32* %9
%1428 = add i32 %1427, %1426
store i32 %1428, i32* %9
%1429 = load i32, i32* %11
%1430 = shl i32 %1429, 25
%1431 = load i32, i32* %11
%1432 = lshr i32 %1431, 7
%1433 = xor i32 %1430, %1432
store i32 %1433, i32* %11
%1434 = load i32, i32* %9
%1435 = shl i32 %1434, 15
%1436 = load i32, i32* %9
%1437 = lshr i32 %1436, 17
%1438 = xor i32 %1435, %1437
%1439 = load i32, i32* %11
%1440 = load i32, i32* %10
%1441 = load i32, i32* %7
%1442 = xor i32 %1441, -1
%1443 = or i32 %1440, %1442
%1444 = xor i32 %1439, %1443
%1445 = add i32 %1438, %1444
%1446 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 6
%1447 = load i32, i32* %1446
%1448 = add i32 %1445, %1447
%1449 = add i32 %1448, 1859775393
%1450 = load i32, i32* %8
%1451 = add i32 %1450, %1449
store i32 %1451, i32* %8
%1452 = load i32, i32* %10
%1453 = shl i32 %1452, 25
%1454 = load i32, i32* %10
%1455 = lshr i32 %1454, 7
%1456 = xor i32 %1453, %1455
store i32 %1456, i32* %10
%1457 = load i32, i32* %8
%1458 = shl i32 %1457, 6
%1459 = load i32, i32* %8
%1460 = lshr i32 %1459, 26
%1461 = xor i32 %1458, %1460
%1462 = load i32, i32* %10
%1463 = load i32, i32* %9
%1464 = load i32, i32* %11
%1465 = xor i32 %1464, -1
%1466 = or i32 %1463, %1465
%1467 = xor i32 %1462, %1466
%1468 = add i32 %1461, %1467
%1469 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 15
%1470 = load i32, i32* %1469
%1471 = add i32 %1468, %1470
%1472 = add i32 %1471, 1859775393
%1473 = load i32, i32* %7
%1474 = add i32 %1473, %1472
store i32 %1474, i32* %7
%1475 = load i32, i32* %9
%1476 = shl i32 %1475, 25
%1477 = load i32, i32* %9
%1478 = lshr i32 %1477, 7
%1479 = xor i32 %1476, %1478
store i32 %1479, i32* %9
%1480 = load i32, i32* %7
%1481 = shl i32 %1480, 12
%1482 = load i32, i32* %7
%1483 = lshr i32 %1482, 20
%1484 = xor i32 %1481, %1483
%1485 = load i32, i32* %9
%1486 = load i32, i32* %8
%1487 = load i32, i32* %10
%1488 = xor i32 %1487, -1
%1489 = or i32 %1486, %1488
%1490 = xor i32 %1485, %1489
%1491 = add i32 %1484, %1490
%1492 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 25
%1493 = load i32, i32* %1492
%1494 = add i32 %1491, %1493
%1495 = add i32 %1494, 1859775393
%1496 = load i32, i32* %11
%1497 = add i32 %1496, %1495
store i32 %1497, i32* %11
%1498 = load i32, i32* %8
%1499 = shl i32 %1498, 25
%1500 = load i32, i32* %8
%1501 = lshr i32 %1500, 7
%1502 = xor i32 %1499, %1501
store i32 %1502, i32* %8
%1503 = load i32, i32* %11
%1504 = shl i32 %1503, 9
%1505 = load i32, i32* %11
%1506 = lshr i32 %1505, 23
%1507 = xor i32 %1504, %1506
%1508 = load i32, i32* %8
%1509 = load i32, i32* %7
%1510 = load i32, i32* %9
%1511 = xor i32 %1510, -1
%1512 = or i32 %1509, %1511
%1513 = xor i32 %1508, %1512
%1514 = add i32 %1507, %1513
%1515 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 8
%1516 = load i32, i32* %1515
%1517 = add i32 %1514, %1516
%1518 = add i32 %1517, 1859775393
%1519 = load i32, i32* %10
%1520 = add i32 %1519, %1518
store i32 %1520, i32* %10
%1521 = load i32, i32* %7
%1522 = shl i32 %1521, 25
%1523 = load i32, i32* %7
%1524 = lshr i32 %1523, 7
%1525 = xor i32 %1522, %1524
store i32 %1525, i32* %7
%1526 = load i32, i32* %10
%1527 = shl i32 %1526, 14
%1528 = load i32, i32* %10
%1529 = lshr i32 %1528, 18
%1530 = xor i32 %1527, %1529
%1531 = load i32, i32* %7
%1532 = load i32, i32* %11
%1533 = load i32, i32* %8
%1534 = xor i32 %1533, -1
%1535 = or i32 %1532, %1534
%1536 = xor i32 %1531, %1535
%1537 = add i32 %1530, %1536
%1538 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%1539 = load i32, i32* %1538
%1540 = add i32 %1537, %1539
%1541 = add i32 %1540, 1859775393
%1542 = load i32, i32* %9
%1543 = add i32 %1542, %1541
store i32 %1543, i32* %9
%1544 = load i32, i32* %11
%1545 = shl i32 %1544, 25
%1546 = load i32, i32* %11
%1547 = lshr i32 %1546, 7
%1548 = xor i32 %1545, %1547
store i32 %1548, i32* %11
%1549 = load i32, i32* %9
%1550 = shl i32 %1549, 5
%1551 = load i32, i32* %9
%1552 = lshr i32 %1551, 27
%1553 = xor i32 %1550, %1552
%1554 = load i32, i32* %11
%1555 = load i32, i32* %10
%1556 = load i32, i32* %7
%1557 = xor i32 %1556, -1
%1558 = or i32 %1555, %1557
%1559 = xor i32 %1554, %1558
%1560 = add i32 %1553, %1559
%1561 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 10
%1562 = load i32, i32* %1561
%1563 = add i32 %1560, %1562
%1564 = add i32 %1563, 1859775393
%1565 = load i32, i32* %8
%1566 = add i32 %1565, %1564
store i32 %1566, i32* %8
%1567 = load i32, i32* %10
%1568 = shl i32 %1567, 25
%1569 = load i32, i32* %10
%1570 = lshr i32 %1569, 7
%1571 = xor i32 %1568, %1570
store i32 %1571, i32* %10
%1572 = load i32, i32* %8
%1573 = shl i32 %1572, 13
%1574 = load i32, i32* %8
%1575 = lshr i32 %1574, 19
%1576 = xor i32 %1573, %1575
%1577 = load i32, i32* %10
%1578 = load i32, i32* %9
%1579 = load i32, i32* %11
%1580 = xor i32 %1579, -1
%1581 = or i32 %1578, %1580
%1582 = xor i32 %1577, %1581
%1583 = add i32 %1576, %1582
%1584 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 3
%1585 = load i32, i32* %1584
%1586 = add i32 %1583, %1585
%1587 = add i32 %1586, 1859775393
%1588 = load i32, i32* %7
%1589 = add i32 %1588, %1587
store i32 %1589, i32* %7
%1590 = load i32, i32* %9
%1591 = shl i32 %1590, 25
%1592 = load i32, i32* %9
%1593 = lshr i32 %1592, 7
%1594 = xor i32 %1591, %1593
store i32 %1594, i32* %9
%1595 = load i32, i32* %7
%1596 = shl i32 %1595, 5
%1597 = load i32, i32* %7
%1598 = lshr i32 %1597, 27
%1599 = xor i32 %1596, %1598
%1600 = load i32, i32* %8
%1601 = load i32, i32* %9
%1602 = xor i32 %1600, %1601
%1603 = load i32, i32* %10
%1604 = xor i32 %1602, %1603
%1605 = add i32 %1599, %1604
%1606 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 30
%1607 = load i32, i32* %1606
%1608 = add i32 %1605, %1607
%1609 = add i32 %1608, -1894007588
%1610 = load i32, i32* %11
%1611 = add i32 %1610, %1609
store i32 %1611, i32* %11
%1612 = load i32, i32* %8
%1613 = shl i32 %1612, 30
%1614 = load i32, i32* %8
%1615 = lshr i32 %1614, 2
%1616 = xor i32 %1613, %1615
store i32 %1616, i32* %8
%1617 = load i32, i32* %11
%1618 = shl i32 %1617, 11
%1619 = load i32, i32* %11
%1620 = lshr i32 %1619, 21
%1621 = xor i32 %1618, %1620
%1622 = load i32, i32* %7
%1623 = load i32, i32* %8
%1624 = xor i32 %1622, %1623
%1625 = load i32, i32* %9
%1626 = xor i32 %1624, %1625
%1627 = add i32 %1621, %1626
%1628 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 7
%1629 = load i32, i32* %1628
%1630 = add i32 %1627, %1629
%1631 = add i32 %1630, -1894007588
%1632 = load i32, i32* %10
%1633 = add i32 %1632, %1631
store i32 %1633, i32* %10
%1634 = load i32, i32* %7
%1635 = shl i32 %1634, 30
%1636 = load i32, i32* %7
%1637 = lshr i32 %1636, 2
%1638 = xor i32 %1635, %1637
store i32 %1638, i32* %7
%1639 = load i32, i32* %10
%1640 = shl i32 %1639, 7
%1641 = load i32, i32* %10
%1642 = lshr i32 %1641, 25
%1643 = xor i32 %1640, %1642
%1644 = load i32, i32* %11
%1645 = load i32, i32* %7
%1646 = xor i32 %1644, %1645
%1647 = load i32, i32* %8
%1648 = xor i32 %1646, %1647
%1649 = add i32 %1643, %1648
%1650 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 2
%1651 = load i32, i32* %1650
%1652 = add i32 %1649, %1651
%1653 = add i32 %1652, -1894007588
%1654 = load i32, i32* %9
%1655 = add i32 %1654, %1653
store i32 %1655, i32* %9
%1656 = load i32, i32* %11
%1657 = shl i32 %1656, 30
%1658 = load i32, i32* %11
%1659 = lshr i32 %1658, 2
%1660 = xor i32 %1657, %1659
store i32 %1660, i32* %11
%1661 = load i32, i32* %9
%1662 = shl i32 %1661, 15
%1663 = load i32, i32* %9
%1664 = lshr i32 %1663, 17
%1665 = xor i32 %1662, %1664
%1666 = load i32, i32* %10
%1667 = load i32, i32* %11
%1668 = xor i32 %1666, %1667
%1669 = load i32, i32* %7
%1670 = xor i32 %1668, %1669
%1671 = add i32 %1665, %1670
%1672 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 13
%1673 = load i32, i32* %1672
%1674 = add i32 %1671, %1673
%1675 = add i32 %1674, -1894007588
%1676 = load i32, i32* %8
%1677 = add i32 %1676, %1675
store i32 %1677, i32* %8
%1678 = load i32, i32* %10
%1679 = shl i32 %1678, 30
%1680 = load i32, i32* %10
%1681 = lshr i32 %1680, 2
%1682 = xor i32 %1679, %1681
store i32 %1682, i32* %10
%1683 = load i32, i32* %8
%1684 = shl i32 %1683, 6
%1685 = load i32, i32* %8
%1686 = lshr i32 %1685, 26
%1687 = xor i32 %1684, %1686
%1688 = load i32, i32* %9
%1689 = load i32, i32* %10
%1690 = xor i32 %1688, %1689
%1691 = load i32, i32* %11
%1692 = xor i32 %1690, %1691
%1693 = add i32 %1687, %1692
%1694 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 8
%1695 = load i32, i32* %1694
%1696 = add i32 %1693, %1695
%1697 = add i32 %1696, -1894007588
%1698 = load i32, i32* %7
%1699 = add i32 %1698, %1697
store i32 %1699, i32* %7
%1700 = load i32, i32* %9
%1701 = shl i32 %1700, 30
%1702 = load i32, i32* %9
%1703 = lshr i32 %1702, 2
%1704 = xor i32 %1701, %1703
store i32 %1704, i32* %9
%1705 = load i32, i32* %7
%1706 = shl i32 %1705, 13
%1707 = load i32, i32* %7
%1708 = lshr i32 %1707, 19
%1709 = xor i32 %1706, %1708
%1710 = load i32, i32* %8
%1711 = load i32, i32* %9
%1712 = xor i32 %1710, %1711
%1713 = load i32, i32* %10
%1714 = xor i32 %1712, %1713
%1715 = add i32 %1709, %1714
%1716 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 31
%1717 = load i32, i32* %1716
%1718 = add i32 %1715, %1717
%1719 = add i32 %1718, -1894007588
%1720 = load i32, i32* %11
%1721 = add i32 %1720, %1719
store i32 %1721, i32* %11
%1722 = load i32, i32* %8
%1723 = shl i32 %1722, 30
%1724 = load i32, i32* %8
%1725 = lshr i32 %1724, 2
%1726 = xor i32 %1723, %1725
store i32 %1726, i32* %8
%1727 = load i32, i32* %11
%1728 = shl i32 %1727, 8
%1729 = load i32, i32* %11
%1730 = lshr i32 %1729, 24
%1731 = xor i32 %1728, %1730
%1732 = load i32, i32* %7
%1733 = load i32, i32* %8
%1734 = xor i32 %1732, %1733
%1735 = load i32, i32* %9
%1736 = xor i32 %1734, %1735
%1737 = add i32 %1731, %1736
%1738 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 3
%1739 = load i32, i32* %1738
%1740 = add i32 %1737, %1739
%1741 = add i32 %1740, -1894007588
%1742 = load i32, i32* %10
%1743 = add i32 %1742, %1741
store i32 %1743, i32* %10
%1744 = load i32, i32* %7
%1745 = shl i32 %1744, 30
%1746 = load i32, i32* %7
%1747 = lshr i32 %1746, 2
%1748 = xor i32 %1745, %1747
store i32 %1748, i32* %7
%1749 = load i32, i32* %10
%1750 = shl i32 %1749, 14
%1751 = load i32, i32* %10
%1752 = lshr i32 %1751, 18
%1753 = xor i32 %1750, %1752
%1754 = load i32, i32* %11
%1755 = load i32, i32* %7
%1756 = xor i32 %1754, %1755
%1757 = load i32, i32* %8
%1758 = xor i32 %1756, %1757
%1759 = add i32 %1753, %1758
%1760 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 14
%1761 = load i32, i32* %1760
%1762 = add i32 %1759, %1761
%1763 = add i32 %1762, -1894007588
%1764 = load i32, i32* %9
%1765 = add i32 %1764, %1763
store i32 %1765, i32* %9
%1766 = load i32, i32* %11
%1767 = shl i32 %1766, 30
%1768 = load i32, i32* %11
%1769 = lshr i32 %1768, 2
%1770 = xor i32 %1767, %1769
store i32 %1770, i32* %11
%1771 = load i32, i32* %9
%1772 = shl i32 %1771, 7
%1773 = load i32, i32* %9
%1774 = lshr i32 %1773, 25
%1775 = xor i32 %1772, %1774
%1776 = load i32, i32* %10
%1777 = load i32, i32* %11
%1778 = xor i32 %1776, %1777
%1779 = load i32, i32* %7
%1780 = xor i32 %1778, %1779
%1781 = add i32 %1775, %1780
%1782 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 9
%1783 = load i32, i32* %1782
%1784 = add i32 %1781, %1783
%1785 = add i32 %1784, -1894007588
%1786 = load i32, i32* %8
%1787 = add i32 %1786, %1785
store i32 %1787, i32* %8
%1788 = load i32, i32* %10
%1789 = shl i32 %1788, 30
%1790 = load i32, i32* %10
%1791 = lshr i32 %1790, 2
%1792 = xor i32 %1789, %1791
store i32 %1792, i32* %10
%1793 = load i32, i32* %8
%1794 = shl i32 %1793, 12
%1795 = load i32, i32* %8
%1796 = lshr i32 %1795, 20
%1797 = xor i32 %1794, %1796
%1798 = load i32, i32* %9
%1799 = load i32, i32* %10
%1800 = xor i32 %1798, %1799
%1801 = load i32, i32* %11
%1802 = xor i32 %1800, %1801
%1803 = add i32 %1797, %1802
%1804 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 4
%1805 = load i32, i32* %1804
%1806 = add i32 %1803, %1805
%1807 = add i32 %1806, -1894007588
%1808 = load i32, i32* %7
%1809 = add i32 %1808, %1807
store i32 %1809, i32* %7
%1810 = load i32, i32* %9
%1811 = shl i32 %1810, 30
%1812 = load i32, i32* %9
%1813 = lshr i32 %1812, 2
%1814 = xor i32 %1811, %1813
store i32 %1814, i32* %9
%1815 = load i32, i32* %7
%1816 = shl i32 %1815, 9
%1817 = load i32, i32* %7
%1818 = lshr i32 %1817, 23
%1819 = xor i32 %1816, %1818
%1820 = load i32, i32* %8
%1821 = load i32, i32* %9
%1822 = xor i32 %1820, %1821
%1823 = load i32, i32* %10
%1824 = xor i32 %1822, %1823
%1825 = add i32 %1819, %1824
%1826 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 28
%1827 = load i32, i32* %1826
%1828 = add i32 %1825, %1827
%1829 = add i32 %1828, -1894007588
%1830 = load i32, i32* %11
%1831 = add i32 %1830, %1829
store i32 %1831, i32* %11
%1832 = load i32, i32* %8
%1833 = shl i32 %1832, 30
%1834 = load i32, i32* %8
%1835 = lshr i32 %1834, 2
%1836 = xor i32 %1833, %1835
store i32 %1836, i32* %8
%1837 = load i32, i32* %11
%1838 = shl i32 %1837, 11
%1839 = load i32, i32* %11
%1840 = lshr i32 %1839, 21
%1841 = xor i32 %1838, %1840
%1842 = load i32, i32* %7
%1843 = load i32, i32* %8
%1844 = xor i32 %1842, %1843
%1845 = load i32, i32* %9
%1846 = xor i32 %1844, %1845
%1847 = add i32 %1841, %1846
%1848 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 15
%1849 = load i32, i32* %1848
%1850 = add i32 %1847, %1849
%1851 = add i32 %1850, -1894007588
%1852 = load i32, i32* %10
%1853 = add i32 %1852, %1851
store i32 %1853, i32* %10
%1854 = load i32, i32* %7
%1855 = shl i32 %1854, 30
%1856 = load i32, i32* %7
%1857 = lshr i32 %1856, 2
%1858 = xor i32 %1855, %1857
store i32 %1858, i32* %7
%1859 = load i32, i32* %10
%1860 = shl i32 %1859, 8
%1861 = load i32, i32* %10
%1862 = lshr i32 %1861, 24
%1863 = xor i32 %1860, %1862
%1864 = load i32, i32* %11
%1865 = load i32, i32* %7
%1866 = xor i32 %1864, %1865
%1867 = load i32, i32* %8
%1868 = xor i32 %1866, %1867
%1869 = add i32 %1863, %1868
%1870 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 10
%1871 = load i32, i32* %1870
%1872 = add i32 %1869, %1871
%1873 = add i32 %1872, -1894007588
%1874 = load i32, i32* %9
%1875 = add i32 %1874, %1873
store i32 %1875, i32* %9
%1876 = load i32, i32* %11
%1877 = shl i32 %1876, 30
%1878 = load i32, i32* %11
%1879 = lshr i32 %1878, 2
%1880 = xor i32 %1877, %1879
store i32 %1880, i32* %11
%1881 = load i32, i32* %9
%1882 = shl i32 %1881, 15
%1883 = load i32, i32* %9
%1884 = lshr i32 %1883, 17
%1885 = xor i32 %1882, %1884
%1886 = load i32, i32* %10
%1887 = load i32, i32* %11
%1888 = xor i32 %1886, %1887
%1889 = load i32, i32* %7
%1890 = xor i32 %1888, %1889
%1891 = add i32 %1885, %1890
%1892 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 5
%1893 = load i32, i32* %1892
%1894 = add i32 %1891, %1893
%1895 = add i32 %1894, -1894007588
%1896 = load i32, i32* %8
%1897 = add i32 %1896, %1895
store i32 %1897, i32* %8
%1898 = load i32, i32* %10
%1899 = shl i32 %1898, 30
%1900 = load i32, i32* %10
%1901 = lshr i32 %1900, 2
%1902 = xor i32 %1899, %1901
store i32 %1902, i32* %10
%1903 = load i32, i32* %8
%1904 = shl i32 %1903, 6
%1905 = load i32, i32* %8
%1906 = lshr i32 %1905, 26
%1907 = xor i32 %1904, %1906
%1908 = load i32, i32* %9
%1909 = load i32, i32* %10
%1910 = xor i32 %1908, %1909
%1911 = load i32, i32* %11
%1912 = xor i32 %1910, %1911
%1913 = add i32 %1907, %1912
%1914 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 0
%1915 = load i32, i32* %1914
%1916 = add i32 %1913, %1915
%1917 = add i32 %1916, -1894007588
%1918 = load i32, i32* %7
%1919 = add i32 %1918, %1917
store i32 %1919, i32* %7
%1920 = load i32, i32* %9
%1921 = shl i32 %1920, 30
%1922 = load i32, i32* %9
%1923 = lshr i32 %1922, 2
%1924 = xor i32 %1921, %1923
store i32 %1924, i32* %9
%1925 = load i32, i32* %7
%1926 = shl i32 %1925, 12
%1927 = load i32, i32* %7
%1928 = lshr i32 %1927, 20
%1929 = xor i32 %1926, %1928
%1930 = load i32, i32* %8
%1931 = load i32, i32* %9
%1932 = xor i32 %1930, %1931
%1933 = load i32, i32* %10
%1934 = xor i32 %1932, %1933
%1935 = add i32 %1929, %1934
%1936 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 29
%1937 = load i32, i32* %1936
%1938 = add i32 %1935, %1937
%1939 = add i32 %1938, -1894007588
%1940 = load i32, i32* %11
%1941 = add i32 %1940, %1939
store i32 %1941, i32* %11
%1942 = load i32, i32* %8
%1943 = shl i32 %1942, 30
%1944 = load i32, i32* %8
%1945 = lshr i32 %1944, 2
%1946 = xor i32 %1943, %1945
store i32 %1946, i32* %8
%1947 = load i32, i32* %11
%1948 = shl i32 %1947, 9
%1949 = load i32, i32* %11
%1950 = lshr i32 %1949, 23
%1951 = xor i32 %1948, %1950
%1952 = load i32, i32* %7
%1953 = load i32, i32* %8
%1954 = xor i32 %1952, %1953
%1955 = load i32, i32* %9
%1956 = xor i32 %1954, %1955
%1957 = add i32 %1951, %1956
%1958 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 11
%1959 = load i32, i32* %1958
%1960 = add i32 %1957, %1959
%1961 = add i32 %1960, -1894007588
%1962 = load i32, i32* %10
%1963 = add i32 %1962, %1961
store i32 %1963, i32* %10
%1964 = load i32, i32* %7
%1965 = shl i32 %1964, 30
%1966 = load i32, i32* %7
%1967 = lshr i32 %1966, 2
%1968 = xor i32 %1965, %1967
store i32 %1968, i32* %7
%1969 = load i32, i32* %10
%1970 = shl i32 %1969, 14
%1971 = load i32, i32* %10
%1972 = lshr i32 %1971, 18
%1973 = xor i32 %1970, %1972
%1974 = load i32, i32* %11
%1975 = load i32, i32* %7
%1976 = xor i32 %1974, %1975
%1977 = load i32, i32* %8
%1978 = xor i32 %1976, %1977
%1979 = add i32 %1973, %1978
%1980 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 6
%1981 = load i32, i32* %1980
%1982 = add i32 %1979, %1981
%1983 = add i32 %1982, -1894007588
%1984 = load i32, i32* %9
%1985 = add i32 %1984, %1983
store i32 %1985, i32* %9
%1986 = load i32, i32* %11
%1987 = shl i32 %1986, 30
%1988 = load i32, i32* %11
%1989 = lshr i32 %1988, 2
%1990 = xor i32 %1987, %1989
store i32 %1990, i32* %11
%1991 = load i32, i32* %9
%1992 = shl i32 %1991, 5
%1993 = load i32, i32* %9
%1994 = lshr i32 %1993, 27
%1995 = xor i32 %1992, %1994
%1996 = load i32, i32* %10
%1997 = load i32, i32* %11
%1998 = xor i32 %1996, %1997
%1999 = load i32, i32* %7
%2000 = xor i32 %1998, %1999
%2001 = add i32 %1995, %2000
%2002 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 1
%2003 = load i32, i32* %2002
%2004 = add i32 %2001, %2003
%2005 = add i32 %2004, -1894007588
%2006 = load i32, i32* %8
%2007 = add i32 %2006, %2005
store i32 %2007, i32* %8
%2008 = load i32, i32* %10
%2009 = shl i32 %2008, 30
%2010 = load i32, i32* %10
%2011 = lshr i32 %2010, 2
%2012 = xor i32 %2009, %2011
store i32 %2012, i32* %10
%2013 = load i32, i32* %8
%2014 = shl i32 %2013, 13
%2015 = load i32, i32* %8
%2016 = lshr i32 %2015, 19
%2017 = xor i32 %2014, %2016
%2018 = load i32, i32* %9
%2019 = load i32, i32* %10
%2020 = xor i32 %2018, %2019
%2021 = load i32, i32* %11
%2022 = xor i32 %2020, %2021
%2023 = add i32 %2017, %2022
%2024 = getelementptr inbounds [32 x i32], [32 x i32]* %5, i64 0, i64 12
%2025 = load i32, i32* %2024
%2026 = add i32 %2023, %2025
%2027 = add i32 %2026, -1894007588
%2028 = load i32, i32* %7
%2029 = add i32 %2028, %2027
store i32 %2029, i32* %7
%2030 = load i32, i32* %9
%2031 = shl i32 %2030, 30
%2032 = load i32, i32* %9
%2033 = lshr i32 %2032, 2
%2034 = xor i32 %2031, %2033
store i32 %2034, i32* %9
%2035 = load i32, i32* %7
%2036 = load i32*, i32** %3
%2037 = getelementptr inbounds i32, i32* %2036, i64 0
%2038 = load i32, i32* %2037
%2039 = add i32 %2038, %2035
store i32 %2039, i32* %2037
%2040 = load i32, i32* %8
%2041 = load i32*, i32** %3
%2042 = getelementptr inbounds i32, i32* %2041, i64 1
%2043 = load i32, i32* %2042
%2044 = add i32 %2043, %2040
store i32 %2044, i32* %2042
%2045 = load i32, i32* %9
%2046 = load i32*, i32** %3
%2047 = getelementptr inbounds i32, i32* %2046, i64 2
%2048 = load i32, i32* %2047
%2049 = add i32 %2048, %2045
store i32 %2049, i32* %2047
%2050 = load i32, i32* %10
%2051 = load i32*, i32** %3
%2052 = getelementptr inbounds i32, i32* %2051, i64 3
%2053 = load i32, i32* %2052
%2054 = add i32 %2053, %2050
store i32 %2054, i32* %2052
%2055 = load i32, i32* %11
%2056 = load i32*, i32** %3
%2057 = getelementptr inbounds i32, i32* %2056, i64 4
%2058 = load i32, i32* %2057
%2059 = add i32 %2058, %2055
store i32 %2059, i32* %2057
ret void
}

LLVM IR (-O2):
define void @has160_process_block(i32* nocapture %0, i32* nocapture %1) {
%3 = load i32, i32* %1
%4 = getelementptr inbounds i32, i32* %1, i64 1
%5 = load i32, i32* %4
%6 = getelementptr inbounds i32, i32* %1, i64 2
%7 = load i32, i32* %6
%8 = getelementptr inbounds i32, i32* %1, i64 3
%9 = load i32, i32* %8
%10 = getelementptr inbounds i32, i32* %1, i64 4
%11 = load i32, i32* %10
%12 = getelementptr inbounds i32, i32* %1, i64 5
%13 = load i32, i32* %12
%14 = getelementptr inbounds i32, i32* %1, i64 6
%15 = load i32, i32* %14
%16 = getelementptr inbounds i32, i32* %1, i64 7
%17 = load i32, i32* %16
%18 = getelementptr inbounds i32, i32* %1, i64 8
%19 = load i32, i32* %18
%20 = getelementptr inbounds i32, i32* %1, i64 9
%21 = load i32, i32* %20
%22 = getelementptr inbounds i32, i32* %1, i64 10
%23 = load i32, i32* %22
%24 = getelementptr inbounds i32, i32* %1, i64 11
%25 = load i32, i32* %24
%26 = getelementptr inbounds i32, i32* %1, i64 12
%27 = load i32, i32* %26
%28 = getelementptr inbounds i32, i32* %1, i64 13
%29 = load i32, i32* %28
%30 = getelementptr inbounds i32, i32* %1, i64 14
%31 = load i32, i32* %30
%32 = getelementptr inbounds i32, i32* %1, i64 15
%33 = load i32, i32* %32
%34 = xor i32 %7, %3
%35 = xor i32 %34, %5
%36 = xor i32 %35, %9
%37 = xor i32 %15, %11
%38 = xor i32 %37, %13
%39 = xor i32 %38, %17
%40 = xor i32 %23, %19
%41 = xor i32 %40, %21
%42 = xor i32 %41, %25
%43 = xor i32 %31, %27
%44 = xor i32 %43, %29
%45 = xor i32 %44, %33
%46 = xor i32 %21, %9
%47 = xor i32 %46, %15
%48 = xor i32 %47, %27
%49 = xor i32 %19, %7
%50 = xor i32 %49, %13
%51 = xor i32 %50, %33
%52 = xor i32 %25, %5
%53 = xor i32 %52, %11
%54 = xor i32 %53, %31
%55 = xor i32 %23, %3
%56 = xor i32 %55, %17
%57 = xor i32 %56, %29
%58 = xor i32 %17, %13
%59 = xor i32 %58, %27
%60 = xor i32 %59, %31
%61 = xor i32 %34, %21
%62 = xor i32 %61, %25
%63 = xor i32 %37, %29
%64 = xor i32 %63, %33
%65 = xor i32 %9, %5
%66 = xor i32 %65, %19
%67 = xor i32 %66, %23
%68 = xor i32 %49, %17
%69 = xor i32 %68, %29
%70 = xor i32 %46, %11
%71 = xor i32 %70, %31
%72 = xor i32 %55, %13
%73 = xor i32 %72, %33
%74 = xor i32 %52, %15
%75 = xor i32 %74, %27
%76 = load i32, i32* %0
%77 = getelementptr inbounds i32, i32* %0, i64 1
%78 = load i32, i32* %77
%79 = getelementptr inbounds i32, i32* %0, i64 2
%80 = load i32, i32* %79
%81 = getelementptr inbounds i32, i32* %0, i64 3
%82 = load i32, i32* %81
%83 = getelementptr inbounds i32, i32* %0, i64 4
%84 = load i32, i32* %83
%85 = tail call i32 @llvm.fshl.i32(i32 %76, i32 %76, i32 5)
%86 = xor i32 %82, %80
%87 = and i32 %86, %78
%88 = xor i32 %87, %82
%89 = add i32 %85, %42
%90 = add i32 %89, %84
%91 = add i32 %90, %88
%92 = tail call i32 @llvm.fshl.i32(i32 %78, i32 %78, i32 10)
%93 = tail call i32 @llvm.fshl.i32(i32 %91, i32 %91, i32 11)
%94 = xor i32 %92, %80
%95 = and i32 %94, %76
%96 = xor i32 %95, %80
%97 = add i32 %82, %3
%98 = add i32 %97, %96
%99 = add i32 %98, %93
%100 = tail call i32 @llvm.fshl.i32(i32 %76, i32 %76, i32 10)
%101 = tail call i32 @llvm.fshl.i32(i32 %99, i32 %99, i32 7)
%102 = xor i32 %92, %100
%103 = and i32 %91, %102
%104 = xor i32 %103, %92
%105 = add i32 %80, %5
%106 = add i32 %105, %104
%107 = add i32 %106, %101
%108 = tail call i32 @llvm.fshl.i32(i32 %91, i32 %91, i32 10)
%109 = tail call i32 @llvm.fshl.i32(i32 %107, i32 %107, i32 15)
%110 = xor i32 %108, %100
%111 = and i32 %99, %110
%112 = xor i32 %111, %100
%113 = add i32 %92, %7
%114 = add i32 %113, %112
%115 = add i32 %114, %109
%116 = tail call i32 @llvm.fshl.i32(i32 %99, i32 %99, i32 10)
%117 = tail call i32 @llvm.fshl.i32(i32 %115, i32 %115, i32 6)
%118 = xor i32 %116, %108
%119 = and i32 %107, %118
%120 = xor i32 %119, %108
%121 = add i32 %100, %9
%122 = add i32 %121, %120
%123 = add i32 %122, %117
%124 = tail call i32 @llvm.fshl.i32(i32 %107, i32 %107, i32 10)
%125 = tail call i32 @llvm.fshl.i32(i32 %123, i32 %123, i32 13)
%126 = xor i32 %124, %116
%127 = and i32 %115, %126
%128 = xor i32 %127, %116
%129 = add i32 %108, %45
%130 = add i32 %129, %128
%131 = add i32 %130, %125
%132 = tail call i32 @llvm.fshl.i32(i32 %115, i32 %115, i32 10)
%133 = tail call i32 @llvm.fshl.i32(i32 %131, i32 %131, i32 8)
%134 = xor i32 %132, %124
%135 = and i32 %123, %134
%136 = xor i32 %135, %124
%137 = add i32 %116, %11
%138 = add i32 %137, %136
%139 = add i32 %138, %133
%140 = tail call i32 @llvm.fshl.i32(i32 %123, i32 %123, i32 10)
%141 = tail call i32 @llvm.fshl.i32(i32 %139, i32 %139, i32 14)
%142 = xor i32 %140, %132
%143 = and i32 %131, %142
%144 = xor i32 %143, %132
%145 = add i32 %124, %13
%146 = add i32 %145, %144
%147 = add i32 %146, %141
%148 = tail call i32 @llvm.fshl.i32(i32 %131, i32 %131, i32 10)
%149 = tail call i32 @llvm.fshl.i32(i32 %147, i32 %147, i32 7)
%150 = xor i32 %148, %140
%151 = and i32 %139, %150
%152 = xor i32 %151, %140
%153 = add i32 %132, %15
%154 = add i32 %153, %152
%155 = add i32 %154, %149
%156 = tail call i32 @llvm.fshl.i32(i32 %139, i32 %139, i32 10)
%157 = tail call i32 @llvm.fshl.i32(i32 %155, i32 %155, i32 12)
%158 = xor i32 %156, %148
%159 = and i32 %147, %158
%160 = xor i32 %159, %148
%161 = add i32 %140, %17
%162 = add i32 %161, %160
%163 = add i32 %162, %157
%164 = tail call i32 @llvm.fshl.i32(i32 %147, i32 %147, i32 10)
%165 = tail call i32 @llvm.fshl.i32(i32 %163, i32 %163, i32 9)
%166 = xor i32 %164, %156
%167 = and i32 %155, %166
%168 = xor i32 %167, %156
%169 = add i32 %148, %36
%170 = add i32 %169, %168
%171 = add i32 %170, %165
%172 = tail call i32 @llvm.fshl.i32(i32 %155, i32 %155, i32 10)
%173 = tail call i32 @llvm.fshl.i32(i32 %171, i32 %171, i32 11)
%174 = xor i32 %172, %164
%175 = and i32 %163, %174
%176 = xor i32 %175, %164
%177 = add i32 %156, %19
%178 = add i32 %177, %176
%179 = add i32 %178, %173
%180 = tail call i32 @llvm.fshl.i32(i32 %163, i32 %163, i32 10)
%181 = tail call i32 @llvm.fshl.i32(i32 %179, i32 %179, i32 8)
%182 = xor i32 %180, %172
%183 = and i32 %171, %182
%184 = xor i32 %183, %172
%185 = add i32 %164, %21
%186 = add i32 %185, %184
%187 = add i32 %186, %181
%188 = tail call i32 @llvm.fshl.i32(i32 %171, i32 %171, i32 10)
%189 = tail call i32 @llvm.fshl.i32(i32 %187, i32 %187, i32 15)
%190 = xor i32 %188, %180
%191 = and i32 %179, %190
%192 = xor i32 %191, %180
%193 = add i32 %172, %23
%194 = add i32 %193, %192
%195 = add i32 %194, %189
%196 = tail call i32 @llvm.fshl.i32(i32 %179, i32 %179, i32 10)
%197 = tail call i32 @llvm.fshl.i32(i32 %195, i32 %195, i32 6)
%198 = xor i32 %196, %188
%199 = and i32 %187, %198
%200 = xor i32 %199, %188
%201 = add i32 %180, %25
%202 = add i32 %201, %200
%203 = add i32 %202, %197
%204 = tail call i32 @llvm.fshl.i32(i32 %187, i32 %187, i32 10)
%205 = tail call i32 @llvm.fshl.i32(i32 %203, i32 %203, i32 12)
%206 = xor i32 %204, %196
%207 = and i32 %195, %206
%208 = xor i32 %207, %196
%209 = add i32 %188, %39
%210 = add i32 %209, %208
%211 = add i32 %210, %205
%212 = tail call i32 @llvm.fshl.i32(i32 %195, i32 %195, i32 10)
%213 = tail call i32 @llvm.fshl.i32(i32 %211, i32 %211, i32 9)
%214 = xor i32 %212, %204
%215 = and i32 %203, %214
%216 = xor i32 %215, %204
%217 = add i32 %196, %27
%218 = add i32 %217, %216
%219 = add i32 %218, %213
%220 = tail call i32 @llvm.fshl.i32(i32 %203, i32 %203, i32 10)
%221 = tail call i32 @llvm.fshl.i32(i32 %219, i32 %219, i32 14)
%222 = xor i32 %220, %212
%223 = and i32 %211, %222
%224 = xor i32 %223, %212
%225 = add i32 %204, %29
%226 = add i32 %225, %224
%227 = add i32 %226, %221
%228 = tail call i32 @llvm.fshl.i32(i32 %211, i32 %211, i32 10)
%229 = tail call i32 @llvm.fshl.i32(i32 %227, i32 %227, i32 5)
%230 = xor i32 %228, %220
%231 = and i32 %219, %230
%232 = xor i32 %231, %220
%233 = add i32 %212, %31
%234 = add i32 %233, %232
%235 = add i32 %234, %229
%236 = tail call i32 @llvm.fshl.i32(i32 %219, i32 %219, i32 10)
%237 = tail call i32 @llvm.fshl.i32(i32 %235, i32 %235, i32 13)
%238 = xor i32 %236, %228
%239 = and i32 %227, %238
%240 = xor i32 %239, %228
%241 = add i32 %220, %33
%242 = add i32 %241, %240
%243 = add i32 %242, %237
%244 = tail call i32 @llvm.fshl.i32(i32 %227, i32 %227, i32 10)
%245 = tail call i32 @llvm.fshl.i32(i32 %243, i32 %243, i32 5)
%246 = xor i32 %244, %236
%247 = xor i32 %246, %235
%248 = add i32 %54, 1518500249
%249 = add i32 %248, %228
%250 = add i32 %249, %247
%251 = add i32 %250, %245
%252 = tail call i32 @llvm.fshl.i32(i32 %235, i32 %235, i32 17)
%253 = tail call i32 @llvm.fshl.i32(i32 %251, i32 %251, i32 11)
%254 = xor i32 %252, %244
%255 = xor i32 %254, %243
%256 = add i32 %9, 1518500249
%257 = add i32 %256, %236
%258 = add i32 %257, %255
%259 = add i32 %258, %253
%260 = tail call i32 @llvm.fshl.i32(i32 %243, i32 %243, i32 17)
%261 = tail call i32 @llvm.fshl.i32(i32 %259, i32 %259, i32 7)
%262 = xor i32 %260, %252
%263 = xor i32 %262, %251
%264 = add i32 %15, 1518500249
%265 = add i32 %264, %244
%266 = add i32 %265, %263
%267 = add i32 %266, %261
%268 = tail call i32 @llvm.fshl.i32(i32 %251, i32 %251, i32 17)
%269 = tail call i32 @llvm.fshl.i32(i32 %267, i32 %267, i32 15)
%270 = xor i32 %268, %260
%271 = xor i32 %270, %259
%272 = add i32 %21, 1518500249
%273 = add i32 %272, %252
%274 = add i32 %273, %271
%275 = add i32 %274, %269
%276 = tail call i32 @llvm.fshl.i32(i32 %259, i32 %259, i32 17)
%277 = tail call i32 @llvm.fshl.i32(i32 %275, i32 %275, i32 6)
%278 = xor i32 %276, %268
%279 = xor i32 %278, %267
%280 = add i32 %27, 1518500249
%281 = add i32 %280, %260
%282 = add i32 %281, %279
%283 = add i32 %282, %277
%284 = tail call i32 @llvm.fshl.i32(i32 %267, i32 %267, i32 17)
%285 = tail call i32 @llvm.fshl.i32(i32 %283, i32 %283, i32 13)
%286 = xor i32 %284, %276
%287 = xor i32 %286, %275
%288 = add i32 %57, 1518500249
%289 = add i32 %288, %268
%290 = add i32 %289, %287
%291 = add i32 %290, %285
%292 = tail call i32 @llvm.fshl.i32(i32 %275, i32 %275, i32 17)
%293 = tail call i32 @llvm.fshl.i32(i32 %291, i32 %291, i32 8)
%294 = xor i32 %292, %284
%295 = xor i32 %294, %283
%296 = add i32 %33, 1518500249
%297 = add i32 %296, %276
%298 = add i32 %297, %295
%299 = add i32 %298, %293
%300 = tail call i32 @llvm.fshl.i32(i32 %283, i32 %283, i32 17)
%301 = tail call i32 @llvm.fshl.i32(i32 %299, i32 %299, i32 14)
%302 = xor i32 %300, %292
%303 = xor i32 %302, %291
%304 = add i32 %7, 1518500249
%305 = add i32 %304, %284
%306 = add i32 %305, %303
%307 = add i32 %306, %301
%308 = tail call i32 @llvm.fshl.i32(i32 %291, i32 %291, i32 17)
%309 = tail call i32 @llvm.fshl.i32(i32 %307, i32 %307, i32 7)
%310 = xor i32 %308, %300
%311 = xor i32 %310, %299
%312 = add i32 %13, 1518500249
%313 = add i32 %312, %292
%314 = add i32 %313, %311
%315 = add i32 %314, %309
%316 = tail call i32 @llvm.fshl.i32(i32 %299, i32 %299, i32 17)
%317 = tail call i32 @llvm.fshl.i32(i32 %315, i32 %315, i32 12)
%318 = xor i32 %316, %308
%319 = xor i32 %318, %307
%320 = add i32 %19, 1518500249
%321 = add i32 %320, %300
%322 = add i32 %321, %319
%323 = add i32 %322, %317
%324 = tail call i32 @llvm.fshl.i32(i32 %307, i32 %307, i32 17)
%325 = tail call i32 @llvm.fshl.i32(i32 %323, i32 %323, i32 9)
%326 = xor i32 %324, %316
%327 = xor i32 %326, %315
%328 = add i32 %48, 1518500249
%329 = add i32 %328, %308
%330 = add i32 %329, %327
%331 = add i32 %330, %325
%332 = tail call i32 @llvm.fshl.i32(i32 %315, i32 %315, i32 17)
%333 = tail call i32 @llvm.fshl.i32(i32 %331, i32 %331, i32 11)
%334 = xor i32 %332, %324
%335 = xor i32 %334, %323
%336 = add i32 %25, 1518500249
%337 = add i32 %336, %316
%338 = add i32 %337, %335
%339 = add i32 %338, %333
%340 = tail call i32 @llvm.fshl.i32(i32 %323, i32 %323, i32 17)
%341 = tail call i32 @llvm.fshl.i32(i32 %339, i32 %339, i32 8)
%342 = xor i32 %340, %332
%343 = xor i32 %342, %331
%344 = add i32 %31, 1518500249
%345 = add i32 %344, %324
%346 = add i32 %345, %343
%347 = add i32 %346, %341
%348 = tail call i32 @llvm.fshl.i32(i32 %331, i32 %331, i32 17)
%349 = tail call i32 @llvm.fshl.i32(i32 %347, i32 %347, i32 15)
%350 = xor i32 %348, %340
%351 = xor i32 %350, %339
%352 = add i32 %5, 1518500249
%353 = add i32 %352, %332
%354 = add i32 %353, %351
%355 = add i32 %354, %349
%356 = tail call i32 @llvm.fshl.i32(i32 %339, i32 %339, i32 17)
%357 = tail call i32 @llvm.fshl.i32(i32 %355, i32 %355, i32 6)
%358 = xor i32 %356, %348
%359 = xor i32 %358, %347
%360 = add i32 %11, 1518500249
%361 = add i32 %360, %340
%362 = add i32 %361, %359
%363 = add i32 %362, %357
%364 = tail call i32 @llvm.fshl.i32(i32 %347, i32 %347, i32 17)
%365 = tail call i32 @llvm.fshl.i32(i32 %363, i32 %363, i32 12)
%366 = xor i32 %364, %356
%367 = xor i32 %366, %355
%368 = add i32 %51, 1518500249
%369 = add i32 %368, %348
%370 = add i32 %369, %367
%371 = add i32 %370, %365
%372 = tail call i32 @llvm.fshl.i32(i32 %355, i32 %355, i32 17)
%373 = tail call i32 @llvm.fshl.i32(i32 %371, i32 %371, i32 9)
%374 = xor i32 %372, %364
%375 = xor i32 %374, %363
%376 = add i32 %17, 1518500249
%377 = add i32 %376, %356
%378 = add i32 %377, %375
%379 = add i32 %378, %373
%380 = tail call i32 @llvm.fshl.i32(i32 %363, i32 %363, i32 17)
%381 = tail call i32 @llvm.fshl.i32(i32 %379, i32 %379, i32 14)
%382 = xor i32 %380, %372
%383 = xor i32 %382, %371
%384 = add i32 %23, 1518500249
%385 = add i32 %384, %364
%386 = add i32 %385, %383
%387 = add i32 %386, %381
%388 = tail call i32 @llvm.fshl.i32(i32 %371, i32 %371, i32 17)
%389 = tail call i32 @llvm.fshl.i32(i32 %387, i32 %387, i32 5)
%390 = xor i32 %388, %380
%391 = xor i32 %390, %379
%392 = add i32 %29, 1518500249
%393 = add i32 %392, %372
%394 = add i32 %393, %391
%395 = add i32 %394, %389
%396 = tail call i32 @llvm.fshl.i32(i32 %379, i32 %379, i32 17)
%397 = tail call i32 @llvm.fshl.i32(i32 %395, i32 %395, i32 13)
%398 = xor i32 %396, %388
%399 = xor i32 %398, %387
%400 = add i32 %3, 1518500249
%401 = add i32 %400, %380
%402 = add i32 %401, %399
%403 = add i32 %402, %397
%404 = tail call i32 @llvm.fshl.i32(i32 %387, i32 %387, i32 17)
%405 = tail call i32 @llvm.fshl.i32(i32 %403, i32 %403, i32 5)
%406 = xor i32 %396, -1
%407 = or i32 %395, %406
%408 = xor i32 %407, %404
%409 = add i32 %64, 1859775393
%410 = add i32 %409, %388
%411 = add i32 %410, %408
%412 = add i32 %411, %405
%413 = tail call i32 @llvm.fshl.i32(i32 %395, i32 %395, i32 25)
%414 = tail call i32 @llvm.fshl.i32(i32 %412, i32 %412, i32 11)
%415 = xor i32 %404, -1
%416 = or i32 %403, %415
%417 = xor i32 %416, %413
%418 = add i32 %27, 1859775393
%419 = add i32 %418, %396
%420 = add i32 %419, %417
%421 = add i32 %420, %414
%422 = tail call i32 @llvm.fshl.i32(i32 %403, i32 %403, i32 25)
%423 = tail call i32 @llvm.fshl.i32(i32 %421, i32 %421, i32 7)
%424 = xor i32 %413, -1
%425 = or i32 %412, %424
%426 = xor i32 %425, %422
%427 = add i32 %13, 1859775393
%428 = add i32 %427, %404
%429 = add i32 %428, %426
%430 = add i32 %429, %423
%431 = tail call i32 @llvm.fshl.i32(i32 %412, i32 %412, i32 25)
%432 = tail call i32 @llvm.fshl.i32(i32 %430, i32 %430, i32 15)
%433 = xor i32 %422, -1
%434 = or i32 %421, %433
%435 = xor i32 %434, %431
%436 = add i32 %31, 1859775393
%437 = add i32 %436, %413
%438 = add i32 %437, %435
%439 = add i32 %438, %432
%440 = tail call i32 @llvm.fshl.i32(i32 %421, i32 %421, i32 25)
%441 = tail call i32 @llvm.fshl.i32(i32 %439, i32 %439, i32 6)
%442 = xor i32 %431, -1
%443 = or i32 %430, %442
%444 = xor i32 %443, %440
%445 = add i32 %17, 1859775393
%446 = add i32 %445, %422
%447 = add i32 %446, %444
%448 = add i32 %447, %441
%449 = tail call i32 @llvm.fshl.i32(i32 %430, i32 %430, i32 25)
%450 = tail call i32 @llvm.fshl.i32(i32 %448, i32 %448, i32 13)
%451 = xor i32 %440, -1
%452 = or i32 %439, %451
%453 = xor i32 %452, %449
%454 = add i32 %67, 1859775393
%455 = add i32 %454, %431
%456 = add i32 %455, %453
%457 = add i32 %456, %450
%458 = tail call i32 @llvm.fshl.i32(i32 %439, i32 %439, i32 25)
%459 = tail call i32 @llvm.fshl.i32(i32 %457, i32 %457, i32 8)
%460 = xor i32 %449, -1
%461 = or i32 %448, %460
%462 = xor i32 %461, %458
%463 = add i32 %3, 1859775393
%464 = add i32 %463, %440
%465 = add i32 %464, %462
%466 = add i32 %465, %459
%467 = tail call i32 @llvm.fshl.i32(i32 %448, i32 %448, i32 25)
%468 = tail call i32 @llvm.fshl.i32(i32 %466, i32 %466, i32 14)
%469 = xor i32 %458, -1
%470 = or i32 %457, %469
%471 = xor i32 %470, %467
%472 = add i32 %21, 1859775393
%473 = add i32 %472, %449
%474 = add i32 %473, %471
%475 = add i32 %474, %468
%476 = tail call i32 @llvm.fshl.i32(i32 %457, i32 %457, i32 25)
%477 = tail call i32 @llvm.fshl.i32(i32 %475, i32 %475, i32 7)
%478 = xor i32 %467, -1
%479 = or i32 %466, %478
%480 = xor i32 %479, %476
%481 = add i32 %7, 1859775393
%482 = add i32 %481, %458
%483 = add i32 %482, %480
%484 = add i32 %483, %477
%485 = tail call i32 @llvm.fshl.i32(i32 %466, i32 %466, i32 25)
%486 = tail call i32 @llvm.fshl.i32(i32 %484, i32 %484, i32 12)
%487 = xor i32 %476, -1
%488 = or i32 %475, %487
%489 = xor i32 %488, %485
%490 = add i32 %25, 1859775393
%491 = add i32 %490, %467
%492 = add i32 %491, %489
%493 = add i32 %492, %486
%494 = tail call i32 @llvm.fshl.i32(i32 %475, i32 %475, i32 25)
%495 = tail call i32 @llvm.fshl.i32(i32 %493, i32 %493, i32 9)
%496 = xor i32 %485, -1
%497 = or i32 %484, %496
%498 = xor i32 %497, %494
%499 = add i32 %60, 1859775393
%500 = add i32 %499, %476
%501 = add i32 %500, %498
%502 = add i32 %501, %495
%503 = tail call i32 @llvm.fshl.i32(i32 %484, i32 %484, i32 25)
%504 = tail call i32 @llvm.fshl.i32(i32 %502, i32 %502, i32 11)
%505 = xor i32 %494, -1
%506 = or i32 %493, %505
%507 = xor i32 %506, %503
%508 = add i32 %11, 1859775393
%509 = add i32 %508, %485
%510 = add i32 %509, %507
%511 = add i32 %510, %504
%512 = tail call i32 @llvm.fshl.i32(i32 %493, i32 %493, i32 25)
%513 = tail call i32 @llvm.fshl.i32(i32 %511, i32 %511, i32 8)
%514 = xor i32 %503, -1
%515 = or i32 %502, %514
%516 = xor i32 %515, %512
%517 = add i32 %29, 1859775393
%518 = add i32 %517, %494
%519 = add i32 %518, %516
%520 = add i32 %519, %513
%521 = tail call i32 @llvm.fshl.i32(i32 %502, i32 %502, i32 25)
%522 = tail call i32 @llvm.fshl.i32(i32 %520, i32 %520, i32 15)
%523 = xor i32 %512, -1
%524 = or i32 %511, %523
%525 = xor i32 %524, %521
%526 = add i32 %15, 1859775393
%527 = add i32 %526, %503
%528 = add i32 %527, %525
%529 = add i32 %528, %522
%530 = tail call i32 @llvm.fshl.i32(i32 %511, i32 %511, i32 25)
%531 = tail call i32 @llvm.fshl.i32(i32 %529, i32 %529, i32 6)
%532 = xor i32 %521, -1
%533 = or i32 %520, %532
%534 = xor i32 %533, %530
%535 = add i32 %33, 1859775393
%536 = add i32 %535, %512
%537 = add i32 %536, %534
%538 = add i32 %537, %531
%539 = tail call i32 @llvm.fshl.i32(i32 %520, i32 %520, i32 25)
%540 = tail call i32 @llvm.fshl.i32(i32 %538, i32 %538, i32 12)
%541 = xor i32 %530, -1
%542 = or i32 %529, %541
%543 = xor i32 %542, %539
%544 = add i32 %62, 1859775393
%545 = add i32 %544, %521
%546 = add i32 %545, %543
%547 = add i32 %546, %540
%548 = tail call i32 @llvm.fshl.i32(i32 %529, i32 %529, i32 25)
%549 = tail call i32 @llvm.fshl.i32(i32 %547, i32 %547, i32 9)
%550 = xor i32 %539, -1
%551 = or i32 %538, %550
%552 = xor i32 %551, %548
%553 = add i32 %19, 1859775393
%554 = add i32 %553, %530
%555 = add i32 %554, %552
%556 = add i32 %555, %549
%557 = tail call i32 @llvm.fshl.i32(i32 %538, i32 %538, i32 25)
%558 = tail call i32 @llvm.fshl.i32(i32 %556, i32 %556, i32 14)
%559 = xor i32 %548, -1
%560 = or i32 %547, %559
%561 = xor i32 %560, %557
%562 = add i32 %5, 1859775393
%563 = add i32 %562, %539
%564 = add i32 %563, %561
%565 = add i32 %564, %558
%566 = tail call i32 @llvm.fshl.i32(i32 %547, i32 %547, i32 25)
%567 = tail call i32 @llvm.fshl.i32(i32 %565, i32 %565, i32 5)
%568 = xor i32 %557, -1
%569 = or i32 %556, %568
%570 = xor i32 %569, %566
%571 = add i32 %23, 1859775393
%572 = add i32 %571, %548
%573 = add i32 %572, %570
%574 = add i32 %573, %567
%575 = tail call i32 @llvm.fshl.i32(i32 %556, i32 %556, i32 25)
%576 = tail call i32 @llvm.fshl.i32(i32 %574, i32 %574, i32 13)
%577 = xor i32 %566, -1
%578 = or i32 %565, %577
%579 = xor i32 %578, %575
%580 = add i32 %9, 1859775393
%581 = add i32 %580, %557
%582 = add i32 %581, %579
%583 = add i32 %582, %576
%584 = tail call i32 @llvm.fshl.i32(i32 %565, i32 %565, i32 25)
%585 = tail call i32 @llvm.fshl.i32(i32 %583, i32 %583, i32 5)
%586 = xor i32 %584, %575
%587 = xor i32 %586, %574
%588 = add i32 %73, -1894007588
%589 = add i32 %588, %566
%590 = add i32 %589, %587
%591 = add i32 %590, %585
%592 = tail call i32 @llvm.fshl.i32(i32 %574, i32 %574, i32 30)
%593 = tail call i32 @llvm.fshl.i32(i32 %591, i32 %591, i32 11)
%594 = xor i32 %592, %584
%595 = xor i32 %594, %583
%596 = add i32 %17, -1894007588
%597 = add i32 %596, %575
%598 = add i32 %597, %595
%599 = add i32 %598, %593
%600 = tail call i32 @llvm.fshl.i32(i32 %583, i32 %583, i32 30)
%601 = tail call i32 @llvm.fshl.i32(i32 %599, i32 %599, i32 7)
%602 = xor i32 %600, %592
%603 = xor i32 %602, %591
%604 = add i32 %7, -1894007588
%605 = add i32 %604, %584
%606 = add i32 %605, %603
%607 = add i32 %606, %601
%608 = tail call i32 @llvm.fshl.i32(i32 %591, i32 %591, i32 30)
%609 = tail call i32 @llvm.fshl.i32(i32 %607, i32 %607, i32 15)
%610 = xor i32 %608, %600
%611 = xor i32 %610, %599
%612 = add i32 %29, -1894007588
%613 = add i32 %612, %592
%614 = add i32 %613, %611
%615 = add i32 %614, %609
%616 = tail call i32 @llvm.fshl.i32(i32 %599, i32 %599, i32 30)
%617 = tail call i32 @llvm.fshl.i32(i32 %615, i32 %615, i32 6)
%618 = xor i32 %616, %608
%619 = xor i32 %618, %607
%620 = add i32 %19, -1894007588
%621 = add i32 %620, %600
%622 = add i32 %621, %619
%623 = add i32 %622, %617
%624 = tail call i32 @llvm.fshl.i32(i32 %607, i32 %607, i32 30)
%625 = tail call i32 @llvm.fshl.i32(i32 %623, i32 %623, i32 13)
%626 = xor i32 %624, %616
%627 = xor i32 %626, %615
%628 = add i32 %75, -1894007588
%629 = add i32 %628, %608
%630 = add i32 %629, %627
%631 = add i32 %630, %625
%632 = tail call i32 @llvm.fshl.i32(i32 %615, i32 %615, i32 30)
%633 = tail call i32 @llvm.fshl.i32(i32 %631, i32 %631, i32 8)
%634 = xor i32 %632, %624
%635 = xor i32 %634, %623
%636 = add i32 %9, -1894007588
%637 = add i32 %636, %616
%638 = add i32 %637, %635
%639 = add i32 %638, %633
%640 = tail call i32 @llvm.fshl.i32(i32 %623, i32 %623, i32 30)
%641 = tail call i32 @llvm.fshl.i32(i32 %639, i32 %639, i32 14)
%642 = xor i32 %640, %632
%643 = xor i32 %642, %631
%644 = add i32 %31, -1894007588
%645 = add i32 %644, %624
%646 = add i32 %645, %643
%647 = add i32 %646, %641
%648 = tail call i32 @llvm.fshl.i32(i32 %631, i32 %631, i32 30)
%649 = tail call i32 @llvm.fshl.i32(i32 %647, i32 %647, i32 7)
%650 = xor i32 %648, %640
%651 = xor i32 %650, %639
%652 = add i32 %21, -1894007588
%653 = add i32 %652, %632
%654 = add i32 %653, %651
%655 = add i32 %654, %649
%656 = tail call i32 @llvm.fshl.i32(i32 %639, i32 %639, i32 30)
%657 = tail call i32 @llvm.fshl.i32(i32 %655, i32 %655, i32 12)
%658 = xor i32 %656, %648
%659 = xor i32 %658, %647
%660 = add i32 %11, -1894007588
%661 = add i32 %660, %640
%662 = add i32 %661, %659
%663 = add i32 %662, %657
%664 = tail call i32 @llvm.fshl.i32(i32 %647, i32 %647, i32 30)
%665 = tail call i32 @llvm.fshl.i32(i32 %663, i32 %663, i32 9)
%666 = xor i32 %664, %656
%667 = xor i32 %666, %655
%668 = add i32 %69, -1894007588
%669 = add i32 %668, %648
%670 = add i32 %669, %667
%671 = add i32 %670, %665
%672 = tail call i32 @llvm.fshl.i32(i32 %655, i32 %655, i32 30)
%673 = tail call i32 @llvm.fshl.i32(i32 %671, i32 %671, i32 11)
%674 = xor i32 %672, %664
%675 = xor i32 %674, %663
%676 = add i32 %33, -1894007588
%677 = add i32 %676, %656
%678 = add i32 %677, %675
%679 = add i32 %678, %673
%680 = tail call i32 @llvm.fshl.i32(i32 %663, i32 %663, i32 30)
%681 = tail call i32 @llvm.fshl.i32(i32 %679, i32 %679, i32 8)
%682 = xor i32 %680, %672
%683 = xor i32 %682, %671
%684 = add i32 %23, -1894007588
%685 = add i32 %684, %664
%686 = add i32 %685, %683
%687 = add i32 %686, %681
%688 = tail call i32 @llvm.fshl.i32(i32 %671, i32 %671, i32 30)
%689 = tail call i32 @llvm.fshl.i32(i32 %687, i32 %687, i32 15)
%690 = xor i32 %688, %680
%691 = xor i32 %690, %679
%692 = add i32 %13, -1894007588
%693 = add i32 %692, %672
%694 = add i32 %693, %691
%695 = add i32 %694, %689
%696 = tail call i32 @llvm.fshl.i32(i32 %679, i32 %679, i32 30)
%697 = tail call i32 @llvm.fshl.i32(i32 %695, i32 %695, i32 6)
%698 = xor i32 %696, %688
%699 = xor i32 %698, %687
%700 = add i32 %3, -1894007588
%701 = add i32 %700, %680
%702 = add i32 %701, %699
%703 = add i32 %702, %697
%704 = tail call i32 @llvm.fshl.i32(i32 %687, i32 %687, i32 30)
%705 = tail call i32 @llvm.fshl.i32(i32 %703, i32 %703, i32 12)
%706 = xor i32 %704, %696
%707 = xor i32 %706, %695
%708 = add i32 %71, -1894007588
%709 = add i32 %708, %688
%710 = add i32 %709, %707
%711 = add i32 %710, %705
%712 = tail call i32 @llvm.fshl.i32(i32 %695, i32 %695, i32 30)
%713 = tail call i32 @llvm.fshl.i32(i32 %711, i32 %711, i32 9)
%714 = xor i32 %712, %704
%715 = xor i32 %714, %703
%716 = add i32 %25, -1894007588
%717 = add i32 %716, %696
%718 = add i32 %717, %715
%719 = add i32 %718, %713
%720 = tail call i32 @llvm.fshl.i32(i32 %703, i32 %703, i32 30)
%721 = tail call i32 @llvm.fshl.i32(i32 %719, i32 %719, i32 14)
%722 = xor i32 %720, %712
%723 = xor i32 %722, %711
%724 = add i32 %15, -1894007588
%725 = add i32 %724, %704
%726 = add i32 %725, %723
%727 = add i32 %726, %721
%728 = tail call i32 @llvm.fshl.i32(i32 %711, i32 %711, i32 30)
%729 = tail call i32 @llvm.fshl.i32(i32 %727, i32 %727, i32 5)
%730 = xor i32 %728, %720
%731 = xor i32 %730, %719
%732 = add i32 %5, -1894007588
%733 = add i32 %732, %712
%734 = add i32 %733, %731
%735 = add i32 %734, %729
%736 = tail call i32 @llvm.fshl.i32(i32 %719, i32 %719, i32 30)
%737 = tail call i32 @llvm.fshl.i32(i32 %735, i32 %735, i32 13)
%738 = xor i32 %736, %728
%739 = xor i32 %738, %727
%740 = tail call i32 @llvm.fshl.i32(i32 %727, i32 %727, i32 30)
%741 = add i32 %27, -1894007588
%742 = add i32 %741, %76
%743 = add i32 %742, %720
%744 = add i32 %743, %739
%745 = add i32 %744, %737
store i32 %745, i32* %0
%746 = add i32 %735, %78
store i32 %746, i32* %77
%747 = add i32 %740, %80
store i32 %747, i32* %79
%748 = add i32 %736, %82
store i32 %748, i32* %81
%749 = add i32 %728, %84
store i32 %749, i32* %83
ret void
}