void SHA1Transform(unsigned int state[5], unsigned char buffer[64]) {
  unsigned int a, b, c, d, e;
  typedef union {
    unsigned char c[64];
    unsigned int l[16];
  } CHAR64LONG16;
  CHAR64LONG16 *block;
  static unsigned char workspace[64];
  block = (CHAR64LONG16 *)workspace;
  memcpy(block, buffer, 64);
  a = state[0];
  b = state[1];
  c = state[2];
  d = state[3];
  e = state[4];
  e += ((b & (c ^ d)) ^ d) + (block->l[0] = (block->l[0])) + 0x5A827999 +
       (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += ((a & (b ^ c)) ^ c) + (block->l[1] = (block->l[1])) + 0x5A827999 +
       (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += ((e & (a ^ b)) ^ b) + (block->l[2] = (block->l[2])) + 0x5A827999 +
       (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += ((d & (e ^ a)) ^ a) + (block->l[3] = (block->l[3])) + 0x5A827999 +
       (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += ((c & (d ^ e)) ^ e) + (block->l[4] = (block->l[4])) + 0x5A827999 +
       (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += ((b & (c ^ d)) ^ d) + (block->l[5] = (block->l[5])) + 0x5A827999 +
       (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += ((a & (b ^ c)) ^ c) + (block->l[6] = (block->l[6])) + 0x5A827999 +
       (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += ((e & (a ^ b)) ^ b) + (block->l[7] = (block->l[7])) + 0x5A827999 +
       (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += ((d & (e ^ a)) ^ a) + (block->l[8] = (block->l[8])) + 0x5A827999 +
       (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += ((c & (d ^ e)) ^ e) + (block->l[9] = (block->l[9])) + 0x5A827999 +
       (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += ((b & (c ^ d)) ^ d) + (block->l[10] = (block->l[10])) + 0x5A827999 +
       (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += ((a & (b ^ c)) ^ c) + (block->l[11] = (block->l[11])) + 0x5A827999 +
       (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += ((e & (a ^ b)) ^ b) + (block->l[12] = (block->l[12])) + 0x5A827999 +
       (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += ((d & (e ^ a)) ^ a) + (block->l[13] = (block->l[13])) + 0x5A827999 +
       (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += ((c & (d ^ e)) ^ e) + (block->l[14] = (block->l[14])) + 0x5A827999 +
       (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += ((b & (c ^ d)) ^ d) + (block->l[15] = (block->l[15])) + 0x5A827999 +
       (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += ((a & (b ^ c)) ^ c) +
       (block->l[16 & 15] =
            (((block->l[(16 + 13) & 15] ^ block->l[(16 + 8) & 15] ^
               block->l[(16 + 2) & 15] ^ block->l[16 & 15])
              << (1)) |
             ((block->l[(16 + 13) & 15] ^ block->l[(16 + 8) & 15] ^
               block->l[(16 + 2) & 15] ^ block->l[16 & 15]) >>
              (32 - (1))))) +
       0x5A827999 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += ((e & (a ^ b)) ^ b) +
       (block->l[17 & 15] =
            (((block->l[(17 + 13) & 15] ^ block->l[(17 + 8) & 15] ^
               block->l[(17 + 2) & 15] ^ block->l[17 & 15])
              << (1)) |
             ((block->l[(17 + 13) & 15] ^ block->l[(17 + 8) & 15] ^
               block->l[(17 + 2) & 15] ^ block->l[17 & 15]) >>
              (32 - (1))))) +
       0x5A827999 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += ((d & (e ^ a)) ^ a) +
       (block->l[18 & 15] =
            (((block->l[(18 + 13) & 15] ^ block->l[(18 + 8) & 15] ^
               block->l[(18 + 2) & 15] ^ block->l[18 & 15])
              << (1)) |
             ((block->l[(18 + 13) & 15] ^ block->l[(18 + 8) & 15] ^
               block->l[(18 + 2) & 15] ^ block->l[18 & 15]) >>
              (32 - (1))))) +
       0x5A827999 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += ((c & (d ^ e)) ^ e) +
       (block->l[19 & 15] =
            (((block->l[(19 + 13) & 15] ^ block->l[(19 + 8) & 15] ^
               block->l[(19 + 2) & 15] ^ block->l[19 & 15])
              << (1)) |
             ((block->l[(19 + 13) & 15] ^ block->l[(19 + 8) & 15] ^
               block->l[(19 + 2) & 15] ^ block->l[19 & 15]) >>
              (32 - (1))))) +
       0x5A827999 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (b ^ c ^ d) +
       (block->l[20 & 15] =
            (((block->l[(20 + 13) & 15] ^ block->l[(20 + 8) & 15] ^
               block->l[(20 + 2) & 15] ^ block->l[20 & 15])
              << (1)) |
             ((block->l[(20 + 13) & 15] ^ block->l[(20 + 8) & 15] ^
               block->l[(20 + 2) & 15] ^ block->l[20 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (a ^ b ^ c) +
       (block->l[21 & 15] =
            (((block->l[(21 + 13) & 15] ^ block->l[(21 + 8) & 15] ^
               block->l[(21 + 2) & 15] ^ block->l[21 & 15])
              << (1)) |
             ((block->l[(21 + 13) & 15] ^ block->l[(21 + 8) & 15] ^
               block->l[(21 + 2) & 15] ^ block->l[21 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (e ^ a ^ b) +
       (block->l[22 & 15] =
            (((block->l[(22 + 13) & 15] ^ block->l[(22 + 8) & 15] ^
               block->l[(22 + 2) & 15] ^ block->l[22 & 15])
              << (1)) |
             ((block->l[(22 + 13) & 15] ^ block->l[(22 + 8) & 15] ^
               block->l[(22 + 2) & 15] ^ block->l[22 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (d ^ e ^ a) +
       (block->l[23 & 15] =
            (((block->l[(23 + 13) & 15] ^ block->l[(23 + 8) & 15] ^
               block->l[(23 + 2) & 15] ^ block->l[23 & 15])
              << (1)) |
             ((block->l[(23 + 13) & 15] ^ block->l[(23 + 8) & 15] ^
               block->l[(23 + 2) & 15] ^ block->l[23 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (c ^ d ^ e) +
       (block->l[24 & 15] =
            (((block->l[(24 + 13) & 15] ^ block->l[(24 + 8) & 15] ^
               block->l[(24 + 2) & 15] ^ block->l[24 & 15])
              << (1)) |
             ((block->l[(24 + 13) & 15] ^ block->l[(24 + 8) & 15] ^
               block->l[(24 + 2) & 15] ^ block->l[24 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (b ^ c ^ d) +
       (block->l[25 & 15] =
            (((block->l[(25 + 13) & 15] ^ block->l[(25 + 8) & 15] ^
               block->l[(25 + 2) & 15] ^ block->l[25 & 15])
              << (1)) |
             ((block->l[(25 + 13) & 15] ^ block->l[(25 + 8) & 15] ^
               block->l[(25 + 2) & 15] ^ block->l[25 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (a ^ b ^ c) +
       (block->l[26 & 15] =
            (((block->l[(26 + 13) & 15] ^ block->l[(26 + 8) & 15] ^
               block->l[(26 + 2) & 15] ^ block->l[26 & 15])
              << (1)) |
             ((block->l[(26 + 13) & 15] ^ block->l[(26 + 8) & 15] ^
               block->l[(26 + 2) & 15] ^ block->l[26 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (e ^ a ^ b) +
       (block->l[27 & 15] =
            (((block->l[(27 + 13) & 15] ^ block->l[(27 + 8) & 15] ^
               block->l[(27 + 2) & 15] ^ block->l[27 & 15])
              << (1)) |
             ((block->l[(27 + 13) & 15] ^ block->l[(27 + 8) & 15] ^
               block->l[(27 + 2) & 15] ^ block->l[27 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (d ^ e ^ a) +
       (block->l[28 & 15] =
            (((block->l[(28 + 13) & 15] ^ block->l[(28 + 8) & 15] ^
               block->l[(28 + 2) & 15] ^ block->l[28 & 15])
              << (1)) |
             ((block->l[(28 + 13) & 15] ^ block->l[(28 + 8) & 15] ^
               block->l[(28 + 2) & 15] ^ block->l[28 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (c ^ d ^ e) +
       (block->l[29 & 15] =
            (((block->l[(29 + 13) & 15] ^ block->l[(29 + 8) & 15] ^
               block->l[(29 + 2) & 15] ^ block->l[29 & 15])
              << (1)) |
             ((block->l[(29 + 13) & 15] ^ block->l[(29 + 8) & 15] ^
               block->l[(29 + 2) & 15] ^ block->l[29 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (b ^ c ^ d) +
       (block->l[30 & 15] =
            (((block->l[(30 + 13) & 15] ^ block->l[(30 + 8) & 15] ^
               block->l[(30 + 2) & 15] ^ block->l[30 & 15])
              << (1)) |
             ((block->l[(30 + 13) & 15] ^ block->l[(30 + 8) & 15] ^
               block->l[(30 + 2) & 15] ^ block->l[30 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (a ^ b ^ c) +
       (block->l[31 & 15] =
            (((block->l[(31 + 13) & 15] ^ block->l[(31 + 8) & 15] ^
               block->l[(31 + 2) & 15] ^ block->l[31 & 15])
              << (1)) |
             ((block->l[(31 + 13) & 15] ^ block->l[(31 + 8) & 15] ^
               block->l[(31 + 2) & 15] ^ block->l[31 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (e ^ a ^ b) +
       (block->l[32 & 15] =
            (((block->l[(32 + 13) & 15] ^ block->l[(32 + 8) & 15] ^
               block->l[(32 + 2) & 15] ^ block->l[32 & 15])
              << (1)) |
             ((block->l[(32 + 13) & 15] ^ block->l[(32 + 8) & 15] ^
               block->l[(32 + 2) & 15] ^ block->l[32 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (d ^ e ^ a) +
       (block->l[33 & 15] =
            (((block->l[(33 + 13) & 15] ^ block->l[(33 + 8) & 15] ^
               block->l[(33 + 2) & 15] ^ block->l[33 & 15])
              << (1)) |
             ((block->l[(33 + 13) & 15] ^ block->l[(33 + 8) & 15] ^
               block->l[(33 + 2) & 15] ^ block->l[33 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (c ^ d ^ e) +
       (block->l[34 & 15] =
            (((block->l[(34 + 13) & 15] ^ block->l[(34 + 8) & 15] ^
               block->l[(34 + 2) & 15] ^ block->l[34 & 15])
              << (1)) |
             ((block->l[(34 + 13) & 15] ^ block->l[(34 + 8) & 15] ^
               block->l[(34 + 2) & 15] ^ block->l[34 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (b ^ c ^ d) +
       (block->l[35 & 15] =
            (((block->l[(35 + 13) & 15] ^ block->l[(35 + 8) & 15] ^
               block->l[(35 + 2) & 15] ^ block->l[35 & 15])
              << (1)) |
             ((block->l[(35 + 13) & 15] ^ block->l[(35 + 8) & 15] ^
               block->l[(35 + 2) & 15] ^ block->l[35 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (a ^ b ^ c) +
       (block->l[36 & 15] =
            (((block->l[(36 + 13) & 15] ^ block->l[(36 + 8) & 15] ^
               block->l[(36 + 2) & 15] ^ block->l[36 & 15])
              << (1)) |
             ((block->l[(36 + 13) & 15] ^ block->l[(36 + 8) & 15] ^
               block->l[(36 + 2) & 15] ^ block->l[36 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (e ^ a ^ b) +
       (block->l[37 & 15] =
            (((block->l[(37 + 13) & 15] ^ block->l[(37 + 8) & 15] ^
               block->l[(37 + 2) & 15] ^ block->l[37 & 15])
              << (1)) |
             ((block->l[(37 + 13) & 15] ^ block->l[(37 + 8) & 15] ^
               block->l[(37 + 2) & 15] ^ block->l[37 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (d ^ e ^ a) +
       (block->l[38 & 15] =
            (((block->l[(38 + 13) & 15] ^ block->l[(38 + 8) & 15] ^
               block->l[(38 + 2) & 15] ^ block->l[38 & 15])
              << (1)) |
             ((block->l[(38 + 13) & 15] ^ block->l[(38 + 8) & 15] ^
               block->l[(38 + 2) & 15] ^ block->l[38 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (c ^ d ^ e) +
       (block->l[39 & 15] =
            (((block->l[(39 + 13) & 15] ^ block->l[(39 + 8) & 15] ^
               block->l[(39 + 2) & 15] ^ block->l[39 & 15])
              << (1)) |
             ((block->l[(39 + 13) & 15] ^ block->l[(39 + 8) & 15] ^
               block->l[(39 + 2) & 15] ^ block->l[39 & 15]) >>
              (32 - (1))))) +
       0x6ED9EBA1 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (((b | c) & d) | (b & c)) +
       (block->l[40 & 15] =
            (((block->l[(40 + 13) & 15] ^ block->l[(40 + 8) & 15] ^
               block->l[(40 + 2) & 15] ^ block->l[40 & 15])
              << (1)) |
             ((block->l[(40 + 13) & 15] ^ block->l[(40 + 8) & 15] ^
               block->l[(40 + 2) & 15] ^ block->l[40 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (((a | b) & c) | (a & b)) +
       (block->l[41 & 15] =
            (((block->l[(41 + 13) & 15] ^ block->l[(41 + 8) & 15] ^
               block->l[(41 + 2) & 15] ^ block->l[41 & 15])
              << (1)) |
             ((block->l[(41 + 13) & 15] ^ block->l[(41 + 8) & 15] ^
               block->l[(41 + 2) & 15] ^ block->l[41 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (((e | a) & b) | (e & a)) +
       (block->l[42 & 15] =
            (((block->l[(42 + 13) & 15] ^ block->l[(42 + 8) & 15] ^
               block->l[(42 + 2) & 15] ^ block->l[42 & 15])
              << (1)) |
             ((block->l[(42 + 13) & 15] ^ block->l[(42 + 8) & 15] ^
               block->l[(42 + 2) & 15] ^ block->l[42 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (((d | e) & a) | (d & e)) +
       (block->l[43 & 15] =
            (((block->l[(43 + 13) & 15] ^ block->l[(43 + 8) & 15] ^
               block->l[(43 + 2) & 15] ^ block->l[43 & 15])
              << (1)) |
             ((block->l[(43 + 13) & 15] ^ block->l[(43 + 8) & 15] ^
               block->l[(43 + 2) & 15] ^ block->l[43 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (((c | d) & e) | (c & d)) +
       (block->l[44 & 15] =
            (((block->l[(44 + 13) & 15] ^ block->l[(44 + 8) & 15] ^
               block->l[(44 + 2) & 15] ^ block->l[44 & 15])
              << (1)) |
             ((block->l[(44 + 13) & 15] ^ block->l[(44 + 8) & 15] ^
               block->l[(44 + 2) & 15] ^ block->l[44 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (((b | c) & d) | (b & c)) +
       (block->l[45 & 15] =
            (((block->l[(45 + 13) & 15] ^ block->l[(45 + 8) & 15] ^
               block->l[(45 + 2) & 15] ^ block->l[45 & 15])
              << (1)) |
             ((block->l[(45 + 13) & 15] ^ block->l[(45 + 8) & 15] ^
               block->l[(45 + 2) & 15] ^ block->l[45 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (((a | b) & c) | (a & b)) +
       (block->l[46 & 15] =
            (((block->l[(46 + 13) & 15] ^ block->l[(46 + 8) & 15] ^
               block->l[(46 + 2) & 15] ^ block->l[46 & 15])
              << (1)) |
             ((block->l[(46 + 13) & 15] ^ block->l[(46 + 8) & 15] ^
               block->l[(46 + 2) & 15] ^ block->l[46 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (((e | a) & b) | (e & a)) +
       (block->l[47 & 15] =
            (((block->l[(47 + 13) & 15] ^ block->l[(47 + 8) & 15] ^
               block->l[(47 + 2) & 15] ^ block->l[47 & 15])
              << (1)) |
             ((block->l[(47 + 13) & 15] ^ block->l[(47 + 8) & 15] ^
               block->l[(47 + 2) & 15] ^ block->l[47 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (((d | e) & a) | (d & e)) +
       (block->l[48 & 15] =
            (((block->l[(48 + 13) & 15] ^ block->l[(48 + 8) & 15] ^
               block->l[(48 + 2) & 15] ^ block->l[48 & 15])
              << (1)) |
             ((block->l[(48 + 13) & 15] ^ block->l[(48 + 8) & 15] ^
               block->l[(48 + 2) & 15] ^ block->l[48 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (((c | d) & e) | (c & d)) +
       (block->l[49 & 15] =
            (((block->l[(49 + 13) & 15] ^ block->l[(49 + 8) & 15] ^
               block->l[(49 + 2) & 15] ^ block->l[49 & 15])
              << (1)) |
             ((block->l[(49 + 13) & 15] ^ block->l[(49 + 8) & 15] ^
               block->l[(49 + 2) & 15] ^ block->l[49 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (((b | c) & d) | (b & c)) +
       (block->l[50 & 15] =
            (((block->l[(50 + 13) & 15] ^ block->l[(50 + 8) & 15] ^
               block->l[(50 + 2) & 15] ^ block->l[50 & 15])
              << (1)) |
             ((block->l[(50 + 13) & 15] ^ block->l[(50 + 8) & 15] ^
               block->l[(50 + 2) & 15] ^ block->l[50 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (((a | b) & c) | (a & b)) +
       (block->l[51 & 15] =
            (((block->l[(51 + 13) & 15] ^ block->l[(51 + 8) & 15] ^
               block->l[(51 + 2) & 15] ^ block->l[51 & 15])
              << (1)) |
             ((block->l[(51 + 13) & 15] ^ block->l[(51 + 8) & 15] ^
               block->l[(51 + 2) & 15] ^ block->l[51 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (((e | a) & b) | (e & a)) +
       (block->l[52 & 15] =
            (((block->l[(52 + 13) & 15] ^ block->l[(52 + 8) & 15] ^
               block->l[(52 + 2) & 15] ^ block->l[52 & 15])
              << (1)) |
             ((block->l[(52 + 13) & 15] ^ block->l[(52 + 8) & 15] ^
               block->l[(52 + 2) & 15] ^ block->l[52 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (((d | e) & a) | (d & e)) +
       (block->l[53 & 15] =
            (((block->l[(53 + 13) & 15] ^ block->l[(53 + 8) & 15] ^
               block->l[(53 + 2) & 15] ^ block->l[53 & 15])
              << (1)) |
             ((block->l[(53 + 13) & 15] ^ block->l[(53 + 8) & 15] ^
               block->l[(53 + 2) & 15] ^ block->l[53 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (((c | d) & e) | (c & d)) +
       (block->l[54 & 15] =
            (((block->l[(54 + 13) & 15] ^ block->l[(54 + 8) & 15] ^
               block->l[(54 + 2) & 15] ^ block->l[54 & 15])
              << (1)) |
             ((block->l[(54 + 13) & 15] ^ block->l[(54 + 8) & 15] ^
               block->l[(54 + 2) & 15] ^ block->l[54 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (((b | c) & d) | (b & c)) +
       (block->l[55 & 15] =
            (((block->l[(55 + 13) & 15] ^ block->l[(55 + 8) & 15] ^
               block->l[(55 + 2) & 15] ^ block->l[55 & 15])
              << (1)) |
             ((block->l[(55 + 13) & 15] ^ block->l[(55 + 8) & 15] ^
               block->l[(55 + 2) & 15] ^ block->l[55 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (((a | b) & c) | (a & b)) +
       (block->l[56 & 15] =
            (((block->l[(56 + 13) & 15] ^ block->l[(56 + 8) & 15] ^
               block->l[(56 + 2) & 15] ^ block->l[56 & 15])
              << (1)) |
             ((block->l[(56 + 13) & 15] ^ block->l[(56 + 8) & 15] ^
               block->l[(56 + 2) & 15] ^ block->l[56 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (((e | a) & b) | (e & a)) +
       (block->l[57 & 15] =
            (((block->l[(57 + 13) & 15] ^ block->l[(57 + 8) & 15] ^
               block->l[(57 + 2) & 15] ^ block->l[57 & 15])
              << (1)) |
             ((block->l[(57 + 13) & 15] ^ block->l[(57 + 8) & 15] ^
               block->l[(57 + 2) & 15] ^ block->l[57 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (((d | e) & a) | (d & e)) +
       (block->l[58 & 15] =
            (((block->l[(58 + 13) & 15] ^ block->l[(58 + 8) & 15] ^
               block->l[(58 + 2) & 15] ^ block->l[58 & 15])
              << (1)) |
             ((block->l[(58 + 13) & 15] ^ block->l[(58 + 8) & 15] ^
               block->l[(58 + 2) & 15] ^ block->l[58 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (((c | d) & e) | (c & d)) +
       (block->l[59 & 15] =
            (((block->l[(59 + 13) & 15] ^ block->l[(59 + 8) & 15] ^
               block->l[(59 + 2) & 15] ^ block->l[59 & 15])
              << (1)) |
             ((block->l[(59 + 13) & 15] ^ block->l[(59 + 8) & 15] ^
               block->l[(59 + 2) & 15] ^ block->l[59 & 15]) >>
              (32 - (1))))) +
       0x8F1BBCDC + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (b ^ c ^ d) +
       (block->l[60 & 15] =
            (((block->l[(60 + 13) & 15] ^ block->l[(60 + 8) & 15] ^
               block->l[(60 + 2) & 15] ^ block->l[60 & 15])
              << (1)) |
             ((block->l[(60 + 13) & 15] ^ block->l[(60 + 8) & 15] ^
               block->l[(60 + 2) & 15] ^ block->l[60 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (a ^ b ^ c) +
       (block->l[61 & 15] =
            (((block->l[(61 + 13) & 15] ^ block->l[(61 + 8) & 15] ^
               block->l[(61 + 2) & 15] ^ block->l[61 & 15])
              << (1)) |
             ((block->l[(61 + 13) & 15] ^ block->l[(61 + 8) & 15] ^
               block->l[(61 + 2) & 15] ^ block->l[61 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (e ^ a ^ b) +
       (block->l[62 & 15] =
            (((block->l[(62 + 13) & 15] ^ block->l[(62 + 8) & 15] ^
               block->l[(62 + 2) & 15] ^ block->l[62 & 15])
              << (1)) |
             ((block->l[(62 + 13) & 15] ^ block->l[(62 + 8) & 15] ^
               block->l[(62 + 2) & 15] ^ block->l[62 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (d ^ e ^ a) +
       (block->l[63 & 15] =
            (((block->l[(63 + 13) & 15] ^ block->l[(63 + 8) & 15] ^
               block->l[(63 + 2) & 15] ^ block->l[63 & 15])
              << (1)) |
             ((block->l[(63 + 13) & 15] ^ block->l[(63 + 8) & 15] ^
               block->l[(63 + 2) & 15] ^ block->l[63 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (c ^ d ^ e) +
       (block->l[64 & 15] =
            (((block->l[(64 + 13) & 15] ^ block->l[(64 + 8) & 15] ^
               block->l[(64 + 2) & 15] ^ block->l[64 & 15])
              << (1)) |
             ((block->l[(64 + 13) & 15] ^ block->l[(64 + 8) & 15] ^
               block->l[(64 + 2) & 15] ^ block->l[64 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (b ^ c ^ d) +
       (block->l[65 & 15] =
            (((block->l[(65 + 13) & 15] ^ block->l[(65 + 8) & 15] ^
               block->l[(65 + 2) & 15] ^ block->l[65 & 15])
              << (1)) |
             ((block->l[(65 + 13) & 15] ^ block->l[(65 + 8) & 15] ^
               block->l[(65 + 2) & 15] ^ block->l[65 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (a ^ b ^ c) +
       (block->l[66 & 15] =
            (((block->l[(66 + 13) & 15] ^ block->l[(66 + 8) & 15] ^
               block->l[(66 + 2) & 15] ^ block->l[66 & 15])
              << (1)) |
             ((block->l[(66 + 13) & 15] ^ block->l[(66 + 8) & 15] ^
               block->l[(66 + 2) & 15] ^ block->l[66 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (e ^ a ^ b) +
       (block->l[67 & 15] =
            (((block->l[(67 + 13) & 15] ^ block->l[(67 + 8) & 15] ^
               block->l[(67 + 2) & 15] ^ block->l[67 & 15])
              << (1)) |
             ((block->l[(67 + 13) & 15] ^ block->l[(67 + 8) & 15] ^
               block->l[(67 + 2) & 15] ^ block->l[67 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (d ^ e ^ a) +
       (block->l[68 & 15] =
            (((block->l[(68 + 13) & 15] ^ block->l[(68 + 8) & 15] ^
               block->l[(68 + 2) & 15] ^ block->l[68 & 15])
              << (1)) |
             ((block->l[(68 + 13) & 15] ^ block->l[(68 + 8) & 15] ^
               block->l[(68 + 2) & 15] ^ block->l[68 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (c ^ d ^ e) +
       (block->l[69 & 15] =
            (((block->l[(69 + 13) & 15] ^ block->l[(69 + 8) & 15] ^
               block->l[(69 + 2) & 15] ^ block->l[69 & 15])
              << (1)) |
             ((block->l[(69 + 13) & 15] ^ block->l[(69 + 8) & 15] ^
               block->l[(69 + 2) & 15] ^ block->l[69 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (b ^ c ^ d) +
       (block->l[70 & 15] =
            (((block->l[(70 + 13) & 15] ^ block->l[(70 + 8) & 15] ^
               block->l[(70 + 2) & 15] ^ block->l[70 & 15])
              << (1)) |
             ((block->l[(70 + 13) & 15] ^ block->l[(70 + 8) & 15] ^
               block->l[(70 + 2) & 15] ^ block->l[70 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (a ^ b ^ c) +
       (block->l[71 & 15] =
            (((block->l[(71 + 13) & 15] ^ block->l[(71 + 8) & 15] ^
               block->l[(71 + 2) & 15] ^ block->l[71 & 15])
              << (1)) |
             ((block->l[(71 + 13) & 15] ^ block->l[(71 + 8) & 15] ^
               block->l[(71 + 2) & 15] ^ block->l[71 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (e ^ a ^ b) +
       (block->l[72 & 15] =
            (((block->l[(72 + 13) & 15] ^ block->l[(72 + 8) & 15] ^
               block->l[(72 + 2) & 15] ^ block->l[72 & 15])
              << (1)) |
             ((block->l[(72 + 13) & 15] ^ block->l[(72 + 8) & 15] ^
               block->l[(72 + 2) & 15] ^ block->l[72 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (d ^ e ^ a) +
       (block->l[73 & 15] =
            (((block->l[(73 + 13) & 15] ^ block->l[(73 + 8) & 15] ^
               block->l[(73 + 2) & 15] ^ block->l[73 & 15])
              << (1)) |
             ((block->l[(73 + 13) & 15] ^ block->l[(73 + 8) & 15] ^
               block->l[(73 + 2) & 15] ^ block->l[73 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (c ^ d ^ e) +
       (block->l[74 & 15] =
            (((block->l[(74 + 13) & 15] ^ block->l[(74 + 8) & 15] ^
               block->l[(74 + 2) & 15] ^ block->l[74 & 15])
              << (1)) |
             ((block->l[(74 + 13) & 15] ^ block->l[(74 + 8) & 15] ^
               block->l[(74 + 2) & 15] ^ block->l[74 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += (b ^ c ^ d) +
       (block->l[75 & 15] =
            (((block->l[(75 + 13) & 15] ^ block->l[(75 + 8) & 15] ^
               block->l[(75 + 2) & 15] ^ block->l[75 & 15])
              << (1)) |
             ((block->l[(75 + 13) & 15] ^ block->l[(75 + 8) & 15] ^
               block->l[(75 + 2) & 15] ^ block->l[75 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += (a ^ b ^ c) +
       (block->l[76 & 15] =
            (((block->l[(76 + 13) & 15] ^ block->l[(76 + 8) & 15] ^
               block->l[(76 + 2) & 15] ^ block->l[76 & 15])
              << (1)) |
             ((block->l[(76 + 13) & 15] ^ block->l[(76 + 8) & 15] ^
               block->l[(76 + 2) & 15] ^ block->l[76 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += (e ^ a ^ b) +
       (block->l[77 & 15] =
            (((block->l[(77 + 13) & 15] ^ block->l[(77 + 8) & 15] ^
               block->l[(77 + 2) & 15] ^ block->l[77 & 15])
              << (1)) |
             ((block->l[(77 + 13) & 15] ^ block->l[(77 + 8) & 15] ^
               block->l[(77 + 2) & 15] ^ block->l[77 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += (d ^ e ^ a) +
       (block->l[78 & 15] =
            (((block->l[(78 + 13) & 15] ^ block->l[(78 + 8) & 15] ^
               block->l[(78 + 2) & 15] ^ block->l[78 & 15])
              << (1)) |
             ((block->l[(78 + 13) & 15] ^ block->l[(78 + 8) & 15] ^
               block->l[(78 + 2) & 15] ^ block->l[78 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += (c ^ d ^ e) +
       (block->l[79 & 15] =
            (((block->l[(79 + 13) & 15] ^ block->l[(79 + 8) & 15] ^
               block->l[(79 + 2) & 15] ^ block->l[79 & 15])
              << (1)) |
             ((block->l[(79 + 13) & 15] ^ block->l[(79 + 8) & 15] ^
               block->l[(79 + 2) & 15] ^ block->l[79 & 15]) >>
              (32 - (1))))) +
       0xCA62C1D6 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  state[0] += a;
  state[1] += b;
  state[2] += c;
  state[3] += d;
  state[4] += e;
  a = b = c = d = e = 0;
}


x86 assembly (clang, -O0):
<SHA1Transform>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    0x4f19(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    $0x40,%edx
call   1030 <memcpy@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
xor    -0x20(%rbp),%ecx
and    %ecx,%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    -0x1c(%rbp),%ecx
and    %ecx,%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x4(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
xor    -0x18(%rbp),%ecx
and    %ecx,%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x8(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x24(%rbp),%ecx
xor    -0x14(%rbp),%ecx
and    %ecx,%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0xc(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0xc(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
xor    -0x24(%rbp),%ecx
and    %ecx,%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x10(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x10(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
xor    -0x20(%rbp),%ecx
and    %ecx,%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x14(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x14(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    -0x1c(%rbp),%ecx
and    %ecx,%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x18(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x18(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
xor    -0x18(%rbp),%ecx
and    %ecx,%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x1c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x1c(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x24(%rbp),%ecx
xor    -0x14(%rbp),%ecx
and    %ecx,%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x20(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x20(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
xor    -0x24(%rbp),%ecx
and    %ecx,%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x24(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x24(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
xor    -0x20(%rbp),%ecx
and    %ecx,%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x28(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x28(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    -0x1c(%rbp),%ecx
and    %ecx,%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x2c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x2c(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
xor    -0x18(%rbp),%ecx
and    %ecx,%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x30(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x30(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x24(%rbp),%ecx
xor    -0x14(%rbp),%ecx
and    %ecx,%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x34(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x34(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
xor    -0x24(%rbp),%ecx
and    %ecx,%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x38(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x38(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
mov    -0x1c(%rbp),%ecx
xor    -0x20(%rbp),%ecx
and    %ecx,%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x3c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x3c(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
mov    -0x18(%rbp),%ecx
xor    -0x1c(%rbp),%ecx
and    %ecx,%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x34(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x34(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x14(%rbp),%ecx
xor    -0x18(%rbp),%ecx
and    %ecx,%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x38(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x38(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x4(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x24(%rbp),%ecx
xor    -0x14(%rbp),%ecx
and    %ecx,%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x3c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x3c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x8(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x20(%rbp),%ecx
xor    -0x24(%rbp),%ecx
and    %ecx,%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0xc(%rdx)
add    %ecx,%eax
add    $0x5a827999,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x4(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x10(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x8(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x14(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0xc(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0xc(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x18(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x10(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x10(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x1c(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x14(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x14(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x20(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x18(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x18(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x24(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x1c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x1c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x28(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x20(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x20(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x2c(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x24(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x24(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x30(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x28(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x28(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x34(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x2c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x2c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x38(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x30(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x30(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x3c(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x34(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x34(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x38(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x38(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x4(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x3c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x3c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x8(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0xc(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x4(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x10(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x8(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x14(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0xc(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0xc(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x18(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x10(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x10(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x1c(%rdx)
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
or     -0x1c(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
and    -0x1c(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x14(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x14(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x20(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
or     -0x18(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
and    -0x18(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x18(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x18(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x24(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
or     -0x14(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x24(%rbp),%ecx
and    -0x14(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x1c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x1c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x28(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
or     -0x24(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
and    -0x24(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x20(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x20(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x2c(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
or     -0x20(%rbp),%eax
and    -0x24(%rbp),%eax
mov    -0x1c(%rbp),%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x24(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x24(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x30(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
or     -0x1c(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
and    -0x1c(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x28(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x28(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x34(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
or     -0x18(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
and    -0x18(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x2c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x2c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x38(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
or     -0x14(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x24(%rbp),%ecx
and    -0x14(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x30(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x30(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x3c(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
or     -0x24(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
and    -0x24(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x34(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x34(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
or     -0x20(%rbp),%eax
and    -0x24(%rbp),%eax
mov    -0x1c(%rbp),%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x38(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x38(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x4(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
or     -0x1c(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
and    -0x1c(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x3c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x3c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x8(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
or     -0x18(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
and    -0x18(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0xc(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
or     -0x14(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x24(%rbp),%ecx
and    -0x14(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x4(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x10(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
or     -0x24(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
and    -0x24(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x8(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x14(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
or     -0x20(%rbp),%eax
and    -0x24(%rbp),%eax
mov    -0x1c(%rbp),%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0xc(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0xc(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x18(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
or     -0x1c(%rbp),%eax
and    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
and    -0x1c(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x10(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x10(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x1c(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
or     -0x18(%rbp),%eax
and    -0x1c(%rbp),%eax
mov    -0x14(%rbp),%ecx
and    -0x18(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x14(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x14(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x20(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
or     -0x14(%rbp),%eax
and    -0x18(%rbp),%eax
mov    -0x24(%rbp),%ecx
and    -0x14(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x18(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x18(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x24(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
or     -0x24(%rbp),%eax
and    -0x14(%rbp),%eax
mov    -0x20(%rbp),%ecx
and    -0x24(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x1c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x1c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x28(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
or     -0x20(%rbp),%eax
and    -0x24(%rbp),%eax
mov    -0x1c(%rbp),%ecx
and    -0x20(%rbp),%ecx
or     %ecx,%eax
mov    -0x30(%rbp),%rcx
mov    0x20(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x20(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x2c(%rdx)
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x24(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x24(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x30(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x28(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x28(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x34(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x2c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x2c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x38(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x30(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x30(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x3c(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x34(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x34(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x38(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x38(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x4(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x3c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x3c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x8(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    (%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0xc(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x4(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x4(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x10(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x8(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x8(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x14(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0xc(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0xc(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x18(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x10(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x10(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x1c(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x14(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x20(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x14(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x20(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x20(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x18(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x24(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x18(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x24(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x24(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x1c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x8(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x28(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x1c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x8(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x28(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x28(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x20(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0xc(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x2c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x20(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0xc(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x2c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x2c(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x14(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x14(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1e,%eax
mov    -0x18(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x24(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x10(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x30(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x24(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x10(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x30(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x30(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x24(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x24(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x1e,%eax
mov    -0x14(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x14(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
xor    -0x18(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x28(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x14(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x34(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x28(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x14(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x34(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x34(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x20(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x20(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x1e,%eax
mov    -0x24(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x14(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x2c(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x18(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    (%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x38(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x2c(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x18(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    (%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x38(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x38(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x1c(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x1c(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x1e,%eax
mov    -0x20(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    -0x30(%rbp),%rcx
mov    0x30(%rcx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x1c(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x4(%rdx),%ecx
mov    -0x30(%rbp),%rdx
xor    0x3c(%rdx),%ecx
shl    $0x1,%ecx
mov    -0x30(%rbp),%rdx
mov    0x30(%rdx),%edx
mov    -0x30(%rbp),%rsi
xor    0x1c(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x4(%rsi),%edx
mov    -0x30(%rbp),%rsi
xor    0x3c(%rsi),%edx
shr    $0x1f,%edx
or     %edx,%ecx
mov    -0x30(%rbp),%rdx
mov    %ecx,0x3c(%rdx)
add    %ecx,%eax
add    $0xca62c1d6,%eax
mov    -0x18(%rbp),%ecx
shl    $0x5,%ecx
mov    -0x18(%rbp),%edx
shr    $0x1b,%edx
or     %edx,%ecx
add    %ecx,%eax
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x1e,%eax
mov    -0x1c(%rbp),%ecx
shr    $0x2,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x20(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
mov    -0x24(%rbp),%ecx
mov    -0x8(%rbp),%rax
add    0x10(%rax),%ecx
mov    %ecx,0x10(%rax)
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x14(%rbp)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<SHA1Transform>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movups (%rsi),%xmm0
movups 0x10(%rsi),%xmm1
movups 0x20(%rsi),%xmm2
movups 0x30(%rsi),%xmm3
movaps %xmm3,0x3f40(%rip)
movaps %xmm2,0x3f29(%rip)
movaps %xmm1,0x3f12(%rip)
movaps %xmm0,0x3efb(%rip)
mov    (%rdi),%ebx
mov    0x4(%rdi),%eax
mov    0x8(%rdi),%esi
mov    0xc(%rdi),%ebp
mov    %rdi,-0x8(%rsp)
mov    %ebp,%ecx
xor    %esi,%ecx
and    %eax,%ecx
xor    %ebp,%ecx
mov    0x3edc(%rip),%r9d
mov    %ebx,%edx
rol    $0x5,%edx
add    0x10(%rdi),%edx
add    %r9d,%edx
lea    (%rcx,%rdx,1),%r10d
add    $0x5a827999,%r10d
rol    $0x1e,%eax
mov    %eax,%edx
xor    %esi,%edx
and    %ebx,%edx
xor    %esi,%edx
mov    0x3eb9(%rip),%edi
mov    %edi,-0x48(%rsp)
mov    %r10d,%ecx
rol    $0x5,%ecx
add    %ebp,%edx
add    %edi,%edx
rol    $0x1e,%ebx
lea    (%rcx,%rdx,1),%ebp
add    $0x5a827999,%ebp
mov    %eax,%ecx
xor    %ebx,%ecx
and    %r10d,%ecx
xor    %eax,%ecx
mov    0x3e93(%rip),%r13d
mov    %ebp,%edx
rol    $0x5,%edx
add    %r13d,%esi
add    %ecx,%esi
add    %edx,%esi
add    $0x5a827999,%esi
rol    $0x1e,%r10d
mov    %r10d,%ecx
xor    %ebx,%ecx
and    %ebp,%ecx
xor    %ebx,%ecx
mov    0x3e72(%rip),%edi
mov    %edi,-0x3c(%rsp)
mov    %esi,%edx
rol    $0x5,%edx
add    %edi,%eax
add    %ecx,%eax
lea    (%rdx,%rax,1),%edi
add    $0x5a827999,%edi
rol    $0x1e,%ebp
mov    %ebp,%eax
xor    %r10d,%eax
and    %esi,%eax
xor    %r10d,%eax
mov    %edi,%ecx
rol    $0x5,%ecx
mov    0x3e48(%rip),%edx
mov    %edx,-0x50(%rsp)
add    %edx,%ebx
add    %eax,%ebx
lea    (%rcx,%rbx,1),%r11d
add    $0x5a827999,%r11d
rol    $0x1e,%esi
mov    %esi,%eax
xor    %ebp,%eax
and    %edi,%eax
xor    %ebp,%eax
mov    0x3e28(%rip),%edx
mov    %edx,-0x44(%rsp)
mov    %r11d,%ecx
rol    $0x5,%ecx
add    %edx,%r10d
add    %eax,%r10d
rol    $0x1e,%edi
lea    (%rcx,%r10,1),%edx
add    $0x5a827999,%edx
mov    %edi,%ecx
xor    %esi,%ecx
and    %r11d,%ecx
xor    %esi,%ecx
mov    0x3e00(%rip),%ebx
mov    %ebx,-0x4c(%rsp)
mov    %edx,%eax
rol    $0x5,%eax
add    %ebx,%ebp
add    %ecx,%ebp
add    %eax,%ebp
add    $0x5a827999,%ebp
rol    $0x1e,%r11d
mov    %r11d,%eax
xor    %edi,%eax
and    %edx,%eax
xor    %edi,%eax
mov    0x3ddc(%rip),%ecx
mov    %ecx,-0x54(%rsp)
add    %ecx,%esi
add    %eax,%esi
mov    %ebp,%eax
rol    $0x5,%eax
lea    (%rax,%rsi,1),%ebx
add    $0x5a827999,%ebx
rol    $0x1e,%edx
mov    %edx,%eax
xor    %r11d,%eax
and    %ebp,%eax
xor    %r11d,%eax
mov    0x3db7(%rip),%ecx
add    %ecx,%edi
mov    %ecx,%r15d
mov    %ecx,-0x24(%rsp)
add    %eax,%edi
mov    %ebx,%eax
rol    $0x5,%eax
lea    (%rax,%rdi,1),%r14d
add    $0x5a827999,%r14d
rol    $0x1e,%ebp
mov    %ebp,%eax
xor    %edx,%eax
and    %ebx,%eax
xor    %edx,%eax
mov    0x3d8e(%rip),%r8d
add    %r8d,%r11d
mov    %r8d,-0x2c(%rsp)
add    %eax,%r11d
mov    %r14d,%eax
rol    $0x5,%eax
rol    $0x1e,%ebx
lea    (%rax,%r11,1),%edi
add    $0x5a827999,%edi
mov    %ebx,%eax
xor    %ebp,%eax
and    %r14d,%eax
xor    %ebp,%eax
mov    %edi,%esi
rol    $0x5,%esi
mov    0x3d5f(%rip),%r12d
add    %r12d,%edx
mov    %r12d,-0x40(%rsp)
add    %eax,%edx
add    %esi,%edx
add    $0x5a827999,%edx
rol    $0x1e,%r14d
mov    %r14d,%eax
xor    %ebx,%eax
and    %edi,%eax
xor    %ebx,%eax
mov    0x3d3e(%rip),%ecx
mov    %ecx,-0x34(%rsp)
add    %ecx,%ebp
add    %eax,%ebp
mov    %edx,%eax
rol    $0x5,%eax
lea    (%rax,%rbp,1),%r10d
add    $0x5a827999,%r10d
rol    $0x1e,%edi
mov    %edi,%eax
xor    %r14d,%eax
and    %edx,%eax
xor    %r14d,%eax
mov    0x3d17(%rip),%ecx
mov    %ecx,-0x30(%rsp)
add    %ecx,%ebx
add    %eax,%ebx
mov    %r10d,%eax
rol    $0x5,%eax
lea    (%rax,%rbx,1),%ebp
add    $0x5a827999,%ebp
rol    $0x1e,%edx
mov    %edx,%eax
xor    %edi,%eax
and    %r10d,%eax
xor    %edi,%eax
mov    0x3cf2(%rip),%esi
add    %esi,%r14d
mov    %rsi,%rbx
mov    %rsi,-0x20(%rsp)
add    %eax,%r14d
mov    %ebp,%eax
rol    $0x5,%eax
rol    $0x1e,%r10d
lea    (%rax,%r14,1),%ecx
add    $0x5a827999,%ecx
mov    %r10d,%eax
xor    %edx,%eax
and    %ebp,%eax
xor    %edx,%eax
mov    %ecx,%esi
rol    $0x5,%esi
mov    0x3cc0(%rip),%r11d
add    %r11d,%edi
mov    %r11d,%r14d
mov    %r11d,-0x38(%rsp)
add    %eax,%edi
lea    (%rsi,%rdi,1),%r11d
add    $0x5a827999,%r11d
rol    $0x1e,%ebp
mov    %ebp,%eax
xor    %r10d,%eax
and    %ecx,%eax
xor    %r10d,%eax
mov    0x3c99(%rip),%esi
add    %esi,%edx
add    %eax,%edx
mov    %r11d,%eax
rol    $0x5,%eax
add    %eax,%edx
add    $0x5a827999,%edx
xor    %r13d,%r9d
xor    %ebx,%r15d
xor    %r9d,%r15d
rol    $0x1e,%ecx
mov    %ecx,%r9d
xor    %ebp,%r9d
and    %r11d,%r9d
xor    %ebp,%r9d
rol    %r15d
add    %r15d,%r10d
mov    %r15,-0x10(%rsp)
add    %r9d,%r10d
mov    %edx,%eax
rol    $0x5,%eax
lea    (%rax,%r10,1),%r9d
add    $0x5a827999,%r9d
rol    $0x1e,%r11d
mov    -0x3c(%rsp),%ebx
mov    -0x48(%rsp),%eax
xor    %ebx,%eax
mov    %r8d,%edi
xor    %r14d,%edi
xor    %eax,%edi
mov    %r11d,%eax
xor    %ecx,%eax
and    %edx,%eax
xor    %ecx,%eax
rol    %edi
add    %edi,%ebp
mov    %rdi,%r14
mov    %rdi,-0x18(%rsp)
add    %eax,%ebp
mov    %r9d,%eax
rol    $0x5,%eax
lea    (%rax,%rbp,1),%r8d
add    $0x5a827999,%r8d
mov    -0x50(%rsp),%ebp
mov    %r13d,%eax
xor    %ebp,%eax
xor    %esi,%r12d
mov    %esi,%r13d
mov    %esi,-0x28(%rsp)
xor    %eax,%r12d
rol    $0x1e,%edx
mov    %edx,%eax
xor    %r11d,%eax
and    %r9d,%eax
rol    %r12d
xor    %r11d,%eax
mov    %r8d,%esi
rol    $0x5,%esi
add    %r12d,%ecx
mov    %r12d,-0x48(%rsp)
add    %eax,%ecx
lea    (%rsi,%rcx,1),%eax
add    $0x5a827999,%eax
rol    $0x1e,%r9d
mov    %r9d,%ecx
xor    %edx,%ecx
and    %r8d,%ecx
xor    %edx,%ecx
mov    %ebx,%esi
mov    -0x44(%rsp),%r10d
xor    %r10d,%esi
xor    -0x34(%rsp),%esi
xor    %r15d,%esi
rol    %esi
add    %esi,%r11d
mov    %esi,%r15d
add    %ecx,%r11d
mov    %eax,%ecx
rol    $0x5,%ecx
add    %r11d,%ecx
add    $0x5a827999,%ecx
rol    $0x1e,%r8d
mov    %r8d,%esi
xor    %r9d,%esi
xor    %eax,%esi
mov    -0x4c(%rsp),%r11d
xor    %r11d,%ebp
xor    -0x30(%rsp),%ebp
xor    %r14d,%ebp
rol    %ebp
add    %ebp,%edx
mov    %ebp,-0x50(%rsp)
add    %esi,%edx
mov    %ecx,%esi
rol    $0x5,%esi
rol    $0x1e,%eax
lea    (%rsi,%rdx,1),%edi
add    $0x6ed9eba1,%edi
mov    %eax,%edx
xor    %r8d,%edx
xor    %ecx,%edx
mov    %r10d,%esi
mov    -0x54(%rsp),%r10d
xor    %r10d,%esi
xor    -0x20(%rsp),%esi
xor    %r12d,%esi
rol    %esi
add    %esi,%r9d
mov    %esi,%r14d
mov    %esi,-0x44(%rsp)
add    %edx,%r9d
mov    %edi,%edx
rol    $0x5,%edx
add    %edx,%r9d
add    $0x6ed9eba1,%r9d
rol    $0x1e,%ecx
mov    %ecx,%esi
xor    %eax,%esi
xor    %edi,%esi
mov    %r11d,%edx
mov    -0x24(%rsp),%r12d
xor    %r12d,%edx
xor    -0x38(%rsp),%edx
xor    %r15d,%edx
mov    %r15d,%r11d
mov    %r15d,-0x3c(%rsp)
rol    %edx
add    %edx,%r8d
mov    %edx,%ebx
mov    %edx,-0x4c(%rsp)
add    %esi,%r8d
mov    %r9d,%esi
rol    $0x5,%esi
rol    $0x1e,%edi
add    %r8d,%esi
add    $0x6ed9eba1,%esi
mov    %edi,%r8d
xor    %ecx,%r8d
xor    %r9d,%r8d
mov    %r10d,%edx
mov    -0x2c(%rsp),%r15d
xor    %r15d,%edx
xor    %r13d,%edx
xor    %ebp,%edx
rol    %edx
add    %edx,%eax
mov    %edx,%r10d
mov    %edx,-0x54(%rsp)
add    %r8d,%eax
mov    %esi,%edx
rol    $0x5,%edx
lea    (%rdx,%rax,1),%r8d
add    $0x6ed9eba1,%r8d
rol    $0x1e,%r9d
mov    %r9d,%eax
xor    %edi,%eax
xor    %esi,%eax
mov    -0x40(%rsp),%ebp
xor    %ebp,%r12d
xor    -0x10(%rsp),%r12d
xor    %r14d,%r12d
rol    %r12d
add    %r12d,%ecx
add    %eax,%ecx
mov    %r8d,%eax
rol    $0x5,%eax
rol    $0x1e,%esi
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    %esi,%ecx
xor    %r9d,%ecx
xor    %r8d,%ecx
mov    -0x34(%rsp),%r14d
xor    %r14d,%r15d
xor    -0x18(%rsp),%r15d
xor    %ebx,%r15d
rol    %r15d
add    %r15d,%edi
mov    %r15d,-0x2c(%rsp)
add    %ecx,%edi
mov    %eax,%ecx
rol    $0x5,%ecx
add    %edi,%ecx
add    $0x6ed9eba1,%ecx
rol    $0x1e,%r8d
mov    %r8d,%edx
xor    %esi,%edx
xor    %eax,%edx
mov    %ebp,%r13d
mov    -0x30(%rsp),%edi
xor    %edi,%r13d
xor    -0x48(%rsp),%r13d
xor    %r10d,%r13d
rol    %r13d
add    %r13d,%r9d
mov    %r13d,-0x40(%rsp)
add    %edx,%r9d
mov    %ecx,%edx
rol    $0x5,%edx
rol    $0x1e,%eax
add    %edx,%r9d
add    $0x6ed9eba1,%r9d
mov    %eax,%edx
xor    %r8d,%edx
xor    %ecx,%edx
mov    -0x20(%rsp),%rbx
xor    %ebx,%r14d
xor    %r11d,%r14d
xor    %r12d,%r14d
mov    %r12d,-0x24(%rsp)
rol    %r14d
add    %r14d,%esi
mov    %r14d,%r11d
add    %edx,%esi
mov    %r9d,%edx
rol    $0x5,%edx
add    %esi,%edx
add    $0x6ed9eba1,%edx
rol    $0x1e,%ecx
mov    %ecx,%esi
xor    %eax,%esi
xor    %r9d,%esi
mov    -0x38(%rsp),%r10d
xor    %r10d,%edi
xor    -0x50(%rsp),%edi
xor    %r15d,%edi
rol    %edi
add    %edi,%r8d
mov    %edi,%r14d
mov    %edi,-0x30(%rsp)
add    %esi,%r8d
mov    %edx,%esi
rol    $0x5,%esi
rol    $0x1e,%r9d
add    %r8d,%esi
add    $0x6ed9eba1,%esi
mov    %r9d,%edi
xor    %ecx,%edi
xor    %edx,%edi
mov    -0x28(%rsp),%ebp
xor    %ebp,%ebx
xor    -0x44(%rsp),%ebx
xor    %r13d,%ebx
rol    %ebx
add    %ebx,%eax
mov    %rbx,%r15
mov    %rbx,-0x20(%rsp)
add    %edi,%eax
mov    %esi,%edi
rol    $0x5,%edi
lea    (%rdi,%rax,1),%r8d
add    $0x6ed9eba1,%r8d
rol    $0x1e,%edx
mov    %edx,%eax
xor    %r9d,%eax
xor    %esi,%eax
mov    %r10d,%edi
mov    -0x10(%rsp),%r10
xor    %r10d,%edi
xor    -0x4c(%rsp),%edi
xor    %r11d,%edi
mov    %r11d,%r13d
mov    %r11d,-0x34(%rsp)
rol    %edi
add    %edi,%ecx
mov    %edi,%r11d
mov    %edi,-0x38(%rsp)
add    %eax,%ecx
mov    %r8d,%eax
rol    $0x5,%eax
rol    $0x1e,%esi
add    %ecx,%eax
add    $0x6ed9eba1,%eax
mov    %esi,%ecx
xor    %edx,%ecx
xor    %r8d,%ecx
mov    %ebp,%edi
mov    -0x18(%rsp),%rbx
xor    %ebx,%edi
xor    -0x54(%rsp),%edi
xor    %r14d,%edi
rol    %edi
add    %edi,%r9d
mov    %edi,%r14d
mov    %edi,-0x28(%rsp)
add    %ecx,%r9d
mov    %eax,%ecx
rol    $0x5,%ecx
add    %ecx,%r9d
add    $0x6ed9eba1,%r9d
rol    $0x1e,%r8d
mov    %r8d,%ecx
xor    %esi,%ecx
xor    %eax,%ecx
mov    -0x48(%rsp),%ebp
xor    %ebp,%r10d
xor    %r12d,%r10d
xor    %r15d,%r10d
rol    %r10d
add    %r10d,%edx
mov    %r10,%r12
add    %ecx,%edx
mov    %r9d,%ecx
rol    $0x5,%ecx
rol    $0x1e,%eax
add    %edx,%ecx
add    $0x6ed9eba1,%ecx
mov    %eax,%edx
xor    %r8d,%edx
xor    %r9d,%edx
mov    -0x3c(%rsp),%r10d
mov    %rbx,%rdi
xor    %r10d,%edi
xor    -0x2c(%rsp),%edi
xor    %r11d,%edi
rol    %edi
add    %edi,%esi
mov    %rdi,%r11
mov    %rdi,-0x18(%rsp)
add    %edx,%esi
mov    %ecx,%edx
rol    $0x5,%edx
lea    (%rdx,%rsi,1),%edi
add    $0x6ed9eba1,%edi
rol    $0x1e,%r9d
mov    %r9d,%edx
xor    %eax,%edx
xor    %ecx,%edx
mov    -0x50(%rsp),%ebx
mov    %ebp,%r15d
xor    %ebx,%r15d
xor    -0x40(%rsp),%r15d
xor    %r14d,%r15d
rol    %r15d
add    %r15d,%r8d
mov    %r15d,-0x48(%rsp)
add    %edx,%r8d
mov    %edi,%edx
rol    $0x5,%edx
rol    $0x1e,%ecx
add    %edx,%r8d
add    $0x6ed9eba1,%r8d
mov    %ecx,%edx
xor    %r9d,%edx
xor    %edi,%edx
mov    %r10d,%ebp
mov    -0x44(%rsp),%r10d
xor    %r10d,%ebp
xor    %r13d,%ebp
xor    %r12d,%ebp
mov    %r12,%r13
mov    %r12,-0x10(%rsp)
rol    %ebp
add    %ebp,%eax
mov    %ebp,-0x3c(%rsp)
add    %edx,%eax
mov    %r8d,%edx
rol    $0x5,%edx
add    %eax,%edx
add    $0x6ed9eba1,%edx
rol    $0x1e,%edi
mov    %edi,%eax
xor    %ecx,%eax
xor    %r8d,%eax
mov    -0x4c(%rsp),%r14d
xor    %r14d,%ebx
xor    -0x30(%rsp),%ebx
xor    %r11d,%ebx
rol    %ebx
add    %ebx,%r9d
mov    %ebx,-0x50(%rsp)
add    %eax,%r9d
mov    %edx,%eax
rol    $0x5,%eax
rol    $0x1e,%r8d
add    %eax,%r9d
add    $0x6ed9eba1,%r9d
mov    %r8d,%eax
xor    %edi,%eax
xor    %edx,%eax
mov    %r10d,%r11d
mov    -0x54(%rsp),%r10d
xor    %r10d,%r11d
xor    -0x20(%rsp),%r11d
xor    %r15d,%r11d
rol    %r11d
add    %r11d,%ecx
mov    %r11d,-0x44(%rsp)
add    %eax,%ecx
mov    %r9d,%eax
rol    $0x5,%eax
lea    (%rax,%rcx,1),%esi
add    $0x6ed9eba1,%esi
rol    $0x1e,%edx
mov    %edx,%eax
xor    %r8d,%eax
xor    %r9d,%eax
mov    -0x24(%rsp),%r12d
xor    %r12d,%r14d
xor    -0x38(%rsp),%r14d
xor    %ebp,%r14d
rol    %r14d
add    %r14d,%edi
mov    %r14d,-0x4c(%rsp)
add    %eax,%edi
mov    %esi,%eax
rol    $0x5,%eax
rol    $0x1e,%r9d
add    %eax,%edi
add    $0x6ed9eba1,%edi
mov    %r9d,%eax
xor    %edx,%eax
xor    %esi,%eax
mov    -0x2c(%rsp),%r15d
xor    %r15d,%r10d
xor    -0x28(%rsp),%r10d
xor    %ebx,%r10d
rol    %r10d
add    %r10d,%r8d
add    %eax,%r8d
mov    %edi,%eax
rol    $0x5,%eax
add    %eax,%r8d
add    $0x6ed9eba1,%r8d
rol    $0x1e,%esi
mov    %edi,%ecx
or     %esi,%ecx
and    %r9d,%ecx
mov    %edi,%eax
and    %esi,%eax
or     %ecx,%eax
mov    -0x40(%rsp),%ebp
xor    %ebp,%r12d
xor    %r13d,%r12d
xor    %r11d,%r12d
rol    %r12d
add    %r12d,%edx
add    %eax,%edx
mov    %r8d,%eax
rol    $0x5,%eax
lea    (%rax,%rdx,1),%ecx
add    $0x8f1bbcdc,%ecx
rol    $0x1e,%edi
mov    %r8d,%eax
or     %edi,%eax
and    %esi,%eax
mov    %r8d,%edx
and    %edi,%edx
or     %eax,%edx
mov    -0x34(%rsp),%ebx
xor    %ebx,%r15d
mov    -0x18(%rsp),%r11
xor    %r11d,%r15d
xor    %r14d,%r15d
rol    %r15d
add    %r15d,%r9d
mov    %r15d,-0x2c(%rsp)
add    %edx,%r9d
mov    %ecx,%eax
rol    $0x5,%eax
add    %eax,%r9d
add    $0x8f1bbcdc,%r9d
rol    $0x1e,%r8d
mov    %ecx,%eax
or     %r8d,%eax
and    %edi,%eax
mov    %ecx,%edx
and    %r8d,%edx
or     %eax,%edx
mov    %ebp,%r13d
mov    -0x30(%rsp),%ebp
xor    %ebp,%r13d
xor    -0x48(%rsp),%r13d
mov    %r10d,-0x54(%rsp)
xor    %r10d,%r13d
rol    %r13d
add    %r13d,%esi
mov    %r13d,%r10d
mov    %r13d,-0x40(%rsp)
add    %edx,%esi
mov    %r9d,%eax
rol    $0x5,%eax
add    %eax,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%ecx
mov    %r9d,%eax
or     %ecx,%eax
and    %r8d,%eax
mov    %r9d,%edx
and    %ecx,%edx
or     %eax,%edx
mov    %ebx,%r14d
mov    -0x20(%rsp),%rbx
xor    %ebx,%r14d
xor    -0x3c(%rsp),%r14d
xor    %r12d,%r14d
rol    %r14d
add    %r14d,%edi
mov    %r14d,-0x34(%rsp)
add    %edx,%edi
mov    %esi,%eax
rol    $0x5,%eax
add    %eax,%edi
add    $0x8f1bbcdc,%edi
rol    $0x1e,%r9d
mov    %esi,%eax
or     %r9d,%eax
and    %ecx,%eax
mov    %esi,%edx
and    %r9d,%edx
or     %eax,%edx
mov    %ebp,%eax
mov    -0x38(%rsp),%r13d
xor    %r13d,%eax
xor    -0x50(%rsp),%eax
xor    %r15d,%eax
rol    %eax
add    %eax,%r8d
mov    %eax,%r15d
add    %edx,%r8d
mov    %edi,%eax
rol    $0x5,%eax
add    %eax,%r8d
add    $0x8f1bbcdc,%r8d
rol    $0x1e,%esi
mov    %edi,%edx
or     %esi,%edx
and    %r9d,%edx
mov    %edi,%eax
and    %esi,%eax
or     %edx,%eax
mov    -0x28(%rsp),%ebp
xor    %ebp,%ebx
xor    -0x44(%rsp),%ebx
xor    %r10d,%ebx
rol    %ebx
add    %ebx,%ecx
mov    %rbx,-0x20(%rsp)
add    %eax,%ecx
mov    %r8d,%eax
rol    $0x5,%eax
add    %eax,%ecx
add    $0x8f1bbcdc,%ecx
rol    $0x1e,%edi
mov    %r8d,%eax
or     %edi,%eax
and    %esi,%eax
mov    %r8d,%edx
and    %edi,%edx
or     %eax,%edx
mov    -0x10(%rsp),%r10
xor    %r10d,%r13d
xor    -0x4c(%rsp),%r13d
xor    %r14d,%r13d
rol    %r13d
add    %r13d,%r9d
mov    %r13d,%r14d
mov    %r13d,-0x38(%rsp)
add    %edx,%r9d
mov    %ecx,%eax
rol    $0x5,%eax
add    %eax,%r9d
add    $0x8f1bbcdc,%r9d
rol    $0x1e,%r8d
mov    %ecx,%eax
or     %r8d,%eax
and    %edi,%eax
mov    %ecx,%edx
and    %r8d,%edx
or     %eax,%edx
xor    %r11d,%ebp
xor    -0x54(%rsp),%ebp
mov    %r15d,-0x30(%rsp)
xor    %r15d,%ebp
rol    %ebp
mov    %ebp,-0x28(%rsp)
add    %ebp,%esi
add    %edx,%esi
mov    %r9d,%eax
rol    $0x5,%eax
add    %eax,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%ecx
mov    %r9d,%eax
or     %ecx,%eax
and    %r8d,%eax
mov    %r9d,%edx
and    %ecx,%edx
or     %eax,%edx
mov    -0x48(%rsp),%ebp
xor    %ebp,%r10d
mov    %r12d,-0x24(%rsp)
xor    %r12d,%r10d
xor    %ebx,%r10d
rol    %r10d
add    %r10d,%edi
mov    %r10,-0x10(%rsp)
add    %edx,%edi
mov    %esi,%eax
rol    $0x5,%eax
add    %eax,%edi
add    $0x8f1bbcdc,%edi
rol    $0x1e,%r9d
mov    %esi,%eax
or     %r9d,%eax
and    %ecx,%eax
mov    %esi,%edx
and    %r9d,%edx
or     %eax,%edx
mov    -0x3c(%rsp),%r13d
xor    %r13d,%r11d
mov    -0x2c(%rsp),%r12d
xor    %r12d,%r11d
xor    %r14d,%r11d
rol    %r11d
add    %r11d,%r8d
mov    %r11,-0x18(%rsp)
add    %edx,%r8d
mov    %edi,%eax
rol    $0x5,%eax
add    %eax,%r8d
add    $0x8f1bbcdc,%r8d
rol    $0x1e,%esi
mov    %edi,%edx
or     %esi,%edx
and    %r9d,%edx
mov    %edi,%eax
and    %esi,%eax
or     %edx,%eax
mov    -0x50(%rsp),%ebx
xor    %ebx,%ebp
xor    -0x40(%rsp),%ebp
mov    -0x28(%rsp),%r14d
xor    %r14d,%ebp
rol    %ebp
add    %ebp,%ecx
mov    %ebp,-0x48(%rsp)
add    %eax,%ecx
mov    %r8d,%eax
rol    $0x5,%eax
add    %eax,%ecx
add    $0x8f1bbcdc,%ecx
rol    $0x1e,%edi
mov    %r8d,%eax
or     %edi,%eax
and    %esi,%eax
mov    %r8d,%edx
and    %edi,%edx
or     %eax,%edx
mov    %r13d,%eax
mov    -0x44(%rsp),%r13d
xor    %r13d,%eax
xor    -0x34(%rsp),%eax
xor    %r10d,%eax
rol    %eax
add    %eax,%r9d
mov    %eax,%r10d
mov    %eax,-0x3c(%rsp)
add    %edx,%r9d
mov    %ecx,%eax
rol    $0x5,%eax
add    %eax,%r9d
add    $0x8f1bbcdc,%r9d
rol    $0x1e,%r8d
mov    %ecx,%eax
or     %r8d,%eax
and    %edi,%eax
mov    %ecx,%edx
and    %r8d,%edx
or     %eax,%edx
mov    %ebx,%eax
mov    -0x4c(%rsp),%ebx
xor    %ebx,%eax
xor    %r15d,%eax
xor    %r11d,%eax
rol    %eax
mov    %eax,-0x50(%rsp)
add    %eax,%esi
add    %edx,%esi
mov    %r9d,%eax
rol    $0x5,%eax
add    %eax,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%ecx
mov    %r9d,%eax
or     %ecx,%eax
and    %r8d,%eax
mov    %r9d,%edx
and    %ecx,%edx
or     %eax,%edx
mov    %r13d,%r11d
mov    -0x54(%rsp),%r13d
xor    %r13d,%r11d
xor    -0x20(%rsp),%r11d
xor    %ebp,%r11d
rol    %r11d
add    %r11d,%edi
mov    %r11d,-0x44(%rsp)
add    %edx,%edi
mov    %esi,%eax
rol    $0x5,%eax
add    %eax,%edi
add    $0x8f1bbcdc,%edi
rol    $0x1e,%r9d
mov    %esi,%eax
or     %r9d,%eax
and    %ecx,%eax
mov    %esi,%edx
and    %r9d,%edx
or     %eax,%edx
mov    %ebx,%eax
mov    -0x24(%rsp),%ebx
xor    %ebx,%eax
xor    -0x38(%rsp),%eax
xor    %r10d,%eax
rol    %eax
add    %eax,%r8d
mov    %eax,%r10d
mov    %eax,-0x4c(%rsp)
add    %edx,%r8d
mov    %edi,%eax
rol    $0x5,%eax
add    %eax,%r8d
add    $0x8f1bbcdc,%r8d
rol    $0x1e,%esi
mov    %edi,%edx
or     %esi,%edx
and    %r9d,%edx
mov    %edi,%eax
and    %esi,%eax
or     %edx,%eax
mov    %r13d,%edx
xor    %r12d,%edx
xor    %r14d,%edx
xor    -0x50(%rsp),%edx
rol    %edx
mov    %edx,-0x54(%rsp)
add    %edx,%ecx
add    %eax,%ecx
mov    %r8d,%eax
rol    $0x5,%eax
add    %eax,%ecx
add    $0x8f1bbcdc,%ecx
rol    $0x1e,%edi
mov    %r8d,%eax
or     %edi,%eax
and    %esi,%eax
mov    %r8d,%edx
and    %edi,%edx
or     %eax,%edx
mov    -0x40(%rsp),%r13d
xor    %r13d,%ebx
xor    -0x10(%rsp),%ebx
xor    %r11d,%ebx
rol    %ebx
add    %ebx,%r9d
mov    %ebx,-0x24(%rsp)
add    %edx,%r9d
mov    %ecx,%eax
rol    $0x5,%eax
add    %eax,%r9d
add    $0x8f1bbcdc,%r9d
rol    $0x1e,%r8d
mov    %ecx,%eax
or     %r8d,%eax
and    %edi,%eax
mov    %ecx,%edx
and    %r8d,%edx
or     %eax,%edx
mov    %r12d,%r11d
mov    -0x34(%rsp),%r14d
xor    %r14d,%r11d
xor    -0x18(%rsp),%r11d
xor    %r10d,%r11d
rol    %r11d
add    %r11d,%esi
add    %edx,%esi
mov    %r9d,%eax
rol    $0x5,%eax
add    %eax,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%ecx
mov    %r9d,%eax
or     %ecx,%eax
and    %r8d,%eax
mov    %r9d,%edx
and    %ecx,%edx
or     %eax,%edx
mov    %r13d,%r10d
mov    -0x30(%rsp),%r12d
xor    %r12d,%r10d
xor    -0x48(%rsp),%r10d
xor    -0x54(%rsp),%r10d
rol    %r10d
add    %r10d,%edi
mov    %r10d,-0x40(%rsp)
add    %edx,%edi
mov    %esi,%eax
rol    $0x5,%eax
add    %eax,%edi
add    $0x8f1bbcdc,%edi
rol    $0x1e,%r9d
mov    %esi,%eax
or     %r9d,%eax
and    %ecx,%eax
mov    %esi,%edx
and    %r9d,%edx
or     %eax,%edx
mov    -0x20(%rsp),%rbp
xor    %ebp,%r14d
xor    -0x3c(%rsp),%r14d
xor    %ebx,%r14d
rol    %r14d
add    %r14d,%r8d
mov    %r14d,%r13d
mov    %r14d,-0x34(%rsp)
add    %edx,%r8d
mov    %edi,%eax
rol    $0x5,%eax
add    %r8d,%eax
add    $0x8f1bbcdc,%eax
rol    $0x1e,%esi
mov    %esi,%edx
xor    %r9d,%edx
xor    %edi,%edx
mov    -0x38(%rsp),%r15d
xor    %r15d,%r12d
xor    -0x50(%rsp),%r12d
mov    %r11d,-0x2c(%rsp)
xor    %r11d,%r12d
rol    %r12d
add    %r12d,%ecx
add    %edx,%ecx
mov    %eax,%edx
rol    $0x5,%edx
rol    $0x1e,%edi
add    %edx,%ecx
add    $0xca62c1d6,%ecx
mov    %edi,%edx
xor    %esi,%edx
xor    %eax,%edx
mov    %rbp,%rbx
mov    -0x28(%rsp),%r14d
xor    %r14d,%ebx
xor    -0x44(%rsp),%ebx
xor    %r10d,%ebx
rol    %ebx
add    %ebx,%r9d
mov    %rbx,-0x20(%rsp)
add    %edx,%r9d
mov    %ecx,%edx
rol    $0x5,%edx
lea    (%rdx,%r9,1),%r8d
add    $0xca62c1d6,%r8d
rol    $0x1e,%eax
mov    %eax,%r9d
xor    %edi,%r9d
xor    %ecx,%r9d
mov    %r15d,%edx
mov    -0x10(%rsp),%r10
xor    %r10d,%edx
xor    -0x4c(%rsp),%edx
xor    %r13d,%edx
rol    %edx
add    %edx,%esi
mov    %edx,%r15d
mov    %edx,-0x38(%rsp)
add    %r9d,%esi
mov    %r8d,%edx
rol    $0x5,%edx
rol    $0x1e,%ecx
add    %esi,%edx
add    $0xca62c1d6,%edx
mov    %ecx,%r9d
xor    %eax,%r9d
xor    %r8d,%r9d
mov    %r14d,%r13d
mov    -0x18(%rsp),%r11
xor    %r11d,%r13d
xor    -0x54(%rsp),%r13d
xor    %r12d,%r13d
rol    %r13d
add    %r13d,%edi
add    %r9d,%edi
mov    %edx,%esi
rol    $0x5,%esi
add    %edi,%esi
add    $0xca62c1d6,%esi
rol    $0x1e,%r8d
mov    %r8d,%edi
xor    %ecx,%edi
xor    %edx,%edi
mov    -0x48(%rsp),%ebp
xor    %ebp,%r10d
xor    -0x24(%rsp),%r10d
xor    %ebx,%r10d
rol    %r10d
add    %r10d,%eax
mov    %r10,-0x10(%rsp)
add    %edi,%eax
mov    %esi,%edi
rol    $0x5,%edi
rol    $0x1e,%edx
add    %edi,%eax
add    $0xca62c1d6,%eax
mov    %edx,%edi
xor    %r8d,%edi
xor    %esi,%edi
mov    -0x3c(%rsp),%r14d
xor    %r14d,%r11d
xor    -0x2c(%rsp),%r11d
xor    %r15d,%r11d
rol    %r11d
add    %r11d,%ecx
mov    %r11,-0x18(%rsp)
add    %edi,%ecx
mov    %eax,%edi
rol    $0x5,%edi
lea    (%rdi,%rcx,1),%r9d
add    $0xca62c1d6,%r9d
rol    $0x1e,%esi
mov    %esi,%edi
xor    %edx,%edi
xor    %eax,%edi
mov    -0x50(%rsp),%r15d
xor    %r15d,%ebp
xor    -0x40(%rsp),%ebp
mov    %r13d,-0x28(%rsp)
xor    %r13d,%ebp
rol    %ebp
add    %ebp,%r8d
mov    %ebp,-0x48(%rsp)
add    %edi,%r8d
mov    %r9d,%edi
rol    $0x5,%edi
rol    $0x1e,%eax
add    %r8d,%edi
add    $0xca62c1d6,%edi
mov    %eax,%r8d
xor    %esi,%r8d
xor    %r9d,%r8d
mov    %r14d,%ecx
mov    -0x44(%rsp),%r14d
xor    %r14d,%ecx
xor    -0x34(%rsp),%ecx
xor    %r10d,%ecx
rol    %ecx
add    %ecx,%edx
mov    %ecx,%r10d
mov    %ecx,-0x3c(%rsp)
add    %r8d,%edx
mov    %edi,%ecx
rol    $0x5,%ecx
lea    (%rcx,%rdx,1),%r8d
add    $0xca62c1d6,%r8d
rol    $0x1e,%r9d
mov    %r9d,%ecx
xor    %eax,%ecx
xor    %edi,%ecx
mov    %r15d,%edx
mov    -0x4c(%rsp),%r15d
xor    %r15d,%edx
mov    %r12d,-0x30(%rsp)
xor    %r12d,%edx
xor    %r11d,%edx
rol    %edx
add    %edx,%esi
mov    %edx,%r12d
mov    %edx,-0x50(%rsp)
add    %ecx,%esi
mov    %r8d,%ecx
rol    $0x5,%ecx
rol    $0x1e,%edi
add    %ecx,%esi
add    $0xca62c1d6,%esi
mov    %edi,%ecx
xor    %r9d,%ecx
xor    %r8d,%ecx
mov    %r14d,%ebx
mov    -0x54(%rsp),%r14d
xor    %r14d,%ebx
xor    -0x20(%rsp),%ebx
xor    %ebp,%ebx
rol    %ebx
add    %ebx,%eax
mov    %ebx,-0x44(%rsp)
add    %ecx,%eax
mov    %esi,%ecx
rol    $0x5,%ecx
lea    (%rcx,%rax,1),%edx
add    $0xca62c1d6,%edx
rol    $0x1e,%r8d
mov    %r8d,%eax
xor    %edi,%eax
xor    %esi,%eax
mov    %r15d,%ecx
mov    -0x24(%rsp),%r15d
xor    %r15d,%ecx
xor    -0x38(%rsp),%ecx
xor    %r10d,%ecx
rol    %ecx
mov    %ecx,-0x4c(%rsp)
add    %ecx,%r9d
add    %eax,%r9d
mov    %edx,%eax
rol    $0x5,%eax
rol    $0x1e,%esi
add    %r9d,%eax
add    $0xca62c1d6,%eax
mov    %esi,%r9d
xor    %r8d,%r9d
xor    %edx,%r9d
mov    %r14d,%ecx
mov    -0x2c(%rsp),%r11d
xor    %r11d,%ecx
xor    %r13d,%ecx
xor    %r12d,%ecx
rol    %ecx
mov    %ecx,-0x54(%rsp)
add    %ecx,%edi
add    %r9d,%edi
mov    %eax,%ecx
rol    $0x5,%ecx
add    %edi,%ecx
add    $0xca62c1d6,%ecx
rol    $0x1e,%edx
mov    %edx,%edi
xor    %esi,%edi
xor    %eax,%edi
mov    %r15d,%r12d
mov    -0x40(%rsp),%r15d
xor    %r15d,%r12d
mov    -0x10(%rsp),%r10
xor    %r10d,%r12d
xor    %ebx,%r12d
rol    %r12d
add    %r12d,%r8d
add    %edi,%r8d
mov    %ecx,%edi
rol    $0x5,%edi
rol    $0x1e,%eax
lea    (%rdi,%r8,1),%r9d
add    $0xca62c1d6,%r9d
mov    %eax,%edi
xor    %edx,%edi
xor    %ecx,%edi
mov    -0x34(%rsp),%r8d
xor    %r8d,%r11d
mov    -0x18(%rsp),%rbp
xor    %ebp,%r11d
mov    -0x4c(%rsp),%ebx
xor    %ebx,%r11d
rol    %r11d
add    %r11d,%esi
mov    %r11d,%r13d
add    %edi,%esi
mov    %r9d,%edi
rol    $0x5,%edi
lea    (%rdi,%rsi,1),%r14d
add    $0xca62c1d6,%r14d
mov    %r10d,0x2f3b(%rip)
mov    %ebp,0x2f39(%rip)
mov    -0x48(%rsp),%esi
mov    %esi,0x2f33(%rip)
mov    %r15d,%ebp
xor    -0x30(%rsp),%ebp
xor    %esi,%ebp
rol    $0x1e,%ecx
mov    %ecx,%edi
xor    %eax,%edi
mov    -0x54(%rsp),%esi
xor    %esi,%ebp
rol    %ebp
mov    %ebp,-0x40(%rsp)
xor    %r9d,%edi
mov    %r14d,%r10d
rol    $0x5,%r10d
add    %ebp,%edx
add    %edi,%edx
add    %edx,%r10d
add    $0xca62c1d6,%r10d
mov    -0x3c(%rsp),%edx
mov    %edx,0x2ef9(%rip)
mov    -0x20(%rsp),%r15
mov    %r8d,%ebp
xor    %r15d,%ebp
xor    %edx,%ebp
mov    -0x50(%rsp),%r8d
mov    %r8d,0x2ee4(%rip)
mov    -0x44(%rsp),%r11d
mov    %r11d,0x2edc(%rip)
mov    %ebx,0x2eda(%rip)
mov    %esi,0x2ed8(%rip)
mov    %r12d,0x2ed5(%rip)
rol    $0x1e,%r9d
xor    %r12d,%ebp
mov    %r9d,%edi
xor    %ecx,%edi
rol    %ebp
mov    %ebp,%esi
xor    %r14d,%edi
mov    %r10d,%ebp
rol    $0x5,%ebp
add    %esi,%eax
add    %edi,%eax
add    %ebp,%eax
add    $0xca62c1d6,%eax
mov    -0x30(%rsp),%edx
mov    -0x38(%rsp),%r12d
xor    %r12d,%edx
xor    %r8d,%edx
mov    %r13d,0x2e9f(%rip)
xor    %r13d,%edx
rol    $0x1e,%r14d
mov    %r14d,%edi
xor    %r9d,%edi
xor    %r10d,%edi
rol    %edx
add    %edx,%ecx
add    %edi,%ecx
mov    %eax,%edi
rol    $0x5,%edi
add    %edi,%ecx
add    $0xca62c1d6,%ecx
mov    -0x28(%rsp),%r8d
xor    %r8d,%r15d
xor    %r11d,%r15d
mov    -0x40(%rsp),%edi
mov    %edi,0x2e6b(%rip)
xor    %edi,%r15d
mov    %esi,0x2e66(%rip)
rol    $0x1e,%r10d
mov    %edx,0x2e60(%rip)
rol    %r15d
mov    %r15d,0x2e5a(%rip)
add    %r9d,%r15d
mov    %r10d,%edi
xor    %r14d,%edi
xor    %eax,%edi
add    %edi,%r15d
mov    %ecx,%edi
rol    $0x5,%edi
add    %r15d,%edi
add    $0xca62c1d6,%edi
mov    -0x10(%rsp),%rbx
xor    %r12d,%ebx
xor    -0x4c(%rsp),%ebx
xor    %esi,%ebx
rol    $0x1e,%eax
rol    %ebx
mov    %ebx,0x2e29(%rip)
add    %r14d,%ebx
mov    %eax,%esi
xor    %r10d,%esi
xor    %ecx,%esi
add    %esi,%ebx
mov    -0x18(%rsp),%rbp
xor    %r8d,%ebp
xor    -0x54(%rsp),%ebp
xor    %edx,%ebp
mov    %edi,%esi
rol    $0x5,%esi
rol    $0x1e,%ecx
rol    %ebp
add    %ebx,%esi
add    $0xca62c1d6,%esi
mov    %ebp,0x2dfb(%rip)
mov    -0x8(%rsp),%rdx
add    (%rdx),%ebp
add    %r10d,%ebp
movd   %ecx,%xmm0
xor    %eax,%ecx
xor    %edi,%ecx
add    %ecx,%ebp
movd   %esi,%xmm1
rol    $0x5,%esi
lea    (%rsi,%rbp,1),%ecx
add    $0xca62c1d6,%ecx
mov    %ecx,(%rdx)
rol    $0x1e,%edi
movd   %edi,%xmm2
movd   %eax,%xmm3
punpckldq %xmm2,%xmm1
movdqu 0x4(%rdx),%xmm2
punpckldq %xmm3,%xmm0
punpcklqdq %xmm0,%xmm1
paddd  %xmm2,%xmm1
movdqu %xmm1,0x4(%rdx)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%union.CHAR64LONG16 = type { [16 x i32] }
@SHA1Transform.workspace = internal global [64 x i8] zeroinitializer
define void @SHA1Transform(i32* %0, i8* %1) {
%3 = alloca i32*
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca %union.CHAR64LONG16*
store i32* %0, i32** %3
store i8* %1, i8** %4
store %union.CHAR64LONG16* bitcast ([64 x i8]* @SHA1Transform.workspace to %union.CHAR64LONG16*), %union.CHAR64LONG16** %10
%11 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%12 = bitcast %union.CHAR64LONG16* %11 to i8*
%13 = load i8*, i8** %4
%14 = load i32*, i32** %3
%15 = getelementptr inbounds i32, i32* %14, i64 0
%16 = load i32, i32* %15
store i32 %16, i32* %5
%17 = load i32*, i32** %3
%18 = getelementptr inbounds i32, i32* %17, i64 1
%19 = load i32, i32* %18
store i32 %19, i32* %6
%20 = load i32*, i32** %3
%21 = getelementptr inbounds i32, i32* %20, i64 2
%22 = load i32, i32* %21
store i32 %22, i32* %7
%23 = load i32*, i32** %3
%24 = getelementptr inbounds i32, i32* %23, i64 3
%25 = load i32, i32* %24
store i32 %25, i32* %8
%26 = load i32*, i32** %3
%27 = getelementptr inbounds i32, i32* %26, i64 4
%28 = load i32, i32* %27
store i32 %28, i32* %9
%29 = load i32, i32* %6
%30 = load i32, i32* %7
%31 = load i32, i32* %8
%32 = xor i32 %30, %31
%33 = and i32 %29, %32
%34 = load i32, i32* %8
%35 = xor i32 %33, %34
%36 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%37 = bitcast %union.CHAR64LONG16* %36 to [16 x i32]*
%38 = getelementptr inbounds [16 x i32], [16 x i32]* %37, i64 0, i64 0
%39 = load i32, i32* %38
%40 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%41 = bitcast %union.CHAR64LONG16* %40 to [16 x i32]*
%42 = getelementptr inbounds [16 x i32], [16 x i32]* %41, i64 0, i64 0
store i32 %39, i32* %42
%43 = add i32 %35, %39
%44 = add i32 %43, 1518500249
%45 = load i32, i32* %5
%46 = shl i32 %45, 5
%47 = load i32, i32* %5
%48 = lshr i32 %47, 27
%49 = or i32 %46, %48
%50 = add i32 %44, %49
%51 = load i32, i32* %9
%52 = add i32 %51, %50
store i32 %52, i32* %9
%53 = load i32, i32* %6
%54 = shl i32 %53, 30
%55 = load i32, i32* %6
%56 = lshr i32 %55, 2
%57 = or i32 %54, %56
store i32 %57, i32* %6
%58 = load i32, i32* %5
%59 = load i32, i32* %6
%60 = load i32, i32* %7
%61 = xor i32 %59, %60
%62 = and i32 %58, %61
%63 = load i32, i32* %7
%64 = xor i32 %62, %63
%65 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%66 = bitcast %union.CHAR64LONG16* %65 to [16 x i32]*
%67 = getelementptr inbounds [16 x i32], [16 x i32]* %66, i64 0, i64 1
%68 = load i32, i32* %67
%69 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%70 = bitcast %union.CHAR64LONG16* %69 to [16 x i32]*
%71 = getelementptr inbounds [16 x i32], [16 x i32]* %70, i64 0, i64 1
store i32 %68, i32* %71
%72 = add i32 %64, %68
%73 = add i32 %72, 1518500249
%74 = load i32, i32* %9
%75 = shl i32 %74, 5
%76 = load i32, i32* %9
%77 = lshr i32 %76, 27
%78 = or i32 %75, %77
%79 = add i32 %73, %78
%80 = load i32, i32* %8
%81 = add i32 %80, %79
store i32 %81, i32* %8
%82 = load i32, i32* %5
%83 = shl i32 %82, 30
%84 = load i32, i32* %5
%85 = lshr i32 %84, 2
%86 = or i32 %83, %85
store i32 %86, i32* %5
%87 = load i32, i32* %9
%88 = load i32, i32* %5
%89 = load i32, i32* %6
%90 = xor i32 %88, %89
%91 = and i32 %87, %90
%92 = load i32, i32* %6
%93 = xor i32 %91, %92
%94 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%95 = bitcast %union.CHAR64LONG16* %94 to [16 x i32]*
%96 = getelementptr inbounds [16 x i32], [16 x i32]* %95, i64 0, i64 2
%97 = load i32, i32* %96
%98 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%99 = bitcast %union.CHAR64LONG16* %98 to [16 x i32]*
%100 = getelementptr inbounds [16 x i32], [16 x i32]* %99, i64 0, i64 2
store i32 %97, i32* %100
%101 = add i32 %93, %97
%102 = add i32 %101, 1518500249
%103 = load i32, i32* %8
%104 = shl i32 %103, 5
%105 = load i32, i32* %8
%106 = lshr i32 %105, 27
%107 = or i32 %104, %106
%108 = add i32 %102, %107
%109 = load i32, i32* %7
%110 = add i32 %109, %108
store i32 %110, i32* %7
%111 = load i32, i32* %9
%112 = shl i32 %111, 30
%113 = load i32, i32* %9
%114 = lshr i32 %113, 2
%115 = or i32 %112, %114
store i32 %115, i32* %9
%116 = load i32, i32* %8
%117 = load i32, i32* %9
%118 = load i32, i32* %5
%119 = xor i32 %117, %118
%120 = and i32 %116, %119
%121 = load i32, i32* %5
%122 = xor i32 %120, %121
%123 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%124 = bitcast %union.CHAR64LONG16* %123 to [16 x i32]*
%125 = getelementptr inbounds [16 x i32], [16 x i32]* %124, i64 0, i64 3
%126 = load i32, i32* %125
%127 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%128 = bitcast %union.CHAR64LONG16* %127 to [16 x i32]*
%129 = getelementptr inbounds [16 x i32], [16 x i32]* %128, i64 0, i64 3
store i32 %126, i32* %129
%130 = add i32 %122, %126
%131 = add i32 %130, 1518500249
%132 = load i32, i32* %7
%133 = shl i32 %132, 5
%134 = load i32, i32* %7
%135 = lshr i32 %134, 27
%136 = or i32 %133, %135
%137 = add i32 %131, %136
%138 = load i32, i32* %6
%139 = add i32 %138, %137
store i32 %139, i32* %6
%140 = load i32, i32* %8
%141 = shl i32 %140, 30
%142 = load i32, i32* %8
%143 = lshr i32 %142, 2
%144 = or i32 %141, %143
store i32 %144, i32* %8
%145 = load i32, i32* %7
%146 = load i32, i32* %8
%147 = load i32, i32* %9
%148 = xor i32 %146, %147
%149 = and i32 %145, %148
%150 = load i32, i32* %9
%151 = xor i32 %149, %150
%152 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%153 = bitcast %union.CHAR64LONG16* %152 to [16 x i32]*
%154 = getelementptr inbounds [16 x i32], [16 x i32]* %153, i64 0, i64 4
%155 = load i32, i32* %154
%156 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%157 = bitcast %union.CHAR64LONG16* %156 to [16 x i32]*
%158 = getelementptr inbounds [16 x i32], [16 x i32]* %157, i64 0, i64 4
store i32 %155, i32* %158
%159 = add i32 %151, %155
%160 = add i32 %159, 1518500249
%161 = load i32, i32* %6
%162 = shl i32 %161, 5
%163 = load i32, i32* %6
%164 = lshr i32 %163, 27
%165 = or i32 %162, %164
%166 = add i32 %160, %165
%167 = load i32, i32* %5
%168 = add i32 %167, %166
store i32 %168, i32* %5
%169 = load i32, i32* %7
%170 = shl i32 %169, 30
%171 = load i32, i32* %7
%172 = lshr i32 %171, 2
%173 = or i32 %170, %172
store i32 %173, i32* %7
%174 = load i32, i32* %6
%175 = load i32, i32* %7
%176 = load i32, i32* %8
%177 = xor i32 %175, %176
%178 = and i32 %174, %177
%179 = load i32, i32* %8
%180 = xor i32 %178, %179
%181 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%182 = bitcast %union.CHAR64LONG16* %181 to [16 x i32]*
%183 = getelementptr inbounds [16 x i32], [16 x i32]* %182, i64 0, i64 5
%184 = load i32, i32* %183
%185 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%186 = bitcast %union.CHAR64LONG16* %185 to [16 x i32]*
%187 = getelementptr inbounds [16 x i32], [16 x i32]* %186, i64 0, i64 5
store i32 %184, i32* %187
%188 = add i32 %180, %184
%189 = add i32 %188, 1518500249
%190 = load i32, i32* %5
%191 = shl i32 %190, 5
%192 = load i32, i32* %5
%193 = lshr i32 %192, 27
%194 = or i32 %191, %193
%195 = add i32 %189, %194
%196 = load i32, i32* %9
%197 = add i32 %196, %195
store i32 %197, i32* %9
%198 = load i32, i32* %6
%199 = shl i32 %198, 30
%200 = load i32, i32* %6
%201 = lshr i32 %200, 2
%202 = or i32 %199, %201
store i32 %202, i32* %6
%203 = load i32, i32* %5
%204 = load i32, i32* %6
%205 = load i32, i32* %7
%206 = xor i32 %204, %205
%207 = and i32 %203, %206
%208 = load i32, i32* %7
%209 = xor i32 %207, %208
%210 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%211 = bitcast %union.CHAR64LONG16* %210 to [16 x i32]*
%212 = getelementptr inbounds [16 x i32], [16 x i32]* %211, i64 0, i64 6
%213 = load i32, i32* %212
%214 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%215 = bitcast %union.CHAR64LONG16* %214 to [16 x i32]*
%216 = getelementptr inbounds [16 x i32], [16 x i32]* %215, i64 0, i64 6
store i32 %213, i32* %216
%217 = add i32 %209, %213
%218 = add i32 %217, 1518500249
%219 = load i32, i32* %9
%220 = shl i32 %219, 5
%221 = load i32, i32* %9
%222 = lshr i32 %221, 27
%223 = or i32 %220, %222
%224 = add i32 %218, %223
%225 = load i32, i32* %8
%226 = add i32 %225, %224
store i32 %226, i32* %8
%227 = load i32, i32* %5
%228 = shl i32 %227, 30
%229 = load i32, i32* %5
%230 = lshr i32 %229, 2
%231 = or i32 %228, %230
store i32 %231, i32* %5
%232 = load i32, i32* %9
%233 = load i32, i32* %5
%234 = load i32, i32* %6
%235 = xor i32 %233, %234
%236 = and i32 %232, %235
%237 = load i32, i32* %6
%238 = xor i32 %236, %237
%239 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%240 = bitcast %union.CHAR64LONG16* %239 to [16 x i32]*
%241 = getelementptr inbounds [16 x i32], [16 x i32]* %240, i64 0, i64 7
%242 = load i32, i32* %241
%243 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%244 = bitcast %union.CHAR64LONG16* %243 to [16 x i32]*
%245 = getelementptr inbounds [16 x i32], [16 x i32]* %244, i64 0, i64 7
store i32 %242, i32* %245
%246 = add i32 %238, %242
%247 = add i32 %246, 1518500249
%248 = load i32, i32* %8
%249 = shl i32 %248, 5
%250 = load i32, i32* %8
%251 = lshr i32 %250, 27
%252 = or i32 %249, %251
%253 = add i32 %247, %252
%254 = load i32, i32* %7
%255 = add i32 %254, %253
store i32 %255, i32* %7
%256 = load i32, i32* %9
%257 = shl i32 %256, 30
%258 = load i32, i32* %9
%259 = lshr i32 %258, 2
%260 = or i32 %257, %259
store i32 %260, i32* %9
%261 = load i32, i32* %8
%262 = load i32, i32* %9
%263 = load i32, i32* %5
%264 = xor i32 %262, %263
%265 = and i32 %261, %264
%266 = load i32, i32* %5
%267 = xor i32 %265, %266
%268 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%269 = bitcast %union.CHAR64LONG16* %268 to [16 x i32]*
%270 = getelementptr inbounds [16 x i32], [16 x i32]* %269, i64 0, i64 8
%271 = load i32, i32* %270
%272 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%273 = bitcast %union.CHAR64LONG16* %272 to [16 x i32]*
%274 = getelementptr inbounds [16 x i32], [16 x i32]* %273, i64 0, i64 8
store i32 %271, i32* %274
%275 = add i32 %267, %271
%276 = add i32 %275, 1518500249
%277 = load i32, i32* %7
%278 = shl i32 %277, 5
%279 = load i32, i32* %7
%280 = lshr i32 %279, 27
%281 = or i32 %278, %280
%282 = add i32 %276, %281
%283 = load i32, i32* %6
%284 = add i32 %283, %282
store i32 %284, i32* %6
%285 = load i32, i32* %8
%286 = shl i32 %285, 30
%287 = load i32, i32* %8
%288 = lshr i32 %287, 2
%289 = or i32 %286, %288
store i32 %289, i32* %8
%290 = load i32, i32* %7
%291 = load i32, i32* %8
%292 = load i32, i32* %9
%293 = xor i32 %291, %292
%294 = and i32 %290, %293
%295 = load i32, i32* %9
%296 = xor i32 %294, %295
%297 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%298 = bitcast %union.CHAR64LONG16* %297 to [16 x i32]*
%299 = getelementptr inbounds [16 x i32], [16 x i32]* %298, i64 0, i64 9
%300 = load i32, i32* %299
%301 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%302 = bitcast %union.CHAR64LONG16* %301 to [16 x i32]*
%303 = getelementptr inbounds [16 x i32], [16 x i32]* %302, i64 0, i64 9
store i32 %300, i32* %303
%304 = add i32 %296, %300
%305 = add i32 %304, 1518500249
%306 = load i32, i32* %6
%307 = shl i32 %306, 5
%308 = load i32, i32* %6
%309 = lshr i32 %308, 27
%310 = or i32 %307, %309
%311 = add i32 %305, %310
%312 = load i32, i32* %5
%313 = add i32 %312, %311
store i32 %313, i32* %5
%314 = load i32, i32* %7
%315 = shl i32 %314, 30
%316 = load i32, i32* %7
%317 = lshr i32 %316, 2
%318 = or i32 %315, %317
store i32 %318, i32* %7
%319 = load i32, i32* %6
%320 = load i32, i32* %7
%321 = load i32, i32* %8
%322 = xor i32 %320, %321
%323 = and i32 %319, %322
%324 = load i32, i32* %8
%325 = xor i32 %323, %324
%326 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%327 = bitcast %union.CHAR64LONG16* %326 to [16 x i32]*
%328 = getelementptr inbounds [16 x i32], [16 x i32]* %327, i64 0, i64 10
%329 = load i32, i32* %328
%330 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%331 = bitcast %union.CHAR64LONG16* %330 to [16 x i32]*
%332 = getelementptr inbounds [16 x i32], [16 x i32]* %331, i64 0, i64 10
store i32 %329, i32* %332
%333 = add i32 %325, %329
%334 = add i32 %333, 1518500249
%335 = load i32, i32* %5
%336 = shl i32 %335, 5
%337 = load i32, i32* %5
%338 = lshr i32 %337, 27
%339 = or i32 %336, %338
%340 = add i32 %334, %339
%341 = load i32, i32* %9
%342 = add i32 %341, %340
store i32 %342, i32* %9
%343 = load i32, i32* %6
%344 = shl i32 %343, 30
%345 = load i32, i32* %6
%346 = lshr i32 %345, 2
%347 = or i32 %344, %346
store i32 %347, i32* %6
%348 = load i32, i32* %5
%349 = load i32, i32* %6
%350 = load i32, i32* %7
%351 = xor i32 %349, %350
%352 = and i32 %348, %351
%353 = load i32, i32* %7
%354 = xor i32 %352, %353
%355 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%356 = bitcast %union.CHAR64LONG16* %355 to [16 x i32]*
%357 = getelementptr inbounds [16 x i32], [16 x i32]* %356, i64 0, i64 11
%358 = load i32, i32* %357
%359 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%360 = bitcast %union.CHAR64LONG16* %359 to [16 x i32]*
%361 = getelementptr inbounds [16 x i32], [16 x i32]* %360, i64 0, i64 11
store i32 %358, i32* %361
%362 = add i32 %354, %358
%363 = add i32 %362, 1518500249
%364 = load i32, i32* %9
%365 = shl i32 %364, 5
%366 = load i32, i32* %9
%367 = lshr i32 %366, 27
%368 = or i32 %365, %367
%369 = add i32 %363, %368
%370 = load i32, i32* %8
%371 = add i32 %370, %369
store i32 %371, i32* %8
%372 = load i32, i32* %5
%373 = shl i32 %372, 30
%374 = load i32, i32* %5
%375 = lshr i32 %374, 2
%376 = or i32 %373, %375
store i32 %376, i32* %5
%377 = load i32, i32* %9
%378 = load i32, i32* %5
%379 = load i32, i32* %6
%380 = xor i32 %378, %379
%381 = and i32 %377, %380
%382 = load i32, i32* %6
%383 = xor i32 %381, %382
%384 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%385 = bitcast %union.CHAR64LONG16* %384 to [16 x i32]*
%386 = getelementptr inbounds [16 x i32], [16 x i32]* %385, i64 0, i64 12
%387 = load i32, i32* %386
%388 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%389 = bitcast %union.CHAR64LONG16* %388 to [16 x i32]*
%390 = getelementptr inbounds [16 x i32], [16 x i32]* %389, i64 0, i64 12
store i32 %387, i32* %390
%391 = add i32 %383, %387
%392 = add i32 %391, 1518500249
%393 = load i32, i32* %8
%394 = shl i32 %393, 5
%395 = load i32, i32* %8
%396 = lshr i32 %395, 27
%397 = or i32 %394, %396
%398 = add i32 %392, %397
%399 = load i32, i32* %7
%400 = add i32 %399, %398
store i32 %400, i32* %7
%401 = load i32, i32* %9
%402 = shl i32 %401, 30
%403 = load i32, i32* %9
%404 = lshr i32 %403, 2
%405 = or i32 %402, %404
store i32 %405, i32* %9
%406 = load i32, i32* %8
%407 = load i32, i32* %9
%408 = load i32, i32* %5
%409 = xor i32 %407, %408
%410 = and i32 %406, %409
%411 = load i32, i32* %5
%412 = xor i32 %410, %411
%413 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%414 = bitcast %union.CHAR64LONG16* %413 to [16 x i32]*
%415 = getelementptr inbounds [16 x i32], [16 x i32]* %414, i64 0, i64 13
%416 = load i32, i32* %415
%417 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%418 = bitcast %union.CHAR64LONG16* %417 to [16 x i32]*
%419 = getelementptr inbounds [16 x i32], [16 x i32]* %418, i64 0, i64 13
store i32 %416, i32* %419
%420 = add i32 %412, %416
%421 = add i32 %420, 1518500249
%422 = load i32, i32* %7
%423 = shl i32 %422, 5
%424 = load i32, i32* %7
%425 = lshr i32 %424, 27
%426 = or i32 %423, %425
%427 = add i32 %421, %426
%428 = load i32, i32* %6
%429 = add i32 %428, %427
store i32 %429, i32* %6
%430 = load i32, i32* %8
%431 = shl i32 %430, 30
%432 = load i32, i32* %8
%433 = lshr i32 %432, 2
%434 = or i32 %431, %433
store i32 %434, i32* %8
%435 = load i32, i32* %7
%436 = load i32, i32* %8
%437 = load i32, i32* %9
%438 = xor i32 %436, %437
%439 = and i32 %435, %438
%440 = load i32, i32* %9
%441 = xor i32 %439, %440
%442 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%443 = bitcast %union.CHAR64LONG16* %442 to [16 x i32]*
%444 = getelementptr inbounds [16 x i32], [16 x i32]* %443, i64 0, i64 14
%445 = load i32, i32* %444
%446 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%447 = bitcast %union.CHAR64LONG16* %446 to [16 x i32]*
%448 = getelementptr inbounds [16 x i32], [16 x i32]* %447, i64 0, i64 14
store i32 %445, i32* %448
%449 = add i32 %441, %445
%450 = add i32 %449, 1518500249
%451 = load i32, i32* %6
%452 = shl i32 %451, 5
%453 = load i32, i32* %6
%454 = lshr i32 %453, 27
%455 = or i32 %452, %454
%456 = add i32 %450, %455
%457 = load i32, i32* %5
%458 = add i32 %457, %456
store i32 %458, i32* %5
%459 = load i32, i32* %7
%460 = shl i32 %459, 30
%461 = load i32, i32* %7
%462 = lshr i32 %461, 2
%463 = or i32 %460, %462
store i32 %463, i32* %7
%464 = load i32, i32* %6
%465 = load i32, i32* %7
%466 = load i32, i32* %8
%467 = xor i32 %465, %466
%468 = and i32 %464, %467
%469 = load i32, i32* %8
%470 = xor i32 %468, %469
%471 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%472 = bitcast %union.CHAR64LONG16* %471 to [16 x i32]*
%473 = getelementptr inbounds [16 x i32], [16 x i32]* %472, i64 0, i64 15
%474 = load i32, i32* %473
%475 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%476 = bitcast %union.CHAR64LONG16* %475 to [16 x i32]*
%477 = getelementptr inbounds [16 x i32], [16 x i32]* %476, i64 0, i64 15
store i32 %474, i32* %477
%478 = add i32 %470, %474
%479 = add i32 %478, 1518500249
%480 = load i32, i32* %5
%481 = shl i32 %480, 5
%482 = load i32, i32* %5
%483 = lshr i32 %482, 27
%484 = or i32 %481, %483
%485 = add i32 %479, %484
%486 = load i32, i32* %9
%487 = add i32 %486, %485
store i32 %487, i32* %9
%488 = load i32, i32* %6
%489 = shl i32 %488, 30
%490 = load i32, i32* %6
%491 = lshr i32 %490, 2
%492 = or i32 %489, %491
store i32 %492, i32* %6
%493 = load i32, i32* %5
%494 = load i32, i32* %6
%495 = load i32, i32* %7
%496 = xor i32 %494, %495
%497 = and i32 %493, %496
%498 = load i32, i32* %7
%499 = xor i32 %497, %498
%500 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%501 = bitcast %union.CHAR64LONG16* %500 to [16 x i32]*
%502 = getelementptr inbounds [16 x i32], [16 x i32]* %501, i64 0, i64 13
%503 = load i32, i32* %502
%504 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%505 = bitcast %union.CHAR64LONG16* %504 to [16 x i32]*
%506 = getelementptr inbounds [16 x i32], [16 x i32]* %505, i64 0, i64 8
%507 = load i32, i32* %506
%508 = xor i32 %503, %507
%509 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%510 = bitcast %union.CHAR64LONG16* %509 to [16 x i32]*
%511 = getelementptr inbounds [16 x i32], [16 x i32]* %510, i64 0, i64 2
%512 = load i32, i32* %511
%513 = xor i32 %508, %512
%514 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%515 = bitcast %union.CHAR64LONG16* %514 to [16 x i32]*
%516 = getelementptr inbounds [16 x i32], [16 x i32]* %515, i64 0, i64 0
%517 = load i32, i32* %516
%518 = xor i32 %513, %517
%519 = shl i32 %518, 1
%520 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%521 = bitcast %union.CHAR64LONG16* %520 to [16 x i32]*
%522 = getelementptr inbounds [16 x i32], [16 x i32]* %521, i64 0, i64 13
%523 = load i32, i32* %522
%524 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%525 = bitcast %union.CHAR64LONG16* %524 to [16 x i32]*
%526 = getelementptr inbounds [16 x i32], [16 x i32]* %525, i64 0, i64 8
%527 = load i32, i32* %526
%528 = xor i32 %523, %527
%529 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%530 = bitcast %union.CHAR64LONG16* %529 to [16 x i32]*
%531 = getelementptr inbounds [16 x i32], [16 x i32]* %530, i64 0, i64 2
%532 = load i32, i32* %531
%533 = xor i32 %528, %532
%534 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%535 = bitcast %union.CHAR64LONG16* %534 to [16 x i32]*
%536 = getelementptr inbounds [16 x i32], [16 x i32]* %535, i64 0, i64 0
%537 = load i32, i32* %536
%538 = xor i32 %533, %537
%539 = lshr i32 %538, 31
%540 = or i32 %519, %539
%541 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%542 = bitcast %union.CHAR64LONG16* %541 to [16 x i32]*
%543 = getelementptr inbounds [16 x i32], [16 x i32]* %542, i64 0, i64 0
store i32 %540, i32* %543
%544 = add i32 %499, %540
%545 = add i32 %544, 1518500249
%546 = load i32, i32* %9
%547 = shl i32 %546, 5
%548 = load i32, i32* %9
%549 = lshr i32 %548, 27
%550 = or i32 %547, %549
%551 = add i32 %545, %550
%552 = load i32, i32* %8
%553 = add i32 %552, %551
store i32 %553, i32* %8
%554 = load i32, i32* %5
%555 = shl i32 %554, 30
%556 = load i32, i32* %5
%557 = lshr i32 %556, 2
%558 = or i32 %555, %557
store i32 %558, i32* %5
%559 = load i32, i32* %9
%560 = load i32, i32* %5
%561 = load i32, i32* %6
%562 = xor i32 %560, %561
%563 = and i32 %559, %562
%564 = load i32, i32* %6
%565 = xor i32 %563, %564
%566 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%567 = bitcast %union.CHAR64LONG16* %566 to [16 x i32]*
%568 = getelementptr inbounds [16 x i32], [16 x i32]* %567, i64 0, i64 14
%569 = load i32, i32* %568
%570 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%571 = bitcast %union.CHAR64LONG16* %570 to [16 x i32]*
%572 = getelementptr inbounds [16 x i32], [16 x i32]* %571, i64 0, i64 9
%573 = load i32, i32* %572
%574 = xor i32 %569, %573
%575 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%576 = bitcast %union.CHAR64LONG16* %575 to [16 x i32]*
%577 = getelementptr inbounds [16 x i32], [16 x i32]* %576, i64 0, i64 3
%578 = load i32, i32* %577
%579 = xor i32 %574, %578
%580 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%581 = bitcast %union.CHAR64LONG16* %580 to [16 x i32]*
%582 = getelementptr inbounds [16 x i32], [16 x i32]* %581, i64 0, i64 1
%583 = load i32, i32* %582
%584 = xor i32 %579, %583
%585 = shl i32 %584, 1
%586 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%587 = bitcast %union.CHAR64LONG16* %586 to [16 x i32]*
%588 = getelementptr inbounds [16 x i32], [16 x i32]* %587, i64 0, i64 14
%589 = load i32, i32* %588
%590 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%591 = bitcast %union.CHAR64LONG16* %590 to [16 x i32]*
%592 = getelementptr inbounds [16 x i32], [16 x i32]* %591, i64 0, i64 9
%593 = load i32, i32* %592
%594 = xor i32 %589, %593
%595 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%596 = bitcast %union.CHAR64LONG16* %595 to [16 x i32]*
%597 = getelementptr inbounds [16 x i32], [16 x i32]* %596, i64 0, i64 3
%598 = load i32, i32* %597
%599 = xor i32 %594, %598
%600 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%601 = bitcast %union.CHAR64LONG16* %600 to [16 x i32]*
%602 = getelementptr inbounds [16 x i32], [16 x i32]* %601, i64 0, i64 1
%603 = load i32, i32* %602
%604 = xor i32 %599, %603
%605 = lshr i32 %604, 31
%606 = or i32 %585, %605
%607 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%608 = bitcast %union.CHAR64LONG16* %607 to [16 x i32]*
%609 = getelementptr inbounds [16 x i32], [16 x i32]* %608, i64 0, i64 1
store i32 %606, i32* %609
%610 = add i32 %565, %606
%611 = add i32 %610, 1518500249
%612 = load i32, i32* %8
%613 = shl i32 %612, 5
%614 = load i32, i32* %8
%615 = lshr i32 %614, 27
%616 = or i32 %613, %615
%617 = add i32 %611, %616
%618 = load i32, i32* %7
%619 = add i32 %618, %617
store i32 %619, i32* %7
%620 = load i32, i32* %9
%621 = shl i32 %620, 30
%622 = load i32, i32* %9
%623 = lshr i32 %622, 2
%624 = or i32 %621, %623
store i32 %624, i32* %9
%625 = load i32, i32* %8
%626 = load i32, i32* %9
%627 = load i32, i32* %5
%628 = xor i32 %626, %627
%629 = and i32 %625, %628
%630 = load i32, i32* %5
%631 = xor i32 %629, %630
%632 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%633 = bitcast %union.CHAR64LONG16* %632 to [16 x i32]*
%634 = getelementptr inbounds [16 x i32], [16 x i32]* %633, i64 0, i64 15
%635 = load i32, i32* %634
%636 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%637 = bitcast %union.CHAR64LONG16* %636 to [16 x i32]*
%638 = getelementptr inbounds [16 x i32], [16 x i32]* %637, i64 0, i64 10
%639 = load i32, i32* %638
%640 = xor i32 %635, %639
%641 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%642 = bitcast %union.CHAR64LONG16* %641 to [16 x i32]*
%643 = getelementptr inbounds [16 x i32], [16 x i32]* %642, i64 0, i64 4
%644 = load i32, i32* %643
%645 = xor i32 %640, %644
%646 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%647 = bitcast %union.CHAR64LONG16* %646 to [16 x i32]*
%648 = getelementptr inbounds [16 x i32], [16 x i32]* %647, i64 0, i64 2
%649 = load i32, i32* %648
%650 = xor i32 %645, %649
%651 = shl i32 %650, 1
%652 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%653 = bitcast %union.CHAR64LONG16* %652 to [16 x i32]*
%654 = getelementptr inbounds [16 x i32], [16 x i32]* %653, i64 0, i64 15
%655 = load i32, i32* %654
%656 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%657 = bitcast %union.CHAR64LONG16* %656 to [16 x i32]*
%658 = getelementptr inbounds [16 x i32], [16 x i32]* %657, i64 0, i64 10
%659 = load i32, i32* %658
%660 = xor i32 %655, %659
%661 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%662 = bitcast %union.CHAR64LONG16* %661 to [16 x i32]*
%663 = getelementptr inbounds [16 x i32], [16 x i32]* %662, i64 0, i64 4
%664 = load i32, i32* %663
%665 = xor i32 %660, %664
%666 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%667 = bitcast %union.CHAR64LONG16* %666 to [16 x i32]*
%668 = getelementptr inbounds [16 x i32], [16 x i32]* %667, i64 0, i64 2
%669 = load i32, i32* %668
%670 = xor i32 %665, %669
%671 = lshr i32 %670, 31
%672 = or i32 %651, %671
%673 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%674 = bitcast %union.CHAR64LONG16* %673 to [16 x i32]*
%675 = getelementptr inbounds [16 x i32], [16 x i32]* %674, i64 0, i64 2
store i32 %672, i32* %675
%676 = add i32 %631, %672
%677 = add i32 %676, 1518500249
%678 = load i32, i32* %7
%679 = shl i32 %678, 5
%680 = load i32, i32* %7
%681 = lshr i32 %680, 27
%682 = or i32 %679, %681
%683 = add i32 %677, %682
%684 = load i32, i32* %6
%685 = add i32 %684, %683
store i32 %685, i32* %6
%686 = load i32, i32* %8
%687 = shl i32 %686, 30
%688 = load i32, i32* %8
%689 = lshr i32 %688, 2
%690 = or i32 %687, %689
store i32 %690, i32* %8
%691 = load i32, i32* %7
%692 = load i32, i32* %8
%693 = load i32, i32* %9
%694 = xor i32 %692, %693
%695 = and i32 %691, %694
%696 = load i32, i32* %9
%697 = xor i32 %695, %696
%698 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%699 = bitcast %union.CHAR64LONG16* %698 to [16 x i32]*
%700 = getelementptr inbounds [16 x i32], [16 x i32]* %699, i64 0, i64 0
%701 = load i32, i32* %700
%702 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%703 = bitcast %union.CHAR64LONG16* %702 to [16 x i32]*
%704 = getelementptr inbounds [16 x i32], [16 x i32]* %703, i64 0, i64 11
%705 = load i32, i32* %704
%706 = xor i32 %701, %705
%707 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%708 = bitcast %union.CHAR64LONG16* %707 to [16 x i32]*
%709 = getelementptr inbounds [16 x i32], [16 x i32]* %708, i64 0, i64 5
%710 = load i32, i32* %709
%711 = xor i32 %706, %710
%712 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%713 = bitcast %union.CHAR64LONG16* %712 to [16 x i32]*
%714 = getelementptr inbounds [16 x i32], [16 x i32]* %713, i64 0, i64 3
%715 = load i32, i32* %714
%716 = xor i32 %711, %715
%717 = shl i32 %716, 1
%718 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%719 = bitcast %union.CHAR64LONG16* %718 to [16 x i32]*
%720 = getelementptr inbounds [16 x i32], [16 x i32]* %719, i64 0, i64 0
%721 = load i32, i32* %720
%722 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%723 = bitcast %union.CHAR64LONG16* %722 to [16 x i32]*
%724 = getelementptr inbounds [16 x i32], [16 x i32]* %723, i64 0, i64 11
%725 = load i32, i32* %724
%726 = xor i32 %721, %725
%727 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%728 = bitcast %union.CHAR64LONG16* %727 to [16 x i32]*
%729 = getelementptr inbounds [16 x i32], [16 x i32]* %728, i64 0, i64 5
%730 = load i32, i32* %729
%731 = xor i32 %726, %730
%732 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%733 = bitcast %union.CHAR64LONG16* %732 to [16 x i32]*
%734 = getelementptr inbounds [16 x i32], [16 x i32]* %733, i64 0, i64 3
%735 = load i32, i32* %734
%736 = xor i32 %731, %735
%737 = lshr i32 %736, 31
%738 = or i32 %717, %737
%739 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%740 = bitcast %union.CHAR64LONG16* %739 to [16 x i32]*
%741 = getelementptr inbounds [16 x i32], [16 x i32]* %740, i64 0, i64 3
store i32 %738, i32* %741
%742 = add i32 %697, %738
%743 = add i32 %742, 1518500249
%744 = load i32, i32* %6
%745 = shl i32 %744, 5
%746 = load i32, i32* %6
%747 = lshr i32 %746, 27
%748 = or i32 %745, %747
%749 = add i32 %743, %748
%750 = load i32, i32* %5
%751 = add i32 %750, %749
store i32 %751, i32* %5
%752 = load i32, i32* %7
%753 = shl i32 %752, 30
%754 = load i32, i32* %7
%755 = lshr i32 %754, 2
%756 = or i32 %753, %755
store i32 %756, i32* %7
%757 = load i32, i32* %6
%758 = load i32, i32* %7
%759 = xor i32 %757, %758
%760 = load i32, i32* %8
%761 = xor i32 %759, %760
%762 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%763 = bitcast %union.CHAR64LONG16* %762 to [16 x i32]*
%764 = getelementptr inbounds [16 x i32], [16 x i32]* %763, i64 0, i64 1
%765 = load i32, i32* %764
%766 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%767 = bitcast %union.CHAR64LONG16* %766 to [16 x i32]*
%768 = getelementptr inbounds [16 x i32], [16 x i32]* %767, i64 0, i64 12
%769 = load i32, i32* %768
%770 = xor i32 %765, %769
%771 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%772 = bitcast %union.CHAR64LONG16* %771 to [16 x i32]*
%773 = getelementptr inbounds [16 x i32], [16 x i32]* %772, i64 0, i64 6
%774 = load i32, i32* %773
%775 = xor i32 %770, %774
%776 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%777 = bitcast %union.CHAR64LONG16* %776 to [16 x i32]*
%778 = getelementptr inbounds [16 x i32], [16 x i32]* %777, i64 0, i64 4
%779 = load i32, i32* %778
%780 = xor i32 %775, %779
%781 = shl i32 %780, 1
%782 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%783 = bitcast %union.CHAR64LONG16* %782 to [16 x i32]*
%784 = getelementptr inbounds [16 x i32], [16 x i32]* %783, i64 0, i64 1
%785 = load i32, i32* %784
%786 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%787 = bitcast %union.CHAR64LONG16* %786 to [16 x i32]*
%788 = getelementptr inbounds [16 x i32], [16 x i32]* %787, i64 0, i64 12
%789 = load i32, i32* %788
%790 = xor i32 %785, %789
%791 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%792 = bitcast %union.CHAR64LONG16* %791 to [16 x i32]*
%793 = getelementptr inbounds [16 x i32], [16 x i32]* %792, i64 0, i64 6
%794 = load i32, i32* %793
%795 = xor i32 %790, %794
%796 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%797 = bitcast %union.CHAR64LONG16* %796 to [16 x i32]*
%798 = getelementptr inbounds [16 x i32], [16 x i32]* %797, i64 0, i64 4
%799 = load i32, i32* %798
%800 = xor i32 %795, %799
%801 = lshr i32 %800, 31
%802 = or i32 %781, %801
%803 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%804 = bitcast %union.CHAR64LONG16* %803 to [16 x i32]*
%805 = getelementptr inbounds [16 x i32], [16 x i32]* %804, i64 0, i64 4
store i32 %802, i32* %805
%806 = add i32 %761, %802
%807 = add i32 %806, 1859775393
%808 = load i32, i32* %5
%809 = shl i32 %808, 5
%810 = load i32, i32* %5
%811 = lshr i32 %810, 27
%812 = or i32 %809, %811
%813 = add i32 %807, %812
%814 = load i32, i32* %9
%815 = add i32 %814, %813
store i32 %815, i32* %9
%816 = load i32, i32* %6
%817 = shl i32 %816, 30
%818 = load i32, i32* %6
%819 = lshr i32 %818, 2
%820 = or i32 %817, %819
store i32 %820, i32* %6
%821 = load i32, i32* %5
%822 = load i32, i32* %6
%823 = xor i32 %821, %822
%824 = load i32, i32* %7
%825 = xor i32 %823, %824
%826 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%827 = bitcast %union.CHAR64LONG16* %826 to [16 x i32]*
%828 = getelementptr inbounds [16 x i32], [16 x i32]* %827, i64 0, i64 2
%829 = load i32, i32* %828
%830 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%831 = bitcast %union.CHAR64LONG16* %830 to [16 x i32]*
%832 = getelementptr inbounds [16 x i32], [16 x i32]* %831, i64 0, i64 13
%833 = load i32, i32* %832
%834 = xor i32 %829, %833
%835 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%836 = bitcast %union.CHAR64LONG16* %835 to [16 x i32]*
%837 = getelementptr inbounds [16 x i32], [16 x i32]* %836, i64 0, i64 7
%838 = load i32, i32* %837
%839 = xor i32 %834, %838
%840 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%841 = bitcast %union.CHAR64LONG16* %840 to [16 x i32]*
%842 = getelementptr inbounds [16 x i32], [16 x i32]* %841, i64 0, i64 5
%843 = load i32, i32* %842
%844 = xor i32 %839, %843
%845 = shl i32 %844, 1
%846 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%847 = bitcast %union.CHAR64LONG16* %846 to [16 x i32]*
%848 = getelementptr inbounds [16 x i32], [16 x i32]* %847, i64 0, i64 2
%849 = load i32, i32* %848
%850 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%851 = bitcast %union.CHAR64LONG16* %850 to [16 x i32]*
%852 = getelementptr inbounds [16 x i32], [16 x i32]* %851, i64 0, i64 13
%853 = load i32, i32* %852
%854 = xor i32 %849, %853
%855 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%856 = bitcast %union.CHAR64LONG16* %855 to [16 x i32]*
%857 = getelementptr inbounds [16 x i32], [16 x i32]* %856, i64 0, i64 7
%858 = load i32, i32* %857
%859 = xor i32 %854, %858
%860 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%861 = bitcast %union.CHAR64LONG16* %860 to [16 x i32]*
%862 = getelementptr inbounds [16 x i32], [16 x i32]* %861, i64 0, i64 5
%863 = load i32, i32* %862
%864 = xor i32 %859, %863
%865 = lshr i32 %864, 31
%866 = or i32 %845, %865
%867 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%868 = bitcast %union.CHAR64LONG16* %867 to [16 x i32]*
%869 = getelementptr inbounds [16 x i32], [16 x i32]* %868, i64 0, i64 5
store i32 %866, i32* %869
%870 = add i32 %825, %866
%871 = add i32 %870, 1859775393
%872 = load i32, i32* %9
%873 = shl i32 %872, 5
%874 = load i32, i32* %9
%875 = lshr i32 %874, 27
%876 = or i32 %873, %875
%877 = add i32 %871, %876
%878 = load i32, i32* %8
%879 = add i32 %878, %877
store i32 %879, i32* %8
%880 = load i32, i32* %5
%881 = shl i32 %880, 30
%882 = load i32, i32* %5
%883 = lshr i32 %882, 2
%884 = or i32 %881, %883
store i32 %884, i32* %5
%885 = load i32, i32* %9
%886 = load i32, i32* %5
%887 = xor i32 %885, %886
%888 = load i32, i32* %6
%889 = xor i32 %887, %888
%890 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%891 = bitcast %union.CHAR64LONG16* %890 to [16 x i32]*
%892 = getelementptr inbounds [16 x i32], [16 x i32]* %891, i64 0, i64 3
%893 = load i32, i32* %892
%894 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%895 = bitcast %union.CHAR64LONG16* %894 to [16 x i32]*
%896 = getelementptr inbounds [16 x i32], [16 x i32]* %895, i64 0, i64 14
%897 = load i32, i32* %896
%898 = xor i32 %893, %897
%899 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%900 = bitcast %union.CHAR64LONG16* %899 to [16 x i32]*
%901 = getelementptr inbounds [16 x i32], [16 x i32]* %900, i64 0, i64 8
%902 = load i32, i32* %901
%903 = xor i32 %898, %902
%904 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%905 = bitcast %union.CHAR64LONG16* %904 to [16 x i32]*
%906 = getelementptr inbounds [16 x i32], [16 x i32]* %905, i64 0, i64 6
%907 = load i32, i32* %906
%908 = xor i32 %903, %907
%909 = shl i32 %908, 1
%910 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%911 = bitcast %union.CHAR64LONG16* %910 to [16 x i32]*
%912 = getelementptr inbounds [16 x i32], [16 x i32]* %911, i64 0, i64 3
%913 = load i32, i32* %912
%914 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%915 = bitcast %union.CHAR64LONG16* %914 to [16 x i32]*
%916 = getelementptr inbounds [16 x i32], [16 x i32]* %915, i64 0, i64 14
%917 = load i32, i32* %916
%918 = xor i32 %913, %917
%919 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%920 = bitcast %union.CHAR64LONG16* %919 to [16 x i32]*
%921 = getelementptr inbounds [16 x i32], [16 x i32]* %920, i64 0, i64 8
%922 = load i32, i32* %921
%923 = xor i32 %918, %922
%924 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%925 = bitcast %union.CHAR64LONG16* %924 to [16 x i32]*
%926 = getelementptr inbounds [16 x i32], [16 x i32]* %925, i64 0, i64 6
%927 = load i32, i32* %926
%928 = xor i32 %923, %927
%929 = lshr i32 %928, 31
%930 = or i32 %909, %929
%931 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%932 = bitcast %union.CHAR64LONG16* %931 to [16 x i32]*
%933 = getelementptr inbounds [16 x i32], [16 x i32]* %932, i64 0, i64 6
store i32 %930, i32* %933
%934 = add i32 %889, %930
%935 = add i32 %934, 1859775393
%936 = load i32, i32* %8
%937 = shl i32 %936, 5
%938 = load i32, i32* %8
%939 = lshr i32 %938, 27
%940 = or i32 %937, %939
%941 = add i32 %935, %940
%942 = load i32, i32* %7
%943 = add i32 %942, %941
store i32 %943, i32* %7
%944 = load i32, i32* %9
%945 = shl i32 %944, 30
%946 = load i32, i32* %9
%947 = lshr i32 %946, 2
%948 = or i32 %945, %947
store i32 %948, i32* %9
%949 = load i32, i32* %8
%950 = load i32, i32* %9
%951 = xor i32 %949, %950
%952 = load i32, i32* %5
%953 = xor i32 %951, %952
%954 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%955 = bitcast %union.CHAR64LONG16* %954 to [16 x i32]*
%956 = getelementptr inbounds [16 x i32], [16 x i32]* %955, i64 0, i64 4
%957 = load i32, i32* %956
%958 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%959 = bitcast %union.CHAR64LONG16* %958 to [16 x i32]*
%960 = getelementptr inbounds [16 x i32], [16 x i32]* %959, i64 0, i64 15
%961 = load i32, i32* %960
%962 = xor i32 %957, %961
%963 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%964 = bitcast %union.CHAR64LONG16* %963 to [16 x i32]*
%965 = getelementptr inbounds [16 x i32], [16 x i32]* %964, i64 0, i64 9
%966 = load i32, i32* %965
%967 = xor i32 %962, %966
%968 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%969 = bitcast %union.CHAR64LONG16* %968 to [16 x i32]*
%970 = getelementptr inbounds [16 x i32], [16 x i32]* %969, i64 0, i64 7
%971 = load i32, i32* %970
%972 = xor i32 %967, %971
%973 = shl i32 %972, 1
%974 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%975 = bitcast %union.CHAR64LONG16* %974 to [16 x i32]*
%976 = getelementptr inbounds [16 x i32], [16 x i32]* %975, i64 0, i64 4
%977 = load i32, i32* %976
%978 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%979 = bitcast %union.CHAR64LONG16* %978 to [16 x i32]*
%980 = getelementptr inbounds [16 x i32], [16 x i32]* %979, i64 0, i64 15
%981 = load i32, i32* %980
%982 = xor i32 %977, %981
%983 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%984 = bitcast %union.CHAR64LONG16* %983 to [16 x i32]*
%985 = getelementptr inbounds [16 x i32], [16 x i32]* %984, i64 0, i64 9
%986 = load i32, i32* %985
%987 = xor i32 %982, %986
%988 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%989 = bitcast %union.CHAR64LONG16* %988 to [16 x i32]*
%990 = getelementptr inbounds [16 x i32], [16 x i32]* %989, i64 0, i64 7
%991 = load i32, i32* %990
%992 = xor i32 %987, %991
%993 = lshr i32 %992, 31
%994 = or i32 %973, %993
%995 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%996 = bitcast %union.CHAR64LONG16* %995 to [16 x i32]*
%997 = getelementptr inbounds [16 x i32], [16 x i32]* %996, i64 0, i64 7
store i32 %994, i32* %997
%998 = add i32 %953, %994
%999 = add i32 %998, 1859775393
%1000 = load i32, i32* %7
%1001 = shl i32 %1000, 5
%1002 = load i32, i32* %7
%1003 = lshr i32 %1002, 27
%1004 = or i32 %1001, %1003
%1005 = add i32 %999, %1004
%1006 = load i32, i32* %6
%1007 = add i32 %1006, %1005
store i32 %1007, i32* %6
%1008 = load i32, i32* %8
%1009 = shl i32 %1008, 30
%1010 = load i32, i32* %8
%1011 = lshr i32 %1010, 2
%1012 = or i32 %1009, %1011
store i32 %1012, i32* %8
%1013 = load i32, i32* %7
%1014 = load i32, i32* %8
%1015 = xor i32 %1013, %1014
%1016 = load i32, i32* %9
%1017 = xor i32 %1015, %1016
%1018 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1019 = bitcast %union.CHAR64LONG16* %1018 to [16 x i32]*
%1020 = getelementptr inbounds [16 x i32], [16 x i32]* %1019, i64 0, i64 5
%1021 = load i32, i32* %1020
%1022 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1023 = bitcast %union.CHAR64LONG16* %1022 to [16 x i32]*
%1024 = getelementptr inbounds [16 x i32], [16 x i32]* %1023, i64 0, i64 0
%1025 = load i32, i32* %1024
%1026 = xor i32 %1021, %1025
%1027 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1028 = bitcast %union.CHAR64LONG16* %1027 to [16 x i32]*
%1029 = getelementptr inbounds [16 x i32], [16 x i32]* %1028, i64 0, i64 10
%1030 = load i32, i32* %1029
%1031 = xor i32 %1026, %1030
%1032 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1033 = bitcast %union.CHAR64LONG16* %1032 to [16 x i32]*
%1034 = getelementptr inbounds [16 x i32], [16 x i32]* %1033, i64 0, i64 8
%1035 = load i32, i32* %1034
%1036 = xor i32 %1031, %1035
%1037 = shl i32 %1036, 1
%1038 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1039 = bitcast %union.CHAR64LONG16* %1038 to [16 x i32]*
%1040 = getelementptr inbounds [16 x i32], [16 x i32]* %1039, i64 0, i64 5
%1041 = load i32, i32* %1040
%1042 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1043 = bitcast %union.CHAR64LONG16* %1042 to [16 x i32]*
%1044 = getelementptr inbounds [16 x i32], [16 x i32]* %1043, i64 0, i64 0
%1045 = load i32, i32* %1044
%1046 = xor i32 %1041, %1045
%1047 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1048 = bitcast %union.CHAR64LONG16* %1047 to [16 x i32]*
%1049 = getelementptr inbounds [16 x i32], [16 x i32]* %1048, i64 0, i64 10
%1050 = load i32, i32* %1049
%1051 = xor i32 %1046, %1050
%1052 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1053 = bitcast %union.CHAR64LONG16* %1052 to [16 x i32]*
%1054 = getelementptr inbounds [16 x i32], [16 x i32]* %1053, i64 0, i64 8
%1055 = load i32, i32* %1054
%1056 = xor i32 %1051, %1055
%1057 = lshr i32 %1056, 31
%1058 = or i32 %1037, %1057
%1059 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1060 = bitcast %union.CHAR64LONG16* %1059 to [16 x i32]*
%1061 = getelementptr inbounds [16 x i32], [16 x i32]* %1060, i64 0, i64 8
store i32 %1058, i32* %1061
%1062 = add i32 %1017, %1058
%1063 = add i32 %1062, 1859775393
%1064 = load i32, i32* %6
%1065 = shl i32 %1064, 5
%1066 = load i32, i32* %6
%1067 = lshr i32 %1066, 27
%1068 = or i32 %1065, %1067
%1069 = add i32 %1063, %1068
%1070 = load i32, i32* %5
%1071 = add i32 %1070, %1069
store i32 %1071, i32* %5
%1072 = load i32, i32* %7
%1073 = shl i32 %1072, 30
%1074 = load i32, i32* %7
%1075 = lshr i32 %1074, 2
%1076 = or i32 %1073, %1075
store i32 %1076, i32* %7
%1077 = load i32, i32* %6
%1078 = load i32, i32* %7
%1079 = xor i32 %1077, %1078
%1080 = load i32, i32* %8
%1081 = xor i32 %1079, %1080
%1082 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1083 = bitcast %union.CHAR64LONG16* %1082 to [16 x i32]*
%1084 = getelementptr inbounds [16 x i32], [16 x i32]* %1083, i64 0, i64 6
%1085 = load i32, i32* %1084
%1086 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1087 = bitcast %union.CHAR64LONG16* %1086 to [16 x i32]*
%1088 = getelementptr inbounds [16 x i32], [16 x i32]* %1087, i64 0, i64 1
%1089 = load i32, i32* %1088
%1090 = xor i32 %1085, %1089
%1091 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1092 = bitcast %union.CHAR64LONG16* %1091 to [16 x i32]*
%1093 = getelementptr inbounds [16 x i32], [16 x i32]* %1092, i64 0, i64 11
%1094 = load i32, i32* %1093
%1095 = xor i32 %1090, %1094
%1096 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1097 = bitcast %union.CHAR64LONG16* %1096 to [16 x i32]*
%1098 = getelementptr inbounds [16 x i32], [16 x i32]* %1097, i64 0, i64 9
%1099 = load i32, i32* %1098
%1100 = xor i32 %1095, %1099
%1101 = shl i32 %1100, 1
%1102 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1103 = bitcast %union.CHAR64LONG16* %1102 to [16 x i32]*
%1104 = getelementptr inbounds [16 x i32], [16 x i32]* %1103, i64 0, i64 6
%1105 = load i32, i32* %1104
%1106 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1107 = bitcast %union.CHAR64LONG16* %1106 to [16 x i32]*
%1108 = getelementptr inbounds [16 x i32], [16 x i32]* %1107, i64 0, i64 1
%1109 = load i32, i32* %1108
%1110 = xor i32 %1105, %1109
%1111 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1112 = bitcast %union.CHAR64LONG16* %1111 to [16 x i32]*
%1113 = getelementptr inbounds [16 x i32], [16 x i32]* %1112, i64 0, i64 11
%1114 = load i32, i32* %1113
%1115 = xor i32 %1110, %1114
%1116 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1117 = bitcast %union.CHAR64LONG16* %1116 to [16 x i32]*
%1118 = getelementptr inbounds [16 x i32], [16 x i32]* %1117, i64 0, i64 9
%1119 = load i32, i32* %1118
%1120 = xor i32 %1115, %1119
%1121 = lshr i32 %1120, 31
%1122 = or i32 %1101, %1121
%1123 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1124 = bitcast %union.CHAR64LONG16* %1123 to [16 x i32]*
%1125 = getelementptr inbounds [16 x i32], [16 x i32]* %1124, i64 0, i64 9
store i32 %1122, i32* %1125
%1126 = add i32 %1081, %1122
%1127 = add i32 %1126, 1859775393
%1128 = load i32, i32* %5
%1129 = shl i32 %1128, 5
%1130 = load i32, i32* %5
%1131 = lshr i32 %1130, 27
%1132 = or i32 %1129, %1131
%1133 = add i32 %1127, %1132
%1134 = load i32, i32* %9
%1135 = add i32 %1134, %1133
store i32 %1135, i32* %9
%1136 = load i32, i32* %6
%1137 = shl i32 %1136, 30
%1138 = load i32, i32* %6
%1139 = lshr i32 %1138, 2
%1140 = or i32 %1137, %1139
store i32 %1140, i32* %6
%1141 = load i32, i32* %5
%1142 = load i32, i32* %6
%1143 = xor i32 %1141, %1142
%1144 = load i32, i32* %7
%1145 = xor i32 %1143, %1144
%1146 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1147 = bitcast %union.CHAR64LONG16* %1146 to [16 x i32]*
%1148 = getelementptr inbounds [16 x i32], [16 x i32]* %1147, i64 0, i64 7
%1149 = load i32, i32* %1148
%1150 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1151 = bitcast %union.CHAR64LONG16* %1150 to [16 x i32]*
%1152 = getelementptr inbounds [16 x i32], [16 x i32]* %1151, i64 0, i64 2
%1153 = load i32, i32* %1152
%1154 = xor i32 %1149, %1153
%1155 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1156 = bitcast %union.CHAR64LONG16* %1155 to [16 x i32]*
%1157 = getelementptr inbounds [16 x i32], [16 x i32]* %1156, i64 0, i64 12
%1158 = load i32, i32* %1157
%1159 = xor i32 %1154, %1158
%1160 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1161 = bitcast %union.CHAR64LONG16* %1160 to [16 x i32]*
%1162 = getelementptr inbounds [16 x i32], [16 x i32]* %1161, i64 0, i64 10
%1163 = load i32, i32* %1162
%1164 = xor i32 %1159, %1163
%1165 = shl i32 %1164, 1
%1166 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1167 = bitcast %union.CHAR64LONG16* %1166 to [16 x i32]*
%1168 = getelementptr inbounds [16 x i32], [16 x i32]* %1167, i64 0, i64 7
%1169 = load i32, i32* %1168
%1170 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1171 = bitcast %union.CHAR64LONG16* %1170 to [16 x i32]*
%1172 = getelementptr inbounds [16 x i32], [16 x i32]* %1171, i64 0, i64 2
%1173 = load i32, i32* %1172
%1174 = xor i32 %1169, %1173
%1175 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1176 = bitcast %union.CHAR64LONG16* %1175 to [16 x i32]*
%1177 = getelementptr inbounds [16 x i32], [16 x i32]* %1176, i64 0, i64 12
%1178 = load i32, i32* %1177
%1179 = xor i32 %1174, %1178
%1180 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1181 = bitcast %union.CHAR64LONG16* %1180 to [16 x i32]*
%1182 = getelementptr inbounds [16 x i32], [16 x i32]* %1181, i64 0, i64 10
%1183 = load i32, i32* %1182
%1184 = xor i32 %1179, %1183
%1185 = lshr i32 %1184, 31
%1186 = or i32 %1165, %1185
%1187 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1188 = bitcast %union.CHAR64LONG16* %1187 to [16 x i32]*
%1189 = getelementptr inbounds [16 x i32], [16 x i32]* %1188, i64 0, i64 10
store i32 %1186, i32* %1189
%1190 = add i32 %1145, %1186
%1191 = add i32 %1190, 1859775393
%1192 = load i32, i32* %9
%1193 = shl i32 %1192, 5
%1194 = load i32, i32* %9
%1195 = lshr i32 %1194, 27
%1196 = or i32 %1193, %1195
%1197 = add i32 %1191, %1196
%1198 = load i32, i32* %8
%1199 = add i32 %1198, %1197
store i32 %1199, i32* %8
%1200 = load i32, i32* %5
%1201 = shl i32 %1200, 30
%1202 = load i32, i32* %5
%1203 = lshr i32 %1202, 2
%1204 = or i32 %1201, %1203
store i32 %1204, i32* %5
%1205 = load i32, i32* %9
%1206 = load i32, i32* %5
%1207 = xor i32 %1205, %1206
%1208 = load i32, i32* %6
%1209 = xor i32 %1207, %1208
%1210 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1211 = bitcast %union.CHAR64LONG16* %1210 to [16 x i32]*
%1212 = getelementptr inbounds [16 x i32], [16 x i32]* %1211, i64 0, i64 8
%1213 = load i32, i32* %1212
%1214 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1215 = bitcast %union.CHAR64LONG16* %1214 to [16 x i32]*
%1216 = getelementptr inbounds [16 x i32], [16 x i32]* %1215, i64 0, i64 3
%1217 = load i32, i32* %1216
%1218 = xor i32 %1213, %1217
%1219 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1220 = bitcast %union.CHAR64LONG16* %1219 to [16 x i32]*
%1221 = getelementptr inbounds [16 x i32], [16 x i32]* %1220, i64 0, i64 13
%1222 = load i32, i32* %1221
%1223 = xor i32 %1218, %1222
%1224 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1225 = bitcast %union.CHAR64LONG16* %1224 to [16 x i32]*
%1226 = getelementptr inbounds [16 x i32], [16 x i32]* %1225, i64 0, i64 11
%1227 = load i32, i32* %1226
%1228 = xor i32 %1223, %1227
%1229 = shl i32 %1228, 1
%1230 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1231 = bitcast %union.CHAR64LONG16* %1230 to [16 x i32]*
%1232 = getelementptr inbounds [16 x i32], [16 x i32]* %1231, i64 0, i64 8
%1233 = load i32, i32* %1232
%1234 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1235 = bitcast %union.CHAR64LONG16* %1234 to [16 x i32]*
%1236 = getelementptr inbounds [16 x i32], [16 x i32]* %1235, i64 0, i64 3
%1237 = load i32, i32* %1236
%1238 = xor i32 %1233, %1237
%1239 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1240 = bitcast %union.CHAR64LONG16* %1239 to [16 x i32]*
%1241 = getelementptr inbounds [16 x i32], [16 x i32]* %1240, i64 0, i64 13
%1242 = load i32, i32* %1241
%1243 = xor i32 %1238, %1242
%1244 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1245 = bitcast %union.CHAR64LONG16* %1244 to [16 x i32]*
%1246 = getelementptr inbounds [16 x i32], [16 x i32]* %1245, i64 0, i64 11
%1247 = load i32, i32* %1246
%1248 = xor i32 %1243, %1247
%1249 = lshr i32 %1248, 31
%1250 = or i32 %1229, %1249
%1251 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1252 = bitcast %union.CHAR64LONG16* %1251 to [16 x i32]*
%1253 = getelementptr inbounds [16 x i32], [16 x i32]* %1252, i64 0, i64 11
store i32 %1250, i32* %1253
%1254 = add i32 %1209, %1250
%1255 = add i32 %1254, 1859775393
%1256 = load i32, i32* %8
%1257 = shl i32 %1256, 5
%1258 = load i32, i32* %8
%1259 = lshr i32 %1258, 27
%1260 = or i32 %1257, %1259
%1261 = add i32 %1255, %1260
%1262 = load i32, i32* %7
%1263 = add i32 %1262, %1261
store i32 %1263, i32* %7
%1264 = load i32, i32* %9
%1265 = shl i32 %1264, 30
%1266 = load i32, i32* %9
%1267 = lshr i32 %1266, 2
%1268 = or i32 %1265, %1267
store i32 %1268, i32* %9
%1269 = load i32, i32* %8
%1270 = load i32, i32* %9
%1271 = xor i32 %1269, %1270
%1272 = load i32, i32* %5
%1273 = xor i32 %1271, %1272
%1274 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1275 = bitcast %union.CHAR64LONG16* %1274 to [16 x i32]*
%1276 = getelementptr inbounds [16 x i32], [16 x i32]* %1275, i64 0, i64 9
%1277 = load i32, i32* %1276
%1278 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1279 = bitcast %union.CHAR64LONG16* %1278 to [16 x i32]*
%1280 = getelementptr inbounds [16 x i32], [16 x i32]* %1279, i64 0, i64 4
%1281 = load i32, i32* %1280
%1282 = xor i32 %1277, %1281
%1283 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1284 = bitcast %union.CHAR64LONG16* %1283 to [16 x i32]*
%1285 = getelementptr inbounds [16 x i32], [16 x i32]* %1284, i64 0, i64 14
%1286 = load i32, i32* %1285
%1287 = xor i32 %1282, %1286
%1288 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1289 = bitcast %union.CHAR64LONG16* %1288 to [16 x i32]*
%1290 = getelementptr inbounds [16 x i32], [16 x i32]* %1289, i64 0, i64 12
%1291 = load i32, i32* %1290
%1292 = xor i32 %1287, %1291
%1293 = shl i32 %1292, 1
%1294 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1295 = bitcast %union.CHAR64LONG16* %1294 to [16 x i32]*
%1296 = getelementptr inbounds [16 x i32], [16 x i32]* %1295, i64 0, i64 9
%1297 = load i32, i32* %1296
%1298 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1299 = bitcast %union.CHAR64LONG16* %1298 to [16 x i32]*
%1300 = getelementptr inbounds [16 x i32], [16 x i32]* %1299, i64 0, i64 4
%1301 = load i32, i32* %1300
%1302 = xor i32 %1297, %1301
%1303 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1304 = bitcast %union.CHAR64LONG16* %1303 to [16 x i32]*
%1305 = getelementptr inbounds [16 x i32], [16 x i32]* %1304, i64 0, i64 14
%1306 = load i32, i32* %1305
%1307 = xor i32 %1302, %1306
%1308 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1309 = bitcast %union.CHAR64LONG16* %1308 to [16 x i32]*
%1310 = getelementptr inbounds [16 x i32], [16 x i32]* %1309, i64 0, i64 12
%1311 = load i32, i32* %1310
%1312 = xor i32 %1307, %1311
%1313 = lshr i32 %1312, 31
%1314 = or i32 %1293, %1313
%1315 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1316 = bitcast %union.CHAR64LONG16* %1315 to [16 x i32]*
%1317 = getelementptr inbounds [16 x i32], [16 x i32]* %1316, i64 0, i64 12
store i32 %1314, i32* %1317
%1318 = add i32 %1273, %1314
%1319 = add i32 %1318, 1859775393
%1320 = load i32, i32* %7
%1321 = shl i32 %1320, 5
%1322 = load i32, i32* %7
%1323 = lshr i32 %1322, 27
%1324 = or i32 %1321, %1323
%1325 = add i32 %1319, %1324
%1326 = load i32, i32* %6
%1327 = add i32 %1326, %1325
store i32 %1327, i32* %6
%1328 = load i32, i32* %8
%1329 = shl i32 %1328, 30
%1330 = load i32, i32* %8
%1331 = lshr i32 %1330, 2
%1332 = or i32 %1329, %1331
store i32 %1332, i32* %8
%1333 = load i32, i32* %7
%1334 = load i32, i32* %8
%1335 = xor i32 %1333, %1334
%1336 = load i32, i32* %9
%1337 = xor i32 %1335, %1336
%1338 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1339 = bitcast %union.CHAR64LONG16* %1338 to [16 x i32]*
%1340 = getelementptr inbounds [16 x i32], [16 x i32]* %1339, i64 0, i64 10
%1341 = load i32, i32* %1340
%1342 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1343 = bitcast %union.CHAR64LONG16* %1342 to [16 x i32]*
%1344 = getelementptr inbounds [16 x i32], [16 x i32]* %1343, i64 0, i64 5
%1345 = load i32, i32* %1344
%1346 = xor i32 %1341, %1345
%1347 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1348 = bitcast %union.CHAR64LONG16* %1347 to [16 x i32]*
%1349 = getelementptr inbounds [16 x i32], [16 x i32]* %1348, i64 0, i64 15
%1350 = load i32, i32* %1349
%1351 = xor i32 %1346, %1350
%1352 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1353 = bitcast %union.CHAR64LONG16* %1352 to [16 x i32]*
%1354 = getelementptr inbounds [16 x i32], [16 x i32]* %1353, i64 0, i64 13
%1355 = load i32, i32* %1354
%1356 = xor i32 %1351, %1355
%1357 = shl i32 %1356, 1
%1358 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1359 = bitcast %union.CHAR64LONG16* %1358 to [16 x i32]*
%1360 = getelementptr inbounds [16 x i32], [16 x i32]* %1359, i64 0, i64 10
%1361 = load i32, i32* %1360
%1362 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1363 = bitcast %union.CHAR64LONG16* %1362 to [16 x i32]*
%1364 = getelementptr inbounds [16 x i32], [16 x i32]* %1363, i64 0, i64 5
%1365 = load i32, i32* %1364
%1366 = xor i32 %1361, %1365
%1367 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1368 = bitcast %union.CHAR64LONG16* %1367 to [16 x i32]*
%1369 = getelementptr inbounds [16 x i32], [16 x i32]* %1368, i64 0, i64 15
%1370 = load i32, i32* %1369
%1371 = xor i32 %1366, %1370
%1372 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1373 = bitcast %union.CHAR64LONG16* %1372 to [16 x i32]*
%1374 = getelementptr inbounds [16 x i32], [16 x i32]* %1373, i64 0, i64 13
%1375 = load i32, i32* %1374
%1376 = xor i32 %1371, %1375
%1377 = lshr i32 %1376, 31
%1378 = or i32 %1357, %1377
%1379 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1380 = bitcast %union.CHAR64LONG16* %1379 to [16 x i32]*
%1381 = getelementptr inbounds [16 x i32], [16 x i32]* %1380, i64 0, i64 13
store i32 %1378, i32* %1381
%1382 = add i32 %1337, %1378
%1383 = add i32 %1382, 1859775393
%1384 = load i32, i32* %6
%1385 = shl i32 %1384, 5
%1386 = load i32, i32* %6
%1387 = lshr i32 %1386, 27
%1388 = or i32 %1385, %1387
%1389 = add i32 %1383, %1388
%1390 = load i32, i32* %5
%1391 = add i32 %1390, %1389
store i32 %1391, i32* %5
%1392 = load i32, i32* %7
%1393 = shl i32 %1392, 30
%1394 = load i32, i32* %7
%1395 = lshr i32 %1394, 2
%1396 = or i32 %1393, %1395
store i32 %1396, i32* %7
%1397 = load i32, i32* %6
%1398 = load i32, i32* %7
%1399 = xor i32 %1397, %1398
%1400 = load i32, i32* %8
%1401 = xor i32 %1399, %1400
%1402 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1403 = bitcast %union.CHAR64LONG16* %1402 to [16 x i32]*
%1404 = getelementptr inbounds [16 x i32], [16 x i32]* %1403, i64 0, i64 11
%1405 = load i32, i32* %1404
%1406 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1407 = bitcast %union.CHAR64LONG16* %1406 to [16 x i32]*
%1408 = getelementptr inbounds [16 x i32], [16 x i32]* %1407, i64 0, i64 6
%1409 = load i32, i32* %1408
%1410 = xor i32 %1405, %1409
%1411 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1412 = bitcast %union.CHAR64LONG16* %1411 to [16 x i32]*
%1413 = getelementptr inbounds [16 x i32], [16 x i32]* %1412, i64 0, i64 0
%1414 = load i32, i32* %1413
%1415 = xor i32 %1410, %1414
%1416 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1417 = bitcast %union.CHAR64LONG16* %1416 to [16 x i32]*
%1418 = getelementptr inbounds [16 x i32], [16 x i32]* %1417, i64 0, i64 14
%1419 = load i32, i32* %1418
%1420 = xor i32 %1415, %1419
%1421 = shl i32 %1420, 1
%1422 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1423 = bitcast %union.CHAR64LONG16* %1422 to [16 x i32]*
%1424 = getelementptr inbounds [16 x i32], [16 x i32]* %1423, i64 0, i64 11
%1425 = load i32, i32* %1424
%1426 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1427 = bitcast %union.CHAR64LONG16* %1426 to [16 x i32]*
%1428 = getelementptr inbounds [16 x i32], [16 x i32]* %1427, i64 0, i64 6
%1429 = load i32, i32* %1428
%1430 = xor i32 %1425, %1429
%1431 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1432 = bitcast %union.CHAR64LONG16* %1431 to [16 x i32]*
%1433 = getelementptr inbounds [16 x i32], [16 x i32]* %1432, i64 0, i64 0
%1434 = load i32, i32* %1433
%1435 = xor i32 %1430, %1434
%1436 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1437 = bitcast %union.CHAR64LONG16* %1436 to [16 x i32]*
%1438 = getelementptr inbounds [16 x i32], [16 x i32]* %1437, i64 0, i64 14
%1439 = load i32, i32* %1438
%1440 = xor i32 %1435, %1439
%1441 = lshr i32 %1440, 31
%1442 = or i32 %1421, %1441
%1443 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1444 = bitcast %union.CHAR64LONG16* %1443 to [16 x i32]*
%1445 = getelementptr inbounds [16 x i32], [16 x i32]* %1444, i64 0, i64 14
store i32 %1442, i32* %1445
%1446 = add i32 %1401, %1442
%1447 = add i32 %1446, 1859775393
%1448 = load i32, i32* %5
%1449 = shl i32 %1448, 5
%1450 = load i32, i32* %5
%1451 = lshr i32 %1450, 27
%1452 = or i32 %1449, %1451
%1453 = add i32 %1447, %1452
%1454 = load i32, i32* %9
%1455 = add i32 %1454, %1453
store i32 %1455, i32* %9
%1456 = load i32, i32* %6
%1457 = shl i32 %1456, 30
%1458 = load i32, i32* %6
%1459 = lshr i32 %1458, 2
%1460 = or i32 %1457, %1459
store i32 %1460, i32* %6
%1461 = load i32, i32* %5
%1462 = load i32, i32* %6
%1463 = xor i32 %1461, %1462
%1464 = load i32, i32* %7
%1465 = xor i32 %1463, %1464
%1466 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1467 = bitcast %union.CHAR64LONG16* %1466 to [16 x i32]*
%1468 = getelementptr inbounds [16 x i32], [16 x i32]* %1467, i64 0, i64 12
%1469 = load i32, i32* %1468
%1470 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1471 = bitcast %union.CHAR64LONG16* %1470 to [16 x i32]*
%1472 = getelementptr inbounds [16 x i32], [16 x i32]* %1471, i64 0, i64 7
%1473 = load i32, i32* %1472
%1474 = xor i32 %1469, %1473
%1475 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1476 = bitcast %union.CHAR64LONG16* %1475 to [16 x i32]*
%1477 = getelementptr inbounds [16 x i32], [16 x i32]* %1476, i64 0, i64 1
%1478 = load i32, i32* %1477
%1479 = xor i32 %1474, %1478
%1480 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1481 = bitcast %union.CHAR64LONG16* %1480 to [16 x i32]*
%1482 = getelementptr inbounds [16 x i32], [16 x i32]* %1481, i64 0, i64 15
%1483 = load i32, i32* %1482
%1484 = xor i32 %1479, %1483
%1485 = shl i32 %1484, 1
%1486 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1487 = bitcast %union.CHAR64LONG16* %1486 to [16 x i32]*
%1488 = getelementptr inbounds [16 x i32], [16 x i32]* %1487, i64 0, i64 12
%1489 = load i32, i32* %1488
%1490 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1491 = bitcast %union.CHAR64LONG16* %1490 to [16 x i32]*
%1492 = getelementptr inbounds [16 x i32], [16 x i32]* %1491, i64 0, i64 7
%1493 = load i32, i32* %1492
%1494 = xor i32 %1489, %1493
%1495 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1496 = bitcast %union.CHAR64LONG16* %1495 to [16 x i32]*
%1497 = getelementptr inbounds [16 x i32], [16 x i32]* %1496, i64 0, i64 1
%1498 = load i32, i32* %1497
%1499 = xor i32 %1494, %1498
%1500 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1501 = bitcast %union.CHAR64LONG16* %1500 to [16 x i32]*
%1502 = getelementptr inbounds [16 x i32], [16 x i32]* %1501, i64 0, i64 15
%1503 = load i32, i32* %1502
%1504 = xor i32 %1499, %1503
%1505 = lshr i32 %1504, 31
%1506 = or i32 %1485, %1505
%1507 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1508 = bitcast %union.CHAR64LONG16* %1507 to [16 x i32]*
%1509 = getelementptr inbounds [16 x i32], [16 x i32]* %1508, i64 0, i64 15
store i32 %1506, i32* %1509
%1510 = add i32 %1465, %1506
%1511 = add i32 %1510, 1859775393
%1512 = load i32, i32* %9
%1513 = shl i32 %1512, 5
%1514 = load i32, i32* %9
%1515 = lshr i32 %1514, 27
%1516 = or i32 %1513, %1515
%1517 = add i32 %1511, %1516
%1518 = load i32, i32* %8
%1519 = add i32 %1518, %1517
store i32 %1519, i32* %8
%1520 = load i32, i32* %5
%1521 = shl i32 %1520, 30
%1522 = load i32, i32* %5
%1523 = lshr i32 %1522, 2
%1524 = or i32 %1521, %1523
store i32 %1524, i32* %5
%1525 = load i32, i32* %9
%1526 = load i32, i32* %5
%1527 = xor i32 %1525, %1526
%1528 = load i32, i32* %6
%1529 = xor i32 %1527, %1528
%1530 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1531 = bitcast %union.CHAR64LONG16* %1530 to [16 x i32]*
%1532 = getelementptr inbounds [16 x i32], [16 x i32]* %1531, i64 0, i64 13
%1533 = load i32, i32* %1532
%1534 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1535 = bitcast %union.CHAR64LONG16* %1534 to [16 x i32]*
%1536 = getelementptr inbounds [16 x i32], [16 x i32]* %1535, i64 0, i64 8
%1537 = load i32, i32* %1536
%1538 = xor i32 %1533, %1537
%1539 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1540 = bitcast %union.CHAR64LONG16* %1539 to [16 x i32]*
%1541 = getelementptr inbounds [16 x i32], [16 x i32]* %1540, i64 0, i64 2
%1542 = load i32, i32* %1541
%1543 = xor i32 %1538, %1542
%1544 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1545 = bitcast %union.CHAR64LONG16* %1544 to [16 x i32]*
%1546 = getelementptr inbounds [16 x i32], [16 x i32]* %1545, i64 0, i64 0
%1547 = load i32, i32* %1546
%1548 = xor i32 %1543, %1547
%1549 = shl i32 %1548, 1
%1550 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1551 = bitcast %union.CHAR64LONG16* %1550 to [16 x i32]*
%1552 = getelementptr inbounds [16 x i32], [16 x i32]* %1551, i64 0, i64 13
%1553 = load i32, i32* %1552
%1554 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1555 = bitcast %union.CHAR64LONG16* %1554 to [16 x i32]*
%1556 = getelementptr inbounds [16 x i32], [16 x i32]* %1555, i64 0, i64 8
%1557 = load i32, i32* %1556
%1558 = xor i32 %1553, %1557
%1559 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1560 = bitcast %union.CHAR64LONG16* %1559 to [16 x i32]*
%1561 = getelementptr inbounds [16 x i32], [16 x i32]* %1560, i64 0, i64 2
%1562 = load i32, i32* %1561
%1563 = xor i32 %1558, %1562
%1564 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1565 = bitcast %union.CHAR64LONG16* %1564 to [16 x i32]*
%1566 = getelementptr inbounds [16 x i32], [16 x i32]* %1565, i64 0, i64 0
%1567 = load i32, i32* %1566
%1568 = xor i32 %1563, %1567
%1569 = lshr i32 %1568, 31
%1570 = or i32 %1549, %1569
%1571 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1572 = bitcast %union.CHAR64LONG16* %1571 to [16 x i32]*
%1573 = getelementptr inbounds [16 x i32], [16 x i32]* %1572, i64 0, i64 0
store i32 %1570, i32* %1573
%1574 = add i32 %1529, %1570
%1575 = add i32 %1574, 1859775393
%1576 = load i32, i32* %8
%1577 = shl i32 %1576, 5
%1578 = load i32, i32* %8
%1579 = lshr i32 %1578, 27
%1580 = or i32 %1577, %1579
%1581 = add i32 %1575, %1580
%1582 = load i32, i32* %7
%1583 = add i32 %1582, %1581
store i32 %1583, i32* %7
%1584 = load i32, i32* %9
%1585 = shl i32 %1584, 30
%1586 = load i32, i32* %9
%1587 = lshr i32 %1586, 2
%1588 = or i32 %1585, %1587
store i32 %1588, i32* %9
%1589 = load i32, i32* %8
%1590 = load i32, i32* %9
%1591 = xor i32 %1589, %1590
%1592 = load i32, i32* %5
%1593 = xor i32 %1591, %1592
%1594 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1595 = bitcast %union.CHAR64LONG16* %1594 to [16 x i32]*
%1596 = getelementptr inbounds [16 x i32], [16 x i32]* %1595, i64 0, i64 14
%1597 = load i32, i32* %1596
%1598 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1599 = bitcast %union.CHAR64LONG16* %1598 to [16 x i32]*
%1600 = getelementptr inbounds [16 x i32], [16 x i32]* %1599, i64 0, i64 9
%1601 = load i32, i32* %1600
%1602 = xor i32 %1597, %1601
%1603 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1604 = bitcast %union.CHAR64LONG16* %1603 to [16 x i32]*
%1605 = getelementptr inbounds [16 x i32], [16 x i32]* %1604, i64 0, i64 3
%1606 = load i32, i32* %1605
%1607 = xor i32 %1602, %1606
%1608 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1609 = bitcast %union.CHAR64LONG16* %1608 to [16 x i32]*
%1610 = getelementptr inbounds [16 x i32], [16 x i32]* %1609, i64 0, i64 1
%1611 = load i32, i32* %1610
%1612 = xor i32 %1607, %1611
%1613 = shl i32 %1612, 1
%1614 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1615 = bitcast %union.CHAR64LONG16* %1614 to [16 x i32]*
%1616 = getelementptr inbounds [16 x i32], [16 x i32]* %1615, i64 0, i64 14
%1617 = load i32, i32* %1616
%1618 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1619 = bitcast %union.CHAR64LONG16* %1618 to [16 x i32]*
%1620 = getelementptr inbounds [16 x i32], [16 x i32]* %1619, i64 0, i64 9
%1621 = load i32, i32* %1620
%1622 = xor i32 %1617, %1621
%1623 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1624 = bitcast %union.CHAR64LONG16* %1623 to [16 x i32]*
%1625 = getelementptr inbounds [16 x i32], [16 x i32]* %1624, i64 0, i64 3
%1626 = load i32, i32* %1625
%1627 = xor i32 %1622, %1626
%1628 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1629 = bitcast %union.CHAR64LONG16* %1628 to [16 x i32]*
%1630 = getelementptr inbounds [16 x i32], [16 x i32]* %1629, i64 0, i64 1
%1631 = load i32, i32* %1630
%1632 = xor i32 %1627, %1631
%1633 = lshr i32 %1632, 31
%1634 = or i32 %1613, %1633
%1635 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1636 = bitcast %union.CHAR64LONG16* %1635 to [16 x i32]*
%1637 = getelementptr inbounds [16 x i32], [16 x i32]* %1636, i64 0, i64 1
store i32 %1634, i32* %1637
%1638 = add i32 %1593, %1634
%1639 = add i32 %1638, 1859775393
%1640 = load i32, i32* %7
%1641 = shl i32 %1640, 5
%1642 = load i32, i32* %7
%1643 = lshr i32 %1642, 27
%1644 = or i32 %1641, %1643
%1645 = add i32 %1639, %1644
%1646 = load i32, i32* %6
%1647 = add i32 %1646, %1645
store i32 %1647, i32* %6
%1648 = load i32, i32* %8
%1649 = shl i32 %1648, 30
%1650 = load i32, i32* %8
%1651 = lshr i32 %1650, 2
%1652 = or i32 %1649, %1651
store i32 %1652, i32* %8
%1653 = load i32, i32* %7
%1654 = load i32, i32* %8
%1655 = xor i32 %1653, %1654
%1656 = load i32, i32* %9
%1657 = xor i32 %1655, %1656
%1658 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1659 = bitcast %union.CHAR64LONG16* %1658 to [16 x i32]*
%1660 = getelementptr inbounds [16 x i32], [16 x i32]* %1659, i64 0, i64 15
%1661 = load i32, i32* %1660
%1662 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1663 = bitcast %union.CHAR64LONG16* %1662 to [16 x i32]*
%1664 = getelementptr inbounds [16 x i32], [16 x i32]* %1663, i64 0, i64 10
%1665 = load i32, i32* %1664
%1666 = xor i32 %1661, %1665
%1667 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1668 = bitcast %union.CHAR64LONG16* %1667 to [16 x i32]*
%1669 = getelementptr inbounds [16 x i32], [16 x i32]* %1668, i64 0, i64 4
%1670 = load i32, i32* %1669
%1671 = xor i32 %1666, %1670
%1672 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1673 = bitcast %union.CHAR64LONG16* %1672 to [16 x i32]*
%1674 = getelementptr inbounds [16 x i32], [16 x i32]* %1673, i64 0, i64 2
%1675 = load i32, i32* %1674
%1676 = xor i32 %1671, %1675
%1677 = shl i32 %1676, 1
%1678 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1679 = bitcast %union.CHAR64LONG16* %1678 to [16 x i32]*
%1680 = getelementptr inbounds [16 x i32], [16 x i32]* %1679, i64 0, i64 15
%1681 = load i32, i32* %1680
%1682 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1683 = bitcast %union.CHAR64LONG16* %1682 to [16 x i32]*
%1684 = getelementptr inbounds [16 x i32], [16 x i32]* %1683, i64 0, i64 10
%1685 = load i32, i32* %1684
%1686 = xor i32 %1681, %1685
%1687 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1688 = bitcast %union.CHAR64LONG16* %1687 to [16 x i32]*
%1689 = getelementptr inbounds [16 x i32], [16 x i32]* %1688, i64 0, i64 4
%1690 = load i32, i32* %1689
%1691 = xor i32 %1686, %1690
%1692 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1693 = bitcast %union.CHAR64LONG16* %1692 to [16 x i32]*
%1694 = getelementptr inbounds [16 x i32], [16 x i32]* %1693, i64 0, i64 2
%1695 = load i32, i32* %1694
%1696 = xor i32 %1691, %1695
%1697 = lshr i32 %1696, 31
%1698 = or i32 %1677, %1697
%1699 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1700 = bitcast %union.CHAR64LONG16* %1699 to [16 x i32]*
%1701 = getelementptr inbounds [16 x i32], [16 x i32]* %1700, i64 0, i64 2
store i32 %1698, i32* %1701
%1702 = add i32 %1657, %1698
%1703 = add i32 %1702, 1859775393
%1704 = load i32, i32* %6
%1705 = shl i32 %1704, 5
%1706 = load i32, i32* %6
%1707 = lshr i32 %1706, 27
%1708 = or i32 %1705, %1707
%1709 = add i32 %1703, %1708
%1710 = load i32, i32* %5
%1711 = add i32 %1710, %1709
store i32 %1711, i32* %5
%1712 = load i32, i32* %7
%1713 = shl i32 %1712, 30
%1714 = load i32, i32* %7
%1715 = lshr i32 %1714, 2
%1716 = or i32 %1713, %1715
store i32 %1716, i32* %7
%1717 = load i32, i32* %6
%1718 = load i32, i32* %7
%1719 = xor i32 %1717, %1718
%1720 = load i32, i32* %8
%1721 = xor i32 %1719, %1720
%1722 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1723 = bitcast %union.CHAR64LONG16* %1722 to [16 x i32]*
%1724 = getelementptr inbounds [16 x i32], [16 x i32]* %1723, i64 0, i64 0
%1725 = load i32, i32* %1724
%1726 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1727 = bitcast %union.CHAR64LONG16* %1726 to [16 x i32]*
%1728 = getelementptr inbounds [16 x i32], [16 x i32]* %1727, i64 0, i64 11
%1729 = load i32, i32* %1728
%1730 = xor i32 %1725, %1729
%1731 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1732 = bitcast %union.CHAR64LONG16* %1731 to [16 x i32]*
%1733 = getelementptr inbounds [16 x i32], [16 x i32]* %1732, i64 0, i64 5
%1734 = load i32, i32* %1733
%1735 = xor i32 %1730, %1734
%1736 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1737 = bitcast %union.CHAR64LONG16* %1736 to [16 x i32]*
%1738 = getelementptr inbounds [16 x i32], [16 x i32]* %1737, i64 0, i64 3
%1739 = load i32, i32* %1738
%1740 = xor i32 %1735, %1739
%1741 = shl i32 %1740, 1
%1742 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1743 = bitcast %union.CHAR64LONG16* %1742 to [16 x i32]*
%1744 = getelementptr inbounds [16 x i32], [16 x i32]* %1743, i64 0, i64 0
%1745 = load i32, i32* %1744
%1746 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1747 = bitcast %union.CHAR64LONG16* %1746 to [16 x i32]*
%1748 = getelementptr inbounds [16 x i32], [16 x i32]* %1747, i64 0, i64 11
%1749 = load i32, i32* %1748
%1750 = xor i32 %1745, %1749
%1751 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1752 = bitcast %union.CHAR64LONG16* %1751 to [16 x i32]*
%1753 = getelementptr inbounds [16 x i32], [16 x i32]* %1752, i64 0, i64 5
%1754 = load i32, i32* %1753
%1755 = xor i32 %1750, %1754
%1756 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1757 = bitcast %union.CHAR64LONG16* %1756 to [16 x i32]*
%1758 = getelementptr inbounds [16 x i32], [16 x i32]* %1757, i64 0, i64 3
%1759 = load i32, i32* %1758
%1760 = xor i32 %1755, %1759
%1761 = lshr i32 %1760, 31
%1762 = or i32 %1741, %1761
%1763 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1764 = bitcast %union.CHAR64LONG16* %1763 to [16 x i32]*
%1765 = getelementptr inbounds [16 x i32], [16 x i32]* %1764, i64 0, i64 3
store i32 %1762, i32* %1765
%1766 = add i32 %1721, %1762
%1767 = add i32 %1766, 1859775393
%1768 = load i32, i32* %5
%1769 = shl i32 %1768, 5
%1770 = load i32, i32* %5
%1771 = lshr i32 %1770, 27
%1772 = or i32 %1769, %1771
%1773 = add i32 %1767, %1772
%1774 = load i32, i32* %9
%1775 = add i32 %1774, %1773
store i32 %1775, i32* %9
%1776 = load i32, i32* %6
%1777 = shl i32 %1776, 30
%1778 = load i32, i32* %6
%1779 = lshr i32 %1778, 2
%1780 = or i32 %1777, %1779
store i32 %1780, i32* %6
%1781 = load i32, i32* %5
%1782 = load i32, i32* %6
%1783 = xor i32 %1781, %1782
%1784 = load i32, i32* %7
%1785 = xor i32 %1783, %1784
%1786 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1787 = bitcast %union.CHAR64LONG16* %1786 to [16 x i32]*
%1788 = getelementptr inbounds [16 x i32], [16 x i32]* %1787, i64 0, i64 1
%1789 = load i32, i32* %1788
%1790 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1791 = bitcast %union.CHAR64LONG16* %1790 to [16 x i32]*
%1792 = getelementptr inbounds [16 x i32], [16 x i32]* %1791, i64 0, i64 12
%1793 = load i32, i32* %1792
%1794 = xor i32 %1789, %1793
%1795 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1796 = bitcast %union.CHAR64LONG16* %1795 to [16 x i32]*
%1797 = getelementptr inbounds [16 x i32], [16 x i32]* %1796, i64 0, i64 6
%1798 = load i32, i32* %1797
%1799 = xor i32 %1794, %1798
%1800 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1801 = bitcast %union.CHAR64LONG16* %1800 to [16 x i32]*
%1802 = getelementptr inbounds [16 x i32], [16 x i32]* %1801, i64 0, i64 4
%1803 = load i32, i32* %1802
%1804 = xor i32 %1799, %1803
%1805 = shl i32 %1804, 1
%1806 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1807 = bitcast %union.CHAR64LONG16* %1806 to [16 x i32]*
%1808 = getelementptr inbounds [16 x i32], [16 x i32]* %1807, i64 0, i64 1
%1809 = load i32, i32* %1808
%1810 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1811 = bitcast %union.CHAR64LONG16* %1810 to [16 x i32]*
%1812 = getelementptr inbounds [16 x i32], [16 x i32]* %1811, i64 0, i64 12
%1813 = load i32, i32* %1812
%1814 = xor i32 %1809, %1813
%1815 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1816 = bitcast %union.CHAR64LONG16* %1815 to [16 x i32]*
%1817 = getelementptr inbounds [16 x i32], [16 x i32]* %1816, i64 0, i64 6
%1818 = load i32, i32* %1817
%1819 = xor i32 %1814, %1818
%1820 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1821 = bitcast %union.CHAR64LONG16* %1820 to [16 x i32]*
%1822 = getelementptr inbounds [16 x i32], [16 x i32]* %1821, i64 0, i64 4
%1823 = load i32, i32* %1822
%1824 = xor i32 %1819, %1823
%1825 = lshr i32 %1824, 31
%1826 = or i32 %1805, %1825
%1827 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1828 = bitcast %union.CHAR64LONG16* %1827 to [16 x i32]*
%1829 = getelementptr inbounds [16 x i32], [16 x i32]* %1828, i64 0, i64 4
store i32 %1826, i32* %1829
%1830 = add i32 %1785, %1826
%1831 = add i32 %1830, 1859775393
%1832 = load i32, i32* %9
%1833 = shl i32 %1832, 5
%1834 = load i32, i32* %9
%1835 = lshr i32 %1834, 27
%1836 = or i32 %1833, %1835
%1837 = add i32 %1831, %1836
%1838 = load i32, i32* %8
%1839 = add i32 %1838, %1837
store i32 %1839, i32* %8
%1840 = load i32, i32* %5
%1841 = shl i32 %1840, 30
%1842 = load i32, i32* %5
%1843 = lshr i32 %1842, 2
%1844 = or i32 %1841, %1843
store i32 %1844, i32* %5
%1845 = load i32, i32* %9
%1846 = load i32, i32* %5
%1847 = xor i32 %1845, %1846
%1848 = load i32, i32* %6
%1849 = xor i32 %1847, %1848
%1850 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1851 = bitcast %union.CHAR64LONG16* %1850 to [16 x i32]*
%1852 = getelementptr inbounds [16 x i32], [16 x i32]* %1851, i64 0, i64 2
%1853 = load i32, i32* %1852
%1854 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1855 = bitcast %union.CHAR64LONG16* %1854 to [16 x i32]*
%1856 = getelementptr inbounds [16 x i32], [16 x i32]* %1855, i64 0, i64 13
%1857 = load i32, i32* %1856
%1858 = xor i32 %1853, %1857
%1859 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1860 = bitcast %union.CHAR64LONG16* %1859 to [16 x i32]*
%1861 = getelementptr inbounds [16 x i32], [16 x i32]* %1860, i64 0, i64 7
%1862 = load i32, i32* %1861
%1863 = xor i32 %1858, %1862
%1864 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1865 = bitcast %union.CHAR64LONG16* %1864 to [16 x i32]*
%1866 = getelementptr inbounds [16 x i32], [16 x i32]* %1865, i64 0, i64 5
%1867 = load i32, i32* %1866
%1868 = xor i32 %1863, %1867
%1869 = shl i32 %1868, 1
%1870 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1871 = bitcast %union.CHAR64LONG16* %1870 to [16 x i32]*
%1872 = getelementptr inbounds [16 x i32], [16 x i32]* %1871, i64 0, i64 2
%1873 = load i32, i32* %1872
%1874 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1875 = bitcast %union.CHAR64LONG16* %1874 to [16 x i32]*
%1876 = getelementptr inbounds [16 x i32], [16 x i32]* %1875, i64 0, i64 13
%1877 = load i32, i32* %1876
%1878 = xor i32 %1873, %1877
%1879 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1880 = bitcast %union.CHAR64LONG16* %1879 to [16 x i32]*
%1881 = getelementptr inbounds [16 x i32], [16 x i32]* %1880, i64 0, i64 7
%1882 = load i32, i32* %1881
%1883 = xor i32 %1878, %1882
%1884 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1885 = bitcast %union.CHAR64LONG16* %1884 to [16 x i32]*
%1886 = getelementptr inbounds [16 x i32], [16 x i32]* %1885, i64 0, i64 5
%1887 = load i32, i32* %1886
%1888 = xor i32 %1883, %1887
%1889 = lshr i32 %1888, 31
%1890 = or i32 %1869, %1889
%1891 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1892 = bitcast %union.CHAR64LONG16* %1891 to [16 x i32]*
%1893 = getelementptr inbounds [16 x i32], [16 x i32]* %1892, i64 0, i64 5
store i32 %1890, i32* %1893
%1894 = add i32 %1849, %1890
%1895 = add i32 %1894, 1859775393
%1896 = load i32, i32* %8
%1897 = shl i32 %1896, 5
%1898 = load i32, i32* %8
%1899 = lshr i32 %1898, 27
%1900 = or i32 %1897, %1899
%1901 = add i32 %1895, %1900
%1902 = load i32, i32* %7
%1903 = add i32 %1902, %1901
store i32 %1903, i32* %7
%1904 = load i32, i32* %9
%1905 = shl i32 %1904, 30
%1906 = load i32, i32* %9
%1907 = lshr i32 %1906, 2
%1908 = or i32 %1905, %1907
store i32 %1908, i32* %9
%1909 = load i32, i32* %8
%1910 = load i32, i32* %9
%1911 = xor i32 %1909, %1910
%1912 = load i32, i32* %5
%1913 = xor i32 %1911, %1912
%1914 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1915 = bitcast %union.CHAR64LONG16* %1914 to [16 x i32]*
%1916 = getelementptr inbounds [16 x i32], [16 x i32]* %1915, i64 0, i64 3
%1917 = load i32, i32* %1916
%1918 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1919 = bitcast %union.CHAR64LONG16* %1918 to [16 x i32]*
%1920 = getelementptr inbounds [16 x i32], [16 x i32]* %1919, i64 0, i64 14
%1921 = load i32, i32* %1920
%1922 = xor i32 %1917, %1921
%1923 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1924 = bitcast %union.CHAR64LONG16* %1923 to [16 x i32]*
%1925 = getelementptr inbounds [16 x i32], [16 x i32]* %1924, i64 0, i64 8
%1926 = load i32, i32* %1925
%1927 = xor i32 %1922, %1926
%1928 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1929 = bitcast %union.CHAR64LONG16* %1928 to [16 x i32]*
%1930 = getelementptr inbounds [16 x i32], [16 x i32]* %1929, i64 0, i64 6
%1931 = load i32, i32* %1930
%1932 = xor i32 %1927, %1931
%1933 = shl i32 %1932, 1
%1934 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1935 = bitcast %union.CHAR64LONG16* %1934 to [16 x i32]*
%1936 = getelementptr inbounds [16 x i32], [16 x i32]* %1935, i64 0, i64 3
%1937 = load i32, i32* %1936
%1938 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1939 = bitcast %union.CHAR64LONG16* %1938 to [16 x i32]*
%1940 = getelementptr inbounds [16 x i32], [16 x i32]* %1939, i64 0, i64 14
%1941 = load i32, i32* %1940
%1942 = xor i32 %1937, %1941
%1943 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1944 = bitcast %union.CHAR64LONG16* %1943 to [16 x i32]*
%1945 = getelementptr inbounds [16 x i32], [16 x i32]* %1944, i64 0, i64 8
%1946 = load i32, i32* %1945
%1947 = xor i32 %1942, %1946
%1948 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1949 = bitcast %union.CHAR64LONG16* %1948 to [16 x i32]*
%1950 = getelementptr inbounds [16 x i32], [16 x i32]* %1949, i64 0, i64 6
%1951 = load i32, i32* %1950
%1952 = xor i32 %1947, %1951
%1953 = lshr i32 %1952, 31
%1954 = or i32 %1933, %1953
%1955 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1956 = bitcast %union.CHAR64LONG16* %1955 to [16 x i32]*
%1957 = getelementptr inbounds [16 x i32], [16 x i32]* %1956, i64 0, i64 6
store i32 %1954, i32* %1957
%1958 = add i32 %1913, %1954
%1959 = add i32 %1958, 1859775393
%1960 = load i32, i32* %7
%1961 = shl i32 %1960, 5
%1962 = load i32, i32* %7
%1963 = lshr i32 %1962, 27
%1964 = or i32 %1961, %1963
%1965 = add i32 %1959, %1964
%1966 = load i32, i32* %6
%1967 = add i32 %1966, %1965
store i32 %1967, i32* %6
%1968 = load i32, i32* %8
%1969 = shl i32 %1968, 30
%1970 = load i32, i32* %8
%1971 = lshr i32 %1970, 2
%1972 = or i32 %1969, %1971
store i32 %1972, i32* %8
%1973 = load i32, i32* %7
%1974 = load i32, i32* %8
%1975 = xor i32 %1973, %1974
%1976 = load i32, i32* %9
%1977 = xor i32 %1975, %1976
%1978 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1979 = bitcast %union.CHAR64LONG16* %1978 to [16 x i32]*
%1980 = getelementptr inbounds [16 x i32], [16 x i32]* %1979, i64 0, i64 4
%1981 = load i32, i32* %1980
%1982 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1983 = bitcast %union.CHAR64LONG16* %1982 to [16 x i32]*
%1984 = getelementptr inbounds [16 x i32], [16 x i32]* %1983, i64 0, i64 15
%1985 = load i32, i32* %1984
%1986 = xor i32 %1981, %1985
%1987 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1988 = bitcast %union.CHAR64LONG16* %1987 to [16 x i32]*
%1989 = getelementptr inbounds [16 x i32], [16 x i32]* %1988, i64 0, i64 9
%1990 = load i32, i32* %1989
%1991 = xor i32 %1986, %1990
%1992 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1993 = bitcast %union.CHAR64LONG16* %1992 to [16 x i32]*
%1994 = getelementptr inbounds [16 x i32], [16 x i32]* %1993, i64 0, i64 7
%1995 = load i32, i32* %1994
%1996 = xor i32 %1991, %1995
%1997 = shl i32 %1996, 1
%1998 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%1999 = bitcast %union.CHAR64LONG16* %1998 to [16 x i32]*
%2000 = getelementptr inbounds [16 x i32], [16 x i32]* %1999, i64 0, i64 4
%2001 = load i32, i32* %2000
%2002 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2003 = bitcast %union.CHAR64LONG16* %2002 to [16 x i32]*
%2004 = getelementptr inbounds [16 x i32], [16 x i32]* %2003, i64 0, i64 15
%2005 = load i32, i32* %2004
%2006 = xor i32 %2001, %2005
%2007 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2008 = bitcast %union.CHAR64LONG16* %2007 to [16 x i32]*
%2009 = getelementptr inbounds [16 x i32], [16 x i32]* %2008, i64 0, i64 9
%2010 = load i32, i32* %2009
%2011 = xor i32 %2006, %2010
%2012 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2013 = bitcast %union.CHAR64LONG16* %2012 to [16 x i32]*
%2014 = getelementptr inbounds [16 x i32], [16 x i32]* %2013, i64 0, i64 7
%2015 = load i32, i32* %2014
%2016 = xor i32 %2011, %2015
%2017 = lshr i32 %2016, 31
%2018 = or i32 %1997, %2017
%2019 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2020 = bitcast %union.CHAR64LONG16* %2019 to [16 x i32]*
%2021 = getelementptr inbounds [16 x i32], [16 x i32]* %2020, i64 0, i64 7
store i32 %2018, i32* %2021
%2022 = add i32 %1977, %2018
%2023 = add i32 %2022, 1859775393
%2024 = load i32, i32* %6
%2025 = shl i32 %2024, 5
%2026 = load i32, i32* %6
%2027 = lshr i32 %2026, 27
%2028 = or i32 %2025, %2027
%2029 = add i32 %2023, %2028
%2030 = load i32, i32* %5
%2031 = add i32 %2030, %2029
store i32 %2031, i32* %5
%2032 = load i32, i32* %7
%2033 = shl i32 %2032, 30
%2034 = load i32, i32* %7
%2035 = lshr i32 %2034, 2
%2036 = or i32 %2033, %2035
store i32 %2036, i32* %7
%2037 = load i32, i32* %6
%2038 = load i32, i32* %7
%2039 = or i32 %2037, %2038
%2040 = load i32, i32* %8
%2041 = and i32 %2039, %2040
%2042 = load i32, i32* %6
%2043 = load i32, i32* %7
%2044 = and i32 %2042, %2043
%2045 = or i32 %2041, %2044
%2046 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2047 = bitcast %union.CHAR64LONG16* %2046 to [16 x i32]*
%2048 = getelementptr inbounds [16 x i32], [16 x i32]* %2047, i64 0, i64 5
%2049 = load i32, i32* %2048
%2050 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2051 = bitcast %union.CHAR64LONG16* %2050 to [16 x i32]*
%2052 = getelementptr inbounds [16 x i32], [16 x i32]* %2051, i64 0, i64 0
%2053 = load i32, i32* %2052
%2054 = xor i32 %2049, %2053
%2055 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2056 = bitcast %union.CHAR64LONG16* %2055 to [16 x i32]*
%2057 = getelementptr inbounds [16 x i32], [16 x i32]* %2056, i64 0, i64 10
%2058 = load i32, i32* %2057
%2059 = xor i32 %2054, %2058
%2060 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2061 = bitcast %union.CHAR64LONG16* %2060 to [16 x i32]*
%2062 = getelementptr inbounds [16 x i32], [16 x i32]* %2061, i64 0, i64 8
%2063 = load i32, i32* %2062
%2064 = xor i32 %2059, %2063
%2065 = shl i32 %2064, 1
%2066 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2067 = bitcast %union.CHAR64LONG16* %2066 to [16 x i32]*
%2068 = getelementptr inbounds [16 x i32], [16 x i32]* %2067, i64 0, i64 5
%2069 = load i32, i32* %2068
%2070 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2071 = bitcast %union.CHAR64LONG16* %2070 to [16 x i32]*
%2072 = getelementptr inbounds [16 x i32], [16 x i32]* %2071, i64 0, i64 0
%2073 = load i32, i32* %2072
%2074 = xor i32 %2069, %2073
%2075 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2076 = bitcast %union.CHAR64LONG16* %2075 to [16 x i32]*
%2077 = getelementptr inbounds [16 x i32], [16 x i32]* %2076, i64 0, i64 10
%2078 = load i32, i32* %2077
%2079 = xor i32 %2074, %2078
%2080 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2081 = bitcast %union.CHAR64LONG16* %2080 to [16 x i32]*
%2082 = getelementptr inbounds [16 x i32], [16 x i32]* %2081, i64 0, i64 8
%2083 = load i32, i32* %2082
%2084 = xor i32 %2079, %2083
%2085 = lshr i32 %2084, 31
%2086 = or i32 %2065, %2085
%2087 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2088 = bitcast %union.CHAR64LONG16* %2087 to [16 x i32]*
%2089 = getelementptr inbounds [16 x i32], [16 x i32]* %2088, i64 0, i64 8
store i32 %2086, i32* %2089
%2090 = add i32 %2045, %2086
%2091 = add i32 %2090, -1894007588
%2092 = load i32, i32* %5
%2093 = shl i32 %2092, 5
%2094 = load i32, i32* %5
%2095 = lshr i32 %2094, 27
%2096 = or i32 %2093, %2095
%2097 = add i32 %2091, %2096
%2098 = load i32, i32* %9
%2099 = add i32 %2098, %2097
store i32 %2099, i32* %9
%2100 = load i32, i32* %6
%2101 = shl i32 %2100, 30
%2102 = load i32, i32* %6
%2103 = lshr i32 %2102, 2
%2104 = or i32 %2101, %2103
store i32 %2104, i32* %6
%2105 = load i32, i32* %5
%2106 = load i32, i32* %6
%2107 = or i32 %2105, %2106
%2108 = load i32, i32* %7
%2109 = and i32 %2107, %2108
%2110 = load i32, i32* %5
%2111 = load i32, i32* %6
%2112 = and i32 %2110, %2111
%2113 = or i32 %2109, %2112
%2114 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2115 = bitcast %union.CHAR64LONG16* %2114 to [16 x i32]*
%2116 = getelementptr inbounds [16 x i32], [16 x i32]* %2115, i64 0, i64 6
%2117 = load i32, i32* %2116
%2118 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2119 = bitcast %union.CHAR64LONG16* %2118 to [16 x i32]*
%2120 = getelementptr inbounds [16 x i32], [16 x i32]* %2119, i64 0, i64 1
%2121 = load i32, i32* %2120
%2122 = xor i32 %2117, %2121
%2123 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2124 = bitcast %union.CHAR64LONG16* %2123 to [16 x i32]*
%2125 = getelementptr inbounds [16 x i32], [16 x i32]* %2124, i64 0, i64 11
%2126 = load i32, i32* %2125
%2127 = xor i32 %2122, %2126
%2128 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2129 = bitcast %union.CHAR64LONG16* %2128 to [16 x i32]*
%2130 = getelementptr inbounds [16 x i32], [16 x i32]* %2129, i64 0, i64 9
%2131 = load i32, i32* %2130
%2132 = xor i32 %2127, %2131
%2133 = shl i32 %2132, 1
%2134 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2135 = bitcast %union.CHAR64LONG16* %2134 to [16 x i32]*
%2136 = getelementptr inbounds [16 x i32], [16 x i32]* %2135, i64 0, i64 6
%2137 = load i32, i32* %2136
%2138 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2139 = bitcast %union.CHAR64LONG16* %2138 to [16 x i32]*
%2140 = getelementptr inbounds [16 x i32], [16 x i32]* %2139, i64 0, i64 1
%2141 = load i32, i32* %2140
%2142 = xor i32 %2137, %2141
%2143 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2144 = bitcast %union.CHAR64LONG16* %2143 to [16 x i32]*
%2145 = getelementptr inbounds [16 x i32], [16 x i32]* %2144, i64 0, i64 11
%2146 = load i32, i32* %2145
%2147 = xor i32 %2142, %2146
%2148 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2149 = bitcast %union.CHAR64LONG16* %2148 to [16 x i32]*
%2150 = getelementptr inbounds [16 x i32], [16 x i32]* %2149, i64 0, i64 9
%2151 = load i32, i32* %2150
%2152 = xor i32 %2147, %2151
%2153 = lshr i32 %2152, 31
%2154 = or i32 %2133, %2153
%2155 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2156 = bitcast %union.CHAR64LONG16* %2155 to [16 x i32]*
%2157 = getelementptr inbounds [16 x i32], [16 x i32]* %2156, i64 0, i64 9
store i32 %2154, i32* %2157
%2158 = add i32 %2113, %2154
%2159 = add i32 %2158, -1894007588
%2160 = load i32, i32* %9
%2161 = shl i32 %2160, 5
%2162 = load i32, i32* %9
%2163 = lshr i32 %2162, 27
%2164 = or i32 %2161, %2163
%2165 = add i32 %2159, %2164
%2166 = load i32, i32* %8
%2167 = add i32 %2166, %2165
store i32 %2167, i32* %8
%2168 = load i32, i32* %5
%2169 = shl i32 %2168, 30
%2170 = load i32, i32* %5
%2171 = lshr i32 %2170, 2
%2172 = or i32 %2169, %2171
store i32 %2172, i32* %5
%2173 = load i32, i32* %9
%2174 = load i32, i32* %5
%2175 = or i32 %2173, %2174
%2176 = load i32, i32* %6
%2177 = and i32 %2175, %2176
%2178 = load i32, i32* %9
%2179 = load i32, i32* %5
%2180 = and i32 %2178, %2179
%2181 = or i32 %2177, %2180
%2182 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2183 = bitcast %union.CHAR64LONG16* %2182 to [16 x i32]*
%2184 = getelementptr inbounds [16 x i32], [16 x i32]* %2183, i64 0, i64 7
%2185 = load i32, i32* %2184
%2186 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2187 = bitcast %union.CHAR64LONG16* %2186 to [16 x i32]*
%2188 = getelementptr inbounds [16 x i32], [16 x i32]* %2187, i64 0, i64 2
%2189 = load i32, i32* %2188
%2190 = xor i32 %2185, %2189
%2191 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2192 = bitcast %union.CHAR64LONG16* %2191 to [16 x i32]*
%2193 = getelementptr inbounds [16 x i32], [16 x i32]* %2192, i64 0, i64 12
%2194 = load i32, i32* %2193
%2195 = xor i32 %2190, %2194
%2196 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2197 = bitcast %union.CHAR64LONG16* %2196 to [16 x i32]*
%2198 = getelementptr inbounds [16 x i32], [16 x i32]* %2197, i64 0, i64 10
%2199 = load i32, i32* %2198
%2200 = xor i32 %2195, %2199
%2201 = shl i32 %2200, 1
%2202 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2203 = bitcast %union.CHAR64LONG16* %2202 to [16 x i32]*
%2204 = getelementptr inbounds [16 x i32], [16 x i32]* %2203, i64 0, i64 7
%2205 = load i32, i32* %2204
%2206 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2207 = bitcast %union.CHAR64LONG16* %2206 to [16 x i32]*
%2208 = getelementptr inbounds [16 x i32], [16 x i32]* %2207, i64 0, i64 2
%2209 = load i32, i32* %2208
%2210 = xor i32 %2205, %2209
%2211 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2212 = bitcast %union.CHAR64LONG16* %2211 to [16 x i32]*
%2213 = getelementptr inbounds [16 x i32], [16 x i32]* %2212, i64 0, i64 12
%2214 = load i32, i32* %2213
%2215 = xor i32 %2210, %2214
%2216 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2217 = bitcast %union.CHAR64LONG16* %2216 to [16 x i32]*
%2218 = getelementptr inbounds [16 x i32], [16 x i32]* %2217, i64 0, i64 10
%2219 = load i32, i32* %2218
%2220 = xor i32 %2215, %2219
%2221 = lshr i32 %2220, 31
%2222 = or i32 %2201, %2221
%2223 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2224 = bitcast %union.CHAR64LONG16* %2223 to [16 x i32]*
%2225 = getelementptr inbounds [16 x i32], [16 x i32]* %2224, i64 0, i64 10
store i32 %2222, i32* %2225
%2226 = add i32 %2181, %2222
%2227 = add i32 %2226, -1894007588
%2228 = load i32, i32* %8
%2229 = shl i32 %2228, 5
%2230 = load i32, i32* %8
%2231 = lshr i32 %2230, 27
%2232 = or i32 %2229, %2231
%2233 = add i32 %2227, %2232
%2234 = load i32, i32* %7
%2235 = add i32 %2234, %2233
store i32 %2235, i32* %7
%2236 = load i32, i32* %9
%2237 = shl i32 %2236, 30
%2238 = load i32, i32* %9
%2239 = lshr i32 %2238, 2
%2240 = or i32 %2237, %2239
store i32 %2240, i32* %9
%2241 = load i32, i32* %8
%2242 = load i32, i32* %9
%2243 = or i32 %2241, %2242
%2244 = load i32, i32* %5
%2245 = and i32 %2243, %2244
%2246 = load i32, i32* %8
%2247 = load i32, i32* %9
%2248 = and i32 %2246, %2247
%2249 = or i32 %2245, %2248
%2250 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2251 = bitcast %union.CHAR64LONG16* %2250 to [16 x i32]*
%2252 = getelementptr inbounds [16 x i32], [16 x i32]* %2251, i64 0, i64 8
%2253 = load i32, i32* %2252
%2254 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2255 = bitcast %union.CHAR64LONG16* %2254 to [16 x i32]*
%2256 = getelementptr inbounds [16 x i32], [16 x i32]* %2255, i64 0, i64 3
%2257 = load i32, i32* %2256
%2258 = xor i32 %2253, %2257
%2259 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2260 = bitcast %union.CHAR64LONG16* %2259 to [16 x i32]*
%2261 = getelementptr inbounds [16 x i32], [16 x i32]* %2260, i64 0, i64 13
%2262 = load i32, i32* %2261
%2263 = xor i32 %2258, %2262
%2264 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2265 = bitcast %union.CHAR64LONG16* %2264 to [16 x i32]*
%2266 = getelementptr inbounds [16 x i32], [16 x i32]* %2265, i64 0, i64 11
%2267 = load i32, i32* %2266
%2268 = xor i32 %2263, %2267
%2269 = shl i32 %2268, 1
%2270 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2271 = bitcast %union.CHAR64LONG16* %2270 to [16 x i32]*
%2272 = getelementptr inbounds [16 x i32], [16 x i32]* %2271, i64 0, i64 8
%2273 = load i32, i32* %2272
%2274 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2275 = bitcast %union.CHAR64LONG16* %2274 to [16 x i32]*
%2276 = getelementptr inbounds [16 x i32], [16 x i32]* %2275, i64 0, i64 3
%2277 = load i32, i32* %2276
%2278 = xor i32 %2273, %2277
%2279 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2280 = bitcast %union.CHAR64LONG16* %2279 to [16 x i32]*
%2281 = getelementptr inbounds [16 x i32], [16 x i32]* %2280, i64 0, i64 13
%2282 = load i32, i32* %2281
%2283 = xor i32 %2278, %2282
%2284 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2285 = bitcast %union.CHAR64LONG16* %2284 to [16 x i32]*
%2286 = getelementptr inbounds [16 x i32], [16 x i32]* %2285, i64 0, i64 11
%2287 = load i32, i32* %2286
%2288 = xor i32 %2283, %2287
%2289 = lshr i32 %2288, 31
%2290 = or i32 %2269, %2289
%2291 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2292 = bitcast %union.CHAR64LONG16* %2291 to [16 x i32]*
%2293 = getelementptr inbounds [16 x i32], [16 x i32]* %2292, i64 0, i64 11
store i32 %2290, i32* %2293
%2294 = add i32 %2249, %2290
%2295 = add i32 %2294, -1894007588
%2296 = load i32, i32* %7
%2297 = shl i32 %2296, 5
%2298 = load i32, i32* %7
%2299 = lshr i32 %2298, 27
%2300 = or i32 %2297, %2299
%2301 = add i32 %2295, %2300
%2302 = load i32, i32* %6
%2303 = add i32 %2302, %2301
store i32 %2303, i32* %6
%2304 = load i32, i32* %8
%2305 = shl i32 %2304, 30
%2306 = load i32, i32* %8
%2307 = lshr i32 %2306, 2
%2308 = or i32 %2305, %2307
store i32 %2308, i32* %8
%2309 = load i32, i32* %7
%2310 = load i32, i32* %8
%2311 = or i32 %2309, %2310
%2312 = load i32, i32* %9
%2313 = and i32 %2311, %2312
%2314 = load i32, i32* %7
%2315 = load i32, i32* %8
%2316 = and i32 %2314, %2315
%2317 = or i32 %2313, %2316
%2318 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2319 = bitcast %union.CHAR64LONG16* %2318 to [16 x i32]*
%2320 = getelementptr inbounds [16 x i32], [16 x i32]* %2319, i64 0, i64 9
%2321 = load i32, i32* %2320
%2322 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2323 = bitcast %union.CHAR64LONG16* %2322 to [16 x i32]*
%2324 = getelementptr inbounds [16 x i32], [16 x i32]* %2323, i64 0, i64 4
%2325 = load i32, i32* %2324
%2326 = xor i32 %2321, %2325
%2327 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2328 = bitcast %union.CHAR64LONG16* %2327 to [16 x i32]*
%2329 = getelementptr inbounds [16 x i32], [16 x i32]* %2328, i64 0, i64 14
%2330 = load i32, i32* %2329
%2331 = xor i32 %2326, %2330
%2332 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2333 = bitcast %union.CHAR64LONG16* %2332 to [16 x i32]*
%2334 = getelementptr inbounds [16 x i32], [16 x i32]* %2333, i64 0, i64 12
%2335 = load i32, i32* %2334
%2336 = xor i32 %2331, %2335
%2337 = shl i32 %2336, 1
%2338 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2339 = bitcast %union.CHAR64LONG16* %2338 to [16 x i32]*
%2340 = getelementptr inbounds [16 x i32], [16 x i32]* %2339, i64 0, i64 9
%2341 = load i32, i32* %2340
%2342 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2343 = bitcast %union.CHAR64LONG16* %2342 to [16 x i32]*
%2344 = getelementptr inbounds [16 x i32], [16 x i32]* %2343, i64 0, i64 4
%2345 = load i32, i32* %2344
%2346 = xor i32 %2341, %2345
%2347 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2348 = bitcast %union.CHAR64LONG16* %2347 to [16 x i32]*
%2349 = getelementptr inbounds [16 x i32], [16 x i32]* %2348, i64 0, i64 14
%2350 = load i32, i32* %2349
%2351 = xor i32 %2346, %2350
%2352 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2353 = bitcast %union.CHAR64LONG16* %2352 to [16 x i32]*
%2354 = getelementptr inbounds [16 x i32], [16 x i32]* %2353, i64 0, i64 12
%2355 = load i32, i32* %2354
%2356 = xor i32 %2351, %2355
%2357 = lshr i32 %2356, 31
%2358 = or i32 %2337, %2357
%2359 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2360 = bitcast %union.CHAR64LONG16* %2359 to [16 x i32]*
%2361 = getelementptr inbounds [16 x i32], [16 x i32]* %2360, i64 0, i64 12
store i32 %2358, i32* %2361
%2362 = add i32 %2317, %2358
%2363 = add i32 %2362, -1894007588
%2364 = load i32, i32* %6
%2365 = shl i32 %2364, 5
%2366 = load i32, i32* %6
%2367 = lshr i32 %2366, 27
%2368 = or i32 %2365, %2367
%2369 = add i32 %2363, %2368
%2370 = load i32, i32* %5
%2371 = add i32 %2370, %2369
store i32 %2371, i32* %5
%2372 = load i32, i32* %7
%2373 = shl i32 %2372, 30
%2374 = load i32, i32* %7
%2375 = lshr i32 %2374, 2
%2376 = or i32 %2373, %2375
store i32 %2376, i32* %7
%2377 = load i32, i32* %6
%2378 = load i32, i32* %7
%2379 = or i32 %2377, %2378
%2380 = load i32, i32* %8
%2381 = and i32 %2379, %2380
%2382 = load i32, i32* %6
%2383 = load i32, i32* %7
%2384 = and i32 %2382, %2383
%2385 = or i32 %2381, %2384
%2386 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2387 = bitcast %union.CHAR64LONG16* %2386 to [16 x i32]*
%2388 = getelementptr inbounds [16 x i32], [16 x i32]* %2387, i64 0, i64 10
%2389 = load i32, i32* %2388
%2390 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2391 = bitcast %union.CHAR64LONG16* %2390 to [16 x i32]*
%2392 = getelementptr inbounds [16 x i32], [16 x i32]* %2391, i64 0, i64 5
%2393 = load i32, i32* %2392
%2394 = xor i32 %2389, %2393
%2395 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2396 = bitcast %union.CHAR64LONG16* %2395 to [16 x i32]*
%2397 = getelementptr inbounds [16 x i32], [16 x i32]* %2396, i64 0, i64 15
%2398 = load i32, i32* %2397
%2399 = xor i32 %2394, %2398
%2400 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2401 = bitcast %union.CHAR64LONG16* %2400 to [16 x i32]*
%2402 = getelementptr inbounds [16 x i32], [16 x i32]* %2401, i64 0, i64 13
%2403 = load i32, i32* %2402
%2404 = xor i32 %2399, %2403
%2405 = shl i32 %2404, 1
%2406 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2407 = bitcast %union.CHAR64LONG16* %2406 to [16 x i32]*
%2408 = getelementptr inbounds [16 x i32], [16 x i32]* %2407, i64 0, i64 10
%2409 = load i32, i32* %2408
%2410 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2411 = bitcast %union.CHAR64LONG16* %2410 to [16 x i32]*
%2412 = getelementptr inbounds [16 x i32], [16 x i32]* %2411, i64 0, i64 5
%2413 = load i32, i32* %2412
%2414 = xor i32 %2409, %2413
%2415 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2416 = bitcast %union.CHAR64LONG16* %2415 to [16 x i32]*
%2417 = getelementptr inbounds [16 x i32], [16 x i32]* %2416, i64 0, i64 15
%2418 = load i32, i32* %2417
%2419 = xor i32 %2414, %2418
%2420 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2421 = bitcast %union.CHAR64LONG16* %2420 to [16 x i32]*
%2422 = getelementptr inbounds [16 x i32], [16 x i32]* %2421, i64 0, i64 13
%2423 = load i32, i32* %2422
%2424 = xor i32 %2419, %2423
%2425 = lshr i32 %2424, 31
%2426 = or i32 %2405, %2425
%2427 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2428 = bitcast %union.CHAR64LONG16* %2427 to [16 x i32]*
%2429 = getelementptr inbounds [16 x i32], [16 x i32]* %2428, i64 0, i64 13
store i32 %2426, i32* %2429
%2430 = add i32 %2385, %2426
%2431 = add i32 %2430, -1894007588
%2432 = load i32, i32* %5
%2433 = shl i32 %2432, 5
%2434 = load i32, i32* %5
%2435 = lshr i32 %2434, 27
%2436 = or i32 %2433, %2435
%2437 = add i32 %2431, %2436
%2438 = load i32, i32* %9
%2439 = add i32 %2438, %2437
store i32 %2439, i32* %9
%2440 = load i32, i32* %6
%2441 = shl i32 %2440, 30
%2442 = load i32, i32* %6
%2443 = lshr i32 %2442, 2
%2444 = or i32 %2441, %2443
store i32 %2444, i32* %6
%2445 = load i32, i32* %5
%2446 = load i32, i32* %6
%2447 = or i32 %2445, %2446
%2448 = load i32, i32* %7
%2449 = and i32 %2447, %2448
%2450 = load i32, i32* %5
%2451 = load i32, i32* %6
%2452 = and i32 %2450, %2451
%2453 = or i32 %2449, %2452
%2454 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2455 = bitcast %union.CHAR64LONG16* %2454 to [16 x i32]*
%2456 = getelementptr inbounds [16 x i32], [16 x i32]* %2455, i64 0, i64 11
%2457 = load i32, i32* %2456
%2458 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2459 = bitcast %union.CHAR64LONG16* %2458 to [16 x i32]*
%2460 = getelementptr inbounds [16 x i32], [16 x i32]* %2459, i64 0, i64 6
%2461 = load i32, i32* %2460
%2462 = xor i32 %2457, %2461
%2463 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2464 = bitcast %union.CHAR64LONG16* %2463 to [16 x i32]*
%2465 = getelementptr inbounds [16 x i32], [16 x i32]* %2464, i64 0, i64 0
%2466 = load i32, i32* %2465
%2467 = xor i32 %2462, %2466
%2468 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2469 = bitcast %union.CHAR64LONG16* %2468 to [16 x i32]*
%2470 = getelementptr inbounds [16 x i32], [16 x i32]* %2469, i64 0, i64 14
%2471 = load i32, i32* %2470
%2472 = xor i32 %2467, %2471
%2473 = shl i32 %2472, 1
%2474 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2475 = bitcast %union.CHAR64LONG16* %2474 to [16 x i32]*
%2476 = getelementptr inbounds [16 x i32], [16 x i32]* %2475, i64 0, i64 11
%2477 = load i32, i32* %2476
%2478 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2479 = bitcast %union.CHAR64LONG16* %2478 to [16 x i32]*
%2480 = getelementptr inbounds [16 x i32], [16 x i32]* %2479, i64 0, i64 6
%2481 = load i32, i32* %2480
%2482 = xor i32 %2477, %2481
%2483 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2484 = bitcast %union.CHAR64LONG16* %2483 to [16 x i32]*
%2485 = getelementptr inbounds [16 x i32], [16 x i32]* %2484, i64 0, i64 0
%2486 = load i32, i32* %2485
%2487 = xor i32 %2482, %2486
%2488 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2489 = bitcast %union.CHAR64LONG16* %2488 to [16 x i32]*
%2490 = getelementptr inbounds [16 x i32], [16 x i32]* %2489, i64 0, i64 14
%2491 = load i32, i32* %2490
%2492 = xor i32 %2487, %2491
%2493 = lshr i32 %2492, 31
%2494 = or i32 %2473, %2493
%2495 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2496 = bitcast %union.CHAR64LONG16* %2495 to [16 x i32]*
%2497 = getelementptr inbounds [16 x i32], [16 x i32]* %2496, i64 0, i64 14
store i32 %2494, i32* %2497
%2498 = add i32 %2453, %2494
%2499 = add i32 %2498, -1894007588
%2500 = load i32, i32* %9
%2501 = shl i32 %2500, 5
%2502 = load i32, i32* %9
%2503 = lshr i32 %2502, 27
%2504 = or i32 %2501, %2503
%2505 = add i32 %2499, %2504
%2506 = load i32, i32* %8
%2507 = add i32 %2506, %2505
store i32 %2507, i32* %8
%2508 = load i32, i32* %5
%2509 = shl i32 %2508, 30
%2510 = load i32, i32* %5
%2511 = lshr i32 %2510, 2
%2512 = or i32 %2509, %2511
store i32 %2512, i32* %5
%2513 = load i32, i32* %9
%2514 = load i32, i32* %5
%2515 = or i32 %2513, %2514
%2516 = load i32, i32* %6
%2517 = and i32 %2515, %2516
%2518 = load i32, i32* %9
%2519 = load i32, i32* %5
%2520 = and i32 %2518, %2519
%2521 = or i32 %2517, %2520
%2522 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2523 = bitcast %union.CHAR64LONG16* %2522 to [16 x i32]*
%2524 = getelementptr inbounds [16 x i32], [16 x i32]* %2523, i64 0, i64 12
%2525 = load i32, i32* %2524
%2526 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2527 = bitcast %union.CHAR64LONG16* %2526 to [16 x i32]*
%2528 = getelementptr inbounds [16 x i32], [16 x i32]* %2527, i64 0, i64 7
%2529 = load i32, i32* %2528
%2530 = xor i32 %2525, %2529
%2531 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2532 = bitcast %union.CHAR64LONG16* %2531 to [16 x i32]*
%2533 = getelementptr inbounds [16 x i32], [16 x i32]* %2532, i64 0, i64 1
%2534 = load i32, i32* %2533
%2535 = xor i32 %2530, %2534
%2536 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2537 = bitcast %union.CHAR64LONG16* %2536 to [16 x i32]*
%2538 = getelementptr inbounds [16 x i32], [16 x i32]* %2537, i64 0, i64 15
%2539 = load i32, i32* %2538
%2540 = xor i32 %2535, %2539
%2541 = shl i32 %2540, 1
%2542 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2543 = bitcast %union.CHAR64LONG16* %2542 to [16 x i32]*
%2544 = getelementptr inbounds [16 x i32], [16 x i32]* %2543, i64 0, i64 12
%2545 = load i32, i32* %2544
%2546 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2547 = bitcast %union.CHAR64LONG16* %2546 to [16 x i32]*
%2548 = getelementptr inbounds [16 x i32], [16 x i32]* %2547, i64 0, i64 7
%2549 = load i32, i32* %2548
%2550 = xor i32 %2545, %2549
%2551 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2552 = bitcast %union.CHAR64LONG16* %2551 to [16 x i32]*
%2553 = getelementptr inbounds [16 x i32], [16 x i32]* %2552, i64 0, i64 1
%2554 = load i32, i32* %2553
%2555 = xor i32 %2550, %2554
%2556 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2557 = bitcast %union.CHAR64LONG16* %2556 to [16 x i32]*
%2558 = getelementptr inbounds [16 x i32], [16 x i32]* %2557, i64 0, i64 15
%2559 = load i32, i32* %2558
%2560 = xor i32 %2555, %2559
%2561 = lshr i32 %2560, 31
%2562 = or i32 %2541, %2561
%2563 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2564 = bitcast %union.CHAR64LONG16* %2563 to [16 x i32]*
%2565 = getelementptr inbounds [16 x i32], [16 x i32]* %2564, i64 0, i64 15
store i32 %2562, i32* %2565
%2566 = add i32 %2521, %2562
%2567 = add i32 %2566, -1894007588
%2568 = load i32, i32* %8
%2569 = shl i32 %2568, 5
%2570 = load i32, i32* %8
%2571 = lshr i32 %2570, 27
%2572 = or i32 %2569, %2571
%2573 = add i32 %2567, %2572
%2574 = load i32, i32* %7
%2575 = add i32 %2574, %2573
store i32 %2575, i32* %7
%2576 = load i32, i32* %9
%2577 = shl i32 %2576, 30
%2578 = load i32, i32* %9
%2579 = lshr i32 %2578, 2
%2580 = or i32 %2577, %2579
store i32 %2580, i32* %9
%2581 = load i32, i32* %8
%2582 = load i32, i32* %9
%2583 = or i32 %2581, %2582
%2584 = load i32, i32* %5
%2585 = and i32 %2583, %2584
%2586 = load i32, i32* %8
%2587 = load i32, i32* %9
%2588 = and i32 %2586, %2587
%2589 = or i32 %2585, %2588
%2590 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2591 = bitcast %union.CHAR64LONG16* %2590 to [16 x i32]*
%2592 = getelementptr inbounds [16 x i32], [16 x i32]* %2591, i64 0, i64 13
%2593 = load i32, i32* %2592
%2594 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2595 = bitcast %union.CHAR64LONG16* %2594 to [16 x i32]*
%2596 = getelementptr inbounds [16 x i32], [16 x i32]* %2595, i64 0, i64 8
%2597 = load i32, i32* %2596
%2598 = xor i32 %2593, %2597
%2599 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2600 = bitcast %union.CHAR64LONG16* %2599 to [16 x i32]*
%2601 = getelementptr inbounds [16 x i32], [16 x i32]* %2600, i64 0, i64 2
%2602 = load i32, i32* %2601
%2603 = xor i32 %2598, %2602
%2604 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2605 = bitcast %union.CHAR64LONG16* %2604 to [16 x i32]*
%2606 = getelementptr inbounds [16 x i32], [16 x i32]* %2605, i64 0, i64 0
%2607 = load i32, i32* %2606
%2608 = xor i32 %2603, %2607
%2609 = shl i32 %2608, 1
%2610 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2611 = bitcast %union.CHAR64LONG16* %2610 to [16 x i32]*
%2612 = getelementptr inbounds [16 x i32], [16 x i32]* %2611, i64 0, i64 13
%2613 = load i32, i32* %2612
%2614 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2615 = bitcast %union.CHAR64LONG16* %2614 to [16 x i32]*
%2616 = getelementptr inbounds [16 x i32], [16 x i32]* %2615, i64 0, i64 8
%2617 = load i32, i32* %2616
%2618 = xor i32 %2613, %2617
%2619 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2620 = bitcast %union.CHAR64LONG16* %2619 to [16 x i32]*
%2621 = getelementptr inbounds [16 x i32], [16 x i32]* %2620, i64 0, i64 2
%2622 = load i32, i32* %2621
%2623 = xor i32 %2618, %2622
%2624 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2625 = bitcast %union.CHAR64LONG16* %2624 to [16 x i32]*
%2626 = getelementptr inbounds [16 x i32], [16 x i32]* %2625, i64 0, i64 0
%2627 = load i32, i32* %2626
%2628 = xor i32 %2623, %2627
%2629 = lshr i32 %2628, 31
%2630 = or i32 %2609, %2629
%2631 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2632 = bitcast %union.CHAR64LONG16* %2631 to [16 x i32]*
%2633 = getelementptr inbounds [16 x i32], [16 x i32]* %2632, i64 0, i64 0
store i32 %2630, i32* %2633
%2634 = add i32 %2589, %2630
%2635 = add i32 %2634, -1894007588
%2636 = load i32, i32* %7
%2637 = shl i32 %2636, 5
%2638 = load i32, i32* %7
%2639 = lshr i32 %2638, 27
%2640 = or i32 %2637, %2639
%2641 = add i32 %2635, %2640
%2642 = load i32, i32* %6
%2643 = add i32 %2642, %2641
store i32 %2643, i32* %6
%2644 = load i32, i32* %8
%2645 = shl i32 %2644, 30
%2646 = load i32, i32* %8
%2647 = lshr i32 %2646, 2
%2648 = or i32 %2645, %2647
store i32 %2648, i32* %8
%2649 = load i32, i32* %7
%2650 = load i32, i32* %8
%2651 = or i32 %2649, %2650
%2652 = load i32, i32* %9
%2653 = and i32 %2651, %2652
%2654 = load i32, i32* %7
%2655 = load i32, i32* %8
%2656 = and i32 %2654, %2655
%2657 = or i32 %2653, %2656
%2658 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2659 = bitcast %union.CHAR64LONG16* %2658 to [16 x i32]*
%2660 = getelementptr inbounds [16 x i32], [16 x i32]* %2659, i64 0, i64 14
%2661 = load i32, i32* %2660
%2662 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2663 = bitcast %union.CHAR64LONG16* %2662 to [16 x i32]*
%2664 = getelementptr inbounds [16 x i32], [16 x i32]* %2663, i64 0, i64 9
%2665 = load i32, i32* %2664
%2666 = xor i32 %2661, %2665
%2667 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2668 = bitcast %union.CHAR64LONG16* %2667 to [16 x i32]*
%2669 = getelementptr inbounds [16 x i32], [16 x i32]* %2668, i64 0, i64 3
%2670 = load i32, i32* %2669
%2671 = xor i32 %2666, %2670
%2672 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2673 = bitcast %union.CHAR64LONG16* %2672 to [16 x i32]*
%2674 = getelementptr inbounds [16 x i32], [16 x i32]* %2673, i64 0, i64 1
%2675 = load i32, i32* %2674
%2676 = xor i32 %2671, %2675
%2677 = shl i32 %2676, 1
%2678 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2679 = bitcast %union.CHAR64LONG16* %2678 to [16 x i32]*
%2680 = getelementptr inbounds [16 x i32], [16 x i32]* %2679, i64 0, i64 14
%2681 = load i32, i32* %2680
%2682 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2683 = bitcast %union.CHAR64LONG16* %2682 to [16 x i32]*
%2684 = getelementptr inbounds [16 x i32], [16 x i32]* %2683, i64 0, i64 9
%2685 = load i32, i32* %2684
%2686 = xor i32 %2681, %2685
%2687 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2688 = bitcast %union.CHAR64LONG16* %2687 to [16 x i32]*
%2689 = getelementptr inbounds [16 x i32], [16 x i32]* %2688, i64 0, i64 3
%2690 = load i32, i32* %2689
%2691 = xor i32 %2686, %2690
%2692 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2693 = bitcast %union.CHAR64LONG16* %2692 to [16 x i32]*
%2694 = getelementptr inbounds [16 x i32], [16 x i32]* %2693, i64 0, i64 1
%2695 = load i32, i32* %2694
%2696 = xor i32 %2691, %2695
%2697 = lshr i32 %2696, 31
%2698 = or i32 %2677, %2697
%2699 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2700 = bitcast %union.CHAR64LONG16* %2699 to [16 x i32]*
%2701 = getelementptr inbounds [16 x i32], [16 x i32]* %2700, i64 0, i64 1
store i32 %2698, i32* %2701
%2702 = add i32 %2657, %2698
%2703 = add i32 %2702, -1894007588
%2704 = load i32, i32* %6
%2705 = shl i32 %2704, 5
%2706 = load i32, i32* %6
%2707 = lshr i32 %2706, 27
%2708 = or i32 %2705, %2707
%2709 = add i32 %2703, %2708
%2710 = load i32, i32* %5
%2711 = add i32 %2710, %2709
store i32 %2711, i32* %5
%2712 = load i32, i32* %7
%2713 = shl i32 %2712, 30
%2714 = load i32, i32* %7
%2715 = lshr i32 %2714, 2
%2716 = or i32 %2713, %2715
store i32 %2716, i32* %7
%2717 = load i32, i32* %6
%2718 = load i32, i32* %7
%2719 = or i32 %2717, %2718
%2720 = load i32, i32* %8
%2721 = and i32 %2719, %2720
%2722 = load i32, i32* %6
%2723 = load i32, i32* %7
%2724 = and i32 %2722, %2723
%2725 = or i32 %2721, %2724
%2726 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2727 = bitcast %union.CHAR64LONG16* %2726 to [16 x i32]*
%2728 = getelementptr inbounds [16 x i32], [16 x i32]* %2727, i64 0, i64 15
%2729 = load i32, i32* %2728
%2730 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2731 = bitcast %union.CHAR64LONG16* %2730 to [16 x i32]*
%2732 = getelementptr inbounds [16 x i32], [16 x i32]* %2731, i64 0, i64 10
%2733 = load i32, i32* %2732
%2734 = xor i32 %2729, %2733
%2735 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2736 = bitcast %union.CHAR64LONG16* %2735 to [16 x i32]*
%2737 = getelementptr inbounds [16 x i32], [16 x i32]* %2736, i64 0, i64 4
%2738 = load i32, i32* %2737
%2739 = xor i32 %2734, %2738
%2740 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2741 = bitcast %union.CHAR64LONG16* %2740 to [16 x i32]*
%2742 = getelementptr inbounds [16 x i32], [16 x i32]* %2741, i64 0, i64 2
%2743 = load i32, i32* %2742
%2744 = xor i32 %2739, %2743
%2745 = shl i32 %2744, 1
%2746 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2747 = bitcast %union.CHAR64LONG16* %2746 to [16 x i32]*
%2748 = getelementptr inbounds [16 x i32], [16 x i32]* %2747, i64 0, i64 15
%2749 = load i32, i32* %2748
%2750 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2751 = bitcast %union.CHAR64LONG16* %2750 to [16 x i32]*
%2752 = getelementptr inbounds [16 x i32], [16 x i32]* %2751, i64 0, i64 10
%2753 = load i32, i32* %2752
%2754 = xor i32 %2749, %2753
%2755 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2756 = bitcast %union.CHAR64LONG16* %2755 to [16 x i32]*
%2757 = getelementptr inbounds [16 x i32], [16 x i32]* %2756, i64 0, i64 4
%2758 = load i32, i32* %2757
%2759 = xor i32 %2754, %2758
%2760 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2761 = bitcast %union.CHAR64LONG16* %2760 to [16 x i32]*
%2762 = getelementptr inbounds [16 x i32], [16 x i32]* %2761, i64 0, i64 2
%2763 = load i32, i32* %2762
%2764 = xor i32 %2759, %2763
%2765 = lshr i32 %2764, 31
%2766 = or i32 %2745, %2765
%2767 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2768 = bitcast %union.CHAR64LONG16* %2767 to [16 x i32]*
%2769 = getelementptr inbounds [16 x i32], [16 x i32]* %2768, i64 0, i64 2
store i32 %2766, i32* %2769
%2770 = add i32 %2725, %2766
%2771 = add i32 %2770, -1894007588
%2772 = load i32, i32* %5
%2773 = shl i32 %2772, 5
%2774 = load i32, i32* %5
%2775 = lshr i32 %2774, 27
%2776 = or i32 %2773, %2775
%2777 = add i32 %2771, %2776
%2778 = load i32, i32* %9
%2779 = add i32 %2778, %2777
store i32 %2779, i32* %9
%2780 = load i32, i32* %6
%2781 = shl i32 %2780, 30
%2782 = load i32, i32* %6
%2783 = lshr i32 %2782, 2
%2784 = or i32 %2781, %2783
store i32 %2784, i32* %6
%2785 = load i32, i32* %5
%2786 = load i32, i32* %6
%2787 = or i32 %2785, %2786
%2788 = load i32, i32* %7
%2789 = and i32 %2787, %2788
%2790 = load i32, i32* %5
%2791 = load i32, i32* %6
%2792 = and i32 %2790, %2791
%2793 = or i32 %2789, %2792
%2794 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2795 = bitcast %union.CHAR64LONG16* %2794 to [16 x i32]*
%2796 = getelementptr inbounds [16 x i32], [16 x i32]* %2795, i64 0, i64 0
%2797 = load i32, i32* %2796
%2798 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2799 = bitcast %union.CHAR64LONG16* %2798 to [16 x i32]*
%2800 = getelementptr inbounds [16 x i32], [16 x i32]* %2799, i64 0, i64 11
%2801 = load i32, i32* %2800
%2802 = xor i32 %2797, %2801
%2803 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2804 = bitcast %union.CHAR64LONG16* %2803 to [16 x i32]*
%2805 = getelementptr inbounds [16 x i32], [16 x i32]* %2804, i64 0, i64 5
%2806 = load i32, i32* %2805
%2807 = xor i32 %2802, %2806
%2808 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2809 = bitcast %union.CHAR64LONG16* %2808 to [16 x i32]*
%2810 = getelementptr inbounds [16 x i32], [16 x i32]* %2809, i64 0, i64 3
%2811 = load i32, i32* %2810
%2812 = xor i32 %2807, %2811
%2813 = shl i32 %2812, 1
%2814 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2815 = bitcast %union.CHAR64LONG16* %2814 to [16 x i32]*
%2816 = getelementptr inbounds [16 x i32], [16 x i32]* %2815, i64 0, i64 0
%2817 = load i32, i32* %2816
%2818 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2819 = bitcast %union.CHAR64LONG16* %2818 to [16 x i32]*
%2820 = getelementptr inbounds [16 x i32], [16 x i32]* %2819, i64 0, i64 11
%2821 = load i32, i32* %2820
%2822 = xor i32 %2817, %2821
%2823 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2824 = bitcast %union.CHAR64LONG16* %2823 to [16 x i32]*
%2825 = getelementptr inbounds [16 x i32], [16 x i32]* %2824, i64 0, i64 5
%2826 = load i32, i32* %2825
%2827 = xor i32 %2822, %2826
%2828 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2829 = bitcast %union.CHAR64LONG16* %2828 to [16 x i32]*
%2830 = getelementptr inbounds [16 x i32], [16 x i32]* %2829, i64 0, i64 3
%2831 = load i32, i32* %2830
%2832 = xor i32 %2827, %2831
%2833 = lshr i32 %2832, 31
%2834 = or i32 %2813, %2833
%2835 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2836 = bitcast %union.CHAR64LONG16* %2835 to [16 x i32]*
%2837 = getelementptr inbounds [16 x i32], [16 x i32]* %2836, i64 0, i64 3
store i32 %2834, i32* %2837
%2838 = add i32 %2793, %2834
%2839 = add i32 %2838, -1894007588
%2840 = load i32, i32* %9
%2841 = shl i32 %2840, 5
%2842 = load i32, i32* %9
%2843 = lshr i32 %2842, 27
%2844 = or i32 %2841, %2843
%2845 = add i32 %2839, %2844
%2846 = load i32, i32* %8
%2847 = add i32 %2846, %2845
store i32 %2847, i32* %8
%2848 = load i32, i32* %5
%2849 = shl i32 %2848, 30
%2850 = load i32, i32* %5
%2851 = lshr i32 %2850, 2
%2852 = or i32 %2849, %2851
store i32 %2852, i32* %5
%2853 = load i32, i32* %9
%2854 = load i32, i32* %5
%2855 = or i32 %2853, %2854
%2856 = load i32, i32* %6
%2857 = and i32 %2855, %2856
%2858 = load i32, i32* %9
%2859 = load i32, i32* %5
%2860 = and i32 %2858, %2859
%2861 = or i32 %2857, %2860
%2862 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2863 = bitcast %union.CHAR64LONG16* %2862 to [16 x i32]*
%2864 = getelementptr inbounds [16 x i32], [16 x i32]* %2863, i64 0, i64 1
%2865 = load i32, i32* %2864
%2866 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2867 = bitcast %union.CHAR64LONG16* %2866 to [16 x i32]*
%2868 = getelementptr inbounds [16 x i32], [16 x i32]* %2867, i64 0, i64 12
%2869 = load i32, i32* %2868
%2870 = xor i32 %2865, %2869
%2871 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2872 = bitcast %union.CHAR64LONG16* %2871 to [16 x i32]*
%2873 = getelementptr inbounds [16 x i32], [16 x i32]* %2872, i64 0, i64 6
%2874 = load i32, i32* %2873
%2875 = xor i32 %2870, %2874
%2876 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2877 = bitcast %union.CHAR64LONG16* %2876 to [16 x i32]*
%2878 = getelementptr inbounds [16 x i32], [16 x i32]* %2877, i64 0, i64 4
%2879 = load i32, i32* %2878
%2880 = xor i32 %2875, %2879
%2881 = shl i32 %2880, 1
%2882 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2883 = bitcast %union.CHAR64LONG16* %2882 to [16 x i32]*
%2884 = getelementptr inbounds [16 x i32], [16 x i32]* %2883, i64 0, i64 1
%2885 = load i32, i32* %2884
%2886 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2887 = bitcast %union.CHAR64LONG16* %2886 to [16 x i32]*
%2888 = getelementptr inbounds [16 x i32], [16 x i32]* %2887, i64 0, i64 12
%2889 = load i32, i32* %2888
%2890 = xor i32 %2885, %2889
%2891 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2892 = bitcast %union.CHAR64LONG16* %2891 to [16 x i32]*
%2893 = getelementptr inbounds [16 x i32], [16 x i32]* %2892, i64 0, i64 6
%2894 = load i32, i32* %2893
%2895 = xor i32 %2890, %2894
%2896 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2897 = bitcast %union.CHAR64LONG16* %2896 to [16 x i32]*
%2898 = getelementptr inbounds [16 x i32], [16 x i32]* %2897, i64 0, i64 4
%2899 = load i32, i32* %2898
%2900 = xor i32 %2895, %2899
%2901 = lshr i32 %2900, 31
%2902 = or i32 %2881, %2901
%2903 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2904 = bitcast %union.CHAR64LONG16* %2903 to [16 x i32]*
%2905 = getelementptr inbounds [16 x i32], [16 x i32]* %2904, i64 0, i64 4
store i32 %2902, i32* %2905
%2906 = add i32 %2861, %2902
%2907 = add i32 %2906, -1894007588
%2908 = load i32, i32* %8
%2909 = shl i32 %2908, 5
%2910 = load i32, i32* %8
%2911 = lshr i32 %2910, 27
%2912 = or i32 %2909, %2911
%2913 = add i32 %2907, %2912
%2914 = load i32, i32* %7
%2915 = add i32 %2914, %2913
store i32 %2915, i32* %7
%2916 = load i32, i32* %9
%2917 = shl i32 %2916, 30
%2918 = load i32, i32* %9
%2919 = lshr i32 %2918, 2
%2920 = or i32 %2917, %2919
store i32 %2920, i32* %9
%2921 = load i32, i32* %8
%2922 = load i32, i32* %9
%2923 = or i32 %2921, %2922
%2924 = load i32, i32* %5
%2925 = and i32 %2923, %2924
%2926 = load i32, i32* %8
%2927 = load i32, i32* %9
%2928 = and i32 %2926, %2927
%2929 = or i32 %2925, %2928
%2930 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2931 = bitcast %union.CHAR64LONG16* %2930 to [16 x i32]*
%2932 = getelementptr inbounds [16 x i32], [16 x i32]* %2931, i64 0, i64 2
%2933 = load i32, i32* %2932
%2934 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2935 = bitcast %union.CHAR64LONG16* %2934 to [16 x i32]*
%2936 = getelementptr inbounds [16 x i32], [16 x i32]* %2935, i64 0, i64 13
%2937 = load i32, i32* %2936
%2938 = xor i32 %2933, %2937
%2939 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2940 = bitcast %union.CHAR64LONG16* %2939 to [16 x i32]*
%2941 = getelementptr inbounds [16 x i32], [16 x i32]* %2940, i64 0, i64 7
%2942 = load i32, i32* %2941
%2943 = xor i32 %2938, %2942
%2944 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2945 = bitcast %union.CHAR64LONG16* %2944 to [16 x i32]*
%2946 = getelementptr inbounds [16 x i32], [16 x i32]* %2945, i64 0, i64 5
%2947 = load i32, i32* %2946
%2948 = xor i32 %2943, %2947
%2949 = shl i32 %2948, 1
%2950 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2951 = bitcast %union.CHAR64LONG16* %2950 to [16 x i32]*
%2952 = getelementptr inbounds [16 x i32], [16 x i32]* %2951, i64 0, i64 2
%2953 = load i32, i32* %2952
%2954 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2955 = bitcast %union.CHAR64LONG16* %2954 to [16 x i32]*
%2956 = getelementptr inbounds [16 x i32], [16 x i32]* %2955, i64 0, i64 13
%2957 = load i32, i32* %2956
%2958 = xor i32 %2953, %2957
%2959 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2960 = bitcast %union.CHAR64LONG16* %2959 to [16 x i32]*
%2961 = getelementptr inbounds [16 x i32], [16 x i32]* %2960, i64 0, i64 7
%2962 = load i32, i32* %2961
%2963 = xor i32 %2958, %2962
%2964 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2965 = bitcast %union.CHAR64LONG16* %2964 to [16 x i32]*
%2966 = getelementptr inbounds [16 x i32], [16 x i32]* %2965, i64 0, i64 5
%2967 = load i32, i32* %2966
%2968 = xor i32 %2963, %2967
%2969 = lshr i32 %2968, 31
%2970 = or i32 %2949, %2969
%2971 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2972 = bitcast %union.CHAR64LONG16* %2971 to [16 x i32]*
%2973 = getelementptr inbounds [16 x i32], [16 x i32]* %2972, i64 0, i64 5
store i32 %2970, i32* %2973
%2974 = add i32 %2929, %2970
%2975 = add i32 %2974, -1894007588
%2976 = load i32, i32* %7
%2977 = shl i32 %2976, 5
%2978 = load i32, i32* %7
%2979 = lshr i32 %2978, 27
%2980 = or i32 %2977, %2979
%2981 = add i32 %2975, %2980
%2982 = load i32, i32* %6
%2983 = add i32 %2982, %2981
store i32 %2983, i32* %6
%2984 = load i32, i32* %8
%2985 = shl i32 %2984, 30
%2986 = load i32, i32* %8
%2987 = lshr i32 %2986, 2
%2988 = or i32 %2985, %2987
store i32 %2988, i32* %8
%2989 = load i32, i32* %7
%2990 = load i32, i32* %8
%2991 = or i32 %2989, %2990
%2992 = load i32, i32* %9
%2993 = and i32 %2991, %2992
%2994 = load i32, i32* %7
%2995 = load i32, i32* %8
%2996 = and i32 %2994, %2995
%2997 = or i32 %2993, %2996
%2998 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%2999 = bitcast %union.CHAR64LONG16* %2998 to [16 x i32]*
%3000 = getelementptr inbounds [16 x i32], [16 x i32]* %2999, i64 0, i64 3
%3001 = load i32, i32* %3000
%3002 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3003 = bitcast %union.CHAR64LONG16* %3002 to [16 x i32]*
%3004 = getelementptr inbounds [16 x i32], [16 x i32]* %3003, i64 0, i64 14
%3005 = load i32, i32* %3004
%3006 = xor i32 %3001, %3005
%3007 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3008 = bitcast %union.CHAR64LONG16* %3007 to [16 x i32]*
%3009 = getelementptr inbounds [16 x i32], [16 x i32]* %3008, i64 0, i64 8
%3010 = load i32, i32* %3009
%3011 = xor i32 %3006, %3010
%3012 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3013 = bitcast %union.CHAR64LONG16* %3012 to [16 x i32]*
%3014 = getelementptr inbounds [16 x i32], [16 x i32]* %3013, i64 0, i64 6
%3015 = load i32, i32* %3014
%3016 = xor i32 %3011, %3015
%3017 = shl i32 %3016, 1
%3018 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3019 = bitcast %union.CHAR64LONG16* %3018 to [16 x i32]*
%3020 = getelementptr inbounds [16 x i32], [16 x i32]* %3019, i64 0, i64 3
%3021 = load i32, i32* %3020
%3022 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3023 = bitcast %union.CHAR64LONG16* %3022 to [16 x i32]*
%3024 = getelementptr inbounds [16 x i32], [16 x i32]* %3023, i64 0, i64 14
%3025 = load i32, i32* %3024
%3026 = xor i32 %3021, %3025
%3027 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3028 = bitcast %union.CHAR64LONG16* %3027 to [16 x i32]*
%3029 = getelementptr inbounds [16 x i32], [16 x i32]* %3028, i64 0, i64 8
%3030 = load i32, i32* %3029
%3031 = xor i32 %3026, %3030
%3032 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3033 = bitcast %union.CHAR64LONG16* %3032 to [16 x i32]*
%3034 = getelementptr inbounds [16 x i32], [16 x i32]* %3033, i64 0, i64 6
%3035 = load i32, i32* %3034
%3036 = xor i32 %3031, %3035
%3037 = lshr i32 %3036, 31
%3038 = or i32 %3017, %3037
%3039 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3040 = bitcast %union.CHAR64LONG16* %3039 to [16 x i32]*
%3041 = getelementptr inbounds [16 x i32], [16 x i32]* %3040, i64 0, i64 6
store i32 %3038, i32* %3041
%3042 = add i32 %2997, %3038
%3043 = add i32 %3042, -1894007588
%3044 = load i32, i32* %6
%3045 = shl i32 %3044, 5
%3046 = load i32, i32* %6
%3047 = lshr i32 %3046, 27
%3048 = or i32 %3045, %3047
%3049 = add i32 %3043, %3048
%3050 = load i32, i32* %5
%3051 = add i32 %3050, %3049
store i32 %3051, i32* %5
%3052 = load i32, i32* %7
%3053 = shl i32 %3052, 30
%3054 = load i32, i32* %7
%3055 = lshr i32 %3054, 2
%3056 = or i32 %3053, %3055
store i32 %3056, i32* %7
%3057 = load i32, i32* %6
%3058 = load i32, i32* %7
%3059 = or i32 %3057, %3058
%3060 = load i32, i32* %8
%3061 = and i32 %3059, %3060
%3062 = load i32, i32* %6
%3063 = load i32, i32* %7
%3064 = and i32 %3062, %3063
%3065 = or i32 %3061, %3064
%3066 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3067 = bitcast %union.CHAR64LONG16* %3066 to [16 x i32]*
%3068 = getelementptr inbounds [16 x i32], [16 x i32]* %3067, i64 0, i64 4
%3069 = load i32, i32* %3068
%3070 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3071 = bitcast %union.CHAR64LONG16* %3070 to [16 x i32]*
%3072 = getelementptr inbounds [16 x i32], [16 x i32]* %3071, i64 0, i64 15
%3073 = load i32, i32* %3072
%3074 = xor i32 %3069, %3073
%3075 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3076 = bitcast %union.CHAR64LONG16* %3075 to [16 x i32]*
%3077 = getelementptr inbounds [16 x i32], [16 x i32]* %3076, i64 0, i64 9
%3078 = load i32, i32* %3077
%3079 = xor i32 %3074, %3078
%3080 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3081 = bitcast %union.CHAR64LONG16* %3080 to [16 x i32]*
%3082 = getelementptr inbounds [16 x i32], [16 x i32]* %3081, i64 0, i64 7
%3083 = load i32, i32* %3082
%3084 = xor i32 %3079, %3083
%3085 = shl i32 %3084, 1
%3086 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3087 = bitcast %union.CHAR64LONG16* %3086 to [16 x i32]*
%3088 = getelementptr inbounds [16 x i32], [16 x i32]* %3087, i64 0, i64 4
%3089 = load i32, i32* %3088
%3090 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3091 = bitcast %union.CHAR64LONG16* %3090 to [16 x i32]*
%3092 = getelementptr inbounds [16 x i32], [16 x i32]* %3091, i64 0, i64 15
%3093 = load i32, i32* %3092
%3094 = xor i32 %3089, %3093
%3095 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3096 = bitcast %union.CHAR64LONG16* %3095 to [16 x i32]*
%3097 = getelementptr inbounds [16 x i32], [16 x i32]* %3096, i64 0, i64 9
%3098 = load i32, i32* %3097
%3099 = xor i32 %3094, %3098
%3100 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3101 = bitcast %union.CHAR64LONG16* %3100 to [16 x i32]*
%3102 = getelementptr inbounds [16 x i32], [16 x i32]* %3101, i64 0, i64 7
%3103 = load i32, i32* %3102
%3104 = xor i32 %3099, %3103
%3105 = lshr i32 %3104, 31
%3106 = or i32 %3085, %3105
%3107 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3108 = bitcast %union.CHAR64LONG16* %3107 to [16 x i32]*
%3109 = getelementptr inbounds [16 x i32], [16 x i32]* %3108, i64 0, i64 7
store i32 %3106, i32* %3109
%3110 = add i32 %3065, %3106
%3111 = add i32 %3110, -1894007588
%3112 = load i32, i32* %5
%3113 = shl i32 %3112, 5
%3114 = load i32, i32* %5
%3115 = lshr i32 %3114, 27
%3116 = or i32 %3113, %3115
%3117 = add i32 %3111, %3116
%3118 = load i32, i32* %9
%3119 = add i32 %3118, %3117
store i32 %3119, i32* %9
%3120 = load i32, i32* %6
%3121 = shl i32 %3120, 30
%3122 = load i32, i32* %6
%3123 = lshr i32 %3122, 2
%3124 = or i32 %3121, %3123
store i32 %3124, i32* %6
%3125 = load i32, i32* %5
%3126 = load i32, i32* %6
%3127 = or i32 %3125, %3126
%3128 = load i32, i32* %7
%3129 = and i32 %3127, %3128
%3130 = load i32, i32* %5
%3131 = load i32, i32* %6
%3132 = and i32 %3130, %3131
%3133 = or i32 %3129, %3132
%3134 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3135 = bitcast %union.CHAR64LONG16* %3134 to [16 x i32]*
%3136 = getelementptr inbounds [16 x i32], [16 x i32]* %3135, i64 0, i64 5
%3137 = load i32, i32* %3136
%3138 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3139 = bitcast %union.CHAR64LONG16* %3138 to [16 x i32]*
%3140 = getelementptr inbounds [16 x i32], [16 x i32]* %3139, i64 0, i64 0
%3141 = load i32, i32* %3140
%3142 = xor i32 %3137, %3141
%3143 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3144 = bitcast %union.CHAR64LONG16* %3143 to [16 x i32]*
%3145 = getelementptr inbounds [16 x i32], [16 x i32]* %3144, i64 0, i64 10
%3146 = load i32, i32* %3145
%3147 = xor i32 %3142, %3146
%3148 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3149 = bitcast %union.CHAR64LONG16* %3148 to [16 x i32]*
%3150 = getelementptr inbounds [16 x i32], [16 x i32]* %3149, i64 0, i64 8
%3151 = load i32, i32* %3150
%3152 = xor i32 %3147, %3151
%3153 = shl i32 %3152, 1
%3154 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3155 = bitcast %union.CHAR64LONG16* %3154 to [16 x i32]*
%3156 = getelementptr inbounds [16 x i32], [16 x i32]* %3155, i64 0, i64 5
%3157 = load i32, i32* %3156
%3158 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3159 = bitcast %union.CHAR64LONG16* %3158 to [16 x i32]*
%3160 = getelementptr inbounds [16 x i32], [16 x i32]* %3159, i64 0, i64 0
%3161 = load i32, i32* %3160
%3162 = xor i32 %3157, %3161
%3163 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3164 = bitcast %union.CHAR64LONG16* %3163 to [16 x i32]*
%3165 = getelementptr inbounds [16 x i32], [16 x i32]* %3164, i64 0, i64 10
%3166 = load i32, i32* %3165
%3167 = xor i32 %3162, %3166
%3168 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3169 = bitcast %union.CHAR64LONG16* %3168 to [16 x i32]*
%3170 = getelementptr inbounds [16 x i32], [16 x i32]* %3169, i64 0, i64 8
%3171 = load i32, i32* %3170
%3172 = xor i32 %3167, %3171
%3173 = lshr i32 %3172, 31
%3174 = or i32 %3153, %3173
%3175 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3176 = bitcast %union.CHAR64LONG16* %3175 to [16 x i32]*
%3177 = getelementptr inbounds [16 x i32], [16 x i32]* %3176, i64 0, i64 8
store i32 %3174, i32* %3177
%3178 = add i32 %3133, %3174
%3179 = add i32 %3178, -1894007588
%3180 = load i32, i32* %9
%3181 = shl i32 %3180, 5
%3182 = load i32, i32* %9
%3183 = lshr i32 %3182, 27
%3184 = or i32 %3181, %3183
%3185 = add i32 %3179, %3184
%3186 = load i32, i32* %8
%3187 = add i32 %3186, %3185
store i32 %3187, i32* %8
%3188 = load i32, i32* %5
%3189 = shl i32 %3188, 30
%3190 = load i32, i32* %5
%3191 = lshr i32 %3190, 2
%3192 = or i32 %3189, %3191
store i32 %3192, i32* %5
%3193 = load i32, i32* %9
%3194 = load i32, i32* %5
%3195 = or i32 %3193, %3194
%3196 = load i32, i32* %6
%3197 = and i32 %3195, %3196
%3198 = load i32, i32* %9
%3199 = load i32, i32* %5
%3200 = and i32 %3198, %3199
%3201 = or i32 %3197, %3200
%3202 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3203 = bitcast %union.CHAR64LONG16* %3202 to [16 x i32]*
%3204 = getelementptr inbounds [16 x i32], [16 x i32]* %3203, i64 0, i64 6
%3205 = load i32, i32* %3204
%3206 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3207 = bitcast %union.CHAR64LONG16* %3206 to [16 x i32]*
%3208 = getelementptr inbounds [16 x i32], [16 x i32]* %3207, i64 0, i64 1
%3209 = load i32, i32* %3208
%3210 = xor i32 %3205, %3209
%3211 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3212 = bitcast %union.CHAR64LONG16* %3211 to [16 x i32]*
%3213 = getelementptr inbounds [16 x i32], [16 x i32]* %3212, i64 0, i64 11
%3214 = load i32, i32* %3213
%3215 = xor i32 %3210, %3214
%3216 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3217 = bitcast %union.CHAR64LONG16* %3216 to [16 x i32]*
%3218 = getelementptr inbounds [16 x i32], [16 x i32]* %3217, i64 0, i64 9
%3219 = load i32, i32* %3218
%3220 = xor i32 %3215, %3219
%3221 = shl i32 %3220, 1
%3222 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3223 = bitcast %union.CHAR64LONG16* %3222 to [16 x i32]*
%3224 = getelementptr inbounds [16 x i32], [16 x i32]* %3223, i64 0, i64 6
%3225 = load i32, i32* %3224
%3226 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3227 = bitcast %union.CHAR64LONG16* %3226 to [16 x i32]*
%3228 = getelementptr inbounds [16 x i32], [16 x i32]* %3227, i64 0, i64 1
%3229 = load i32, i32* %3228
%3230 = xor i32 %3225, %3229
%3231 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3232 = bitcast %union.CHAR64LONG16* %3231 to [16 x i32]*
%3233 = getelementptr inbounds [16 x i32], [16 x i32]* %3232, i64 0, i64 11
%3234 = load i32, i32* %3233
%3235 = xor i32 %3230, %3234
%3236 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3237 = bitcast %union.CHAR64LONG16* %3236 to [16 x i32]*
%3238 = getelementptr inbounds [16 x i32], [16 x i32]* %3237, i64 0, i64 9
%3239 = load i32, i32* %3238
%3240 = xor i32 %3235, %3239
%3241 = lshr i32 %3240, 31
%3242 = or i32 %3221, %3241
%3243 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3244 = bitcast %union.CHAR64LONG16* %3243 to [16 x i32]*
%3245 = getelementptr inbounds [16 x i32], [16 x i32]* %3244, i64 0, i64 9
store i32 %3242, i32* %3245
%3246 = add i32 %3201, %3242
%3247 = add i32 %3246, -1894007588
%3248 = load i32, i32* %8
%3249 = shl i32 %3248, 5
%3250 = load i32, i32* %8
%3251 = lshr i32 %3250, 27
%3252 = or i32 %3249, %3251
%3253 = add i32 %3247, %3252
%3254 = load i32, i32* %7
%3255 = add i32 %3254, %3253
store i32 %3255, i32* %7
%3256 = load i32, i32* %9
%3257 = shl i32 %3256, 30
%3258 = load i32, i32* %9
%3259 = lshr i32 %3258, 2
%3260 = or i32 %3257, %3259
store i32 %3260, i32* %9
%3261 = load i32, i32* %8
%3262 = load i32, i32* %9
%3263 = or i32 %3261, %3262
%3264 = load i32, i32* %5
%3265 = and i32 %3263, %3264
%3266 = load i32, i32* %8
%3267 = load i32, i32* %9
%3268 = and i32 %3266, %3267
%3269 = or i32 %3265, %3268
%3270 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3271 = bitcast %union.CHAR64LONG16* %3270 to [16 x i32]*
%3272 = getelementptr inbounds [16 x i32], [16 x i32]* %3271, i64 0, i64 7
%3273 = load i32, i32* %3272
%3274 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3275 = bitcast %union.CHAR64LONG16* %3274 to [16 x i32]*
%3276 = getelementptr inbounds [16 x i32], [16 x i32]* %3275, i64 0, i64 2
%3277 = load i32, i32* %3276
%3278 = xor i32 %3273, %3277
%3279 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3280 = bitcast %union.CHAR64LONG16* %3279 to [16 x i32]*
%3281 = getelementptr inbounds [16 x i32], [16 x i32]* %3280, i64 0, i64 12
%3282 = load i32, i32* %3281
%3283 = xor i32 %3278, %3282
%3284 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3285 = bitcast %union.CHAR64LONG16* %3284 to [16 x i32]*
%3286 = getelementptr inbounds [16 x i32], [16 x i32]* %3285, i64 0, i64 10
%3287 = load i32, i32* %3286
%3288 = xor i32 %3283, %3287
%3289 = shl i32 %3288, 1
%3290 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3291 = bitcast %union.CHAR64LONG16* %3290 to [16 x i32]*
%3292 = getelementptr inbounds [16 x i32], [16 x i32]* %3291, i64 0, i64 7
%3293 = load i32, i32* %3292
%3294 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3295 = bitcast %union.CHAR64LONG16* %3294 to [16 x i32]*
%3296 = getelementptr inbounds [16 x i32], [16 x i32]* %3295, i64 0, i64 2
%3297 = load i32, i32* %3296
%3298 = xor i32 %3293, %3297
%3299 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3300 = bitcast %union.CHAR64LONG16* %3299 to [16 x i32]*
%3301 = getelementptr inbounds [16 x i32], [16 x i32]* %3300, i64 0, i64 12
%3302 = load i32, i32* %3301
%3303 = xor i32 %3298, %3302
%3304 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3305 = bitcast %union.CHAR64LONG16* %3304 to [16 x i32]*
%3306 = getelementptr inbounds [16 x i32], [16 x i32]* %3305, i64 0, i64 10
%3307 = load i32, i32* %3306
%3308 = xor i32 %3303, %3307
%3309 = lshr i32 %3308, 31
%3310 = or i32 %3289, %3309
%3311 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3312 = bitcast %union.CHAR64LONG16* %3311 to [16 x i32]*
%3313 = getelementptr inbounds [16 x i32], [16 x i32]* %3312, i64 0, i64 10
store i32 %3310, i32* %3313
%3314 = add i32 %3269, %3310
%3315 = add i32 %3314, -1894007588
%3316 = load i32, i32* %7
%3317 = shl i32 %3316, 5
%3318 = load i32, i32* %7
%3319 = lshr i32 %3318, 27
%3320 = or i32 %3317, %3319
%3321 = add i32 %3315, %3320
%3322 = load i32, i32* %6
%3323 = add i32 %3322, %3321
store i32 %3323, i32* %6
%3324 = load i32, i32* %8
%3325 = shl i32 %3324, 30
%3326 = load i32, i32* %8
%3327 = lshr i32 %3326, 2
%3328 = or i32 %3325, %3327
store i32 %3328, i32* %8
%3329 = load i32, i32* %7
%3330 = load i32, i32* %8
%3331 = or i32 %3329, %3330
%3332 = load i32, i32* %9
%3333 = and i32 %3331, %3332
%3334 = load i32, i32* %7
%3335 = load i32, i32* %8
%3336 = and i32 %3334, %3335
%3337 = or i32 %3333, %3336
%3338 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3339 = bitcast %union.CHAR64LONG16* %3338 to [16 x i32]*
%3340 = getelementptr inbounds [16 x i32], [16 x i32]* %3339, i64 0, i64 8
%3341 = load i32, i32* %3340
%3342 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3343 = bitcast %union.CHAR64LONG16* %3342 to [16 x i32]*
%3344 = getelementptr inbounds [16 x i32], [16 x i32]* %3343, i64 0, i64 3
%3345 = load i32, i32* %3344
%3346 = xor i32 %3341, %3345
%3347 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3348 = bitcast %union.CHAR64LONG16* %3347 to [16 x i32]*
%3349 = getelementptr inbounds [16 x i32], [16 x i32]* %3348, i64 0, i64 13
%3350 = load i32, i32* %3349
%3351 = xor i32 %3346, %3350
%3352 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3353 = bitcast %union.CHAR64LONG16* %3352 to [16 x i32]*
%3354 = getelementptr inbounds [16 x i32], [16 x i32]* %3353, i64 0, i64 11
%3355 = load i32, i32* %3354
%3356 = xor i32 %3351, %3355
%3357 = shl i32 %3356, 1
%3358 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3359 = bitcast %union.CHAR64LONG16* %3358 to [16 x i32]*
%3360 = getelementptr inbounds [16 x i32], [16 x i32]* %3359, i64 0, i64 8
%3361 = load i32, i32* %3360
%3362 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3363 = bitcast %union.CHAR64LONG16* %3362 to [16 x i32]*
%3364 = getelementptr inbounds [16 x i32], [16 x i32]* %3363, i64 0, i64 3
%3365 = load i32, i32* %3364
%3366 = xor i32 %3361, %3365
%3367 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3368 = bitcast %union.CHAR64LONG16* %3367 to [16 x i32]*
%3369 = getelementptr inbounds [16 x i32], [16 x i32]* %3368, i64 0, i64 13
%3370 = load i32, i32* %3369
%3371 = xor i32 %3366, %3370
%3372 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3373 = bitcast %union.CHAR64LONG16* %3372 to [16 x i32]*
%3374 = getelementptr inbounds [16 x i32], [16 x i32]* %3373, i64 0, i64 11
%3375 = load i32, i32* %3374
%3376 = xor i32 %3371, %3375
%3377 = lshr i32 %3376, 31
%3378 = or i32 %3357, %3377
%3379 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3380 = bitcast %union.CHAR64LONG16* %3379 to [16 x i32]*
%3381 = getelementptr inbounds [16 x i32], [16 x i32]* %3380, i64 0, i64 11
store i32 %3378, i32* %3381
%3382 = add i32 %3337, %3378
%3383 = add i32 %3382, -1894007588
%3384 = load i32, i32* %6
%3385 = shl i32 %3384, 5
%3386 = load i32, i32* %6
%3387 = lshr i32 %3386, 27
%3388 = or i32 %3385, %3387
%3389 = add i32 %3383, %3388
%3390 = load i32, i32* %5
%3391 = add i32 %3390, %3389
store i32 %3391, i32* %5
%3392 = load i32, i32* %7
%3393 = shl i32 %3392, 30
%3394 = load i32, i32* %7
%3395 = lshr i32 %3394, 2
%3396 = or i32 %3393, %3395
store i32 %3396, i32* %7
%3397 = load i32, i32* %6
%3398 = load i32, i32* %7
%3399 = xor i32 %3397, %3398
%3400 = load i32, i32* %8
%3401 = xor i32 %3399, %3400
%3402 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3403 = bitcast %union.CHAR64LONG16* %3402 to [16 x i32]*
%3404 = getelementptr inbounds [16 x i32], [16 x i32]* %3403, i64 0, i64 9
%3405 = load i32, i32* %3404
%3406 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3407 = bitcast %union.CHAR64LONG16* %3406 to [16 x i32]*
%3408 = getelementptr inbounds [16 x i32], [16 x i32]* %3407, i64 0, i64 4
%3409 = load i32, i32* %3408
%3410 = xor i32 %3405, %3409
%3411 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3412 = bitcast %union.CHAR64LONG16* %3411 to [16 x i32]*
%3413 = getelementptr inbounds [16 x i32], [16 x i32]* %3412, i64 0, i64 14
%3414 = load i32, i32* %3413
%3415 = xor i32 %3410, %3414
%3416 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3417 = bitcast %union.CHAR64LONG16* %3416 to [16 x i32]*
%3418 = getelementptr inbounds [16 x i32], [16 x i32]* %3417, i64 0, i64 12
%3419 = load i32, i32* %3418
%3420 = xor i32 %3415, %3419
%3421 = shl i32 %3420, 1
%3422 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3423 = bitcast %union.CHAR64LONG16* %3422 to [16 x i32]*
%3424 = getelementptr inbounds [16 x i32], [16 x i32]* %3423, i64 0, i64 9
%3425 = load i32, i32* %3424
%3426 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3427 = bitcast %union.CHAR64LONG16* %3426 to [16 x i32]*
%3428 = getelementptr inbounds [16 x i32], [16 x i32]* %3427, i64 0, i64 4
%3429 = load i32, i32* %3428
%3430 = xor i32 %3425, %3429
%3431 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3432 = bitcast %union.CHAR64LONG16* %3431 to [16 x i32]*
%3433 = getelementptr inbounds [16 x i32], [16 x i32]* %3432, i64 0, i64 14
%3434 = load i32, i32* %3433
%3435 = xor i32 %3430, %3434
%3436 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3437 = bitcast %union.CHAR64LONG16* %3436 to [16 x i32]*
%3438 = getelementptr inbounds [16 x i32], [16 x i32]* %3437, i64 0, i64 12
%3439 = load i32, i32* %3438
%3440 = xor i32 %3435, %3439
%3441 = lshr i32 %3440, 31
%3442 = or i32 %3421, %3441
%3443 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3444 = bitcast %union.CHAR64LONG16* %3443 to [16 x i32]*
%3445 = getelementptr inbounds [16 x i32], [16 x i32]* %3444, i64 0, i64 12
store i32 %3442, i32* %3445
%3446 = add i32 %3401, %3442
%3447 = add i32 %3446, -899497514
%3448 = load i32, i32* %5
%3449 = shl i32 %3448, 5
%3450 = load i32, i32* %5
%3451 = lshr i32 %3450, 27
%3452 = or i32 %3449, %3451
%3453 = add i32 %3447, %3452
%3454 = load i32, i32* %9
%3455 = add i32 %3454, %3453
store i32 %3455, i32* %9
%3456 = load i32, i32* %6
%3457 = shl i32 %3456, 30
%3458 = load i32, i32* %6
%3459 = lshr i32 %3458, 2
%3460 = or i32 %3457, %3459
store i32 %3460, i32* %6
%3461 = load i32, i32* %5
%3462 = load i32, i32* %6
%3463 = xor i32 %3461, %3462
%3464 = load i32, i32* %7
%3465 = xor i32 %3463, %3464
%3466 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3467 = bitcast %union.CHAR64LONG16* %3466 to [16 x i32]*
%3468 = getelementptr inbounds [16 x i32], [16 x i32]* %3467, i64 0, i64 10
%3469 = load i32, i32* %3468
%3470 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3471 = bitcast %union.CHAR64LONG16* %3470 to [16 x i32]*
%3472 = getelementptr inbounds [16 x i32], [16 x i32]* %3471, i64 0, i64 5
%3473 = load i32, i32* %3472
%3474 = xor i32 %3469, %3473
%3475 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3476 = bitcast %union.CHAR64LONG16* %3475 to [16 x i32]*
%3477 = getelementptr inbounds [16 x i32], [16 x i32]* %3476, i64 0, i64 15
%3478 = load i32, i32* %3477
%3479 = xor i32 %3474, %3478
%3480 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3481 = bitcast %union.CHAR64LONG16* %3480 to [16 x i32]*
%3482 = getelementptr inbounds [16 x i32], [16 x i32]* %3481, i64 0, i64 13
%3483 = load i32, i32* %3482
%3484 = xor i32 %3479, %3483
%3485 = shl i32 %3484, 1
%3486 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3487 = bitcast %union.CHAR64LONG16* %3486 to [16 x i32]*
%3488 = getelementptr inbounds [16 x i32], [16 x i32]* %3487, i64 0, i64 10
%3489 = load i32, i32* %3488
%3490 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3491 = bitcast %union.CHAR64LONG16* %3490 to [16 x i32]*
%3492 = getelementptr inbounds [16 x i32], [16 x i32]* %3491, i64 0, i64 5
%3493 = load i32, i32* %3492
%3494 = xor i32 %3489, %3493
%3495 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3496 = bitcast %union.CHAR64LONG16* %3495 to [16 x i32]*
%3497 = getelementptr inbounds [16 x i32], [16 x i32]* %3496, i64 0, i64 15
%3498 = load i32, i32* %3497
%3499 = xor i32 %3494, %3498
%3500 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3501 = bitcast %union.CHAR64LONG16* %3500 to [16 x i32]*
%3502 = getelementptr inbounds [16 x i32], [16 x i32]* %3501, i64 0, i64 13
%3503 = load i32, i32* %3502
%3504 = xor i32 %3499, %3503
%3505 = lshr i32 %3504, 31
%3506 = or i32 %3485, %3505
%3507 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3508 = bitcast %union.CHAR64LONG16* %3507 to [16 x i32]*
%3509 = getelementptr inbounds [16 x i32], [16 x i32]* %3508, i64 0, i64 13
store i32 %3506, i32* %3509
%3510 = add i32 %3465, %3506
%3511 = add i32 %3510, -899497514
%3512 = load i32, i32* %9
%3513 = shl i32 %3512, 5
%3514 = load i32, i32* %9
%3515 = lshr i32 %3514, 27
%3516 = or i32 %3513, %3515
%3517 = add i32 %3511, %3516
%3518 = load i32, i32* %8
%3519 = add i32 %3518, %3517
store i32 %3519, i32* %8
%3520 = load i32, i32* %5
%3521 = shl i32 %3520, 30
%3522 = load i32, i32* %5
%3523 = lshr i32 %3522, 2
%3524 = or i32 %3521, %3523
store i32 %3524, i32* %5
%3525 = load i32, i32* %9
%3526 = load i32, i32* %5
%3527 = xor i32 %3525, %3526
%3528 = load i32, i32* %6
%3529 = xor i32 %3527, %3528
%3530 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3531 = bitcast %union.CHAR64LONG16* %3530 to [16 x i32]*
%3532 = getelementptr inbounds [16 x i32], [16 x i32]* %3531, i64 0, i64 11
%3533 = load i32, i32* %3532
%3534 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3535 = bitcast %union.CHAR64LONG16* %3534 to [16 x i32]*
%3536 = getelementptr inbounds [16 x i32], [16 x i32]* %3535, i64 0, i64 6
%3537 = load i32, i32* %3536
%3538 = xor i32 %3533, %3537
%3539 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3540 = bitcast %union.CHAR64LONG16* %3539 to [16 x i32]*
%3541 = getelementptr inbounds [16 x i32], [16 x i32]* %3540, i64 0, i64 0
%3542 = load i32, i32* %3541
%3543 = xor i32 %3538, %3542
%3544 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3545 = bitcast %union.CHAR64LONG16* %3544 to [16 x i32]*
%3546 = getelementptr inbounds [16 x i32], [16 x i32]* %3545, i64 0, i64 14
%3547 = load i32, i32* %3546
%3548 = xor i32 %3543, %3547
%3549 = shl i32 %3548, 1
%3550 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3551 = bitcast %union.CHAR64LONG16* %3550 to [16 x i32]*
%3552 = getelementptr inbounds [16 x i32], [16 x i32]* %3551, i64 0, i64 11
%3553 = load i32, i32* %3552
%3554 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3555 = bitcast %union.CHAR64LONG16* %3554 to [16 x i32]*
%3556 = getelementptr inbounds [16 x i32], [16 x i32]* %3555, i64 0, i64 6
%3557 = load i32, i32* %3556
%3558 = xor i32 %3553, %3557
%3559 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3560 = bitcast %union.CHAR64LONG16* %3559 to [16 x i32]*
%3561 = getelementptr inbounds [16 x i32], [16 x i32]* %3560, i64 0, i64 0
%3562 = load i32, i32* %3561
%3563 = xor i32 %3558, %3562
%3564 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3565 = bitcast %union.CHAR64LONG16* %3564 to [16 x i32]*
%3566 = getelementptr inbounds [16 x i32], [16 x i32]* %3565, i64 0, i64 14
%3567 = load i32, i32* %3566
%3568 = xor i32 %3563, %3567
%3569 = lshr i32 %3568, 31
%3570 = or i32 %3549, %3569
%3571 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3572 = bitcast %union.CHAR64LONG16* %3571 to [16 x i32]*
%3573 = getelementptr inbounds [16 x i32], [16 x i32]* %3572, i64 0, i64 14
store i32 %3570, i32* %3573
%3574 = add i32 %3529, %3570
%3575 = add i32 %3574, -899497514
%3576 = load i32, i32* %8
%3577 = shl i32 %3576, 5
%3578 = load i32, i32* %8
%3579 = lshr i32 %3578, 27
%3580 = or i32 %3577, %3579
%3581 = add i32 %3575, %3580
%3582 = load i32, i32* %7
%3583 = add i32 %3582, %3581
store i32 %3583, i32* %7
%3584 = load i32, i32* %9
%3585 = shl i32 %3584, 30
%3586 = load i32, i32* %9
%3587 = lshr i32 %3586, 2
%3588 = or i32 %3585, %3587
store i32 %3588, i32* %9
%3589 = load i32, i32* %8
%3590 = load i32, i32* %9
%3591 = xor i32 %3589, %3590
%3592 = load i32, i32* %5
%3593 = xor i32 %3591, %3592
%3594 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3595 = bitcast %union.CHAR64LONG16* %3594 to [16 x i32]*
%3596 = getelementptr inbounds [16 x i32], [16 x i32]* %3595, i64 0, i64 12
%3597 = load i32, i32* %3596
%3598 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3599 = bitcast %union.CHAR64LONG16* %3598 to [16 x i32]*
%3600 = getelementptr inbounds [16 x i32], [16 x i32]* %3599, i64 0, i64 7
%3601 = load i32, i32* %3600
%3602 = xor i32 %3597, %3601
%3603 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3604 = bitcast %union.CHAR64LONG16* %3603 to [16 x i32]*
%3605 = getelementptr inbounds [16 x i32], [16 x i32]* %3604, i64 0, i64 1
%3606 = load i32, i32* %3605
%3607 = xor i32 %3602, %3606
%3608 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3609 = bitcast %union.CHAR64LONG16* %3608 to [16 x i32]*
%3610 = getelementptr inbounds [16 x i32], [16 x i32]* %3609, i64 0, i64 15
%3611 = load i32, i32* %3610
%3612 = xor i32 %3607, %3611
%3613 = shl i32 %3612, 1
%3614 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3615 = bitcast %union.CHAR64LONG16* %3614 to [16 x i32]*
%3616 = getelementptr inbounds [16 x i32], [16 x i32]* %3615, i64 0, i64 12
%3617 = load i32, i32* %3616
%3618 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3619 = bitcast %union.CHAR64LONG16* %3618 to [16 x i32]*
%3620 = getelementptr inbounds [16 x i32], [16 x i32]* %3619, i64 0, i64 7
%3621 = load i32, i32* %3620
%3622 = xor i32 %3617, %3621
%3623 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3624 = bitcast %union.CHAR64LONG16* %3623 to [16 x i32]*
%3625 = getelementptr inbounds [16 x i32], [16 x i32]* %3624, i64 0, i64 1
%3626 = load i32, i32* %3625
%3627 = xor i32 %3622, %3626
%3628 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3629 = bitcast %union.CHAR64LONG16* %3628 to [16 x i32]*
%3630 = getelementptr inbounds [16 x i32], [16 x i32]* %3629, i64 0, i64 15
%3631 = load i32, i32* %3630
%3632 = xor i32 %3627, %3631
%3633 = lshr i32 %3632, 31
%3634 = or i32 %3613, %3633
%3635 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3636 = bitcast %union.CHAR64LONG16* %3635 to [16 x i32]*
%3637 = getelementptr inbounds [16 x i32], [16 x i32]* %3636, i64 0, i64 15
store i32 %3634, i32* %3637
%3638 = add i32 %3593, %3634
%3639 = add i32 %3638, -899497514
%3640 = load i32, i32* %7
%3641 = shl i32 %3640, 5
%3642 = load i32, i32* %7
%3643 = lshr i32 %3642, 27
%3644 = or i32 %3641, %3643
%3645 = add i32 %3639, %3644
%3646 = load i32, i32* %6
%3647 = add i32 %3646, %3645
store i32 %3647, i32* %6
%3648 = load i32, i32* %8
%3649 = shl i32 %3648, 30
%3650 = load i32, i32* %8
%3651 = lshr i32 %3650, 2
%3652 = or i32 %3649, %3651
store i32 %3652, i32* %8
%3653 = load i32, i32* %7
%3654 = load i32, i32* %8
%3655 = xor i32 %3653, %3654
%3656 = load i32, i32* %9
%3657 = xor i32 %3655, %3656
%3658 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3659 = bitcast %union.CHAR64LONG16* %3658 to [16 x i32]*
%3660 = getelementptr inbounds [16 x i32], [16 x i32]* %3659, i64 0, i64 13
%3661 = load i32, i32* %3660
%3662 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3663 = bitcast %union.CHAR64LONG16* %3662 to [16 x i32]*
%3664 = getelementptr inbounds [16 x i32], [16 x i32]* %3663, i64 0, i64 8
%3665 = load i32, i32* %3664
%3666 = xor i32 %3661, %3665
%3667 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3668 = bitcast %union.CHAR64LONG16* %3667 to [16 x i32]*
%3669 = getelementptr inbounds [16 x i32], [16 x i32]* %3668, i64 0, i64 2
%3670 = load i32, i32* %3669
%3671 = xor i32 %3666, %3670
%3672 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3673 = bitcast %union.CHAR64LONG16* %3672 to [16 x i32]*
%3674 = getelementptr inbounds [16 x i32], [16 x i32]* %3673, i64 0, i64 0
%3675 = load i32, i32* %3674
%3676 = xor i32 %3671, %3675
%3677 = shl i32 %3676, 1
%3678 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3679 = bitcast %union.CHAR64LONG16* %3678 to [16 x i32]*
%3680 = getelementptr inbounds [16 x i32], [16 x i32]* %3679, i64 0, i64 13
%3681 = load i32, i32* %3680
%3682 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3683 = bitcast %union.CHAR64LONG16* %3682 to [16 x i32]*
%3684 = getelementptr inbounds [16 x i32], [16 x i32]* %3683, i64 0, i64 8
%3685 = load i32, i32* %3684
%3686 = xor i32 %3681, %3685
%3687 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3688 = bitcast %union.CHAR64LONG16* %3687 to [16 x i32]*
%3689 = getelementptr inbounds [16 x i32], [16 x i32]* %3688, i64 0, i64 2
%3690 = load i32, i32* %3689
%3691 = xor i32 %3686, %3690
%3692 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3693 = bitcast %union.CHAR64LONG16* %3692 to [16 x i32]*
%3694 = getelementptr inbounds [16 x i32], [16 x i32]* %3693, i64 0, i64 0
%3695 = load i32, i32* %3694
%3696 = xor i32 %3691, %3695
%3697 = lshr i32 %3696, 31
%3698 = or i32 %3677, %3697
%3699 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3700 = bitcast %union.CHAR64LONG16* %3699 to [16 x i32]*
%3701 = getelementptr inbounds [16 x i32], [16 x i32]* %3700, i64 0, i64 0
store i32 %3698, i32* %3701
%3702 = add i32 %3657, %3698
%3703 = add i32 %3702, -899497514
%3704 = load i32, i32* %6
%3705 = shl i32 %3704, 5
%3706 = load i32, i32* %6
%3707 = lshr i32 %3706, 27
%3708 = or i32 %3705, %3707
%3709 = add i32 %3703, %3708
%3710 = load i32, i32* %5
%3711 = add i32 %3710, %3709
store i32 %3711, i32* %5
%3712 = load i32, i32* %7
%3713 = shl i32 %3712, 30
%3714 = load i32, i32* %7
%3715 = lshr i32 %3714, 2
%3716 = or i32 %3713, %3715
store i32 %3716, i32* %7
%3717 = load i32, i32* %6
%3718 = load i32, i32* %7
%3719 = xor i32 %3717, %3718
%3720 = load i32, i32* %8
%3721 = xor i32 %3719, %3720
%3722 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3723 = bitcast %union.CHAR64LONG16* %3722 to [16 x i32]*
%3724 = getelementptr inbounds [16 x i32], [16 x i32]* %3723, i64 0, i64 14
%3725 = load i32, i32* %3724
%3726 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3727 = bitcast %union.CHAR64LONG16* %3726 to [16 x i32]*
%3728 = getelementptr inbounds [16 x i32], [16 x i32]* %3727, i64 0, i64 9
%3729 = load i32, i32* %3728
%3730 = xor i32 %3725, %3729
%3731 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3732 = bitcast %union.CHAR64LONG16* %3731 to [16 x i32]*
%3733 = getelementptr inbounds [16 x i32], [16 x i32]* %3732, i64 0, i64 3
%3734 = load i32, i32* %3733
%3735 = xor i32 %3730, %3734
%3736 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3737 = bitcast %union.CHAR64LONG16* %3736 to [16 x i32]*
%3738 = getelementptr inbounds [16 x i32], [16 x i32]* %3737, i64 0, i64 1
%3739 = load i32, i32* %3738
%3740 = xor i32 %3735, %3739
%3741 = shl i32 %3740, 1
%3742 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3743 = bitcast %union.CHAR64LONG16* %3742 to [16 x i32]*
%3744 = getelementptr inbounds [16 x i32], [16 x i32]* %3743, i64 0, i64 14
%3745 = load i32, i32* %3744
%3746 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3747 = bitcast %union.CHAR64LONG16* %3746 to [16 x i32]*
%3748 = getelementptr inbounds [16 x i32], [16 x i32]* %3747, i64 0, i64 9
%3749 = load i32, i32* %3748
%3750 = xor i32 %3745, %3749
%3751 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3752 = bitcast %union.CHAR64LONG16* %3751 to [16 x i32]*
%3753 = getelementptr inbounds [16 x i32], [16 x i32]* %3752, i64 0, i64 3
%3754 = load i32, i32* %3753
%3755 = xor i32 %3750, %3754
%3756 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3757 = bitcast %union.CHAR64LONG16* %3756 to [16 x i32]*
%3758 = getelementptr inbounds [16 x i32], [16 x i32]* %3757, i64 0, i64 1
%3759 = load i32, i32* %3758
%3760 = xor i32 %3755, %3759
%3761 = lshr i32 %3760, 31
%3762 = or i32 %3741, %3761
%3763 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3764 = bitcast %union.CHAR64LONG16* %3763 to [16 x i32]*
%3765 = getelementptr inbounds [16 x i32], [16 x i32]* %3764, i64 0, i64 1
store i32 %3762, i32* %3765
%3766 = add i32 %3721, %3762
%3767 = add i32 %3766, -899497514
%3768 = load i32, i32* %5
%3769 = shl i32 %3768, 5
%3770 = load i32, i32* %5
%3771 = lshr i32 %3770, 27
%3772 = or i32 %3769, %3771
%3773 = add i32 %3767, %3772
%3774 = load i32, i32* %9
%3775 = add i32 %3774, %3773
store i32 %3775, i32* %9
%3776 = load i32, i32* %6
%3777 = shl i32 %3776, 30
%3778 = load i32, i32* %6
%3779 = lshr i32 %3778, 2
%3780 = or i32 %3777, %3779
store i32 %3780, i32* %6
%3781 = load i32, i32* %5
%3782 = load i32, i32* %6
%3783 = xor i32 %3781, %3782
%3784 = load i32, i32* %7
%3785 = xor i32 %3783, %3784
%3786 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3787 = bitcast %union.CHAR64LONG16* %3786 to [16 x i32]*
%3788 = getelementptr inbounds [16 x i32], [16 x i32]* %3787, i64 0, i64 15
%3789 = load i32, i32* %3788
%3790 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3791 = bitcast %union.CHAR64LONG16* %3790 to [16 x i32]*
%3792 = getelementptr inbounds [16 x i32], [16 x i32]* %3791, i64 0, i64 10
%3793 = load i32, i32* %3792
%3794 = xor i32 %3789, %3793
%3795 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3796 = bitcast %union.CHAR64LONG16* %3795 to [16 x i32]*
%3797 = getelementptr inbounds [16 x i32], [16 x i32]* %3796, i64 0, i64 4
%3798 = load i32, i32* %3797
%3799 = xor i32 %3794, %3798
%3800 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3801 = bitcast %union.CHAR64LONG16* %3800 to [16 x i32]*
%3802 = getelementptr inbounds [16 x i32], [16 x i32]* %3801, i64 0, i64 2
%3803 = load i32, i32* %3802
%3804 = xor i32 %3799, %3803
%3805 = shl i32 %3804, 1
%3806 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3807 = bitcast %union.CHAR64LONG16* %3806 to [16 x i32]*
%3808 = getelementptr inbounds [16 x i32], [16 x i32]* %3807, i64 0, i64 15
%3809 = load i32, i32* %3808
%3810 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3811 = bitcast %union.CHAR64LONG16* %3810 to [16 x i32]*
%3812 = getelementptr inbounds [16 x i32], [16 x i32]* %3811, i64 0, i64 10
%3813 = load i32, i32* %3812
%3814 = xor i32 %3809, %3813
%3815 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3816 = bitcast %union.CHAR64LONG16* %3815 to [16 x i32]*
%3817 = getelementptr inbounds [16 x i32], [16 x i32]* %3816, i64 0, i64 4
%3818 = load i32, i32* %3817
%3819 = xor i32 %3814, %3818
%3820 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3821 = bitcast %union.CHAR64LONG16* %3820 to [16 x i32]*
%3822 = getelementptr inbounds [16 x i32], [16 x i32]* %3821, i64 0, i64 2
%3823 = load i32, i32* %3822
%3824 = xor i32 %3819, %3823
%3825 = lshr i32 %3824, 31
%3826 = or i32 %3805, %3825
%3827 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3828 = bitcast %union.CHAR64LONG16* %3827 to [16 x i32]*
%3829 = getelementptr inbounds [16 x i32], [16 x i32]* %3828, i64 0, i64 2
store i32 %3826, i32* %3829
%3830 = add i32 %3785, %3826
%3831 = add i32 %3830, -899497514
%3832 = load i32, i32* %9
%3833 = shl i32 %3832, 5
%3834 = load i32, i32* %9
%3835 = lshr i32 %3834, 27
%3836 = or i32 %3833, %3835
%3837 = add i32 %3831, %3836
%3838 = load i32, i32* %8
%3839 = add i32 %3838, %3837
store i32 %3839, i32* %8
%3840 = load i32, i32* %5
%3841 = shl i32 %3840, 30
%3842 = load i32, i32* %5
%3843 = lshr i32 %3842, 2
%3844 = or i32 %3841, %3843
store i32 %3844, i32* %5
%3845 = load i32, i32* %9
%3846 = load i32, i32* %5
%3847 = xor i32 %3845, %3846
%3848 = load i32, i32* %6
%3849 = xor i32 %3847, %3848
%3850 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3851 = bitcast %union.CHAR64LONG16* %3850 to [16 x i32]*
%3852 = getelementptr inbounds [16 x i32], [16 x i32]* %3851, i64 0, i64 0
%3853 = load i32, i32* %3852
%3854 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3855 = bitcast %union.CHAR64LONG16* %3854 to [16 x i32]*
%3856 = getelementptr inbounds [16 x i32], [16 x i32]* %3855, i64 0, i64 11
%3857 = load i32, i32* %3856
%3858 = xor i32 %3853, %3857
%3859 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3860 = bitcast %union.CHAR64LONG16* %3859 to [16 x i32]*
%3861 = getelementptr inbounds [16 x i32], [16 x i32]* %3860, i64 0, i64 5
%3862 = load i32, i32* %3861
%3863 = xor i32 %3858, %3862
%3864 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3865 = bitcast %union.CHAR64LONG16* %3864 to [16 x i32]*
%3866 = getelementptr inbounds [16 x i32], [16 x i32]* %3865, i64 0, i64 3
%3867 = load i32, i32* %3866
%3868 = xor i32 %3863, %3867
%3869 = shl i32 %3868, 1
%3870 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3871 = bitcast %union.CHAR64LONG16* %3870 to [16 x i32]*
%3872 = getelementptr inbounds [16 x i32], [16 x i32]* %3871, i64 0, i64 0
%3873 = load i32, i32* %3872
%3874 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3875 = bitcast %union.CHAR64LONG16* %3874 to [16 x i32]*
%3876 = getelementptr inbounds [16 x i32], [16 x i32]* %3875, i64 0, i64 11
%3877 = load i32, i32* %3876
%3878 = xor i32 %3873, %3877
%3879 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3880 = bitcast %union.CHAR64LONG16* %3879 to [16 x i32]*
%3881 = getelementptr inbounds [16 x i32], [16 x i32]* %3880, i64 0, i64 5
%3882 = load i32, i32* %3881
%3883 = xor i32 %3878, %3882
%3884 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3885 = bitcast %union.CHAR64LONG16* %3884 to [16 x i32]*
%3886 = getelementptr inbounds [16 x i32], [16 x i32]* %3885, i64 0, i64 3
%3887 = load i32, i32* %3886
%3888 = xor i32 %3883, %3887
%3889 = lshr i32 %3888, 31
%3890 = or i32 %3869, %3889
%3891 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3892 = bitcast %union.CHAR64LONG16* %3891 to [16 x i32]*
%3893 = getelementptr inbounds [16 x i32], [16 x i32]* %3892, i64 0, i64 3
store i32 %3890, i32* %3893
%3894 = add i32 %3849, %3890
%3895 = add i32 %3894, -899497514
%3896 = load i32, i32* %8
%3897 = shl i32 %3896, 5
%3898 = load i32, i32* %8
%3899 = lshr i32 %3898, 27
%3900 = or i32 %3897, %3899
%3901 = add i32 %3895, %3900
%3902 = load i32, i32* %7
%3903 = add i32 %3902, %3901
store i32 %3903, i32* %7
%3904 = load i32, i32* %9
%3905 = shl i32 %3904, 30
%3906 = load i32, i32* %9
%3907 = lshr i32 %3906, 2
%3908 = or i32 %3905, %3907
store i32 %3908, i32* %9
%3909 = load i32, i32* %8
%3910 = load i32, i32* %9
%3911 = xor i32 %3909, %3910
%3912 = load i32, i32* %5
%3913 = xor i32 %3911, %3912
%3914 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3915 = bitcast %union.CHAR64LONG16* %3914 to [16 x i32]*
%3916 = getelementptr inbounds [16 x i32], [16 x i32]* %3915, i64 0, i64 1
%3917 = load i32, i32* %3916
%3918 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3919 = bitcast %union.CHAR64LONG16* %3918 to [16 x i32]*
%3920 = getelementptr inbounds [16 x i32], [16 x i32]* %3919, i64 0, i64 12
%3921 = load i32, i32* %3920
%3922 = xor i32 %3917, %3921
%3923 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3924 = bitcast %union.CHAR64LONG16* %3923 to [16 x i32]*
%3925 = getelementptr inbounds [16 x i32], [16 x i32]* %3924, i64 0, i64 6
%3926 = load i32, i32* %3925
%3927 = xor i32 %3922, %3926
%3928 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3929 = bitcast %union.CHAR64LONG16* %3928 to [16 x i32]*
%3930 = getelementptr inbounds [16 x i32], [16 x i32]* %3929, i64 0, i64 4
%3931 = load i32, i32* %3930
%3932 = xor i32 %3927, %3931
%3933 = shl i32 %3932, 1
%3934 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3935 = bitcast %union.CHAR64LONG16* %3934 to [16 x i32]*
%3936 = getelementptr inbounds [16 x i32], [16 x i32]* %3935, i64 0, i64 1
%3937 = load i32, i32* %3936
%3938 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3939 = bitcast %union.CHAR64LONG16* %3938 to [16 x i32]*
%3940 = getelementptr inbounds [16 x i32], [16 x i32]* %3939, i64 0, i64 12
%3941 = load i32, i32* %3940
%3942 = xor i32 %3937, %3941
%3943 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3944 = bitcast %union.CHAR64LONG16* %3943 to [16 x i32]*
%3945 = getelementptr inbounds [16 x i32], [16 x i32]* %3944, i64 0, i64 6
%3946 = load i32, i32* %3945
%3947 = xor i32 %3942, %3946
%3948 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3949 = bitcast %union.CHAR64LONG16* %3948 to [16 x i32]*
%3950 = getelementptr inbounds [16 x i32], [16 x i32]* %3949, i64 0, i64 4
%3951 = load i32, i32* %3950
%3952 = xor i32 %3947, %3951
%3953 = lshr i32 %3952, 31
%3954 = or i32 %3933, %3953
%3955 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3956 = bitcast %union.CHAR64LONG16* %3955 to [16 x i32]*
%3957 = getelementptr inbounds [16 x i32], [16 x i32]* %3956, i64 0, i64 4
store i32 %3954, i32* %3957
%3958 = add i32 %3913, %3954
%3959 = add i32 %3958, -899497514
%3960 = load i32, i32* %7
%3961 = shl i32 %3960, 5
%3962 = load i32, i32* %7
%3963 = lshr i32 %3962, 27
%3964 = or i32 %3961, %3963
%3965 = add i32 %3959, %3964
%3966 = load i32, i32* %6
%3967 = add i32 %3966, %3965
store i32 %3967, i32* %6
%3968 = load i32, i32* %8
%3969 = shl i32 %3968, 30
%3970 = load i32, i32* %8
%3971 = lshr i32 %3970, 2
%3972 = or i32 %3969, %3971
store i32 %3972, i32* %8
%3973 = load i32, i32* %7
%3974 = load i32, i32* %8
%3975 = xor i32 %3973, %3974
%3976 = load i32, i32* %9
%3977 = xor i32 %3975, %3976
%3978 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3979 = bitcast %union.CHAR64LONG16* %3978 to [16 x i32]*
%3980 = getelementptr inbounds [16 x i32], [16 x i32]* %3979, i64 0, i64 2
%3981 = load i32, i32* %3980
%3982 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3983 = bitcast %union.CHAR64LONG16* %3982 to [16 x i32]*
%3984 = getelementptr inbounds [16 x i32], [16 x i32]* %3983, i64 0, i64 13
%3985 = load i32, i32* %3984
%3986 = xor i32 %3981, %3985
%3987 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3988 = bitcast %union.CHAR64LONG16* %3987 to [16 x i32]*
%3989 = getelementptr inbounds [16 x i32], [16 x i32]* %3988, i64 0, i64 7
%3990 = load i32, i32* %3989
%3991 = xor i32 %3986, %3990
%3992 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3993 = bitcast %union.CHAR64LONG16* %3992 to [16 x i32]*
%3994 = getelementptr inbounds [16 x i32], [16 x i32]* %3993, i64 0, i64 5
%3995 = load i32, i32* %3994
%3996 = xor i32 %3991, %3995
%3997 = shl i32 %3996, 1
%3998 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%3999 = bitcast %union.CHAR64LONG16* %3998 to [16 x i32]*
%4000 = getelementptr inbounds [16 x i32], [16 x i32]* %3999, i64 0, i64 2
%4001 = load i32, i32* %4000
%4002 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4003 = bitcast %union.CHAR64LONG16* %4002 to [16 x i32]*
%4004 = getelementptr inbounds [16 x i32], [16 x i32]* %4003, i64 0, i64 13
%4005 = load i32, i32* %4004
%4006 = xor i32 %4001, %4005
%4007 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4008 = bitcast %union.CHAR64LONG16* %4007 to [16 x i32]*
%4009 = getelementptr inbounds [16 x i32], [16 x i32]* %4008, i64 0, i64 7
%4010 = load i32, i32* %4009
%4011 = xor i32 %4006, %4010
%4012 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4013 = bitcast %union.CHAR64LONG16* %4012 to [16 x i32]*
%4014 = getelementptr inbounds [16 x i32], [16 x i32]* %4013, i64 0, i64 5
%4015 = load i32, i32* %4014
%4016 = xor i32 %4011, %4015
%4017 = lshr i32 %4016, 31
%4018 = or i32 %3997, %4017
%4019 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4020 = bitcast %union.CHAR64LONG16* %4019 to [16 x i32]*
%4021 = getelementptr inbounds [16 x i32], [16 x i32]* %4020, i64 0, i64 5
store i32 %4018, i32* %4021
%4022 = add i32 %3977, %4018
%4023 = add i32 %4022, -899497514
%4024 = load i32, i32* %6
%4025 = shl i32 %4024, 5
%4026 = load i32, i32* %6
%4027 = lshr i32 %4026, 27
%4028 = or i32 %4025, %4027
%4029 = add i32 %4023, %4028
%4030 = load i32, i32* %5
%4031 = add i32 %4030, %4029
store i32 %4031, i32* %5
%4032 = load i32, i32* %7
%4033 = shl i32 %4032, 30
%4034 = load i32, i32* %7
%4035 = lshr i32 %4034, 2
%4036 = or i32 %4033, %4035
store i32 %4036, i32* %7
%4037 = load i32, i32* %6
%4038 = load i32, i32* %7
%4039 = xor i32 %4037, %4038
%4040 = load i32, i32* %8
%4041 = xor i32 %4039, %4040
%4042 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4043 = bitcast %union.CHAR64LONG16* %4042 to [16 x i32]*
%4044 = getelementptr inbounds [16 x i32], [16 x i32]* %4043, i64 0, i64 3
%4045 = load i32, i32* %4044
%4046 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4047 = bitcast %union.CHAR64LONG16* %4046 to [16 x i32]*
%4048 = getelementptr inbounds [16 x i32], [16 x i32]* %4047, i64 0, i64 14
%4049 = load i32, i32* %4048
%4050 = xor i32 %4045, %4049
%4051 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4052 = bitcast %union.CHAR64LONG16* %4051 to [16 x i32]*
%4053 = getelementptr inbounds [16 x i32], [16 x i32]* %4052, i64 0, i64 8
%4054 = load i32, i32* %4053
%4055 = xor i32 %4050, %4054
%4056 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4057 = bitcast %union.CHAR64LONG16* %4056 to [16 x i32]*
%4058 = getelementptr inbounds [16 x i32], [16 x i32]* %4057, i64 0, i64 6
%4059 = load i32, i32* %4058
%4060 = xor i32 %4055, %4059
%4061 = shl i32 %4060, 1
%4062 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4063 = bitcast %union.CHAR64LONG16* %4062 to [16 x i32]*
%4064 = getelementptr inbounds [16 x i32], [16 x i32]* %4063, i64 0, i64 3
%4065 = load i32, i32* %4064
%4066 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4067 = bitcast %union.CHAR64LONG16* %4066 to [16 x i32]*
%4068 = getelementptr inbounds [16 x i32], [16 x i32]* %4067, i64 0, i64 14
%4069 = load i32, i32* %4068
%4070 = xor i32 %4065, %4069
%4071 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4072 = bitcast %union.CHAR64LONG16* %4071 to [16 x i32]*
%4073 = getelementptr inbounds [16 x i32], [16 x i32]* %4072, i64 0, i64 8
%4074 = load i32, i32* %4073
%4075 = xor i32 %4070, %4074
%4076 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4077 = bitcast %union.CHAR64LONG16* %4076 to [16 x i32]*
%4078 = getelementptr inbounds [16 x i32], [16 x i32]* %4077, i64 0, i64 6
%4079 = load i32, i32* %4078
%4080 = xor i32 %4075, %4079
%4081 = lshr i32 %4080, 31
%4082 = or i32 %4061, %4081
%4083 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4084 = bitcast %union.CHAR64LONG16* %4083 to [16 x i32]*
%4085 = getelementptr inbounds [16 x i32], [16 x i32]* %4084, i64 0, i64 6
store i32 %4082, i32* %4085
%4086 = add i32 %4041, %4082
%4087 = add i32 %4086, -899497514
%4088 = load i32, i32* %5
%4089 = shl i32 %4088, 5
%4090 = load i32, i32* %5
%4091 = lshr i32 %4090, 27
%4092 = or i32 %4089, %4091
%4093 = add i32 %4087, %4092
%4094 = load i32, i32* %9
%4095 = add i32 %4094, %4093
store i32 %4095, i32* %9
%4096 = load i32, i32* %6
%4097 = shl i32 %4096, 30
%4098 = load i32, i32* %6
%4099 = lshr i32 %4098, 2
%4100 = or i32 %4097, %4099
store i32 %4100, i32* %6
%4101 = load i32, i32* %5
%4102 = load i32, i32* %6
%4103 = xor i32 %4101, %4102
%4104 = load i32, i32* %7
%4105 = xor i32 %4103, %4104
%4106 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4107 = bitcast %union.CHAR64LONG16* %4106 to [16 x i32]*
%4108 = getelementptr inbounds [16 x i32], [16 x i32]* %4107, i64 0, i64 4
%4109 = load i32, i32* %4108
%4110 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4111 = bitcast %union.CHAR64LONG16* %4110 to [16 x i32]*
%4112 = getelementptr inbounds [16 x i32], [16 x i32]* %4111, i64 0, i64 15
%4113 = load i32, i32* %4112
%4114 = xor i32 %4109, %4113
%4115 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4116 = bitcast %union.CHAR64LONG16* %4115 to [16 x i32]*
%4117 = getelementptr inbounds [16 x i32], [16 x i32]* %4116, i64 0, i64 9
%4118 = load i32, i32* %4117
%4119 = xor i32 %4114, %4118
%4120 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4121 = bitcast %union.CHAR64LONG16* %4120 to [16 x i32]*
%4122 = getelementptr inbounds [16 x i32], [16 x i32]* %4121, i64 0, i64 7
%4123 = load i32, i32* %4122
%4124 = xor i32 %4119, %4123
%4125 = shl i32 %4124, 1
%4126 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4127 = bitcast %union.CHAR64LONG16* %4126 to [16 x i32]*
%4128 = getelementptr inbounds [16 x i32], [16 x i32]* %4127, i64 0, i64 4
%4129 = load i32, i32* %4128
%4130 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4131 = bitcast %union.CHAR64LONG16* %4130 to [16 x i32]*
%4132 = getelementptr inbounds [16 x i32], [16 x i32]* %4131, i64 0, i64 15
%4133 = load i32, i32* %4132
%4134 = xor i32 %4129, %4133
%4135 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4136 = bitcast %union.CHAR64LONG16* %4135 to [16 x i32]*
%4137 = getelementptr inbounds [16 x i32], [16 x i32]* %4136, i64 0, i64 9
%4138 = load i32, i32* %4137
%4139 = xor i32 %4134, %4138
%4140 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4141 = bitcast %union.CHAR64LONG16* %4140 to [16 x i32]*
%4142 = getelementptr inbounds [16 x i32], [16 x i32]* %4141, i64 0, i64 7
%4143 = load i32, i32* %4142
%4144 = xor i32 %4139, %4143
%4145 = lshr i32 %4144, 31
%4146 = or i32 %4125, %4145
%4147 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4148 = bitcast %union.CHAR64LONG16* %4147 to [16 x i32]*
%4149 = getelementptr inbounds [16 x i32], [16 x i32]* %4148, i64 0, i64 7
store i32 %4146, i32* %4149
%4150 = add i32 %4105, %4146
%4151 = add i32 %4150, -899497514
%4152 = load i32, i32* %9
%4153 = shl i32 %4152, 5
%4154 = load i32, i32* %9
%4155 = lshr i32 %4154, 27
%4156 = or i32 %4153, %4155
%4157 = add i32 %4151, %4156
%4158 = load i32, i32* %8
%4159 = add i32 %4158, %4157
store i32 %4159, i32* %8
%4160 = load i32, i32* %5
%4161 = shl i32 %4160, 30
%4162 = load i32, i32* %5
%4163 = lshr i32 %4162, 2
%4164 = or i32 %4161, %4163
store i32 %4164, i32* %5
%4165 = load i32, i32* %9
%4166 = load i32, i32* %5
%4167 = xor i32 %4165, %4166
%4168 = load i32, i32* %6
%4169 = xor i32 %4167, %4168
%4170 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4171 = bitcast %union.CHAR64LONG16* %4170 to [16 x i32]*
%4172 = getelementptr inbounds [16 x i32], [16 x i32]* %4171, i64 0, i64 5
%4173 = load i32, i32* %4172
%4174 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4175 = bitcast %union.CHAR64LONG16* %4174 to [16 x i32]*
%4176 = getelementptr inbounds [16 x i32], [16 x i32]* %4175, i64 0, i64 0
%4177 = load i32, i32* %4176
%4178 = xor i32 %4173, %4177
%4179 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4180 = bitcast %union.CHAR64LONG16* %4179 to [16 x i32]*
%4181 = getelementptr inbounds [16 x i32], [16 x i32]* %4180, i64 0, i64 10
%4182 = load i32, i32* %4181
%4183 = xor i32 %4178, %4182
%4184 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4185 = bitcast %union.CHAR64LONG16* %4184 to [16 x i32]*
%4186 = getelementptr inbounds [16 x i32], [16 x i32]* %4185, i64 0, i64 8
%4187 = load i32, i32* %4186
%4188 = xor i32 %4183, %4187
%4189 = shl i32 %4188, 1
%4190 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4191 = bitcast %union.CHAR64LONG16* %4190 to [16 x i32]*
%4192 = getelementptr inbounds [16 x i32], [16 x i32]* %4191, i64 0, i64 5
%4193 = load i32, i32* %4192
%4194 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4195 = bitcast %union.CHAR64LONG16* %4194 to [16 x i32]*
%4196 = getelementptr inbounds [16 x i32], [16 x i32]* %4195, i64 0, i64 0
%4197 = load i32, i32* %4196
%4198 = xor i32 %4193, %4197
%4199 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4200 = bitcast %union.CHAR64LONG16* %4199 to [16 x i32]*
%4201 = getelementptr inbounds [16 x i32], [16 x i32]* %4200, i64 0, i64 10
%4202 = load i32, i32* %4201
%4203 = xor i32 %4198, %4202
%4204 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4205 = bitcast %union.CHAR64LONG16* %4204 to [16 x i32]*
%4206 = getelementptr inbounds [16 x i32], [16 x i32]* %4205, i64 0, i64 8
%4207 = load i32, i32* %4206
%4208 = xor i32 %4203, %4207
%4209 = lshr i32 %4208, 31
%4210 = or i32 %4189, %4209
%4211 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4212 = bitcast %union.CHAR64LONG16* %4211 to [16 x i32]*
%4213 = getelementptr inbounds [16 x i32], [16 x i32]* %4212, i64 0, i64 8
store i32 %4210, i32* %4213
%4214 = add i32 %4169, %4210
%4215 = add i32 %4214, -899497514
%4216 = load i32, i32* %8
%4217 = shl i32 %4216, 5
%4218 = load i32, i32* %8
%4219 = lshr i32 %4218, 27
%4220 = or i32 %4217, %4219
%4221 = add i32 %4215, %4220
%4222 = load i32, i32* %7
%4223 = add i32 %4222, %4221
store i32 %4223, i32* %7
%4224 = load i32, i32* %9
%4225 = shl i32 %4224, 30
%4226 = load i32, i32* %9
%4227 = lshr i32 %4226, 2
%4228 = or i32 %4225, %4227
store i32 %4228, i32* %9
%4229 = load i32, i32* %8
%4230 = load i32, i32* %9
%4231 = xor i32 %4229, %4230
%4232 = load i32, i32* %5
%4233 = xor i32 %4231, %4232
%4234 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4235 = bitcast %union.CHAR64LONG16* %4234 to [16 x i32]*
%4236 = getelementptr inbounds [16 x i32], [16 x i32]* %4235, i64 0, i64 6
%4237 = load i32, i32* %4236
%4238 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4239 = bitcast %union.CHAR64LONG16* %4238 to [16 x i32]*
%4240 = getelementptr inbounds [16 x i32], [16 x i32]* %4239, i64 0, i64 1
%4241 = load i32, i32* %4240
%4242 = xor i32 %4237, %4241
%4243 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4244 = bitcast %union.CHAR64LONG16* %4243 to [16 x i32]*
%4245 = getelementptr inbounds [16 x i32], [16 x i32]* %4244, i64 0, i64 11
%4246 = load i32, i32* %4245
%4247 = xor i32 %4242, %4246
%4248 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4249 = bitcast %union.CHAR64LONG16* %4248 to [16 x i32]*
%4250 = getelementptr inbounds [16 x i32], [16 x i32]* %4249, i64 0, i64 9
%4251 = load i32, i32* %4250
%4252 = xor i32 %4247, %4251
%4253 = shl i32 %4252, 1
%4254 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4255 = bitcast %union.CHAR64LONG16* %4254 to [16 x i32]*
%4256 = getelementptr inbounds [16 x i32], [16 x i32]* %4255, i64 0, i64 6
%4257 = load i32, i32* %4256
%4258 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4259 = bitcast %union.CHAR64LONG16* %4258 to [16 x i32]*
%4260 = getelementptr inbounds [16 x i32], [16 x i32]* %4259, i64 0, i64 1
%4261 = load i32, i32* %4260
%4262 = xor i32 %4257, %4261
%4263 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4264 = bitcast %union.CHAR64LONG16* %4263 to [16 x i32]*
%4265 = getelementptr inbounds [16 x i32], [16 x i32]* %4264, i64 0, i64 11
%4266 = load i32, i32* %4265
%4267 = xor i32 %4262, %4266
%4268 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4269 = bitcast %union.CHAR64LONG16* %4268 to [16 x i32]*
%4270 = getelementptr inbounds [16 x i32], [16 x i32]* %4269, i64 0, i64 9
%4271 = load i32, i32* %4270
%4272 = xor i32 %4267, %4271
%4273 = lshr i32 %4272, 31
%4274 = or i32 %4253, %4273
%4275 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4276 = bitcast %union.CHAR64LONG16* %4275 to [16 x i32]*
%4277 = getelementptr inbounds [16 x i32], [16 x i32]* %4276, i64 0, i64 9
store i32 %4274, i32* %4277
%4278 = add i32 %4233, %4274
%4279 = add i32 %4278, -899497514
%4280 = load i32, i32* %7
%4281 = shl i32 %4280, 5
%4282 = load i32, i32* %7
%4283 = lshr i32 %4282, 27
%4284 = or i32 %4281, %4283
%4285 = add i32 %4279, %4284
%4286 = load i32, i32* %6
%4287 = add i32 %4286, %4285
store i32 %4287, i32* %6
%4288 = load i32, i32* %8
%4289 = shl i32 %4288, 30
%4290 = load i32, i32* %8
%4291 = lshr i32 %4290, 2
%4292 = or i32 %4289, %4291
store i32 %4292, i32* %8
%4293 = load i32, i32* %7
%4294 = load i32, i32* %8
%4295 = xor i32 %4293, %4294
%4296 = load i32, i32* %9
%4297 = xor i32 %4295, %4296
%4298 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4299 = bitcast %union.CHAR64LONG16* %4298 to [16 x i32]*
%4300 = getelementptr inbounds [16 x i32], [16 x i32]* %4299, i64 0, i64 7
%4301 = load i32, i32* %4300
%4302 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4303 = bitcast %union.CHAR64LONG16* %4302 to [16 x i32]*
%4304 = getelementptr inbounds [16 x i32], [16 x i32]* %4303, i64 0, i64 2
%4305 = load i32, i32* %4304
%4306 = xor i32 %4301, %4305
%4307 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4308 = bitcast %union.CHAR64LONG16* %4307 to [16 x i32]*
%4309 = getelementptr inbounds [16 x i32], [16 x i32]* %4308, i64 0, i64 12
%4310 = load i32, i32* %4309
%4311 = xor i32 %4306, %4310
%4312 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4313 = bitcast %union.CHAR64LONG16* %4312 to [16 x i32]*
%4314 = getelementptr inbounds [16 x i32], [16 x i32]* %4313, i64 0, i64 10
%4315 = load i32, i32* %4314
%4316 = xor i32 %4311, %4315
%4317 = shl i32 %4316, 1
%4318 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4319 = bitcast %union.CHAR64LONG16* %4318 to [16 x i32]*
%4320 = getelementptr inbounds [16 x i32], [16 x i32]* %4319, i64 0, i64 7
%4321 = load i32, i32* %4320
%4322 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4323 = bitcast %union.CHAR64LONG16* %4322 to [16 x i32]*
%4324 = getelementptr inbounds [16 x i32], [16 x i32]* %4323, i64 0, i64 2
%4325 = load i32, i32* %4324
%4326 = xor i32 %4321, %4325
%4327 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4328 = bitcast %union.CHAR64LONG16* %4327 to [16 x i32]*
%4329 = getelementptr inbounds [16 x i32], [16 x i32]* %4328, i64 0, i64 12
%4330 = load i32, i32* %4329
%4331 = xor i32 %4326, %4330
%4332 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4333 = bitcast %union.CHAR64LONG16* %4332 to [16 x i32]*
%4334 = getelementptr inbounds [16 x i32], [16 x i32]* %4333, i64 0, i64 10
%4335 = load i32, i32* %4334
%4336 = xor i32 %4331, %4335
%4337 = lshr i32 %4336, 31
%4338 = or i32 %4317, %4337
%4339 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4340 = bitcast %union.CHAR64LONG16* %4339 to [16 x i32]*
%4341 = getelementptr inbounds [16 x i32], [16 x i32]* %4340, i64 0, i64 10
store i32 %4338, i32* %4341
%4342 = add i32 %4297, %4338
%4343 = add i32 %4342, -899497514
%4344 = load i32, i32* %6
%4345 = shl i32 %4344, 5
%4346 = load i32, i32* %6
%4347 = lshr i32 %4346, 27
%4348 = or i32 %4345, %4347
%4349 = add i32 %4343, %4348
%4350 = load i32, i32* %5
%4351 = add i32 %4350, %4349
store i32 %4351, i32* %5
%4352 = load i32, i32* %7
%4353 = shl i32 %4352, 30
%4354 = load i32, i32* %7
%4355 = lshr i32 %4354, 2
%4356 = or i32 %4353, %4355
store i32 %4356, i32* %7
%4357 = load i32, i32* %6
%4358 = load i32, i32* %7
%4359 = xor i32 %4357, %4358
%4360 = load i32, i32* %8
%4361 = xor i32 %4359, %4360
%4362 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4363 = bitcast %union.CHAR64LONG16* %4362 to [16 x i32]*
%4364 = getelementptr inbounds [16 x i32], [16 x i32]* %4363, i64 0, i64 8
%4365 = load i32, i32* %4364
%4366 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4367 = bitcast %union.CHAR64LONG16* %4366 to [16 x i32]*
%4368 = getelementptr inbounds [16 x i32], [16 x i32]* %4367, i64 0, i64 3
%4369 = load i32, i32* %4368
%4370 = xor i32 %4365, %4369
%4371 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4372 = bitcast %union.CHAR64LONG16* %4371 to [16 x i32]*
%4373 = getelementptr inbounds [16 x i32], [16 x i32]* %4372, i64 0, i64 13
%4374 = load i32, i32* %4373
%4375 = xor i32 %4370, %4374
%4376 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4377 = bitcast %union.CHAR64LONG16* %4376 to [16 x i32]*
%4378 = getelementptr inbounds [16 x i32], [16 x i32]* %4377, i64 0, i64 11
%4379 = load i32, i32* %4378
%4380 = xor i32 %4375, %4379
%4381 = shl i32 %4380, 1
%4382 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4383 = bitcast %union.CHAR64LONG16* %4382 to [16 x i32]*
%4384 = getelementptr inbounds [16 x i32], [16 x i32]* %4383, i64 0, i64 8
%4385 = load i32, i32* %4384
%4386 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4387 = bitcast %union.CHAR64LONG16* %4386 to [16 x i32]*
%4388 = getelementptr inbounds [16 x i32], [16 x i32]* %4387, i64 0, i64 3
%4389 = load i32, i32* %4388
%4390 = xor i32 %4385, %4389
%4391 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4392 = bitcast %union.CHAR64LONG16* %4391 to [16 x i32]*
%4393 = getelementptr inbounds [16 x i32], [16 x i32]* %4392, i64 0, i64 13
%4394 = load i32, i32* %4393
%4395 = xor i32 %4390, %4394
%4396 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4397 = bitcast %union.CHAR64LONG16* %4396 to [16 x i32]*
%4398 = getelementptr inbounds [16 x i32], [16 x i32]* %4397, i64 0, i64 11
%4399 = load i32, i32* %4398
%4400 = xor i32 %4395, %4399
%4401 = lshr i32 %4400, 31
%4402 = or i32 %4381, %4401
%4403 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4404 = bitcast %union.CHAR64LONG16* %4403 to [16 x i32]*
%4405 = getelementptr inbounds [16 x i32], [16 x i32]* %4404, i64 0, i64 11
store i32 %4402, i32* %4405
%4406 = add i32 %4361, %4402
%4407 = add i32 %4406, -899497514
%4408 = load i32, i32* %5
%4409 = shl i32 %4408, 5
%4410 = load i32, i32* %5
%4411 = lshr i32 %4410, 27
%4412 = or i32 %4409, %4411
%4413 = add i32 %4407, %4412
%4414 = load i32, i32* %9
%4415 = add i32 %4414, %4413
store i32 %4415, i32* %9
%4416 = load i32, i32* %6
%4417 = shl i32 %4416, 30
%4418 = load i32, i32* %6
%4419 = lshr i32 %4418, 2
%4420 = or i32 %4417, %4419
store i32 %4420, i32* %6
%4421 = load i32, i32* %5
%4422 = load i32, i32* %6
%4423 = xor i32 %4421, %4422
%4424 = load i32, i32* %7
%4425 = xor i32 %4423, %4424
%4426 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4427 = bitcast %union.CHAR64LONG16* %4426 to [16 x i32]*
%4428 = getelementptr inbounds [16 x i32], [16 x i32]* %4427, i64 0, i64 9
%4429 = load i32, i32* %4428
%4430 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4431 = bitcast %union.CHAR64LONG16* %4430 to [16 x i32]*
%4432 = getelementptr inbounds [16 x i32], [16 x i32]* %4431, i64 0, i64 4
%4433 = load i32, i32* %4432
%4434 = xor i32 %4429, %4433
%4435 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4436 = bitcast %union.CHAR64LONG16* %4435 to [16 x i32]*
%4437 = getelementptr inbounds [16 x i32], [16 x i32]* %4436, i64 0, i64 14
%4438 = load i32, i32* %4437
%4439 = xor i32 %4434, %4438
%4440 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4441 = bitcast %union.CHAR64LONG16* %4440 to [16 x i32]*
%4442 = getelementptr inbounds [16 x i32], [16 x i32]* %4441, i64 0, i64 12
%4443 = load i32, i32* %4442
%4444 = xor i32 %4439, %4443
%4445 = shl i32 %4444, 1
%4446 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4447 = bitcast %union.CHAR64LONG16* %4446 to [16 x i32]*
%4448 = getelementptr inbounds [16 x i32], [16 x i32]* %4447, i64 0, i64 9
%4449 = load i32, i32* %4448
%4450 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4451 = bitcast %union.CHAR64LONG16* %4450 to [16 x i32]*
%4452 = getelementptr inbounds [16 x i32], [16 x i32]* %4451, i64 0, i64 4
%4453 = load i32, i32* %4452
%4454 = xor i32 %4449, %4453
%4455 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4456 = bitcast %union.CHAR64LONG16* %4455 to [16 x i32]*
%4457 = getelementptr inbounds [16 x i32], [16 x i32]* %4456, i64 0, i64 14
%4458 = load i32, i32* %4457
%4459 = xor i32 %4454, %4458
%4460 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4461 = bitcast %union.CHAR64LONG16* %4460 to [16 x i32]*
%4462 = getelementptr inbounds [16 x i32], [16 x i32]* %4461, i64 0, i64 12
%4463 = load i32, i32* %4462
%4464 = xor i32 %4459, %4463
%4465 = lshr i32 %4464, 31
%4466 = or i32 %4445, %4465
%4467 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4468 = bitcast %union.CHAR64LONG16* %4467 to [16 x i32]*
%4469 = getelementptr inbounds [16 x i32], [16 x i32]* %4468, i64 0, i64 12
store i32 %4466, i32* %4469
%4470 = add i32 %4425, %4466
%4471 = add i32 %4470, -899497514
%4472 = load i32, i32* %9
%4473 = shl i32 %4472, 5
%4474 = load i32, i32* %9
%4475 = lshr i32 %4474, 27
%4476 = or i32 %4473, %4475
%4477 = add i32 %4471, %4476
%4478 = load i32, i32* %8
%4479 = add i32 %4478, %4477
store i32 %4479, i32* %8
%4480 = load i32, i32* %5
%4481 = shl i32 %4480, 30
%4482 = load i32, i32* %5
%4483 = lshr i32 %4482, 2
%4484 = or i32 %4481, %4483
store i32 %4484, i32* %5
%4485 = load i32, i32* %9
%4486 = load i32, i32* %5
%4487 = xor i32 %4485, %4486
%4488 = load i32, i32* %6
%4489 = xor i32 %4487, %4488
%4490 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4491 = bitcast %union.CHAR64LONG16* %4490 to [16 x i32]*
%4492 = getelementptr inbounds [16 x i32], [16 x i32]* %4491, i64 0, i64 10
%4493 = load i32, i32* %4492
%4494 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4495 = bitcast %union.CHAR64LONG16* %4494 to [16 x i32]*
%4496 = getelementptr inbounds [16 x i32], [16 x i32]* %4495, i64 0, i64 5
%4497 = load i32, i32* %4496
%4498 = xor i32 %4493, %4497
%4499 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4500 = bitcast %union.CHAR64LONG16* %4499 to [16 x i32]*
%4501 = getelementptr inbounds [16 x i32], [16 x i32]* %4500, i64 0, i64 15
%4502 = load i32, i32* %4501
%4503 = xor i32 %4498, %4502
%4504 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4505 = bitcast %union.CHAR64LONG16* %4504 to [16 x i32]*
%4506 = getelementptr inbounds [16 x i32], [16 x i32]* %4505, i64 0, i64 13
%4507 = load i32, i32* %4506
%4508 = xor i32 %4503, %4507
%4509 = shl i32 %4508, 1
%4510 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4511 = bitcast %union.CHAR64LONG16* %4510 to [16 x i32]*
%4512 = getelementptr inbounds [16 x i32], [16 x i32]* %4511, i64 0, i64 10
%4513 = load i32, i32* %4512
%4514 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4515 = bitcast %union.CHAR64LONG16* %4514 to [16 x i32]*
%4516 = getelementptr inbounds [16 x i32], [16 x i32]* %4515, i64 0, i64 5
%4517 = load i32, i32* %4516
%4518 = xor i32 %4513, %4517
%4519 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4520 = bitcast %union.CHAR64LONG16* %4519 to [16 x i32]*
%4521 = getelementptr inbounds [16 x i32], [16 x i32]* %4520, i64 0, i64 15
%4522 = load i32, i32* %4521
%4523 = xor i32 %4518, %4522
%4524 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4525 = bitcast %union.CHAR64LONG16* %4524 to [16 x i32]*
%4526 = getelementptr inbounds [16 x i32], [16 x i32]* %4525, i64 0, i64 13
%4527 = load i32, i32* %4526
%4528 = xor i32 %4523, %4527
%4529 = lshr i32 %4528, 31
%4530 = or i32 %4509, %4529
%4531 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4532 = bitcast %union.CHAR64LONG16* %4531 to [16 x i32]*
%4533 = getelementptr inbounds [16 x i32], [16 x i32]* %4532, i64 0, i64 13
store i32 %4530, i32* %4533
%4534 = add i32 %4489, %4530
%4535 = add i32 %4534, -899497514
%4536 = load i32, i32* %8
%4537 = shl i32 %4536, 5
%4538 = load i32, i32* %8
%4539 = lshr i32 %4538, 27
%4540 = or i32 %4537, %4539
%4541 = add i32 %4535, %4540
%4542 = load i32, i32* %7
%4543 = add i32 %4542, %4541
store i32 %4543, i32* %7
%4544 = load i32, i32* %9
%4545 = shl i32 %4544, 30
%4546 = load i32, i32* %9
%4547 = lshr i32 %4546, 2
%4548 = or i32 %4545, %4547
store i32 %4548, i32* %9
%4549 = load i32, i32* %8
%4550 = load i32, i32* %9
%4551 = xor i32 %4549, %4550
%4552 = load i32, i32* %5
%4553 = xor i32 %4551, %4552
%4554 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4555 = bitcast %union.CHAR64LONG16* %4554 to [16 x i32]*
%4556 = getelementptr inbounds [16 x i32], [16 x i32]* %4555, i64 0, i64 11
%4557 = load i32, i32* %4556
%4558 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4559 = bitcast %union.CHAR64LONG16* %4558 to [16 x i32]*
%4560 = getelementptr inbounds [16 x i32], [16 x i32]* %4559, i64 0, i64 6
%4561 = load i32, i32* %4560
%4562 = xor i32 %4557, %4561
%4563 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4564 = bitcast %union.CHAR64LONG16* %4563 to [16 x i32]*
%4565 = getelementptr inbounds [16 x i32], [16 x i32]* %4564, i64 0, i64 0
%4566 = load i32, i32* %4565
%4567 = xor i32 %4562, %4566
%4568 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4569 = bitcast %union.CHAR64LONG16* %4568 to [16 x i32]*
%4570 = getelementptr inbounds [16 x i32], [16 x i32]* %4569, i64 0, i64 14
%4571 = load i32, i32* %4570
%4572 = xor i32 %4567, %4571
%4573 = shl i32 %4572, 1
%4574 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4575 = bitcast %union.CHAR64LONG16* %4574 to [16 x i32]*
%4576 = getelementptr inbounds [16 x i32], [16 x i32]* %4575, i64 0, i64 11
%4577 = load i32, i32* %4576
%4578 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4579 = bitcast %union.CHAR64LONG16* %4578 to [16 x i32]*
%4580 = getelementptr inbounds [16 x i32], [16 x i32]* %4579, i64 0, i64 6
%4581 = load i32, i32* %4580
%4582 = xor i32 %4577, %4581
%4583 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4584 = bitcast %union.CHAR64LONG16* %4583 to [16 x i32]*
%4585 = getelementptr inbounds [16 x i32], [16 x i32]* %4584, i64 0, i64 0
%4586 = load i32, i32* %4585
%4587 = xor i32 %4582, %4586
%4588 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4589 = bitcast %union.CHAR64LONG16* %4588 to [16 x i32]*
%4590 = getelementptr inbounds [16 x i32], [16 x i32]* %4589, i64 0, i64 14
%4591 = load i32, i32* %4590
%4592 = xor i32 %4587, %4591
%4593 = lshr i32 %4592, 31
%4594 = or i32 %4573, %4593
%4595 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4596 = bitcast %union.CHAR64LONG16* %4595 to [16 x i32]*
%4597 = getelementptr inbounds [16 x i32], [16 x i32]* %4596, i64 0, i64 14
store i32 %4594, i32* %4597
%4598 = add i32 %4553, %4594
%4599 = add i32 %4598, -899497514
%4600 = load i32, i32* %7
%4601 = shl i32 %4600, 5
%4602 = load i32, i32* %7
%4603 = lshr i32 %4602, 27
%4604 = or i32 %4601, %4603
%4605 = add i32 %4599, %4604
%4606 = load i32, i32* %6
%4607 = add i32 %4606, %4605
store i32 %4607, i32* %6
%4608 = load i32, i32* %8
%4609 = shl i32 %4608, 30
%4610 = load i32, i32* %8
%4611 = lshr i32 %4610, 2
%4612 = or i32 %4609, %4611
store i32 %4612, i32* %8
%4613 = load i32, i32* %7
%4614 = load i32, i32* %8
%4615 = xor i32 %4613, %4614
%4616 = load i32, i32* %9
%4617 = xor i32 %4615, %4616
%4618 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4619 = bitcast %union.CHAR64LONG16* %4618 to [16 x i32]*
%4620 = getelementptr inbounds [16 x i32], [16 x i32]* %4619, i64 0, i64 12
%4621 = load i32, i32* %4620
%4622 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4623 = bitcast %union.CHAR64LONG16* %4622 to [16 x i32]*
%4624 = getelementptr inbounds [16 x i32], [16 x i32]* %4623, i64 0, i64 7
%4625 = load i32, i32* %4624
%4626 = xor i32 %4621, %4625
%4627 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4628 = bitcast %union.CHAR64LONG16* %4627 to [16 x i32]*
%4629 = getelementptr inbounds [16 x i32], [16 x i32]* %4628, i64 0, i64 1
%4630 = load i32, i32* %4629
%4631 = xor i32 %4626, %4630
%4632 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4633 = bitcast %union.CHAR64LONG16* %4632 to [16 x i32]*
%4634 = getelementptr inbounds [16 x i32], [16 x i32]* %4633, i64 0, i64 15
%4635 = load i32, i32* %4634
%4636 = xor i32 %4631, %4635
%4637 = shl i32 %4636, 1
%4638 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4639 = bitcast %union.CHAR64LONG16* %4638 to [16 x i32]*
%4640 = getelementptr inbounds [16 x i32], [16 x i32]* %4639, i64 0, i64 12
%4641 = load i32, i32* %4640
%4642 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4643 = bitcast %union.CHAR64LONG16* %4642 to [16 x i32]*
%4644 = getelementptr inbounds [16 x i32], [16 x i32]* %4643, i64 0, i64 7
%4645 = load i32, i32* %4644
%4646 = xor i32 %4641, %4645
%4647 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4648 = bitcast %union.CHAR64LONG16* %4647 to [16 x i32]*
%4649 = getelementptr inbounds [16 x i32], [16 x i32]* %4648, i64 0, i64 1
%4650 = load i32, i32* %4649
%4651 = xor i32 %4646, %4650
%4652 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4653 = bitcast %union.CHAR64LONG16* %4652 to [16 x i32]*
%4654 = getelementptr inbounds [16 x i32], [16 x i32]* %4653, i64 0, i64 15
%4655 = load i32, i32* %4654
%4656 = xor i32 %4651, %4655
%4657 = lshr i32 %4656, 31
%4658 = or i32 %4637, %4657
%4659 = load %union.CHAR64LONG16*, %union.CHAR64LONG16** %10
%4660 = bitcast %union.CHAR64LONG16* %4659 to [16 x i32]*
%4661 = getelementptr inbounds [16 x i32], [16 x i32]* %4660, i64 0, i64 15
store i32 %4658, i32* %4661
%4662 = add i32 %4617, %4658
%4663 = add i32 %4662, -899497514
%4664 = load i32, i32* %6
%4665 = shl i32 %4664, 5
%4666 = load i32, i32* %6
%4667 = lshr i32 %4666, 27
%4668 = or i32 %4665, %4667
%4669 = add i32 %4663, %4668
%4670 = load i32, i32* %5
%4671 = add i32 %4670, %4669
store i32 %4671, i32* %5
%4672 = load i32, i32* %7
%4673 = shl i32 %4672, 30
%4674 = load i32, i32* %7
%4675 = lshr i32 %4674, 2
%4676 = or i32 %4673, %4675
store i32 %4676, i32* %7
%4677 = load i32, i32* %5
%4678 = load i32*, i32** %3
%4679 = getelementptr inbounds i32, i32* %4678, i64 0
%4680 = load i32, i32* %4679
%4681 = add i32 %4680, %4677
store i32 %4681, i32* %4679
%4682 = load i32, i32* %6
%4683 = load i32*, i32** %3
%4684 = getelementptr inbounds i32, i32* %4683, i64 1
%4685 = load i32, i32* %4684
%4686 = add i32 %4685, %4682
store i32 %4686, i32* %4684
%4687 = load i32, i32* %7
%4688 = load i32*, i32** %3
%4689 = getelementptr inbounds i32, i32* %4688, i64 2
%4690 = load i32, i32* %4689
%4691 = add i32 %4690, %4687
store i32 %4691, i32* %4689
%4692 = load i32, i32* %8
%4693 = load i32*, i32** %3
%4694 = getelementptr inbounds i32, i32* %4693, i64 3
%4695 = load i32, i32* %4694
%4696 = add i32 %4695, %4692
store i32 %4696, i32* %4694
%4697 = load i32, i32* %9
%4698 = load i32*, i32** %3
%4699 = getelementptr inbounds i32, i32* %4698, i64 4
%4700 = load i32, i32* %4699
%4701 = add i32 %4700, %4697
store i32 %4701, i32* %4699
store i32 0, i32* %9
store i32 0, i32* %8
store i32 0, i32* %7
store i32 0, i32* %6
store i32 0, i32* %5
ret void
}

LLVM IR (-O2):
@SHA1Transform.workspace = internal unnamed_addr global [64 x i8] zeroinitializer
define void @SHA1Transform(i32* nocapture %0, i8* nocapture %1) {
tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 16 dereferenceable(64) getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 0), i8* align 1 dereferenceable(64) %1, i64 64, i1 false)
%3 = load i32, i32* %0
%4 = getelementptr inbounds i32, i32* %0, i64 1
%5 = load i32, i32* %4
%6 = getelementptr inbounds i32, i32* %0, i64 2
%7 = load i32, i32* %6
%8 = getelementptr inbounds i32, i32* %0, i64 3
%9 = load i32, i32* %8
%10 = getelementptr inbounds i32, i32* %0, i64 4
%11 = load i32, i32* %10
%12 = xor i32 %9, %7
%13 = and i32 %12, %5
%14 = xor i32 %13, %9
%15 = load i32, i32* bitcast ([64 x i8]* @SHA1Transform.workspace to i32*)
%16 = tail call i32 @llvm.fshl.i32(i32 %3, i32 %3, i32 5)
%17 = add i32 %16, 1518500249
%18 = add i32 %17, %11
%19 = add i32 %18, %15
%20 = add i32 %19, %14
%21 = tail call i32 @llvm.fshl.i32(i32 %5, i32 %5, i32 30)
%22 = xor i32 %21, %7
%23 = and i32 %22, %3
%24 = xor i32 %23, %7
%25 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 4) to i32*)
%26 = tail call i32 @llvm.fshl.i32(i32 %20, i32 %20, i32 5)
%27 = add i32 %9, 1518500249
%28 = add i32 %27, %24
%29 = add i32 %28, %25
%30 = add i32 %29, %26
%31 = tail call i32 @llvm.fshl.i32(i32 %3, i32 %3, i32 30)
%32 = xor i32 %21, %31
%33 = and i32 %20, %32
%34 = xor i32 %33, %21
%35 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 8) to i32*)
%36 = tail call i32 @llvm.fshl.i32(i32 %30, i32 %30, i32 5)
%37 = add i32 %7, 1518500249
%38 = add i32 %37, %35
%39 = add i32 %38, %34
%40 = add i32 %39, %36
%41 = tail call i32 @llvm.fshl.i32(i32 %20, i32 %20, i32 30)
%42 = xor i32 %41, %31
%43 = and i32 %30, %42
%44 = xor i32 %43, %31
%45 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 12) to i32*)
%46 = tail call i32 @llvm.fshl.i32(i32 %40, i32 %40, i32 5)
%47 = add i32 %21, 1518500249
%48 = add i32 %47, %45
%49 = add i32 %48, %44
%50 = add i32 %49, %46
%51 = tail call i32 @llvm.fshl.i32(i32 %30, i32 %30, i32 30)
%52 = xor i32 %51, %41
%53 = and i32 %40, %52
%54 = xor i32 %53, %41
%55 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 16) to i32*)
%56 = tail call i32 @llvm.fshl.i32(i32 %50, i32 %50, i32 5)
%57 = add i32 %31, 1518500249
%58 = add i32 %57, %55
%59 = add i32 %58, %54
%60 = add i32 %59, %56
%61 = tail call i32 @llvm.fshl.i32(i32 %40, i32 %40, i32 30)
%62 = xor i32 %61, %51
%63 = and i32 %50, %62
%64 = xor i32 %63, %51
%65 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 20) to i32*)
%66 = tail call i32 @llvm.fshl.i32(i32 %60, i32 %60, i32 5)
%67 = add i32 %65, 1518500249
%68 = add i32 %67, %41
%69 = add i32 %68, %64
%70 = add i32 %69, %66
%71 = tail call i32 @llvm.fshl.i32(i32 %50, i32 %50, i32 30)
%72 = xor i32 %71, %61
%73 = and i32 %60, %72
%74 = xor i32 %73, %61
%75 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 24) to i32*)
%76 = tail call i32 @llvm.fshl.i32(i32 %70, i32 %70, i32 5)
%77 = add i32 %75, 1518500249
%78 = add i32 %77, %51
%79 = add i32 %78, %74
%80 = add i32 %79, %76
%81 = tail call i32 @llvm.fshl.i32(i32 %60, i32 %60, i32 30)
%82 = xor i32 %81, %71
%83 = and i32 %70, %82
%84 = xor i32 %83, %71
%85 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 28) to i32*)
%86 = tail call i32 @llvm.fshl.i32(i32 %80, i32 %80, i32 5)
%87 = add i32 %85, 1518500249
%88 = add i32 %87, %61
%89 = add i32 %88, %84
%90 = add i32 %89, %86
%91 = tail call i32 @llvm.fshl.i32(i32 %70, i32 %70, i32 30)
%92 = xor i32 %91, %81
%93 = and i32 %80, %92
%94 = xor i32 %93, %81
%95 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 32) to i32*)
%96 = tail call i32 @llvm.fshl.i32(i32 %90, i32 %90, i32 5)
%97 = add i32 %95, 1518500249
%98 = add i32 %97, %71
%99 = add i32 %98, %94
%100 = add i32 %99, %96
%101 = tail call i32 @llvm.fshl.i32(i32 %80, i32 %80, i32 30)
%102 = xor i32 %101, %91
%103 = and i32 %90, %102
%104 = xor i32 %103, %91
%105 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 36) to i32*)
%106 = tail call i32 @llvm.fshl.i32(i32 %100, i32 %100, i32 5)
%107 = add i32 %105, 1518500249
%108 = add i32 %107, %81
%109 = add i32 %108, %104
%110 = add i32 %109, %106
%111 = tail call i32 @llvm.fshl.i32(i32 %90, i32 %90, i32 30)
%112 = xor i32 %111, %101
%113 = and i32 %100, %112
%114 = xor i32 %113, %101
%115 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 40) to i32*)
%116 = tail call i32 @llvm.fshl.i32(i32 %110, i32 %110, i32 5)
%117 = add i32 %115, 1518500249
%118 = add i32 %117, %91
%119 = add i32 %118, %114
%120 = add i32 %119, %116
%121 = tail call i32 @llvm.fshl.i32(i32 %100, i32 %100, i32 30)
%122 = xor i32 %121, %111
%123 = and i32 %110, %122
%124 = xor i32 %123, %111
%125 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 44) to i32*)
%126 = tail call i32 @llvm.fshl.i32(i32 %120, i32 %120, i32 5)
%127 = add i32 %125, 1518500249
%128 = add i32 %127, %101
%129 = add i32 %128, %124
%130 = add i32 %129, %126
%131 = tail call i32 @llvm.fshl.i32(i32 %110, i32 %110, i32 30)
%132 = xor i32 %131, %121
%133 = and i32 %120, %132
%134 = xor i32 %133, %121
%135 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 48) to i32*)
%136 = tail call i32 @llvm.fshl.i32(i32 %130, i32 %130, i32 5)
%137 = add i32 %135, 1518500249
%138 = add i32 %137, %111
%139 = add i32 %138, %134
%140 = add i32 %139, %136
%141 = tail call i32 @llvm.fshl.i32(i32 %120, i32 %120, i32 30)
%142 = xor i32 %141, %131
%143 = and i32 %130, %142
%144 = xor i32 %143, %131
%145 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 52) to i32*)
%146 = tail call i32 @llvm.fshl.i32(i32 %140, i32 %140, i32 5)
%147 = add i32 %145, 1518500249
%148 = add i32 %147, %121
%149 = add i32 %148, %144
%150 = add i32 %149, %146
%151 = tail call i32 @llvm.fshl.i32(i32 %130, i32 %130, i32 30)
%152 = xor i32 %151, %141
%153 = and i32 %140, %152
%154 = xor i32 %153, %141
%155 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 56) to i32*)
%156 = tail call i32 @llvm.fshl.i32(i32 %150, i32 %150, i32 5)
%157 = add i32 %155, 1518500249
%158 = add i32 %157, %131
%159 = add i32 %158, %154
%160 = add i32 %159, %156
%161 = tail call i32 @llvm.fshl.i32(i32 %140, i32 %140, i32 30)
%162 = xor i32 %161, %151
%163 = and i32 %150, %162
%164 = xor i32 %163, %151
%165 = load i32, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 60) to i32*)
%166 = tail call i32 @llvm.fshl.i32(i32 %160, i32 %160, i32 5)
%167 = add i32 %165, 1518500249
%168 = add i32 %167, %141
%169 = add i32 %168, %164
%170 = add i32 %169, %166
%171 = tail call i32 @llvm.fshl.i32(i32 %150, i32 %150, i32 30)
%172 = xor i32 %171, %161
%173 = and i32 %160, %172
%174 = xor i32 %173, %161
%175 = xor i32 %35, %15
%176 = xor i32 %175, %95
%177 = xor i32 %176, %145
%178 = tail call i32 @llvm.fshl.i32(i32 %177, i32 %177, i32 1)
%179 = tail call i32 @llvm.fshl.i32(i32 %170, i32 %170, i32 5)
%180 = add i32 %178, 1518500249
%181 = add i32 %180, %151
%182 = add i32 %181, %174
%183 = add i32 %182, %179
%184 = tail call i32 @llvm.fshl.i32(i32 %160, i32 %160, i32 30)
%185 = xor i32 %184, %171
%186 = and i32 %170, %185
%187 = xor i32 %186, %171
%188 = xor i32 %45, %25
%189 = xor i32 %188, %105
%190 = xor i32 %189, %155
%191 = tail call i32 @llvm.fshl.i32(i32 %190, i32 %190, i32 1)
%192 = tail call i32 @llvm.fshl.i32(i32 %183, i32 %183, i32 5)
%193 = add i32 %191, 1518500249
%194 = add i32 %193, %161
%195 = add i32 %194, %187
%196 = add i32 %195, %192
%197 = tail call i32 @llvm.fshl.i32(i32 %170, i32 %170, i32 30)
%198 = xor i32 %197, %184
%199 = and i32 %183, %198
%200 = xor i32 %199, %184
%201 = xor i32 %55, %35
%202 = xor i32 %201, %115
%203 = xor i32 %202, %165
%204 = tail call i32 @llvm.fshl.i32(i32 %203, i32 %203, i32 1)
%205 = tail call i32 @llvm.fshl.i32(i32 %196, i32 %196, i32 5)
%206 = add i32 %204, 1518500249
%207 = add i32 %206, %171
%208 = add i32 %207, %200
%209 = add i32 %208, %205
%210 = tail call i32 @llvm.fshl.i32(i32 %183, i32 %183, i32 30)
%211 = xor i32 %210, %197
%212 = and i32 %196, %211
%213 = xor i32 %212, %197
%214 = xor i32 %65, %45
%215 = xor i32 %214, %125
%216 = xor i32 %215, %178
%217 = tail call i32 @llvm.fshl.i32(i32 %216, i32 %216, i32 1)
%218 = tail call i32 @llvm.fshl.i32(i32 %209, i32 %209, i32 5)
%219 = add i32 %217, 1518500249
%220 = add i32 %219, %184
%221 = add i32 %220, %213
%222 = add i32 %221, %218
%223 = tail call i32 @llvm.fshl.i32(i32 %196, i32 %196, i32 30)
%224 = xor i32 %223, %210
%225 = xor i32 %224, %209
%226 = xor i32 %75, %55
%227 = xor i32 %226, %135
%228 = xor i32 %227, %191
%229 = tail call i32 @llvm.fshl.i32(i32 %228, i32 %228, i32 1)
%230 = tail call i32 @llvm.fshl.i32(i32 %222, i32 %222, i32 5)
%231 = add i32 %229, 1859775393
%232 = add i32 %231, %197
%233 = add i32 %232, %225
%234 = add i32 %233, %230
%235 = tail call i32 @llvm.fshl.i32(i32 %209, i32 %209, i32 30)
%236 = xor i32 %235, %223
%237 = xor i32 %236, %222
%238 = xor i32 %85, %65
%239 = xor i32 %238, %145
%240 = xor i32 %239, %204
%241 = tail call i32 @llvm.fshl.i32(i32 %240, i32 %240, i32 1)
%242 = tail call i32 @llvm.fshl.i32(i32 %234, i32 %234, i32 5)
%243 = add i32 %241, 1859775393
%244 = add i32 %243, %210
%245 = add i32 %244, %237
%246 = add i32 %245, %242
%247 = tail call i32 @llvm.fshl.i32(i32 %222, i32 %222, i32 30)
%248 = xor i32 %247, %235
%249 = xor i32 %248, %234
%250 = xor i32 %95, %75
%251 = xor i32 %250, %155
%252 = xor i32 %251, %217
%253 = tail call i32 @llvm.fshl.i32(i32 %252, i32 %252, i32 1)
%254 = tail call i32 @llvm.fshl.i32(i32 %246, i32 %246, i32 5)
%255 = add i32 %253, 1859775393
%256 = add i32 %255, %223
%257 = add i32 %256, %249
%258 = add i32 %257, %254
%259 = tail call i32 @llvm.fshl.i32(i32 %234, i32 %234, i32 30)
%260 = xor i32 %259, %247
%261 = xor i32 %260, %246
%262 = xor i32 %105, %85
%263 = xor i32 %262, %165
%264 = xor i32 %263, %229
%265 = tail call i32 @llvm.fshl.i32(i32 %264, i32 %264, i32 1)
%266 = tail call i32 @llvm.fshl.i32(i32 %258, i32 %258, i32 5)
%267 = add i32 %265, 1859775393
%268 = add i32 %267, %235
%269 = add i32 %268, %261
%270 = add i32 %269, %266
%271 = tail call i32 @llvm.fshl.i32(i32 %246, i32 %246, i32 30)
%272 = xor i32 %271, %259
%273 = xor i32 %272, %258
%274 = xor i32 %115, %95
%275 = xor i32 %274, %178
%276 = xor i32 %275, %241
%277 = tail call i32 @llvm.fshl.i32(i32 %276, i32 %276, i32 1)
%278 = tail call i32 @llvm.fshl.i32(i32 %270, i32 %270, i32 5)
%279 = add i32 %277, 1859775393
%280 = add i32 %279, %247
%281 = add i32 %280, %273
%282 = add i32 %281, %278
%283 = tail call i32 @llvm.fshl.i32(i32 %258, i32 %258, i32 30)
%284 = xor i32 %283, %271
%285 = xor i32 %284, %270
%286 = xor i32 %125, %105
%287 = xor i32 %286, %191
%288 = xor i32 %287, %253
%289 = tail call i32 @llvm.fshl.i32(i32 %288, i32 %288, i32 1)
%290 = tail call i32 @llvm.fshl.i32(i32 %282, i32 %282, i32 5)
%291 = add i32 %289, 1859775393
%292 = add i32 %291, %259
%293 = add i32 %292, %285
%294 = add i32 %293, %290
%295 = tail call i32 @llvm.fshl.i32(i32 %270, i32 %270, i32 30)
%296 = xor i32 %295, %283
%297 = xor i32 %296, %282
%298 = xor i32 %135, %115
%299 = xor i32 %298, %204
%300 = xor i32 %299, %265
%301 = tail call i32 @llvm.fshl.i32(i32 %300, i32 %300, i32 1)
%302 = tail call i32 @llvm.fshl.i32(i32 %294, i32 %294, i32 5)
%303 = add i32 %301, 1859775393
%304 = add i32 %303, %271
%305 = add i32 %304, %297
%306 = add i32 %305, %302
%307 = tail call i32 @llvm.fshl.i32(i32 %282, i32 %282, i32 30)
%308 = xor i32 %307, %295
%309 = xor i32 %308, %294
%310 = xor i32 %145, %125
%311 = xor i32 %310, %217
%312 = xor i32 %311, %277
%313 = tail call i32 @llvm.fshl.i32(i32 %312, i32 %312, i32 1)
%314 = tail call i32 @llvm.fshl.i32(i32 %306, i32 %306, i32 5)
%315 = add i32 %313, 1859775393
%316 = add i32 %315, %283
%317 = add i32 %316, %309
%318 = add i32 %317, %314
%319 = tail call i32 @llvm.fshl.i32(i32 %294, i32 %294, i32 30)
%320 = xor i32 %319, %307
%321 = xor i32 %320, %306
%322 = xor i32 %155, %135
%323 = xor i32 %322, %229
%324 = xor i32 %323, %289
%325 = tail call i32 @llvm.fshl.i32(i32 %324, i32 %324, i32 1)
%326 = tail call i32 @llvm.fshl.i32(i32 %318, i32 %318, i32 5)
%327 = add i32 %325, 1859775393
%328 = add i32 %327, %295
%329 = add i32 %328, %321
%330 = add i32 %329, %326
%331 = tail call i32 @llvm.fshl.i32(i32 %306, i32 %306, i32 30)
%332 = xor i32 %331, %319
%333 = xor i32 %332, %318
%334 = xor i32 %165, %145
%335 = xor i32 %334, %241
%336 = xor i32 %335, %301
%337 = tail call i32 @llvm.fshl.i32(i32 %336, i32 %336, i32 1)
%338 = tail call i32 @llvm.fshl.i32(i32 %330, i32 %330, i32 5)
%339 = add i32 %337, 1859775393
%340 = add i32 %339, %307
%341 = add i32 %340, %333
%342 = add i32 %341, %338
%343 = tail call i32 @llvm.fshl.i32(i32 %318, i32 %318, i32 30)
%344 = xor i32 %343, %331
%345 = xor i32 %344, %330
%346 = xor i32 %178, %155
%347 = xor i32 %346, %253
%348 = xor i32 %347, %313
%349 = tail call i32 @llvm.fshl.i32(i32 %348, i32 %348, i32 1)
%350 = tail call i32 @llvm.fshl.i32(i32 %342, i32 %342, i32 5)
%351 = add i32 %349, 1859775393
%352 = add i32 %351, %319
%353 = add i32 %352, %345
%354 = add i32 %353, %350
%355 = tail call i32 @llvm.fshl.i32(i32 %330, i32 %330, i32 30)
%356 = xor i32 %355, %343
%357 = xor i32 %356, %342
%358 = xor i32 %191, %165
%359 = xor i32 %358, %265
%360 = xor i32 %359, %325
%361 = tail call i32 @llvm.fshl.i32(i32 %360, i32 %360, i32 1)
%362 = tail call i32 @llvm.fshl.i32(i32 %354, i32 %354, i32 5)
%363 = add i32 %361, 1859775393
%364 = add i32 %363, %331
%365 = add i32 %364, %357
%366 = add i32 %365, %362
%367 = tail call i32 @llvm.fshl.i32(i32 %342, i32 %342, i32 30)
%368 = xor i32 %367, %355
%369 = xor i32 %368, %354
%370 = xor i32 %204, %178
%371 = xor i32 %370, %277
%372 = xor i32 %371, %337
%373 = tail call i32 @llvm.fshl.i32(i32 %372, i32 %372, i32 1)
%374 = tail call i32 @llvm.fshl.i32(i32 %366, i32 %366, i32 5)
%375 = add i32 %373, 1859775393
%376 = add i32 %375, %343
%377 = add i32 %376, %369
%378 = add i32 %377, %374
%379 = tail call i32 @llvm.fshl.i32(i32 %354, i32 %354, i32 30)
%380 = xor i32 %379, %367
%381 = xor i32 %380, %366
%382 = xor i32 %217, %191
%383 = xor i32 %382, %289
%384 = xor i32 %383, %349
%385 = tail call i32 @llvm.fshl.i32(i32 %384, i32 %384, i32 1)
%386 = tail call i32 @llvm.fshl.i32(i32 %378, i32 %378, i32 5)
%387 = add i32 %385, 1859775393
%388 = add i32 %387, %355
%389 = add i32 %388, %381
%390 = add i32 %389, %386
%391 = tail call i32 @llvm.fshl.i32(i32 %366, i32 %366, i32 30)
%392 = xor i32 %391, %379
%393 = xor i32 %392, %378
%394 = xor i32 %229, %204
%395 = xor i32 %394, %301
%396 = xor i32 %395, %361
%397 = tail call i32 @llvm.fshl.i32(i32 %396, i32 %396, i32 1)
%398 = tail call i32 @llvm.fshl.i32(i32 %390, i32 %390, i32 5)
%399 = add i32 %397, 1859775393
%400 = add i32 %399, %367
%401 = add i32 %400, %393
%402 = add i32 %401, %398
%403 = tail call i32 @llvm.fshl.i32(i32 %378, i32 %378, i32 30)
%404 = xor i32 %403, %391
%405 = xor i32 %404, %390
%406 = xor i32 %241, %217
%407 = xor i32 %406, %313
%408 = xor i32 %407, %373
%409 = tail call i32 @llvm.fshl.i32(i32 %408, i32 %408, i32 1)
%410 = tail call i32 @llvm.fshl.i32(i32 %402, i32 %402, i32 5)
%411 = add i32 %409, 1859775393
%412 = add i32 %411, %379
%413 = add i32 %412, %405
%414 = add i32 %413, %410
%415 = tail call i32 @llvm.fshl.i32(i32 %390, i32 %390, i32 30)
%416 = xor i32 %415, %403
%417 = xor i32 %416, %402
%418 = xor i32 %253, %229
%419 = xor i32 %418, %325
%420 = xor i32 %419, %385
%421 = tail call i32 @llvm.fshl.i32(i32 %420, i32 %420, i32 1)
%422 = tail call i32 @llvm.fshl.i32(i32 %414, i32 %414, i32 5)
%423 = add i32 %421, 1859775393
%424 = add i32 %423, %391
%425 = add i32 %424, %417
%426 = add i32 %425, %422
%427 = tail call i32 @llvm.fshl.i32(i32 %402, i32 %402, i32 30)
%428 = xor i32 %427, %415
%429 = xor i32 %428, %414
%430 = xor i32 %265, %241
%431 = xor i32 %430, %337
%432 = xor i32 %431, %397
%433 = tail call i32 @llvm.fshl.i32(i32 %432, i32 %432, i32 1)
%434 = tail call i32 @llvm.fshl.i32(i32 %426, i32 %426, i32 5)
%435 = add i32 %433, 1859775393
%436 = add i32 %435, %403
%437 = add i32 %436, %429
%438 = add i32 %437, %434
%439 = tail call i32 @llvm.fshl.i32(i32 %414, i32 %414, i32 30)
%440 = xor i32 %439, %427
%441 = xor i32 %440, %426
%442 = xor i32 %277, %253
%443 = xor i32 %442, %349
%444 = xor i32 %443, %409
%445 = tail call i32 @llvm.fshl.i32(i32 %444, i32 %444, i32 1)
%446 = tail call i32 @llvm.fshl.i32(i32 %438, i32 %438, i32 5)
%447 = add i32 %445, 1859775393
%448 = add i32 %447, %415
%449 = add i32 %448, %441
%450 = add i32 %449, %446
%451 = tail call i32 @llvm.fshl.i32(i32 %426, i32 %426, i32 30)
%452 = xor i32 %451, %439
%453 = xor i32 %452, %438
%454 = xor i32 %289, %265
%455 = xor i32 %454, %361
%456 = xor i32 %455, %421
%457 = tail call i32 @llvm.fshl.i32(i32 %456, i32 %456, i32 1)
%458 = tail call i32 @llvm.fshl.i32(i32 %450, i32 %450, i32 5)
%459 = add i32 %457, 1859775393
%460 = add i32 %459, %427
%461 = add i32 %460, %453
%462 = add i32 %461, %458
%463 = tail call i32 @llvm.fshl.i32(i32 %438, i32 %438, i32 30)
%464 = or i32 %450, %463
%465 = and i32 %464, %451
%466 = and i32 %450, %463
%467 = or i32 %465, %466
%468 = xor i32 %301, %277
%469 = xor i32 %468, %373
%470 = xor i32 %469, %433
%471 = tail call i32 @llvm.fshl.i32(i32 %470, i32 %470, i32 1)
%472 = tail call i32 @llvm.fshl.i32(i32 %462, i32 %462, i32 5)
%473 = add i32 %471, -1894007588
%474 = add i32 %473, %439
%475 = add i32 %474, %467
%476 = add i32 %475, %472
%477 = tail call i32 @llvm.fshl.i32(i32 %450, i32 %450, i32 30)
%478 = or i32 %462, %477
%479 = and i32 %478, %463
%480 = and i32 %462, %477
%481 = or i32 %479, %480
%482 = xor i32 %313, %289
%483 = xor i32 %482, %385
%484 = xor i32 %483, %445
%485 = tail call i32 @llvm.fshl.i32(i32 %484, i32 %484, i32 1)
%486 = tail call i32 @llvm.fshl.i32(i32 %476, i32 %476, i32 5)
%487 = add i32 %485, -1894007588
%488 = add i32 %487, %451
%489 = add i32 %488, %481
%490 = add i32 %489, %486
%491 = tail call i32 @llvm.fshl.i32(i32 %462, i32 %462, i32 30)
%492 = or i32 %476, %491
%493 = and i32 %492, %477
%494 = and i32 %476, %491
%495 = or i32 %493, %494
%496 = xor i32 %325, %301
%497 = xor i32 %496, %397
%498 = xor i32 %497, %457
%499 = tail call i32 @llvm.fshl.i32(i32 %498, i32 %498, i32 1)
%500 = tail call i32 @llvm.fshl.i32(i32 %490, i32 %490, i32 5)
%501 = add i32 %499, -1894007588
%502 = add i32 %501, %463
%503 = add i32 %502, %495
%504 = add i32 %503, %500
%505 = tail call i32 @llvm.fshl.i32(i32 %476, i32 %476, i32 30)
%506 = or i32 %490, %505
%507 = and i32 %506, %491
%508 = and i32 %490, %505
%509 = or i32 %507, %508
%510 = xor i32 %337, %313
%511 = xor i32 %510, %409
%512 = xor i32 %511, %471
%513 = tail call i32 @llvm.fshl.i32(i32 %512, i32 %512, i32 1)
%514 = tail call i32 @llvm.fshl.i32(i32 %504, i32 %504, i32 5)
%515 = add i32 %513, -1894007588
%516 = add i32 %515, %477
%517 = add i32 %516, %509
%518 = add i32 %517, %514
%519 = tail call i32 @llvm.fshl.i32(i32 %490, i32 %490, i32 30)
%520 = or i32 %504, %519
%521 = and i32 %520, %505
%522 = and i32 %504, %519
%523 = or i32 %521, %522
%524 = xor i32 %349, %325
%525 = xor i32 %524, %421
%526 = xor i32 %525, %485
%527 = tail call i32 @llvm.fshl.i32(i32 %526, i32 %526, i32 1)
%528 = tail call i32 @llvm.fshl.i32(i32 %518, i32 %518, i32 5)
%529 = add i32 %527, -1894007588
%530 = add i32 %529, %491
%531 = add i32 %530, %523
%532 = add i32 %531, %528
%533 = tail call i32 @llvm.fshl.i32(i32 %504, i32 %504, i32 30)
%534 = or i32 %518, %533
%535 = and i32 %534, %519
%536 = and i32 %518, %533
%537 = or i32 %535, %536
%538 = xor i32 %361, %337
%539 = xor i32 %538, %433
%540 = xor i32 %539, %499
%541 = tail call i32 @llvm.fshl.i32(i32 %540, i32 %540, i32 1)
%542 = tail call i32 @llvm.fshl.i32(i32 %532, i32 %532, i32 5)
%543 = add i32 %541, -1894007588
%544 = add i32 %543, %505
%545 = add i32 %544, %537
%546 = add i32 %545, %542
%547 = tail call i32 @llvm.fshl.i32(i32 %518, i32 %518, i32 30)
%548 = or i32 %532, %547
%549 = and i32 %548, %533
%550 = and i32 %532, %547
%551 = or i32 %549, %550
%552 = xor i32 %373, %349
%553 = xor i32 %552, %445
%554 = xor i32 %553, %513
%555 = tail call i32 @llvm.fshl.i32(i32 %554, i32 %554, i32 1)
%556 = tail call i32 @llvm.fshl.i32(i32 %546, i32 %546, i32 5)
%557 = add i32 %555, -1894007588
%558 = add i32 %557, %519
%559 = add i32 %558, %551
%560 = add i32 %559, %556
%561 = tail call i32 @llvm.fshl.i32(i32 %532, i32 %532, i32 30)
%562 = or i32 %546, %561
%563 = and i32 %562, %547
%564 = and i32 %546, %561
%565 = or i32 %563, %564
%566 = xor i32 %385, %361
%567 = xor i32 %566, %457
%568 = xor i32 %567, %527
%569 = tail call i32 @llvm.fshl.i32(i32 %568, i32 %568, i32 1)
%570 = tail call i32 @llvm.fshl.i32(i32 %560, i32 %560, i32 5)
%571 = add i32 %569, -1894007588
%572 = add i32 %571, %533
%573 = add i32 %572, %565
%574 = add i32 %573, %570
%575 = tail call i32 @llvm.fshl.i32(i32 %546, i32 %546, i32 30)
%576 = or i32 %560, %575
%577 = and i32 %576, %561
%578 = and i32 %560, %575
%579 = or i32 %577, %578
%580 = xor i32 %397, %373
%581 = xor i32 %580, %471
%582 = xor i32 %581, %541
%583 = tail call i32 @llvm.fshl.i32(i32 %582, i32 %582, i32 1)
%584 = tail call i32 @llvm.fshl.i32(i32 %574, i32 %574, i32 5)
%585 = add i32 %583, -1894007588
%586 = add i32 %585, %547
%587 = add i32 %586, %579
%588 = add i32 %587, %584
%589 = tail call i32 @llvm.fshl.i32(i32 %560, i32 %560, i32 30)
%590 = or i32 %574, %589
%591 = and i32 %590, %575
%592 = and i32 %574, %589
%593 = or i32 %591, %592
%594 = xor i32 %409, %385
%595 = xor i32 %594, %485
%596 = xor i32 %595, %555
%597 = tail call i32 @llvm.fshl.i32(i32 %596, i32 %596, i32 1)
%598 = tail call i32 @llvm.fshl.i32(i32 %588, i32 %588, i32 5)
%599 = add i32 %597, -1894007588
%600 = add i32 %599, %561
%601 = add i32 %600, %593
%602 = add i32 %601, %598
%603 = tail call i32 @llvm.fshl.i32(i32 %574, i32 %574, i32 30)
%604 = or i32 %588, %603
%605 = and i32 %604, %589
%606 = and i32 %588, %603
%607 = or i32 %605, %606
%608 = xor i32 %421, %397
%609 = xor i32 %608, %499
%610 = xor i32 %609, %569
%611 = tail call i32 @llvm.fshl.i32(i32 %610, i32 %610, i32 1)
%612 = tail call i32 @llvm.fshl.i32(i32 %602, i32 %602, i32 5)
%613 = add i32 %611, -1894007588
%614 = add i32 %613, %575
%615 = add i32 %614, %607
%616 = add i32 %615, %612
%617 = tail call i32 @llvm.fshl.i32(i32 %588, i32 %588, i32 30)
%618 = or i32 %602, %617
%619 = and i32 %618, %603
%620 = and i32 %602, %617
%621 = or i32 %619, %620
%622 = xor i32 %433, %409
%623 = xor i32 %622, %513
%624 = xor i32 %623, %583
%625 = tail call i32 @llvm.fshl.i32(i32 %624, i32 %624, i32 1)
%626 = tail call i32 @llvm.fshl.i32(i32 %616, i32 %616, i32 5)
%627 = add i32 %625, -1894007588
%628 = add i32 %627, %589
%629 = add i32 %628, %621
%630 = add i32 %629, %626
%631 = tail call i32 @llvm.fshl.i32(i32 %602, i32 %602, i32 30)
%632 = or i32 %616, %631
%633 = and i32 %632, %617
%634 = and i32 %616, %631
%635 = or i32 %633, %634
%636 = xor i32 %445, %421
%637 = xor i32 %636, %527
%638 = xor i32 %637, %597
%639 = tail call i32 @llvm.fshl.i32(i32 %638, i32 %638, i32 1)
%640 = tail call i32 @llvm.fshl.i32(i32 %630, i32 %630, i32 5)
%641 = add i32 %639, -1894007588
%642 = add i32 %641, %603
%643 = add i32 %642, %635
%644 = add i32 %643, %640
%645 = tail call i32 @llvm.fshl.i32(i32 %616, i32 %616, i32 30)
%646 = or i32 %630, %645
%647 = and i32 %646, %631
%648 = and i32 %630, %645
%649 = or i32 %647, %648
%650 = xor i32 %457, %433
%651 = xor i32 %650, %541
%652 = xor i32 %651, %611
%653 = tail call i32 @llvm.fshl.i32(i32 %652, i32 %652, i32 1)
%654 = tail call i32 @llvm.fshl.i32(i32 %644, i32 %644, i32 5)
%655 = add i32 %653, -1894007588
%656 = add i32 %655, %617
%657 = add i32 %656, %649
%658 = add i32 %657, %654
%659 = tail call i32 @llvm.fshl.i32(i32 %630, i32 %630, i32 30)
%660 = or i32 %644, %659
%661 = and i32 %660, %645
%662 = and i32 %644, %659
%663 = or i32 %661, %662
%664 = xor i32 %471, %445
%665 = xor i32 %664, %555
%666 = xor i32 %665, %625
%667 = tail call i32 @llvm.fshl.i32(i32 %666, i32 %666, i32 1)
%668 = tail call i32 @llvm.fshl.i32(i32 %658, i32 %658, i32 5)
%669 = add i32 %667, -1894007588
%670 = add i32 %669, %631
%671 = add i32 %670, %663
%672 = add i32 %671, %668
%673 = tail call i32 @llvm.fshl.i32(i32 %644, i32 %644, i32 30)
%674 = or i32 %658, %673
%675 = and i32 %674, %659
%676 = and i32 %658, %673
%677 = or i32 %675, %676
%678 = xor i32 %485, %457
%679 = xor i32 %678, %569
%680 = xor i32 %679, %639
%681 = tail call i32 @llvm.fshl.i32(i32 %680, i32 %680, i32 1)
%682 = tail call i32 @llvm.fshl.i32(i32 %672, i32 %672, i32 5)
%683 = add i32 %681, -1894007588
%684 = add i32 %683, %645
%685 = add i32 %684, %677
%686 = add i32 %685, %682
%687 = tail call i32 @llvm.fshl.i32(i32 %658, i32 %658, i32 30)
%688 = or i32 %672, %687
%689 = and i32 %688, %673
%690 = and i32 %672, %687
%691 = or i32 %689, %690
%692 = xor i32 %499, %471
%693 = xor i32 %692, %583
%694 = xor i32 %693, %653
%695 = tail call i32 @llvm.fshl.i32(i32 %694, i32 %694, i32 1)
%696 = tail call i32 @llvm.fshl.i32(i32 %686, i32 %686, i32 5)
%697 = add i32 %695, -1894007588
%698 = add i32 %697, %659
%699 = add i32 %698, %691
%700 = add i32 %699, %696
%701 = tail call i32 @llvm.fshl.i32(i32 %672, i32 %672, i32 30)
%702 = or i32 %686, %701
%703 = and i32 %702, %687
%704 = and i32 %686, %701
%705 = or i32 %703, %704
%706 = xor i32 %513, %485
%707 = xor i32 %706, %597
%708 = xor i32 %707, %667
%709 = tail call i32 @llvm.fshl.i32(i32 %708, i32 %708, i32 1)
%710 = tail call i32 @llvm.fshl.i32(i32 %700, i32 %700, i32 5)
%711 = add i32 %709, -1894007588
%712 = add i32 %711, %673
%713 = add i32 %712, %705
%714 = add i32 %713, %710
%715 = tail call i32 @llvm.fshl.i32(i32 %686, i32 %686, i32 30)
%716 = or i32 %700, %715
%717 = and i32 %716, %701
%718 = and i32 %700, %715
%719 = or i32 %717, %718
%720 = xor i32 %527, %499
%721 = xor i32 %720, %611
%722 = xor i32 %721, %681
%723 = tail call i32 @llvm.fshl.i32(i32 %722, i32 %722, i32 1)
%724 = tail call i32 @llvm.fshl.i32(i32 %714, i32 %714, i32 5)
%725 = add i32 %723, -1894007588
%726 = add i32 %725, %687
%727 = add i32 %726, %719
%728 = add i32 %727, %724
%729 = tail call i32 @llvm.fshl.i32(i32 %700, i32 %700, i32 30)
%730 = or i32 %714, %729
%731 = and i32 %730, %715
%732 = and i32 %714, %729
%733 = or i32 %731, %732
%734 = xor i32 %541, %513
%735 = xor i32 %734, %625
%736 = xor i32 %735, %695
%737 = tail call i32 @llvm.fshl.i32(i32 %736, i32 %736, i32 1)
%738 = tail call i32 @llvm.fshl.i32(i32 %728, i32 %728, i32 5)
%739 = add i32 %737, -1894007588
%740 = add i32 %739, %701
%741 = add i32 %740, %733
%742 = add i32 %741, %738
%743 = tail call i32 @llvm.fshl.i32(i32 %714, i32 %714, i32 30)
%744 = xor i32 %743, %729
%745 = xor i32 %744, %728
%746 = xor i32 %555, %527
%747 = xor i32 %746, %639
%748 = xor i32 %747, %709
%749 = tail call i32 @llvm.fshl.i32(i32 %748, i32 %748, i32 1)
%750 = tail call i32 @llvm.fshl.i32(i32 %742, i32 %742, i32 5)
%751 = add i32 %749, -899497514
%752 = add i32 %751, %715
%753 = add i32 %752, %745
%754 = add i32 %753, %750
%755 = tail call i32 @llvm.fshl.i32(i32 %728, i32 %728, i32 30)
%756 = xor i32 %755, %743
%757 = xor i32 %756, %742
%758 = xor i32 %569, %541
%759 = xor i32 %758, %653
%760 = xor i32 %759, %723
%761 = tail call i32 @llvm.fshl.i32(i32 %760, i32 %760, i32 1)
%762 = tail call i32 @llvm.fshl.i32(i32 %754, i32 %754, i32 5)
%763 = add i32 %761, -899497514
%764 = add i32 %763, %729
%765 = add i32 %764, %757
%766 = add i32 %765, %762
%767 = tail call i32 @llvm.fshl.i32(i32 %742, i32 %742, i32 30)
%768 = xor i32 %767, %755
%769 = xor i32 %768, %754
%770 = xor i32 %583, %555
%771 = xor i32 %770, %667
%772 = xor i32 %771, %737
%773 = tail call i32 @llvm.fshl.i32(i32 %772, i32 %772, i32 1)
%774 = tail call i32 @llvm.fshl.i32(i32 %766, i32 %766, i32 5)
%775 = add i32 %773, -899497514
%776 = add i32 %775, %743
%777 = add i32 %776, %769
%778 = add i32 %777, %774
%779 = tail call i32 @llvm.fshl.i32(i32 %754, i32 %754, i32 30)
%780 = xor i32 %779, %767
%781 = xor i32 %780, %766
%782 = xor i32 %597, %569
%783 = xor i32 %782, %681
%784 = xor i32 %783, %749
%785 = tail call i32 @llvm.fshl.i32(i32 %784, i32 %784, i32 1)
%786 = tail call i32 @llvm.fshl.i32(i32 %778, i32 %778, i32 5)
%787 = add i32 %785, -899497514
%788 = add i32 %787, %755
%789 = add i32 %788, %781
%790 = add i32 %789, %786
%791 = tail call i32 @llvm.fshl.i32(i32 %766, i32 %766, i32 30)
%792 = xor i32 %791, %779
%793 = xor i32 %792, %778
%794 = xor i32 %611, %583
%795 = xor i32 %794, %695
%796 = xor i32 %795, %761
%797 = tail call i32 @llvm.fshl.i32(i32 %796, i32 %796, i32 1)
store i32 %797, i32* bitcast ([64 x i8]* @SHA1Transform.workspace to i32*)
%798 = tail call i32 @llvm.fshl.i32(i32 %790, i32 %790, i32 5)
%799 = add i32 %797, -899497514
%800 = add i32 %799, %767
%801 = add i32 %800, %793
%802 = add i32 %801, %798
%803 = tail call i32 @llvm.fshl.i32(i32 %778, i32 %778, i32 30)
%804 = xor i32 %803, %791
%805 = xor i32 %804, %790
%806 = xor i32 %625, %597
%807 = xor i32 %806, %709
%808 = xor i32 %807, %773
%809 = tail call i32 @llvm.fshl.i32(i32 %808, i32 %808, i32 1)
store i32 %809, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 4) to i32*)
%810 = tail call i32 @llvm.fshl.i32(i32 %802, i32 %802, i32 5)
%811 = add i32 %809, -899497514
%812 = add i32 %811, %779
%813 = add i32 %812, %805
%814 = add i32 %813, %810
%815 = tail call i32 @llvm.fshl.i32(i32 %790, i32 %790, i32 30)
%816 = xor i32 %815, %803
%817 = xor i32 %816, %802
%818 = xor i32 %639, %611
%819 = xor i32 %818, %723
%820 = xor i32 %819, %785
%821 = tail call i32 @llvm.fshl.i32(i32 %820, i32 %820, i32 1)
store i32 %821, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 8) to i32*)
%822 = tail call i32 @llvm.fshl.i32(i32 %814, i32 %814, i32 5)
%823 = add i32 %821, -899497514
%824 = add i32 %823, %791
%825 = add i32 %824, %817
%826 = add i32 %825, %822
%827 = tail call i32 @llvm.fshl.i32(i32 %802, i32 %802, i32 30)
%828 = xor i32 %827, %815
%829 = xor i32 %828, %814
%830 = xor i32 %653, %625
%831 = xor i32 %830, %737
%832 = xor i32 %831, %797
%833 = tail call i32 @llvm.fshl.i32(i32 %832, i32 %832, i32 1)
store i32 %833, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 12) to i32*)
%834 = tail call i32 @llvm.fshl.i32(i32 %826, i32 %826, i32 5)
%835 = add i32 %833, -899497514
%836 = add i32 %835, %803
%837 = add i32 %836, %829
%838 = add i32 %837, %834
%839 = tail call i32 @llvm.fshl.i32(i32 %814, i32 %814, i32 30)
%840 = xor i32 %839, %827
%841 = xor i32 %840, %826
%842 = xor i32 %667, %639
%843 = xor i32 %842, %749
%844 = xor i32 %843, %809
%845 = tail call i32 @llvm.fshl.i32(i32 %844, i32 %844, i32 1)
store i32 %845, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 16) to i32*)
%846 = tail call i32 @llvm.fshl.i32(i32 %838, i32 %838, i32 5)
%847 = add i32 %845, -899497514
%848 = add i32 %847, %815
%849 = add i32 %848, %841
%850 = add i32 %849, %846
%851 = tail call i32 @llvm.fshl.i32(i32 %826, i32 %826, i32 30)
%852 = xor i32 %851, %839
%853 = xor i32 %852, %838
%854 = xor i32 %681, %653
%855 = xor i32 %854, %761
%856 = xor i32 %855, %821
%857 = tail call i32 @llvm.fshl.i32(i32 %856, i32 %856, i32 1)
store i32 %857, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 20) to i32*)
%858 = tail call i32 @llvm.fshl.i32(i32 %850, i32 %850, i32 5)
%859 = add i32 %857, -899497514
%860 = add i32 %859, %827
%861 = add i32 %860, %853
%862 = add i32 %861, %858
%863 = tail call i32 @llvm.fshl.i32(i32 %838, i32 %838, i32 30)
%864 = xor i32 %863, %851
%865 = xor i32 %864, %850
%866 = xor i32 %695, %667
%867 = xor i32 %866, %773
%868 = xor i32 %867, %833
%869 = tail call i32 @llvm.fshl.i32(i32 %868, i32 %868, i32 1)
store i32 %869, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 24) to i32*)
%870 = tail call i32 @llvm.fshl.i32(i32 %862, i32 %862, i32 5)
%871 = add i32 %869, -899497514
%872 = add i32 %871, %839
%873 = add i32 %872, %865
%874 = add i32 %873, %870
%875 = tail call i32 @llvm.fshl.i32(i32 %850, i32 %850, i32 30)
%876 = xor i32 %875, %863
%877 = xor i32 %876, %862
%878 = xor i32 %709, %681
%879 = xor i32 %878, %785
%880 = xor i32 %879, %845
%881 = tail call i32 @llvm.fshl.i32(i32 %880, i32 %880, i32 1)
store i32 %881, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 28) to i32*)
%882 = tail call i32 @llvm.fshl.i32(i32 %874, i32 %874, i32 5)
%883 = add i32 %881, -899497514
%884 = add i32 %883, %851
%885 = add i32 %884, %877
%886 = add i32 %885, %882
%887 = tail call i32 @llvm.fshl.i32(i32 %862, i32 %862, i32 30)
%888 = xor i32 %887, %875
%889 = xor i32 %888, %874
%890 = xor i32 %723, %695
%891 = xor i32 %890, %797
%892 = xor i32 %891, %857
%893 = tail call i32 @llvm.fshl.i32(i32 %892, i32 %892, i32 1)
store i32 %893, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 32) to i32*)
%894 = tail call i32 @llvm.fshl.i32(i32 %886, i32 %886, i32 5)
%895 = add i32 %893, -899497514
%896 = add i32 %895, %863
%897 = add i32 %896, %889
%898 = add i32 %897, %894
%899 = tail call i32 @llvm.fshl.i32(i32 %874, i32 %874, i32 30)
%900 = xor i32 %899, %887
%901 = xor i32 %900, %886
%902 = xor i32 %737, %709
%903 = xor i32 %902, %809
%904 = xor i32 %903, %869
%905 = tail call i32 @llvm.fshl.i32(i32 %904, i32 %904, i32 1)
store i32 %905, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 36) to i32*)
%906 = tail call i32 @llvm.fshl.i32(i32 %898, i32 %898, i32 5)
%907 = add i32 %905, -899497514
%908 = add i32 %907, %875
%909 = add i32 %908, %901
%910 = add i32 %909, %906
%911 = tail call i32 @llvm.fshl.i32(i32 %886, i32 %886, i32 30)
%912 = xor i32 %911, %899
%913 = xor i32 %912, %898
%914 = xor i32 %749, %723
%915 = xor i32 %914, %821
%916 = xor i32 %915, %881
%917 = tail call i32 @llvm.fshl.i32(i32 %916, i32 %916, i32 1)
store i32 %917, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 40) to i32*)
%918 = tail call i32 @llvm.fshl.i32(i32 %910, i32 %910, i32 5)
%919 = add i32 %917, -899497514
%920 = add i32 %919, %887
%921 = add i32 %920, %913
%922 = add i32 %921, %918
%923 = tail call i32 @llvm.fshl.i32(i32 %898, i32 %898, i32 30)
%924 = xor i32 %923, %911
%925 = xor i32 %924, %910
%926 = xor i32 %761, %737
%927 = xor i32 %926, %833
%928 = xor i32 %927, %893
%929 = tail call i32 @llvm.fshl.i32(i32 %928, i32 %928, i32 1)
store i32 %929, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 44) to i32*)
%930 = tail call i32 @llvm.fshl.i32(i32 %922, i32 %922, i32 5)
%931 = add i32 %929, -899497514
%932 = add i32 %931, %899
%933 = add i32 %932, %925
%934 = add i32 %933, %930
%935 = tail call i32 @llvm.fshl.i32(i32 %910, i32 %910, i32 30)
%936 = xor i32 %935, %923
%937 = xor i32 %936, %922
%938 = xor i32 %773, %749
%939 = xor i32 %938, %845
%940 = xor i32 %939, %905
%941 = tail call i32 @llvm.fshl.i32(i32 %940, i32 %940, i32 1)
store i32 %941, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 48) to i32*)
%942 = tail call i32 @llvm.fshl.i32(i32 %934, i32 %934, i32 5)
%943 = add i32 %941, -899497514
%944 = add i32 %943, %911
%945 = add i32 %944, %937
%946 = add i32 %945, %942
%947 = tail call i32 @llvm.fshl.i32(i32 %922, i32 %922, i32 30)
%948 = xor i32 %947, %935
%949 = xor i32 %948, %934
%950 = xor i32 %785, %761
%951 = xor i32 %950, %857
%952 = xor i32 %951, %917
%953 = tail call i32 @llvm.fshl.i32(i32 %952, i32 %952, i32 1)
store i32 %953, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 52) to i32*)
%954 = tail call i32 @llvm.fshl.i32(i32 %946, i32 %946, i32 5)
%955 = add i32 %953, -899497514
%956 = add i32 %955, %923
%957 = add i32 %956, %949
%958 = add i32 %957, %954
%959 = tail call i32 @llvm.fshl.i32(i32 %934, i32 %934, i32 30)
%960 = xor i32 %959, %947
%961 = xor i32 %960, %946
%962 = xor i32 %797, %773
%963 = xor i32 %962, %869
%964 = xor i32 %963, %929
%965 = tail call i32 @llvm.fshl.i32(i32 %964, i32 %964, i32 1)
store i32 %965, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 56) to i32*)
%966 = tail call i32 @llvm.fshl.i32(i32 %958, i32 %958, i32 5)
%967 = add i32 %965, -899497514
%968 = add i32 %967, %935
%969 = add i32 %968, %961
%970 = add i32 %969, %966
%971 = tail call i32 @llvm.fshl.i32(i32 %946, i32 %946, i32 30)
%972 = xor i32 %971, %959
%973 = xor i32 %972, %958
%974 = xor i32 %809, %785
%975 = xor i32 %974, %881
%976 = xor i32 %975, %941
%977 = tail call i32 @llvm.fshl.i32(i32 %976, i32 %976, i32 1)
store i32 %977, i32* bitcast (i8* getelementptr inbounds ([64 x i8], [64 x i8]* @SHA1Transform.workspace, i64 0, i64 60) to i32*)
%978 = tail call i32 @llvm.fshl.i32(i32 %970, i32 %970, i32 5)
%979 = tail call i32 @llvm.fshl.i32(i32 %958, i32 %958, i32 30)
%980 = load i32, i32* %0
%981 = add i32 %980, -899497514
%982 = add i32 %981, %977
%983 = add i32 %982, %947
%984 = add i32 %983, %973
%985 = add i32 %984, %978
store i32 %985, i32* %0
%986 = bitcast i32* %4 to <4 x i32>*
%987 = load <4 x i32>, <4 x i32>* %986
%988 = insertelement <4 x i32> poison, i32 %970, i64 0
%989 = insertelement <4 x i32> %988, i32 %979, i64 1
%990 = insertelement <4 x i32> %989, i32 %971, i64 2
%991 = insertelement <4 x i32> %990, i32 %959, i64 3
%992 = add <4 x i32> %991, %987
%993 = bitcast i32* %4 to <4 x i32>*
store <4 x i32> %992, <4 x i32>* %993
ret void
}