void SHA1_Transform(unsigned int state[5], const unsigned char buffer[64]) {
  unsigned int a, b, c, d, e;
  typedef union {
    unsigned char c[64];
    unsigned int l[16];
  } CHAR64LONG16;
  CHAR64LONG16 *block;
  block = (CHAR64LONG16 *)buffer;
  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]) << (24)) | ((block->l[0]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[0]) << (8)) | ((block->l[0]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += ((a & (b ^ c)) ^ c) +
       (block->l[1] =
            ((((block->l[1]) << (24)) | ((block->l[1]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[1]) << (8)) | ((block->l[1]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += ((e & (a ^ b)) ^ b) +
       (block->l[2] =
            ((((block->l[2]) << (24)) | ((block->l[2]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[2]) << (8)) | ((block->l[2]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += ((d & (e ^ a)) ^ a) +
       (block->l[3] =
            ((((block->l[3]) << (24)) | ((block->l[3]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[3]) << (8)) | ((block->l[3]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += ((c & (d ^ e)) ^ e) +
       (block->l[4] =
            ((((block->l[4]) << (24)) | ((block->l[4]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[4]) << (8)) | ((block->l[4]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += ((b & (c ^ d)) ^ d) +
       (block->l[5] =
            ((((block->l[5]) << (24)) | ((block->l[5]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[5]) << (8)) | ((block->l[5]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += ((a & (b ^ c)) ^ c) +
       (block->l[6] =
            ((((block->l[6]) << (24)) | ((block->l[6]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[6]) << (8)) | ((block->l[6]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += ((e & (a ^ b)) ^ b) +
       (block->l[7] =
            ((((block->l[7]) << (24)) | ((block->l[7]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[7]) << (8)) | ((block->l[7]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += ((d & (e ^ a)) ^ a) +
       (block->l[8] =
            ((((block->l[8]) << (24)) | ((block->l[8]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[8]) << (8)) | ((block->l[8]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += ((c & (d ^ e)) ^ e) +
       (block->l[9] =
            ((((block->l[9]) << (24)) | ((block->l[9]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[9]) << (8)) | ((block->l[9]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += ((b & (c ^ d)) ^ d) +
       (block->l[10] =
            ((((block->l[10]) << (24)) | ((block->l[10]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[10]) << (8)) | ((block->l[10]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((a) << (5)) | ((a) >> (32 - (5))));
  b = (((b) << (30)) | ((b) >> (32 - (30))));
  ;
  d += ((a & (b ^ c)) ^ c) +
       (block->l[11] =
            ((((block->l[11]) << (24)) | ((block->l[11]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[11]) << (8)) | ((block->l[11]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((e) << (5)) | ((e) >> (32 - (5))));
  a = (((a) << (30)) | ((a) >> (32 - (30))));
  ;
  c += ((e & (a ^ b)) ^ b) +
       (block->l[12] =
            ((((block->l[12]) << (24)) | ((block->l[12]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[12]) << (8)) | ((block->l[12]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((d) << (5)) | ((d) >> (32 - (5))));
  e = (((e) << (30)) | ((e) >> (32 - (30))));
  ;
  b += ((d & (e ^ a)) ^ a) +
       (block->l[13] =
            ((((block->l[13]) << (24)) | ((block->l[13]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[13]) << (8)) | ((block->l[13]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((c) << (5)) | ((c) >> (32 - (5))));
  d = (((d) << (30)) | ((d) >> (32 - (30))));
  ;
  a += ((c & (d ^ e)) ^ e) +
       (block->l[14] =
            ((((block->l[14]) << (24)) | ((block->l[14]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[14]) << (8)) | ((block->l[14]) >> (32 - (8)))) &
             0x00FF00FF)) +
       0x5A827999 + (((b) << (5)) | ((b) >> (32 - (5))));
  c = (((c) << (30)) | ((c) >> (32 - (30))));
  ;
  e += ((b & (c ^ d)) ^ d) +
       (block->l[15] =
            ((((block->l[15]) << (24)) | ((block->l[15]) >> (32 - (24)))) &
             0xFF00FF00) |
            ((((block->l[15]) << (8)) | ((block->l[15]) >> (32 - (8)))) &
             0x00FF00FF)) +
       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):
<SHA1_Transform>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    (%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    (%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    (%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x4(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x4(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x4(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x8(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x8(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x8(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0xc(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0xc(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0xc(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x10(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x10(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x10(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x14(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x14(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x14(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x18(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x18(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x18(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x1c(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x1c(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x1c(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x20(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x20(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x20(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x24(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x24(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x24(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x28(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x28(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x28(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x2c(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x2c(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x2c(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x30(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x30(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x30(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x34(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x34(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x34(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x38(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x38(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x38(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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
shl    $0x18,%ecx
mov    -0x30(%rbp),%rdx
mov    0x3c(%rdx),%edx
shr    $0x8,%edx
or     %edx,%ecx
and    $0xff00ff00,%ecx
mov    -0x30(%rbp),%rdx
mov    0x3c(%rdx),%edx
shl    $0x8,%edx
mov    -0x30(%rbp),%rsi
mov    0x3c(%rsi),%esi
shr    $0x18,%esi
or     %esi,%edx
and    $0xff00ff,%edx
or     %edx,%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)
pop    %rbp
ret

x86 assembly (clang, -O2):
<SHA1_Transform>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    (%rdi),%r8d
mov    0x4(%rdi),%ebp
mov    0x8(%rdi),%edx
mov    0xc(%rdi),%r10d
mov    %rdi,-0x8(%rsp)
mov    %r10d,%eax
xor    %edx,%eax
and    %ebp,%eax
xor    %r10d,%eax
mov    (%rsi),%r13d
mov    0x4(%rsi),%r14d
mov    %rsi,%r11
bswap  %r13d
mov    %r8d,%ecx
rol    $0x5,%ecx
add    0x10(%rdi),%ecx
add    %r13d,%ecx
lea    (%rax,%rcx,1),%ebx
add    $0x5a827999,%ebx
rol    $0x1e,%ebp
mov    %ebp,%ecx
xor    %edx,%ecx
and    %r8d,%ecx
xor    %edx,%ecx
bswap  %r14d
mov    %r14d,-0x54(%rsp)
mov    %ebx,%eax
rol    $0x5,%eax
add    %r10d,%ecx
add    %r14d,%ecx
lea    (%rax,%rcx,1),%r10d
add    $0x5a827999,%r10d
rol    $0x1e,%r8d
mov    %ebp,%eax
xor    %r8d,%eax
and    %ebx,%eax
xor    %ebp,%eax
mov    0x8(%rsi),%r15d
bswap  %r15d
mov    %r10d,%ecx
rol    $0x5,%ecx
add    %r15d,%edx
add    %eax,%edx
lea    (%rcx,%rdx,1),%esi
add    $0x5a827999,%esi
rol    $0x1e,%ebx
mov    %ebx,%eax
xor    %r8d,%eax
and    %r10d,%eax
xor    %r8d,%eax
mov    0xc(%r11),%edx
bswap  %edx
mov    %edx,-0x50(%rsp)
mov    %esi,%ecx
rol    $0x5,%ecx
add    %edx,%ebp
add    %eax,%ebp
lea    (%rcx,%rbp,1),%edi
add    $0x5a827999,%edi
rol    $0x1e,%r10d
mov    %r10d,%eax
xor    %ebx,%eax
and    %esi,%eax
xor    %ebx,%eax
mov    0x10(%r11),%edx
bswap  %edx
mov    %edx,-0x44(%rsp)
mov    %edi,%ecx
rol    $0x5,%ecx
add    %edx,%r8d
add    %eax,%r8d
lea    (%rcx,%r8,1),%ebp
add    $0x5a827999,%ebp
rol    $0x1e,%esi
mov    %esi,%eax
xor    %r10d,%eax
and    %edi,%eax
xor    %r10d,%eax
mov    0x14(%r11),%edx
bswap  %edx
mov    %edx,-0x4c(%rsp)
mov    %ebp,%ecx
rol    $0x5,%ecx
add    %edx,%ebx
add    %eax,%ebx
add    %ecx,%ebx
add    $0x5a827999,%ebx
rol    $0x1e,%edi
mov    %edi,%eax
xor    %esi,%eax
and    %ebp,%eax
xor    %esi,%eax
mov    0x18(%r11),%ecx
bswap  %ecx
mov    %ecx,-0x48(%rsp)
add    %ecx,%r10d
add    %eax,%r10d
mov    %ebx,%eax
rol    $0x5,%eax
lea    (%rax,%r10,1),%edx
add    $0x5a827999,%edx
rol    $0x1e,%ebp
mov    %ebp,%eax
xor    %edi,%eax
and    %ebx,%eax
xor    %edi,%eax
mov    0x1c(%r11),%ecx
bswap  %ecx
mov    %ecx,-0x40(%rsp)
add    %ecx,%esi
add    %eax,%esi
mov    %edx,%eax
rol    $0x5,%eax
add    %eax,%esi
add    $0x5a827999,%esi
rol    $0x1e,%ebx
mov    %ebx,%eax
xor    %ebp,%eax
and    %edx,%eax
xor    %ebp,%eax
mov    0x20(%r11),%r14d
bswap  %r14d
add    %r14d,%edi
mov    %r14d,-0x3c(%rsp)
add    %eax,%edi
mov    %esi,%eax
rol    $0x5,%eax
add    %eax,%edi
add    $0x5a827999,%edi
rol    $0x1e,%edx
mov    %edx,%eax
xor    %ebx,%eax
and    %esi,%eax
xor    %ebx,%eax
mov    0x24(%r11),%ecx
bswap  %ecx
mov    %ecx,-0x5c(%rsp)
add    %ecx,%ebp
add    %eax,%ebp
mov    %edi,%eax
rol    $0x5,%eax
lea    (%rax,%rbp,1),%ecx
add    $0x5a827999,%ecx
rol    $0x1e,%esi
mov    %esi,%eax
xor    %edx,%eax
and    %edi,%eax
xor    %edx,%eax
mov    0x28(%r11),%ebp
bswap  %ebp
mov    %ebp,-0x58(%rsp)
add    %ebp,%ebx
add    %eax,%ebx
mov    %ecx,%eax
rol    $0x5,%eax
lea    (%rax,%rbx,1),%r10d
add    $0x5a827999,%r10d
rol    $0x1e,%edi
mov    %edi,%ebx
xor    %esi,%ebx
and    %ecx,%ebx
xor    %esi,%ebx
mov    0x2c(%r11),%eax
bswap  %eax
mov    %eax,-0x2c(%rsp)
add    %eax,%edx
add    %ebx,%edx
mov    %r10d,%eax
rol    $0x5,%eax
lea    (%rax,%rdx,1),%r8d
add    $0x5a827999,%r8d
rol    $0x1e,%ecx
mov    %ecx,%eax
xor    %edi,%eax
and    %r10d,%eax
xor    %edi,%eax
mov    0x30(%r11),%edx
bswap  %edx
mov    %edx,-0x34(%rsp)
add    %edx,%esi
add    %eax,%esi
mov    %r8d,%eax
rol    $0x5,%eax
lea    (%rax,%rsi,1),%edx
add    $0x5a827999,%edx
rol    $0x1e,%r10d
mov    %r10d,%eax
xor    %ecx,%eax
and    %r8d,%eax
xor    %ecx,%eax
mov    0x34(%r11),%r9d
bswap  %r9d
add    %r9d,%edi
mov    %r9,-0x20(%rsp)
add    %eax,%edi
mov    %edx,%eax
rol    $0x5,%eax
add    %eax,%edi
add    $0x5a827999,%edi
rol    $0x1e,%r8d
mov    %r8d,%eax
xor    %r10d,%eax
and    %edx,%eax
xor    %r10d,%eax
mov    0x38(%r11),%ebp
mov    %r11,-0x10(%rsp)
bswap  %ebp
add    %ebp,%ecx
mov    %ebp,-0x38(%rsp)
add    %eax,%ecx
mov    %edi,%eax
rol    $0x5,%eax
lea    (%rax,%rcx,1),%esi
add    $0x5a827999,%esi
rol    $0x1e,%edx
mov    %edx,%eax
xor    %r8d,%eax
and    %edi,%eax
xor    %r8d,%eax
mov    0x3c(%r11),%r12d
bswap  %r12d
add    %r12d,%r10d
mov    %r12d,-0x30(%rsp)
add    %eax,%r10d
mov    %esi,%eax
rol    $0x5,%eax
lea    (%rax,%r10,1),%ecx
add    $0x5a827999,%ecx
xor    %r15d,%r13d
mov    %r14d,%ebx
xor    %r9d,%ebx
xor    %r13d,%ebx
rol    $0x1e,%edi
mov    %edi,%eax
xor    %edx,%eax
and    %esi,%eax
xor    %edx,%eax
rol    %ebx
add    %ebx,%r8d
mov    %rbx,%r13
add    %eax,%r8d
mov    %ecx,%eax
rol    $0x5,%eax
add    %eax,%r8d
add    $0x5a827999,%r8d
rol    $0x1e,%esi
mov    -0x50(%rsp),%r10d
mov    -0x54(%rsp),%r9d
xor    %r10d,%r9d
mov    -0x5c(%rsp),%ebx
mov    %ebx,%eax
xor    %ebp,%eax
xor    %r9d,%eax
mov    %esi,%ebx
xor    %edi,%ebx
and    %ecx,%ebx
xor    %edi,%ebx
rol    %eax
add    %eax,%edx
mov    %rax,%r14
mov    %rax,-0x18(%rsp)
add    %ebx,%edx
mov    %r8d,%eax
rol    $0x5,%eax
lea    (%rax,%rdx,1),%r9d
add    $0x5a827999,%r9d
mov    -0x44(%rsp),%r11d
xor    %r11d,%r15d
mov    -0x58(%rsp),%ebx
xor    %r12d,%ebx
xor    %r15d,%ebx
rol    $0x1e,%ecx
mov    %ecx,%edx
xor    %esi,%edx
and    %r8d,%edx
rol    %ebx
xor    %esi,%edx
mov    %r9d,%eax
rol    $0x5,%eax
add    %ebx,%edi
mov    %ebx,%r12d
mov    %ebx,-0x54(%rsp)
add    %edx,%edi
add    %eax,%edi
add    $0x5a827999,%edi
rol    $0x1e,%r8d
mov    %r8d,%eax
xor    %ecx,%eax
and    %r9d,%eax
xor    %ecx,%eax
mov    %r10d,%ebp
mov    -0x4c(%rsp),%ebx
xor    %ebx,%ebp
xor    -0x2c(%rsp),%ebp
mov    %r13,-0x28(%rsp)
xor    %r13d,%ebp
rol    %ebp
add    %ebp,%esi
mov    %ebp,-0x50(%rsp)
add    %eax,%esi
mov    %edi,%eax
rol    $0x5,%eax
lea    (%rax,%rsi,1),%r10d
add    $0x5a827999,%r10d
rol    $0x1e,%r9d
mov    %r9d,%eax
xor    %r8d,%eax
xor    %edi,%eax
mov    %r11d,%edx
mov    -0x48(%rsp),%r15d
xor    %r15d,%edx
xor    -0x34(%rsp),%edx
xor    %r14d,%edx
rol    %edx
add    %edx,%ecx
mov    %edx,%r14d
mov    %edx,-0x44(%rsp)
add    %eax,%ecx
mov    %r10d,%eax
rol    $0x5,%eax
rol    $0x1e,%edi
lea    (%rax,%rcx,1),%edx
add    $0x6ed9eba1,%edx
mov    %edi,%eax
xor    %r9d,%eax
xor    %r10d,%eax
mov    -0x40(%rsp),%esi
xor    %esi,%ebx
xor    -0x20(%rsp),%ebx
xor    %r12d,%ebx
rol    %ebx
add    %ebx,%r8d
mov    %ebx,%r13d
mov    %ebx,-0x4c(%rsp)
add    %eax,%r8d
mov    %edx,%eax
rol    $0x5,%eax
add    %eax,%r8d
add    $0x6ed9eba1,%r8d
rol    $0x1e,%r10d
mov    %r10d,%eax
xor    %edi,%eax
xor    %edx,%eax
mov    -0x3c(%rsp),%r12d
xor    %r12d,%r15d
xor    -0x38(%rsp),%r15d
xor    %ebp,%r15d
rol    %r15d
add    %r15d,%r9d
mov    %r15d,-0x48(%rsp)
add    %eax,%r9d
mov    %r8d,%eax
rol    $0x5,%eax
rol    $0x1e,%edx
add    %r9d,%eax
add    $0x6ed9eba1,%eax
mov    %edx,%ecx
xor    %r10d,%ecx
xor    %r8d,%ecx
mov    -0x5c(%rsp),%ebx
xor    %ebx,%esi
xor    -0x30(%rsp),%esi
xor    %r14d,%esi
rol    %esi
add    %esi,%edi
mov    %esi,%r14d
mov    %esi,-0x40(%rsp)
add    %ecx,%edi
mov    %eax,%ecx
rol    $0x5,%ecx
add    %ecx,%edi
add    $0x6ed9eba1,%edi
rol    $0x1e,%r8d
mov    %r8d,%ecx
xor    %edx,%ecx
xor    %eax,%ecx
mov    -0x58(%rsp),%ebp
xor    %ebp,%r12d
xor    -0x28(%rsp),%r12d
xor    %r13d,%r12d
rol    %r12d
add    %r12d,%r10d
mov    %r12d,-0x3c(%rsp)
add    %ecx,%r10d
mov    %edi,%ecx
rol    $0x5,%ecx
rol    $0x1e,%eax
lea    (%rcx,%r10,1),%esi
add    $0x6ed9eba1,%esi
mov    %eax,%ecx
xor    %r8d,%ecx
xor    %edi,%ecx
mov    %ebx,%r13d
mov    -0x2c(%rsp),%r11d
xor    %r11d,%r13d
xor    -0x18(%rsp),%r13d
xor    %r15d,%r13d
rol    %r13d
add    %r13d,%edx
mov    %r13d,%ebx
mov    %r13d,-0x5c(%rsp)
add    %ecx,%edx
mov    %esi,%ecx
rol    $0x5,%ecx
lea    (%rcx,%rdx,1),%r9d
add    $0x6ed9eba1,%r9d
rol    $0x1e,%edi
mov    %edi,%ecx
xor    %eax,%ecx
xor    %esi,%ecx
mov    -0x34(%rsp),%r10d
xor    %r10d,%ebp
xor    -0x54(%rsp),%ebp
xor    %r14d,%ebp
rol    %ebp
add    %ebp,%r8d
mov    %ebp,%r15d
mov    %ebp,-0x58(%rsp)
add    %ecx,%r8d
mov    %r9d,%ecx
rol    $0x5,%ecx
rol    $0x1e,%esi
add    %r8d,%ecx
add    $0x6ed9eba1,%ecx
mov    %esi,%edx
xor    %edi,%edx
xor    %r9d,%edx
mov    %r11d,%r13d
mov    -0x20(%rsp),%r11
xor    %r11d,%r13d
xor    -0x50(%rsp),%r13d
xor    %r12d,%r13d
rol    %r13d
add    %r13d,%eax
mov    %r13d,-0x2c(%rsp)
add    %edx,%eax
mov    %ecx,%edx
rol    $0x5,%edx
lea    (%rdx,%rax,1),%r8d
add    $0x6ed9eba1,%r8d
rol    $0x1e,%r9d
mov    %r9d,%eax
xor    %esi,%eax
xor    %ecx,%eax
mov    %r10d,%edx
mov    -0x38(%rsp),%ebp
xor    %ebp,%edx
mov    -0x44(%rsp),%r12d
xor    %r12d,%edx
xor    %ebx,%edx
rol    %edx
add    %edx,%edi
mov    %edx,%ebx
mov    %edx,-0x34(%rsp)
add    %eax,%edi
mov    %r8d,%eax
rol    $0x5,%eax
rol    $0x1e,%ecx
add    %eax,%edi
add    $0x6ed9eba1,%edi
mov    %ecx,%eax
xor    %r9d,%eax
xor    %r8d,%eax
mov    -0x30(%rsp),%r10d
mov    %r11,%rdx
xor    %r10d,%edx
xor    -0x4c(%rsp),%edx
xor    %r15d,%edx
rol    %edx
mov    %rdx,-0x20(%rsp)
add    %edx,%esi
add    %eax,%esi
mov    %edi,%eax
rol    $0x5,%eax
add    %esi,%eax
add    $0x6ed9eba1,%eax
rol    $0x1e,%r8d
mov    %r8d,%edx
xor    %ecx,%edx
xor    %edi,%edx
mov    %ebp,%r15d
mov    -0x28(%rsp),%r11
xor    %r11d,%r15d
xor    -0x48(%rsp),%r15d
xor    %r13d,%r15d
rol    %r15d
add    %r15d,%r9d
mov    %r15d,-0x38(%rsp)
add    %edx,%r9d
mov    %eax,%edx
rol    $0x5,%edx
rol    $0x1e,%edi
lea    (%rdx,%r9,1),%esi
add    $0x6ed9eba1,%esi
mov    %edi,%r9d
xor    %r8d,%r9d
xor    %eax,%r9d
mov    %r10d,%edx
mov    -0x18(%rsp),%r14
xor    %r14d,%edx
xor    -0x40(%rsp),%edx
xor    %ebx,%edx
rol    %edx
add    %edx,%ecx
mov    %edx,%ebp
mov    %edx,-0x30(%rsp)
add    %r9d,%ecx
mov    %esi,%edx
rol    $0x5,%edx
lea    (%rdx,%rcx,1),%r9d
add    $0x6ed9eba1,%r9d
rol    $0x1e,%eax
mov    %eax,%ecx
xor    %edi,%ecx
xor    %esi,%ecx
mov    -0x54(%rsp),%ebx
mov    %r11,%rdx
xor    %ebx,%edx
xor    -0x3c(%rsp),%edx
mov    -0x20(%rsp),%r11
xor    %r11d,%edx
rol    %edx
add    %edx,%r8d
mov    %rdx,%r13
mov    %rdx,-0x28(%rsp)
add    %ecx,%r8d
mov    %r9d,%ecx
rol    $0x5,%ecx
rol    $0x1e,%esi
add    %r8d,%ecx
add    $0x6ed9eba1,%ecx
mov    %esi,%edx
xor    %eax,%edx
xor    %r9d,%edx
mov    -0x50(%rsp),%r10d
xor    %r10d,%r14d
xor    -0x5c(%rsp),%r14d
xor    %r15d,%r14d
rol    %r14d
add    %r14d,%edi
add    %edx,%edi
mov    %ecx,%edx
rol    $0x5,%edx
add    %edx,%edi
add    $0x6ed9eba1,%edi
rol    $0x1e,%r9d
mov    %r9d,%edx
xor    %esi,%edx
xor    %ecx,%edx
mov    %ebx,%r15d
xor    %r12d,%r15d
xor    -0x58(%rsp),%r15d
xor    %ebp,%r15d
rol    %r15d
add    %r15d,%eax
mov    %r15d,-0x54(%rsp)
add    %edx,%eax
mov    %edi,%edx
rol    $0x5,%edx
rol    $0x1e,%ecx
add    %edx,%eax
add    $0x6ed9eba1,%eax
mov    %ecx,%r8d
xor    %r9d,%r8d
xor    %edi,%r8d
mov    %r10d,%ebx
mov    -0x4c(%rsp),%r10d
xor    %r10d,%ebx
xor    -0x2c(%rsp),%ebx
xor    %r13d,%ebx
rol    %ebx
add    %ebx,%esi
mov    %ebx,-0x50(%rsp)
add    %r8d,%esi
mov    %eax,%edx
rol    $0x5,%edx
lea    (%rdx,%rsi,1),%r8d
add    $0x6ed9eba1,%r8d
rol    $0x1e,%edi
mov    %edi,%edx
xor    %ecx,%edx
xor    %eax,%edx
mov    -0x48(%rsp),%r13d
xor    %r13d,%r12d
xor    -0x34(%rsp),%r12d
xor    %r14d,%r12d
rol    %r12d
add    %r12d,%r9d
mov    %r12d,-0x44(%rsp)
add    %edx,%r9d
mov    %r8d,%edx
rol    $0x5,%edx
rol    $0x1e,%eax
add    %edx,%r9d
add    $0x6ed9eba1,%r9d
mov    %eax,%esi
xor    %edi,%esi
xor    %r8d,%esi
mov    -0x40(%rsp),%ebp
xor    %ebp,%r10d
xor    %r11d,%r10d
xor    %r15d,%r10d
rol    %r10d
add    %r10d,%ecx
mov    %r10d,-0x4c(%rsp)
add    %esi,%ecx
mov    %r9d,%esi
rol    $0x5,%esi
add    %ecx,%esi
add    $0x6ed9eba1,%esi
rol    $0x1e,%r8d
mov    %r8d,%ecx
xor    %eax,%ecx
xor    %r9d,%ecx
mov    %r13d,%r11d
mov    -0x3c(%rsp),%r15d
xor    %r15d,%r11d
xor    -0x38(%rsp),%r11d
xor    %ebx,%r11d
rol    %r11d
add    %r11d,%edi
mov    %r11d,-0x48(%rsp)
add    %ecx,%edi
mov    %esi,%ecx
rol    $0x5,%ecx
rol    $0x1e,%r9d
add    %ecx,%edi
add    $0x6ed9eba1,%edi
mov    %r9d,%ecx
xor    %r8d,%ecx
xor    %esi,%ecx
mov    %ebp,%edx
mov    -0x5c(%rsp),%r13d
xor    %r13d,%edx
xor    -0x30(%rsp),%edx
xor    %r12d,%edx
rol    %edx
add    %edx,%eax
mov    %edx,%r12d
mov    %edx,-0x40(%rsp)
add    %ecx,%eax
mov    %edi,%ecx
rol    $0x5,%ecx
add    %ecx,%eax
add    $0x6ed9eba1,%eax
rol    $0x1e,%esi
mov    %edi,%ecx
or     %esi,%ecx
and    %r9d,%ecx
mov    %edi,%edx
and    %esi,%edx
or     %ecx,%edx
mov    -0x58(%rsp),%ebp
xor    %ebp,%r15d
xor    -0x28(%rsp),%r15d
xor    %r10d,%r15d
rol    %r15d
add    %r15d,%r8d
mov    %r15d,-0x3c(%rsp)
add    %edx,%r8d
mov    %eax,%ecx
rol    $0x5,%ecx
add    %ecx,%r8d
add    $0x8f1bbcdc,%r8d
rol    $0x1e,%edi
mov    %eax,%edx
or     %edi,%edx
and    %esi,%edx
mov    %eax,%ecx
and    %edi,%ecx
or     %edx,%ecx
mov    %r13d,%r10d
mov    -0x2c(%rsp),%r13d
xor    %r13d,%r10d
xor    %r14d,%r10d
xor    %r11d,%r10d
rol    %r10d
add    %r10d,%r9d
mov    %r10d,-0x5c(%rsp)
add    %ecx,%r9d
mov    %r8d,%ecx
rol    $0x5,%ecx
add    %ecx,%r9d
add    $0x8f1bbcdc,%r9d
rol    $0x1e,%eax
mov    %r8d,%ecx
or     %eax,%ecx
and    %edi,%ecx
mov    %r8d,%edx
and    %eax,%edx
or     %ecx,%edx
mov    -0x34(%rsp),%ebx
xor    %ebx,%ebp
xor    -0x54(%rsp),%ebp
xor    %r12d,%ebp
rol    %ebp
add    %ebp,%esi
mov    %ebp,-0x58(%rsp)
add    %edx,%esi
mov    %r9d,%ecx
rol    $0x5,%ecx
add    %ecx,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%r8d
mov    %r9d,%ecx
or     %r8d,%ecx
and    %eax,%ecx
mov    %r9d,%edx
and    %r8d,%edx
or     %ecx,%edx
mov    -0x20(%rsp),%r11
xor    %r11d,%r13d
xor    -0x50(%rsp),%r13d
xor    %r15d,%r13d
rol    %r13d
add    %r13d,%edi
mov    %r13d,-0x2c(%rsp)
add    %edx,%edi
mov    %esi,%ecx
rol    $0x5,%ecx
add    %ecx,%edi
add    $0x8f1bbcdc,%edi
rol    $0x1e,%r9d
mov    %esi,%ecx
or     %r9d,%ecx
and    %r8d,%ecx
mov    %esi,%edx
and    %r9d,%edx
or     %ecx,%edx
mov    %ebx,%ecx
mov    -0x38(%rsp),%ebx
xor    %ebx,%ecx
xor    -0x44(%rsp),%ecx
xor    %r10d,%ecx
rol    %ecx
add    %ecx,%eax
mov    %ecx,%r12d
mov    %ecx,-0x34(%rsp)
add    %edx,%eax
mov    %edi,%ecx
rol    $0x5,%ecx
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
rol    $0x1e,%esi
mov    %edi,%ecx
or     %esi,%ecx
and    %r9d,%ecx
mov    %edi,%edx
and    %esi,%edx
or     %ecx,%edx
mov    -0x30(%rsp),%r10d
xor    %r10d,%r11d
xor    -0x4c(%rsp),%r11d
xor    %ebp,%r11d
rol    %r11d
add    %r11d,%r8d
add    %edx,%r8d
mov    %eax,%ecx
rol    $0x5,%ecx
add    %ecx,%r8d
add    $0x8f1bbcdc,%r8d
rol    $0x1e,%edi
mov    %eax,%edx
or     %edi,%edx
and    %esi,%edx
mov    %eax,%ecx
and    %edi,%ecx
or     %edx,%ecx
mov    %ebx,%edx
mov    -0x28(%rsp),%r15
xor    %r15d,%edx
xor    -0x48(%rsp),%edx
xor    %r13d,%edx
rol    %edx
add    %edx,%r9d
mov    %edx,%r13d
mov    %edx,-0x38(%rsp)
add    %ecx,%r9d
mov    %r8d,%ecx
rol    $0x5,%ecx
add    %ecx,%r9d
add    $0x8f1bbcdc,%r9d
rol    $0x1e,%eax
mov    %r8d,%ecx
or     %eax,%ecx
and    %edi,%ecx
mov    %r8d,%edx
and    %eax,%edx
or     %ecx,%edx
xor    %r14d,%r10d
xor    -0x40(%rsp),%r10d
xor    %r12d,%r10d
rol    %r10d
add    %r10d,%esi
mov    %r10d,%ebp
mov    %r10d,-0x30(%rsp)
add    %edx,%esi
mov    %r9d,%ecx
rol    $0x5,%ecx
add    %ecx,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%r8d
mov    %r9d,%ecx
or     %r8d,%ecx
and    %eax,%ecx
mov    %r9d,%edx
and    %r8d,%edx
or     %ecx,%edx
mov    -0x54(%rsp),%ebx
xor    %ebx,%r15d
xor    -0x3c(%rsp),%r15d
xor    %r11d,%r15d
mov    %r11,%r12
mov    %r11,-0x20(%rsp)
rol    %r15d
add    %r15d,%edi
mov    %r15,-0x28(%rsp)
add    %edx,%edi
mov    %esi,%ecx
rol    $0x5,%ecx
add    %ecx,%edi
add    $0x8f1bbcdc,%edi
rol    $0x1e,%r9d
mov    %esi,%ecx
or     %r9d,%ecx
and    %r8d,%ecx
mov    %esi,%edx
and    %r9d,%edx
or     %ecx,%edx
mov    -0x50(%rsp),%r11d
xor    %r11d,%r14d
xor    -0x5c(%rsp),%r14d
xor    %r13d,%r14d
rol    %r14d
add    %r14d,%eax
add    %edx,%eax
mov    %edi,%ecx
rol    $0x5,%ecx
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
rol    $0x1e,%esi
mov    %edi,%ecx
or     %esi,%ecx
and    %r9d,%ecx
mov    %edi,%edx
and    %esi,%edx
or     %ecx,%edx
mov    -0x44(%rsp),%r10d
xor    %r10d,%ebx
xor    -0x58(%rsp),%ebx
xor    %ebp,%ebx
rol    %ebx
add    %ebx,%r8d
mov    %ebx,-0x54(%rsp)
add    %edx,%r8d
mov    %eax,%ecx
rol    $0x5,%ecx
add    %ecx,%r8d
add    $0x8f1bbcdc,%r8d
rol    $0x1e,%edi
mov    %eax,%edx
or     %edi,%edx
and    %esi,%edx
mov    %eax,%ecx
and    %edi,%ecx
or     %edx,%ecx
mov    %r11d,%edx
mov    -0x4c(%rsp),%r11d
xor    %r11d,%edx
mov    -0x2c(%rsp),%r13d
xor    %r13d,%edx
xor    %r15d,%edx
rol    %edx
add    %edx,%r9d
mov    %edx,%r15d
add    %ecx,%r9d
mov    %r8d,%ecx
rol    $0x5,%ecx
add    %ecx,%r9d
add    $0x8f1bbcdc,%r9d
rol    $0x1e,%eax
mov    %r8d,%ecx
or     %eax,%ecx
and    %edi,%ecx
mov    %r8d,%edx
and    %eax,%edx
or     %ecx,%edx
mov    -0x48(%rsp),%ebp
xor    %ebp,%r10d
xor    -0x34(%rsp),%r10d
xor    %r14d,%r10d
mov    %r14,-0x18(%rsp)
rol    %r10d
mov    %r10d,-0x44(%rsp)
add    %r10d,%esi
add    %edx,%esi
mov    %r9d,%ecx
rol    $0x5,%ecx
add    %ecx,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%r8d
mov    %r9d,%ecx
or     %r8d,%ecx
and    %eax,%ecx
mov    %r9d,%edx
and    %r8d,%edx
or     %ecx,%edx
mov    %r11d,%ecx
mov    -0x40(%rsp),%r10d
xor    %r10d,%ecx
xor    %r12d,%ecx
xor    %ebx,%ecx
rol    %ecx
add    %ecx,%edi
mov    %ecx,%ebx
mov    %ecx,-0x4c(%rsp)
add    %edx,%edi
mov    %esi,%ecx
rol    $0x5,%ecx
add    %ecx,%edi
add    $0x8f1bbcdc,%edi
rol    $0x1e,%r9d
mov    %esi,%ecx
or     %r9d,%ecx
and    %r8d,%ecx
mov    %esi,%edx
and    %r9d,%edx
or     %ecx,%edx
mov    %ebp,%ecx
mov    -0x3c(%rsp),%r12d
xor    %r12d,%ecx
xor    -0x38(%rsp),%ecx
mov    %r15d,-0x50(%rsp)
xor    %r15d,%ecx
rol    %ecx
add    %ecx,%eax
mov    %ecx,%r11d
mov    %ecx,-0x48(%rsp)
add    %edx,%eax
mov    %edi,%ecx
rol    $0x5,%ecx
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
rol    $0x1e,%esi
mov    %edi,%ecx
or     %esi,%ecx
and    %r9d,%ecx
mov    %edi,%edx
and    %esi,%edx
or     %ecx,%edx
mov    %r10d,%r15d
mov    -0x5c(%rsp),%r10d
xor    %r10d,%r15d
xor    -0x30(%rsp),%r15d
xor    -0x44(%rsp),%r15d
rol    %r15d
add    %r15d,%r8d
mov    %r15d,-0x40(%rsp)
add    %edx,%r8d
mov    %eax,%ecx
rol    $0x5,%ecx
add    %ecx,%r8d
add    $0x8f1bbcdc,%r8d
rol    $0x1e,%edi
mov    %eax,%edx
or     %edi,%edx
and    %esi,%edx
mov    %eax,%ecx
and    %edi,%ecx
or     %edx,%ecx
mov    -0x58(%rsp),%ebp
xor    %ebp,%r12d
xor    -0x28(%rsp),%r12d
xor    %ebx,%r12d
rol    %r12d
add    %r12d,%r9d
mov    %r12d,%ebx
add    %ecx,%r9d
mov    %r8d,%ecx
rol    $0x5,%ecx
add    %ecx,%r9d
add    $0x8f1bbcdc,%r9d
rol    $0x1e,%eax
mov    %r8d,%ecx
or     %eax,%ecx
and    %edi,%ecx
mov    %r8d,%edx
and    %eax,%edx
or     %ecx,%edx
mov    %r10d,%ecx
xor    %r13d,%ecx
xor    %r14d,%ecx
xor    %r11d,%ecx
rol    %ecx
mov    %ecx,-0x5c(%rsp)
add    %ecx,%esi
add    %edx,%esi
mov    %r9d,%ecx
rol    $0x5,%ecx
add    %ecx,%esi
add    $0x8f1bbcdc,%esi
rol    $0x1e,%r8d
mov    %r9d,%ecx
or     %r8d,%ecx
and    %eax,%ecx
mov    %r9d,%edx
and    %r8d,%edx
or     %ecx,%edx
mov    -0x34(%rsp),%r12d
xor    %r12d,%ebp
xor    -0x54(%rsp),%ebp
xor    %r15d,%ebp
rol    %ebp
add    %ebp,%edi
mov    %ebp,%r15d
mov    %ebp,-0x58(%rsp)
add    %edx,%edi
mov    %esi,%ecx
rol    $0x5,%ecx
lea    (%rcx,%rdi,1),%r10d
add    $0x8f1bbcdc,%r10d
rol    $0x1e,%r9d
mov    %esi,%ecx
or     %r9d,%ecx
and    %r8d,%ecx
mov    %esi,%edx
and    %r9d,%edx
or     %ecx,%edx
mov    -0x20(%rsp),%r11
xor    %r11d,%r13d
xor    -0x50(%rsp),%r13d
xor    %ebx,%r13d
mov    %ebx,%r14d
rol    %r13d
add    %r13d,%eax
mov    %r13d,%ebx
mov    %r13d,-0x2c(%rsp)
add    %edx,%eax
mov    %r10d,%ecx
rol    $0x5,%ecx
add    %ecx,%eax
add    $0x8f1bbcdc,%eax
rol    $0x1e,%esi
mov    %esi,%ecx
xor    %r9d,%ecx
xor    %r10d,%ecx
mov    %r12d,%r13d
mov    -0x38(%rsp),%edi
xor    %edi,%r13d
xor    -0x44(%rsp),%r13d
mov    -0x5c(%rsp),%r12d
xor    %r12d,%r13d
rol    %r13d
add    %r13d,%r8d
mov    %r13d,-0x34(%rsp)
add    %ecx,%r8d
mov    %eax,%ecx
rol    $0x5,%ecx
rol    $0x1e,%r10d
add    %r8d,%ecx
add    $0xca62c1d6,%ecx
mov    %r10d,%edx
xor    %esi,%edx
xor    %eax,%edx
mov    -0x30(%rsp),%ebp
xor    %ebp,%r11d
xor    -0x4c(%rsp),%r11d
xor    %r15d,%r11d
rol    %r11d
add    %r11d,%r9d
add    %edx,%r9d
mov    %ecx,%edx
rol    $0x5,%edx
lea    (%rdx,%r9,1),%r8d
add    $0xca62c1d6,%r8d
rol    $0x1e,%eax
mov    %eax,%edx
xor    %r10d,%edx
xor    %ecx,%edx
mov    -0x28(%rsp),%r15
xor    %r15d,%edi
xor    -0x48(%rsp),%edi
xor    %ebx,%edi
rol    %edi
add    %edi,%esi
mov    %edi,%r9d
mov    %edi,-0x38(%rsp)
add    %edx,%esi
mov    %r8d,%edx
rol    $0x5,%edx
rol    $0x1e,%ecx
add    %esi,%edx
add    $0xca62c1d6,%edx
mov    %ecx,%esi
xor    %eax,%esi
xor    %r8d,%esi
mov    %ebp,%edi
mov    -0x18(%rsp),%rbp
xor    %ebp,%edi
xor    -0x40(%rsp),%edi
xor    %r13d,%edi
rol    %edi
add    %edi,%r10d
mov    %edi,%r13d
add    %esi,%r10d
mov    %edx,%esi
rol    $0x5,%esi
add    %esi,%r10d
add    $0xca62c1d6,%r10d
rol    $0x1e,%r8d
mov    %r8d,%edi
xor    %ecx,%edi
xor    %edx,%edi
mov    -0x54(%rsp),%ebx
xor    %ebx,%r15d
mov    %r14d,-0x3c(%rsp)
xor    %r14d,%r15d
mov    %r11,-0x20(%rsp)
xor    %r11d,%r15d
rol    %r15d
add    %r15d,%eax
mov    %r15,-0x28(%rsp)
add    %edi,%eax
mov    %r10d,%edi
rol    $0x5,%edi
rol    $0x1e,%edx
add    %edi,%eax
add    $0xca62c1d6,%eax
mov    %edx,%edi
xor    %r8d,%edi
xor    %r10d,%edi
mov    -0x50(%rsp),%esi
mov    %rbp,%r14
xor    %esi,%r14d
xor    %r12d,%r14d
xor    %r9d,%r14d
rol    %r14d
add    %r14d,%ecx
mov    %r14,-0x18(%rsp)
add    %edi,%ecx
mov    %eax,%edi
rol    $0x5,%edi
lea    (%rdi,%rcx,1),%r9d
add    $0xca62c1d6,%r9d
rol    $0x1e,%r10d
mov    %r10d,%edi
xor    %edx,%edi
xor    %eax,%edi
mov    -0x44(%rsp),%ebp
xor    %ebp,%ebx
xor    -0x58(%rsp),%ebx
mov    %r13d,-0x30(%rsp)
xor    %r13d,%ebx
rol    %ebx
add    %ebx,%r8d
mov    %ebx,-0x54(%rsp)
add    %edi,%r8d
mov    %r9d,%edi
rol    $0x5,%edi
rol    $0x1e,%eax
add    %r8d,%edi
add    $0xca62c1d6,%edi
mov    %eax,%ecx
xor    %r10d,%ecx
xor    %r9d,%ecx
mov    -0x4c(%rsp),%r12d
xor    %r12d,%esi
xor    -0x2c(%rsp),%esi
xor    %r15d,%esi
rol    %esi
add    %esi,%edx
mov    %esi,%r15d
mov    %esi,-0x50(%rsp)
add    %ecx,%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    %ebp,%edx
mov    -0x48(%rsp),%esi
xor    %esi,%edx
xor    -0x34(%rsp),%edx
xor    %r14d,%edx
rol    %edx
add    %edx,%r10d
mov    %edx,%r14d
mov    %edx,-0x44(%rsp)
add    %ecx,%r10d
mov    %r8d,%ecx
rol    $0x5,%ecx
rol    $0x1e,%edi
add    %ecx,%r10d
add    $0xca62c1d6,%r10d
mov    %edi,%ecx
xor    %r9d,%ecx
xor    %r8d,%ecx
mov    %r12d,%edx
mov    -0x40(%rsp),%ebp
xor    %ebp,%edx
xor    %r11d,%edx
xor    %ebx,%edx
rol    %edx
add    %edx,%eax
mov    %edx,%r11d
mov    %edx,-0x4c(%rsp)
add    %ecx,%eax
mov    %r10d,%ecx
rol    $0x5,%ecx
lea    (%rcx,%rax,1),%edx
add    $0xca62c1d6,%edx
rol    $0x1e,%r8d
mov    %r8d,%eax
xor    %edi,%eax
xor    %r10d,%eax
mov    %esi,%ecx
mov    -0x3c(%rsp),%r12d
xor    %r12d,%ecx
xor    -0x38(%rsp),%ecx
xor    %r15d,%ecx
rol    %ecx
add    %ecx,%r9d
mov    %ecx,%r15d
add    %eax,%r9d
mov    %edx,%eax
rol    $0x5,%eax
rol    $0x1e,%r10d
add    %r9d,%eax
add    $0xca62c1d6,%eax
mov    %r10d,%ecx
xor    %r8d,%ecx
xor    %edx,%ecx
mov    %ebp,%esi
mov    -0x5c(%rsp),%r9d
xor    %r9d,%esi
xor    %r13d,%esi
xor    %r14d,%esi
rol    %esi
add    %esi,%edi
mov    %esi,%r14d
add    %ecx,%edi
mov    %eax,%ecx
rol    $0x5,%ecx
add    %edi,%ecx
add    $0xca62c1d6,%ecx
rol    $0x1e,%edx
mov    %edx,%edi
xor    %r10d,%edi
xor    %eax,%edi
mov    %r12d,%esi
mov    -0x58(%rsp),%r12d
xor    %r12d,%esi
mov    -0x28(%rsp),%rbx
xor    %ebx,%esi
xor    %r11d,%esi
rol    %esi
mov    %esi,-0x3c(%rsp)
add    %esi,%r8d
add    %edi,%r8d
mov    %ecx,%edi
rol    $0x5,%edi
rol    $0x1e,%eax
add    %edi,%r8d
add    $0xca62c1d6,%r8d
mov    %eax,%edi
xor    %edx,%edi
xor    %ecx,%edi
mov    %r9d,%ebp
mov    -0x2c(%rsp),%r13d
xor    %r13d,%ebp
mov    -0x18(%rsp),%rsi
xor    %esi,%ebp
mov    %r15d,%r11d
mov    %r15d,-0x48(%rsp)
xor    %r15d,%ebp
rol    %ebp
mov    %ebp,-0x5c(%rsp)
add    %ebp,%r10d
add    %edi,%r10d
mov    %r8d,%edi
rol    $0x5,%edi
lea    (%rdi,%r10,1),%r9d
add    $0xca62c1d6,%r9d
mov    -0x10(%rsp),%r10
mov    %ebx,(%r10)
mov    %esi,0x4(%r10)
mov    -0x54(%rsp),%esi
mov    %esi,0x8(%r10)
mov    %r12d,%ebp
mov    -0x34(%rsp),%r15d
xor    %r15d,%ebp
xor    %esi,%ebp
rol    $0x1e,%ecx
mov    %ecx,%edi
xor    %eax,%edi
mov    %r14d,%esi
mov    %r14d,-0x40(%rsp)
xor    %r14d,%ebp
rol    %ebp
mov    %ebp,-0x58(%rsp)
xor    %r8d,%edi
mov    %r9d,%ebx
rol    $0x5,%ebx
add    %ebp,%edx
add    %edi,%edx
lea    (%rbx,%rdx,1),%r14d
add    $0xca62c1d6,%r14d
mov    %r10,%rdx
mov    -0x50(%rsp),%edi
mov    %edi,0xc(%r10)
mov    %r13d,%r10d
mov    -0x20(%rsp),%r12
xor    %r12d,%r10d
xor    %edi,%r10d
mov    -0x44(%rsp),%r13d
mov    %r13d,0x10(%rdx)
mov    -0x4c(%rsp),%ebp
mov    %ebp,0x14(%rdx)
mov    %r11d,0x18(%rdx)
mov    %esi,0x1c(%rdx)
mov    -0x3c(%rsp),%esi
mov    %esi,0x20(%rdx)
rol    $0x1e,%r8d
xor    %esi,%r10d
mov    %r8d,%edi
xor    %ecx,%edi
rol    %r10d
xor    %r9d,%edi
mov    %r14d,%ebx
rol    $0x5,%ebx
add    %r10d,%eax
add    %edi,%eax
add    %eax,%ebx
add    $0xca62c1d6,%ebx
mov    %r15d,%eax
mov    -0x38(%rsp),%r11d
xor    %r11d,%eax
xor    %r13d,%eax
mov    -0x5c(%rsp),%esi
mov    %esi,0x24(%rdx)
xor    %esi,%eax
rol    $0x1e,%r9d
mov    %r9d,%edi
xor    %r8d,%edi
xor    %r14d,%edi
rol    %eax
add    %eax,%ecx
mov    %eax,%r13d
add    %edi,%ecx
mov    %ebx,%edi
rol    $0x5,%edi
add    %edi,%ecx
add    $0xca62c1d6,%ecx
mov    -0x30(%rsp),%r15d
xor    %r15d,%r12d
xor    %ebp,%r12d
mov    -0x58(%rsp),%esi
mov    %esi,0x28(%rdx)
xor    %esi,%r12d
mov    %r10d,0x2c(%rdx)
rol    $0x1e,%r14d
mov    %eax,0x30(%rdx)
rol    %r12d
mov    %r12d,0x34(%rdx)
add    %r8d,%r12d
mov    %r14d,%edi
xor    %r9d,%edi
xor    %ebx,%edi
add    %edi,%r12d
mov    %ecx,%edi
rol    $0x5,%edi
add    %r12d,%edi
add    $0xca62c1d6,%edi
mov    -0x28(%rsp),%rbp
xor    %r11d,%ebp
xor    -0x48(%rsp),%ebp
rol    $0x1e,%ebx
xor    %r10d,%ebp
mov    %ebx,%eax
xor    %r14d,%eax
xor    %ecx,%eax
rol    %ebp
mov    %ebp,0x38(%rdx)
add    %r9d,%ebp
mov    %edi,%esi
rol    $0x5,%esi
add    %eax,%ebp
add    %ebp,%esi
add    $0xca62c1d6,%esi
mov    -0x18(%rsp),%rax
xor    %r15d,%eax
xor    -0x40(%rsp),%eax
xor    %r13d,%eax
rol    %eax
mov    %eax,0x3c(%rdx)
rol    $0x1e,%ecx
mov    -0x8(%rsp),%rbp
add    0x0(%rbp),%eax
add    %r14d,%eax
movd   %ecx,%xmm0
xor    %ebx,%ecx
xor    %edi,%ecx
add    %ecx,%eax
movd   %esi,%xmm1
rol    $0x5,%esi
add    %esi,%eax
add    $0xca62c1d6,%eax
mov    %eax,0x0(%rbp)
rol    $0x1e,%edi
movd   %edi,%xmm2
movd   %ebx,%xmm3
punpckldq %xmm2,%xmm1
movdqu 0x4(%rbp),%xmm2
punpckldq %xmm3,%xmm0
punpcklqdq %xmm0,%xmm1
paddd  %xmm2,%xmm1
movdqu %xmm1,0x4(%rbp)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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