void garble(unsigned char *buffer0, unsigned char *buffer1,
            unsigned char *buffer2, unsigned char *buffer3,
            unsigned char *buffer4) {
  unsigned int tmp, tmp2, tmp3;
  unsigned int A, B, C, D, E, M, J, G, F, H, K, R, S, T, U, V, W, X, Y, Z;
  buffer2[12] = 0x14 + (((buffer1[64] & 92) | ((buffer1[99] / 3) & 35)) &
                        buffer4[rol8x(buffer4[(buffer1[206] % 21)], 4) % 21]);
  (void)0;
  ;
  buffer1[4] = (buffer1[99] / 5) * (buffer1[99] / 5) * 2;
  (void)0;
  ;
  buffer2[34] = 0xb8;
  (void)0;
  ;
  buffer1[153] ^=
      (buffer2[buffer1[203] % 35] * buffer2[buffer1[203] % 35] * buffer1[190]);
  (void)0;
  ;
  buffer0[3] -= (((buffer4[buffer1[205] % 21] >> 1) & 80) | 0xe6440);
  (void)0;
  ;
  buffer0[16] = 0x93;
  (void)0;
  ;
  buffer0[13] = 0x62;
  (void)0;
  ;
  buffer1[33] -= (buffer4[buffer1[36] % 21] & 0xf6);
  (void)0;
  ;
  tmp2 = buffer2[buffer1[67] % 35];
  buffer2[12] = 0x07;
  (void)0;
  ;
  tmp = buffer0[buffer1[181] % 20];
  buffer1[2] -= 3136;
  (void)0;
  ;
  buffer0[19] = buffer4[buffer1[58] % 21];
  (void)0;
  ;
  buffer3[0] = 92 - buffer2[buffer1[32] % 35];
  (void)0;
  ;
  buffer3[4] = buffer2[buffer1[15] % 35] + 0x9e;
  (void)0;
  ;
  buffer1[34] +=
      (buffer4[((buffer2[buffer1[15] % 35] + 0x9e) & 0xff) % 21] / 5);
  (void)0;
  ;
  buffer0[19] += 0xfffffee6 - ((buffer0[buffer3[4] % 20] >> 1) & 102);
  (void)0;
  ;
  buffer1[15] =
      (3 * (((buffer1[72] >> (buffer4[buffer1[190] % 21] & 7)) ^
             (buffer1[72] << ((7 - (buffer4[buffer1[190] % 21] - 1) & 7)))) -
            (3 * buffer4[buffer1[126] % 21]))) ^
      buffer1[15];
  (void)0;
  ;
  buffer0[15] ^= buffer2[buffer1[181] % 35] * buffer2[buffer1[181] % 35] *
                 buffer2[buffer1[181] % 35];
  (void)0;
  ;
  buffer2[4] ^= buffer1[202] / 3;
  (void)0;
  ;
  A = 92 - buffer0[buffer3[0] % 20];
  E = (A & 0xc6) | (~buffer1[105] & 0xc6) | (A & (~buffer1[105]));
  buffer2[1] += (E * E * E);
  (void)0;
  ;
  buffer0[19] ^=
      ((224 | (buffer4[buffer1[92] % 21] & 27)) * buffer2[buffer1[41] % 35]) /
      3;
  (void)0;
  ;
  buffer1[140] += weird_ror8(92, buffer1[5] & 7);
  (void)0;
  ;
  buffer2[12] +=
      ((((~buffer1[4]) ^ buffer2[buffer1[12] % 35]) | buffer1[182]) & 192) |
      (((~buffer1[4]) ^ buffer2[buffer1[12] % 35]) & buffer1[182]);
  (void)0;
  ;
  buffer1[36] += 125;
  (void)0;
  ;
  buffer1[124] =
      rol8x((((74 & buffer1[138]) | ((74 | buffer1[138]) & buffer0[15])) &
             buffer0[buffer1[43] % 20]) |
                (((74 & buffer1[138]) | ((74 | buffer1[138]) & buffer0[15]) |
                  buffer0[buffer1[43] % 20]) &
                 95),
            4);
  (void)0;
  ;
  buffer3[8] = ((((buffer0[buffer3[4] % 20] & 95)) &
                 ((buffer4[buffer1[68] % 21] & 46) << 1)) |
                16) ^
               92;
  (void)0;
  ;
  A = buffer1[177] + buffer4[buffer1[79] % 21];
  D = (((A >> 1) | ((3 * buffer1[148]) / 5)) & buffer2[1]) |
      ((A >> 1) & ((3 * buffer1[148]) / 5));
  buffer3[12] = ((-34 - D));
  (void)0;
  ;
  A = 8 - ((buffer2[22] & 7));
  B = (buffer1[33] >> (A & 7));
  C = buffer1[33] << (buffer2[22] & 7);
  buffer2[16] +=
      ((buffer2[buffer3[0] % 35] & 159) | buffer0[buffer3[4] % 20] | 8) -
      ((B ^ C) | 128);
  (void)0;
  ;
  buffer0[14] ^= buffer2[buffer3[12] % 35];
  (void)0;
  ;
  A = weird_rol8(buffer4[buffer0[buffer1[201] % 20] % 21],
                 ((buffer2[buffer1[112] % 35] << 1) & 7));
  D = (buffer0[buffer1[208] % 20] & 131) | (buffer0[buffer1[164] % 20] & 124);
  buffer1[19] += (A & (D / 5)) | ((A | (D / 5)) & 37);
  (void)0;
  ;
  buffer2[8] = weird_ror8(140, ((buffer4[buffer1[45] % 21] + 92) *
                                (buffer4[buffer1[45] % 21] + 92)) &
                                   7);
  (void)0;
  ;
  buffer1[190] = 56;
  (void)0;
  ;
  buffer2[8] ^= buffer3[0];
  (void)0;
  ;
  buffer1[53] = ~((buffer0[buffer1[83] % 20] | 204) / 5);
  (void)0;
  ;
  buffer0[13] += buffer0[buffer1[41] % 20];
  (void)0;
  ;
  buffer0[10] = ((buffer2[buffer3[0] % 35] & buffer1[2]) |
                 ((buffer2[buffer3[0] % 35] | buffer1[2]) & buffer3[12])) /
                15;
  (void)0;
  ;
  A = (((56 | (buffer4[buffer1[2] % 21] & 68)) | buffer2[buffer3[8] % 35]) &
       42) |
      (((buffer4[buffer1[2] % 21] & 68) | 56) & buffer2[buffer3[8] % 35]);
  buffer3[16] = (A * A) + 110;
  (void)0;
  ;
  buffer3[20] = 202 - buffer3[16];
  (void)0;
  ;
  buffer3[24] = buffer1[151];
  (void)0;
  ;
  buffer2[13] ^= buffer4[buffer3[0] % 21];
  (void)0;
  ;
  B = ((buffer2[buffer1[179] % 35] - 38) & 177) | (buffer3[12] & 177);
  C = ((buffer2[buffer1[179] % 35] - 38)) & buffer3[12];
  buffer3[28] = 30 + ((B | C) * (B | C));
  (void)0;
  ;
  buffer3[32] = buffer3[28] + 62;
  (void)0;
  ;
  A = ((buffer3[20] + (buffer3[0] & 74)) | ~buffer4[buffer3[0] % 21]) & 121;
  B = ((buffer3[20] + (buffer3[0] & 74)) & ~buffer4[buffer3[0] % 21]);
  tmp3 = (A | B);
  C = ((((A | B) ^ 0xffffffa6) | buffer3[0]) & 4) |
      (((A | B) ^ 0xffffffa6) & buffer3[0]);
  buffer1[47] = (buffer2[buffer1[89] % 35] + C) ^ buffer1[47];
  (void)0;
  ;
  buffer3[36] =
      ((rol8((tmp & 179) + 68, 2) & buffer0[3]) | (tmp2 & ~buffer0[3])) - 15;
  (void)0;
  ;
  buffer1[123] ^= 221;
  (void)0;
  ;
  A = ((buffer4[buffer3[0] % 21]) / 3) - buffer2[buffer3[4] % 35];
  C = (((buffer3[0] & 163) + 92) & 246) | (buffer3[0] & 92);
  E = ((C | buffer3[24]) & 54) | (C & buffer3[24]);
  buffer3[40] = A - E;
  (void)0;
  ;
  buffer3[44] = tmp3 ^ 81 ^ (((buffer3[0] >> 1) & 101) + 26);
  (void)0;
  ;
  buffer3[48] = buffer2[buffer3[4] % 35] & 27;
  (void)0;
  ;
  buffer3[52] = 27;
  (void)0;
  ;
  buffer3[56] = 199;
  (void)0;
  ;
  buffer3[64] =
      buffer3[4] +
      (((((((buffer3[40] | buffer3[24]) & 177) | (buffer3[40] & buffer3[24])) &
          ((((buffer4[buffer3[0] % 20] & 177) | 176)) |
           ((buffer4[buffer3[0] % 21]) & ~3))) |
         ((((buffer3[40] & buffer3[24]) | ((buffer3[40] | buffer3[24]) & 177)) &
           199) |
          ((((buffer4[buffer3[0] % 21] & 1) + 176) |
            (buffer4[buffer3[0] % 21] & ~3)) &
           buffer3[56]))) &
        (~buffer3[52])) |
       buffer3[48]);
  (void)0;
  ;
  buffer2[33] ^= buffer1[26];
  (void)0;
  ;
  buffer1[106] ^= buffer3[20] ^ 133;
  (void)0;
  ;
  buffer2[30] = ((buffer3[64] / 3) - (275 | (buffer3[0] & 247))) ^
                buffer0[buffer1[122] % 20];
  (void)0;
  ;
  buffer1[22] = (buffer2[buffer1[90] % 35] & 95) | 68;
  (void)0;
  ;
  A = (buffer4[buffer3[36] % 21] & 184) | (buffer2[buffer3[44] % 35] & ~184);
  buffer2[18] += ((A * A * A) >> 1);
  (void)0;
  ;
  buffer2[5] -= buffer4[buffer1[92] % 21];
  (void)0;
  ;
  A = (((buffer1[41] & ~24) | (buffer2[buffer1[183] % 35] & 24)) &
       (buffer3[16] + 53)) |
      (buffer3[20] & buffer2[buffer3[20] % 35]);
  B = (buffer1[17] & (~buffer3[44])) |
      (buffer0[buffer1[59] % 20] & buffer3[44]);
  buffer2[18] ^= (A * B);
  (void)0;
  ;
  A = weird_ror8(buffer1[11], buffer2[buffer1[28] % 35] & 7) & 7;
  B = (((buffer0[buffer1[93] % 20] & ~buffer0[14]) | (buffer0[14] & 150)) &
       ~28) |
      (buffer1[7] & 28);
  buffer2[22] =
      (((((B | weird_rol8(buffer2[buffer3[0] % 35], A)) & buffer2[33]) |
         (B & weird_rol8(buffer2[buffer3[0] % 35], A))) +
        74) &
       0xff);
  (void)0;
  ;
  A = buffer4[(buffer0[buffer1[39] % 20] ^ 217) % 21];
  buffer0[15] -=
      ((((buffer3[20] | buffer3[0]) & 214) | (buffer3[20] & buffer3[0])) & A) |
      ((((buffer3[20] | buffer3[0]) & 214) | (buffer3[20] & buffer3[0]) | A) &
       buffer3[32]);
  (void)0;
  ;
  B = (((buffer2[buffer1[57] % 35] & buffer0[buffer3[64] % 20]) |
        ((buffer0[buffer3[64] % 20] | buffer2[buffer1[57] % 35]) & 95) |
        (buffer3[64] & 45) | 82) &
       32);
  C = ((buffer2[buffer1[57] % 35] & buffer0[buffer3[64] % 20]) |
       ((buffer2[buffer1[57] % 35] | buffer0[buffer3[64] % 20]) & 95)) &
      ((buffer3[64] & 45) | 82);
  D = ((((buffer3[0] / 3) - (buffer3[64] | buffer1[22]))) ^ (buffer3[28] + 62) ^
       ((B | C)));
  T = buffer0[(D & 0xff) % 20];
  buffer3[68] = (buffer0[buffer1[99] % 20] * buffer0[buffer1[99] % 20] *
                 buffer0[buffer1[99] % 20] * buffer0[buffer1[99] % 20]) |
                buffer2[buffer3[64] % 35];
  (void)0;
  ;
  U = buffer0[buffer1[50] % 20];
  W = buffer2[buffer1[138] % 35];
  X = buffer4[buffer1[39] % 21];
  Y = buffer0[buffer1[4] % 20];
  Z = buffer4[buffer1[202] % 21];
  V = buffer0[buffer1[151] % 20];
  S = buffer2[buffer1[14] % 35];
  R = buffer0[buffer1[145] % 20];
  A = (buffer2[buffer3[68] % 35] & buffer0[buffer1[209] % 20]) |
      ((buffer2[buffer3[68] % 35] | buffer0[buffer1[209] % 20]) & 24);
  B = weird_rol8(buffer4[buffer1[127] % 21], buffer2[buffer3[68] % 35] & 7);
  C = (A & buffer0[10]) | (B & ~buffer0[10]);
  D = 7 ^ (buffer4[buffer2[buffer3[36] % 35] % 21] << 1);
  buffer3[72] = (C & 71) | (D & ~71);
  (void)0;
  ;
  buffer2[2] += (((buffer0[buffer3[20] % 20] << 1) & 159) |
                 (buffer4[buffer1[190] % 21] & ~159)) &
                ((((buffer4[buffer3[64] % 21] & 110) |
                   (buffer0[buffer1[25] % 20] & ~110)) &
                  ~150) |
                 (buffer1[25] & 150));
  (void)0;
  ;
  buffer2[14] -= ((buffer2[buffer3[20] % 35] &
                   (buffer3[72] ^ buffer2[buffer1[100] % 35])) &
                  ~34) |
                 (buffer1[97] & 34);
  (void)0;
  ;
  buffer0[17] = 115;
  (void)0;
  ;
  buffer1[23] ^= ((((((buffer4[buffer1[17] % 21] | buffer0[buffer3[20] % 20]) &
                      buffer3[72]) |
                     (buffer4[buffer1[17] % 21] & buffer0[buffer3[20] % 20])) &
                    (buffer1[50] / 3)) |
                   ((((buffer4[buffer1[17] % 21] | buffer0[buffer3[20] % 20]) &
                      buffer3[72]) |
                     (buffer4[buffer1[17] % 21] & buffer0[buffer3[20] % 20]) |
                     (buffer1[50] / 3)) &
                    246))
                  << 1);
  (void)0;
  ;
  buffer0[13] = ((((((buffer0[buffer3[40] % 20] | buffer1[10]) & 82) |
                    (buffer0[buffer3[40] % 20] & buffer1[10])) &
                   209) |
                  ((buffer0[buffer1[39] % 20] << 1) & 46)) >>
                 1);
  (void)0;
  ;
  buffer2[33] -= buffer1[113] & 9;
  (void)0;
  ;
  buffer2[28] -=
      ((((2 | (buffer1[110] & 222)) >> 1) & ~223) | (buffer3[20] & 223));
  (void)0;
  ;
  J = weird_rol8((V | Z), (U & 7));
  A = (buffer2[16] & T) | (W & (~buffer2[16]));
  B = (buffer1[33] & 17) | (X & ~17);
  E = ((Y | ((A + B) / 5)) & 147) | (Y & ((A + B) / 5));
  M = (buffer3[40] & buffer4[((buffer3[8] + J + E) & 0xff) % 21]) |
      ((buffer3[40] | buffer4[((buffer3[8] + J + E) & 0xff) % 21]) &
       buffer2[23]);
  buffer0[15] =
      (((buffer4[buffer3[20] % 21] - 48) & (~buffer1[184])) |
       ((buffer4[buffer3[20] % 21] - 48) & 189) | (189 & ~buffer1[184])) &
      (M * M * M);
  (void)0;
  ;
  buffer2[22] += buffer1[183];
  (void)0;
  ;
  buffer3[76] = (3 * buffer4[buffer1[1] % 21]) ^ buffer3[0];
  (void)0;
  ;
  A = buffer2[((buffer3[8] + (J + E)) & 0xff) % 35];
  F = (((buffer4[buffer1[178] % 21] & A) |
        ((buffer4[buffer1[178] % 21] | A) & 209)) *
       buffer0[buffer1[13] % 20]) *
      (buffer4[buffer1[26] % 21] >> 1);
  G = (F + 0x733ffff9) * 198 - (((F + 0x733ffff9) * 396 + 212) & 212) + 85;
  buffer3[80] = buffer3[36] + (G ^ 148) + ((G ^ 107) << 1) - 127;
  (void)0;
  ;
  buffer3[84] =
      ((buffer2[buffer3[64] % 35]) & 245) | (buffer2[buffer3[20] % 35] & 10);
  (void)0;
  ;
  A = buffer0[buffer3[68] % 20] | 81;
  buffer2[18] -=
      ((A * A * A) & ~buffer0[15]) | ((buffer3[80] / 15) & buffer0[15]);
  (void)0;
  ;
  buffer3[88] = buffer3[8] + J + E - buffer0[buffer1[160] % 20] +
                (buffer4[buffer0[((buffer3[8] + J + E) & 255) % 20] % 21] / 3);
  (void)0;
  ;
  B = ((R ^ buffer3[72]) & ~198) | ((S * S) & 198);
  F = (buffer4[buffer1[69] % 21] & buffer1[172]) |
      ((buffer4[buffer1[69] % 21] | buffer1[172]) & ((buffer3[12] - B) + 77));
  buffer0[16] = 147 - ((buffer3[72] & ((F & 251) | 1)) |
                       (((F & 250) | buffer3[72]) & 198));
  (void)0;
  ;
  C = (buffer4[buffer1[168] % 21] & buffer0[buffer1[29] % 20] & 7) |
      ((buffer4[buffer1[168] % 21] | buffer0[buffer1[29] % 20]) & 6);
  F = (buffer4[buffer1[155] % 21] & buffer1[105]) |
      ((buffer4[buffer1[155] % 21] | buffer1[105]) & 141);
  buffer0[3] -= buffer4[weird_rol32(F, C) % 21];
  (void)0;
  ;
  buffer1[5] = weird_ror8(buffer0[12], ((buffer0[buffer1[61] % 20] / 5) & 7)) ^
               (((~buffer2[buffer3[84] % 35]) & 0xffffffff) / 5);
  (void)0;
  ;
  buffer1[198] += buffer1[3];
  (void)0;
  ;
  A = (162 | buffer2[buffer3[64] % 35]);
  buffer1[164] += ((A * A) / 5);
  (void)0;
  ;
  G = weird_ror8(139, (buffer3[80] & 7));
  C = ((buffer4[buffer3[64] % 21] * buffer4[buffer3[64] % 21] *
        buffer4[buffer3[64] % 21]) &
       95) |
      (buffer0[buffer3[40] % 20] & ~95);
  buffer3[92] = (G & 12) | (buffer0[buffer3[20] % 20] & 12) |
                (G & buffer0[buffer3[20] % 20]) | C;
  (void)0;
  ;
  buffer2[12] +=
      ((buffer1[103] & 32) | (buffer3[92] & ((buffer1[103] | 60))) | 16) / 3;
  (void)0;
  ;
  buffer3[96] = buffer1[143];
  (void)0;
  ;
  buffer3[100] = 27;
  (void)0;
  ;
  buffer3[104] = (((buffer3[40] & ~buffer2[8]) | (buffer1[35] & buffer2[8])) &
                  buffer3[64]) ^
                 119;
  (void)0;
  ;
  buffer3[108] =
      238 & ((((buffer3[40] & ~buffer2[8]) | (buffer1[35] & buffer2[8])) &
              buffer3[64])
             << 1);
  (void)0;
  ;
  buffer3[112] = (~buffer3[64] & (buffer3[84] / 3)) ^ 49;
  (void)0;
  ;
  buffer3[116] = 98 & ((~buffer3[64] & (buffer3[84] / 3)) << 1);
  (void)0;
  ;
  A = (buffer1[35] & buffer2[8]) | (buffer3[40] & ~buffer2[8]);
  B = (A & buffer3[64]) | (((buffer3[84] / 3) & ~buffer3[64]));
  buffer1[143] =
      buffer3[96] -
      ((B & (86 + ((buffer1[172] & 64) >> 1))) |
       (((((buffer1[172] & 65) >> 1) ^ 86) |
         ((~buffer3[64] & (buffer3[84] / 3)) |
          (((buffer3[40] & ~buffer2[8]) | (buffer1[35] & buffer2[8])) &
           buffer3[64]))) &
        buffer3[100]));
  (void)0;
  ;
  buffer2[29] = 162;
  (void)0;
  ;
  A = ((((buffer4[buffer3[88] % 21]) & 160) |
        (buffer0[buffer1[125] % 20] & 95)) >>
       1);
  B = buffer2[buffer1[149] % 35] ^ (buffer1[43] * buffer1[43]);
  buffer0[15] += (B & A) | ((A | B) & 115);
  (void)0;
  ;
  buffer3[120] = buffer3[64] - buffer0[buffer3[40] % 20];
  (void)0;
  ;
  buffer1[95] = buffer4[buffer3[20] % 21];
  (void)0;
  ;
  A = weird_ror8(buffer2[buffer3[80] % 35],
                 (buffer2[buffer1[17] % 35] * buffer2[buffer1[17] % 35] *
                  buffer2[buffer1[17] % 35]) &
                     7);
  buffer0[7] -= (A * A);
  (void)0;
  ;
  buffer2[8] = buffer2[8] - buffer1[184] +
               (buffer4[buffer1[202] % 21] * buffer4[buffer1[202] % 21] *
                buffer4[buffer1[202] % 21]);
  (void)0;
  ;
  buffer0[16] = (buffer2[buffer1[102] % 35] << 1) & 132;
  (void)0;
  ;
  buffer3[124] = (buffer4[buffer3[40] % 21] >> 1) ^ buffer3[68];
  (void)0;
  ;
  buffer0[7] -= (buffer0[buffer1[191] % 20] -
                 (((buffer4[buffer1[80] % 21] << 1) & ~177) |
                  (buffer4[buffer4[buffer3[88] % 21] % 21] & 177)));
  (void)0;
  ;
  buffer0[6] = buffer0[buffer1[119] % 20];
  (void)0;
  ;
  A = (buffer4[buffer1[190] % 21] & ~209) | (buffer1[118] & 209);
  B = buffer0[buffer3[120] % 20] * buffer0[buffer3[120] % 20];
  buffer0[12] = (buffer0[buffer3[84] % 20] ^
                 (buffer2[buffer1[71] % 35] + buffer2[buffer1[15] % 35])) &
                ((A & B) | ((A | B) & 27));
  (void)0;
  ;
  B = (buffer1[32] & buffer2[buffer3[88] % 35]) |
      ((buffer1[32] | buffer2[buffer3[88] % 35]) & 23);
  D = (((buffer4[buffer1[57] % 21] * 231) & 169) | (B & 86));
  F = (((buffer0[buffer1[82] % 20] & ~29) | (buffer4[buffer3[124] % 21] & 29)) &
       190) |
      (buffer4[(D / 5) % 21] & ~190);
  H = buffer0[buffer3[40] % 20] * buffer0[buffer3[40] % 20] *
      buffer0[buffer3[40] % 20];
  K = (H & buffer1[82]) | (H & 92) | (buffer1[82] & 92);
  buffer3[128] = ((F & K) | ((F | K) & 192)) ^ (D / 5);
  (void)0;
  ;
  buffer2[25] ^= ((buffer0[buffer3[120] % 20] << 1) * buffer1[5]) -
                 (weird_rol8(buffer3[76], (buffer4[buffer3[124] % 21] & 7)) &
                  (buffer3[20] + 110));
  (void)0;
  ;
}


x86 assembly (clang, -O0):
<garble>:
push   %rbp
mov    %rsp,%rbp
sub    $0x710,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x40(%rax),%eax
and    $0x5c,%eax
mov    %eax,-0x70c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x63(%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70c(%rbp),%eax
and    $0x23,%ecx
or     %ecx,%eax
mov    %eax,-0x6f8(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x700(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x708(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xce(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x708(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1040 <rol8x@plt>
mov    -0x700(%rbp),%rcx
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x6f8(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    %ecx,%eax
add    $0x14,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0xc(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x63(%rax),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,-0x6f4(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x63(%rax),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x6f4(%rbp),%eax
imul   %ecx,%eax
shl    $0x1,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x18(%rbp),%rax
movb   $0xb8,0x22(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x6f0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xcb(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x6f0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x6dc(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x6e8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xcb(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x6e8(%rbp),%rax
mov    %edx,%ecx
mov    -0x6dc(%rbp),%edx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
imul   %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0xbe(%rax),%eax
imul   %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0x99(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x99(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x6d8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xcd(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x6d8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
sar    $0x1,%edx
and    $0x50,%edx
or     $0xe6440,%edx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
movb   $0x93,0x10(%rax)
mov    -0x8(%rbp),%rax
movb   $0x62,0xd(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x6d0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x24(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x6d0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
and    $0xf6,%edx
mov    -0x10(%rbp),%rax
movzbl 0x21(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x21(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x6c8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x43(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x6c8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
movb   $0x7,0xc(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x6c0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb5(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x6c0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%ecx
sub    $0xc40,%ecx
mov    %cl,0x2(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x6b8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3a(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x6b8(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x13(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x6b0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x20(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x6b0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    $0x5c,%eax
sub    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x6a8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xf(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x6a8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
add    $0x9e,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x698(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x6a0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xf(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x6a0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
add    $0x9e,%eax
and    $0xff,%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x698(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0x22(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x22(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x690(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x690(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
sar    $0x1,%eax
and    $0x66,%eax
mov    $0xfffffee6,%edx
sub    %eax,%edx
mov    -0x8(%rbp),%rax
movzbl 0x13(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x13(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x48(%rax),%eax
mov    %eax,-0x688(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xbe(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x688(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0x7,%ecx
sar    %cl,%eax
mov    %eax,-0x684(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x48(%rax),%eax
mov    %eax,-0x680(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xbe(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x684(%rbp),%eax
mov    %edx,%esi
mov    -0x680(%rbp),%edx
movslq %esi,%rsi
movzbl (%rcx,%rsi,1),%esi
sub    $0x1,%esi
mov    $0x7,%ecx
sub    %esi,%ecx
and    $0x7,%ecx
shl    %cl,%edx
mov    %edx,%ecx
xor    %ecx,%eax
mov    %eax,-0x67c(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x7e(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x67c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   $0x3,%ecx,%ecx
sub    %ecx,%eax
imul   $0x3,%eax,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xf(%rcx),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0xf(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x678(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb5(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x678(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x66c(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xb5(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x66c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0x65c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x668(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb5(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x668(%rbp),%rax
mov    %edx,%ecx
mov    -0x65c(%rbp),%edx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
imul   %eax,%edx
mov    -0x8(%rbp),%rax
movzbl 0xf(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xf(%rax)
mov    -0x10(%rbp),%rax
movzbl 0xca(%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0x4(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x4(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x658(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x658(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    $0x5c,%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
and    $0xc6,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x69(%rcx),%ecx
xor    $0xffffffff,%ecx
and    $0xc6,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%ecx
mov    -0x10(%rbp),%rdx
movzbl 0x69(%rdx),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%edx
imul   -0x48(%rbp),%edx
imul   -0x48(%rbp),%edx
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x1(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x650(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5c(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x650(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x1b,%eax
or     $0xe0,%eax
mov    %eax,-0x648(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x29(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x648(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x8(%rbp),%rax
movzbl 0x13(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x13(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%esi
and    $0x7,%esi
mov    $0x5c,%edi
mov    $0x0,%al
call   1070 <weird_ror8@plt>
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0x8c(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x8c(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x644(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xc(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x644(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xb6(%rcx),%ecx
or     %ecx,%eax
and    $0xc0,%eax
mov    %eax,-0x63c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x640(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xc(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x640(%rbp),%eax
mov    %edx,%esi
mov    -0x63c(%rbp),%edx
movslq %esi,%rsi
movzbl (%rcx,%rsi,1),%ecx
xor    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xb6(%rcx),%ecx
and    %ecx,%eax
or     %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0xc(%rax),%ecx
add    %edx,%ecx
mov    %cl,0xc(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x24(%rax),%ecx
add    $0x7d,%ecx
mov    %cl,0x24(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x8a(%rax),%edi
and    $0x4a,%edi
mov    -0x10(%rbp),%rax
movzbl 0x8a(%rax),%eax
or     $0x4a,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xf(%rcx),%ecx
and    %ecx,%eax
or     %eax,%edi
mov    -0x8(%rbp),%rax
mov    %rax,-0x638(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2b(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x638(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    %eax,%edi
mov    -0x10(%rbp),%rax
movzbl 0x8a(%rax),%eax
and    $0x4a,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x8a(%rcx),%ecx
or     $0x4a,%ecx
mov    -0x8(%rbp),%rdx
movzbl 0xf(%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x62c(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x2b(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x62c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
and    $0x5f,%eax
or     %eax,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1040 <rol8x@plt>
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x7c(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x628(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x628(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x5f,%eax
mov    %eax,-0x620(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x44(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x620(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0x2e,%ecx
shl    $0x1,%ecx
and    %ecx,%eax
or     $0x10,%eax
xor    $0x5c,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x8(%rax)
mov    -0x10(%rbp),%rax
movzbl 0xb1(%rax),%eax
mov    %eax,-0x61c(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x4f(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x61c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x618(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x94(%rax),%eax
imul   $0x3,%eax,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x618(%rbp),%eax
or     %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x614(%rbp)
mov    -0x38(%rbp),%ecx
shr    $0x1,%ecx
mov    -0x10(%rbp),%rax
movzbl 0x94(%rax),%eax
imul   $0x3,%eax,%eax
mov    $0x5,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x614(%rbp),%eax
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    $0xffffffde,%eax
sub    -0x44(%rbp),%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0xc(%rax)
mov    -0x18(%rbp),%rax
movzbl 0x16(%rax),%ecx
and    $0x7,%ecx
mov    $0x8,%eax
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x21(%rax),%eax
mov    -0x38(%rbp),%ecx
and    $0x7,%ecx
sar    %cl,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x21(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x16(%rcx),%ecx
and    $0x7,%ecx
shl    %cl,%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x610(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x610(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x9f,%eax
mov    %eax,-0x5fc(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x608(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x608(%rbp),%rax
mov    %edx,%ecx
mov    -0x5fc(%rbp),%edx
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
or     %eax,%edx
or     $0x8,%edx
mov    -0x3c(%rbp),%eax
xor    -0x40(%rbp),%eax
or     $0x80,%eax
sub    %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0x10(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x5f8(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0xc(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x5f8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x8(%rbp),%rax
movzbl 0xe(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xe(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x5e8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x5f0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xc9(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x5f0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x5e8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x18(%rbp),%rax
mov    %rax,-0x5e0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x70(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x5e0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%esi
shl    $0x1,%esi
and    $0x7,%esi
mov    $0x0,%al
call   1030 <weird_rol8@plt>
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x5d8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xd0(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x5d8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x83,%eax
mov    %eax,-0x5d0(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xa4(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x5d0(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0x7c,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x5cc(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x5,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
mov    -0x5cc(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0x5c8(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x5c4(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x5,%ecx
xor    %edx,%edx
div    %ecx
mov    -0x5c8(%rbp),%edx
mov    %eax,%ecx
mov    -0x5c4(%rbp),%eax
or     %ecx,%eax
and    $0x25,%eax
or     %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0x13(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x13(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x5c0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2d(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x5c0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%esi
add    $0x5c,%esi
mov    -0x28(%rbp),%rax
mov    %rax,-0x5b8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2d(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x5b8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
add    $0x5c,%eax
imul   %eax,%esi
and    $0x7,%esi
mov    $0x8c,%edi
mov    $0x0,%al
call   1070 <weird_ror8@plt>
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x8(%rax)
mov    -0x10(%rbp),%rax
movb   $0x38,0xbe(%rax)
mov    -0x20(%rbp),%rax
movzbl (%rax),%edx
mov    -0x18(%rbp),%rax
movzbl 0x8(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x8(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x5b0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x53(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x5b0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
or     $0xcc,%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
xor    $0xffffffff,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x35(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x5a8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x29(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x5a8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x8(%rbp),%rax
movzbl 0xd(%rax),%ecx
add    %edx,%ecx
mov    %cl,0xd(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x5a0(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x5a0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x594(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x594(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
movzbl 0x2(%rdx),%edx
or     %edx,%ecx
mov    -0x20(%rbp),%rdx
movzbl 0xc(%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    $0xf,%ecx
cltd
idiv   %ecx
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0xa(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x590(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x590(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x44,%eax
or     $0x38,%eax
mov    %eax,-0x584(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x584(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
and    $0x2a,%eax
mov    %eax,-0x574(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x580(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x580(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
and    $0x44,%ecx
or     $0x38,%ecx
mov    -0x18(%rbp),%rax
mov    %rax,-0x570(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x574(%rbp),%eax
mov    %edx,%esi
mov    -0x570(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
add    $0x6e,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x10(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x10(%rax),%ecx
mov    $0xca,%eax
sub    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x14(%rax)
mov    -0x10(%rbp),%rax
mov    0x97(%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x18(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x568(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x568(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x18(%rbp),%rax
movzbl 0xd(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0xd(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x560(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb3(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x560(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x26,%eax
and    $0xb1,%eax
mov    -0x20(%rbp),%rcx
movzbl 0xc(%rcx),%ecx
and    $0xb1,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x558(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb3(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x558(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x26,%eax
mov    -0x20(%rbp),%rcx
movzbl 0xc(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x3c(%rbp),%eax
or     -0x40(%rbp),%eax
mov    -0x3c(%rbp),%ecx
or     -0x40(%rbp),%ecx
imul   %ecx,%eax
add    $0x1e,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x1c(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x1c(%rax),%eax
add    $0x3e,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x20(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
and    $0x4a,%ecx
add    %ecx,%eax
mov    %eax,-0x550(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x550(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    $0xffffffff,%ecx
or     %ecx,%eax
and    $0x79,%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
and    $0x4a,%ecx
add    %ecx,%eax
mov    %eax,-0x54c(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x54c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
or     -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x38(%rbp),%eax
or     -0x3c(%rbp),%eax
xor    $0xffffffa6,%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
or     %ecx,%eax
and    $0x4,%eax
mov    -0x38(%rbp),%ecx
or     -0x3c(%rbp),%ecx
xor    $0xffffffa6,%ecx
mov    -0x20(%rbp),%rdx
movzbl (%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x548(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x59(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x548(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
add    -0x40(%rbp),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x2f(%rcx),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x2f(%rax)
mov    -0x2c(%rbp),%edi
and    $0xb3,%edi
add    $0x44,%edi
mov    $0x2,%esi
mov    $0x0,%al
call   1060 <rol8@plt>
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
and    %ecx,%eax
mov    -0x30(%rbp),%ecx
mov    -0x8(%rbp),%rdx
movzbl 0x3(%rdx),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
sub    $0xf,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x24(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x7b(%rax),%ecx
xor    $0xdd,%ecx
mov    %cl,0x7b(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x540(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x540(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x534(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x534(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
and    $0xa3,%eax
add    $0x5c,%eax
and    $0xf6,%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
and    $0x5c,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x20(%rbp),%rcx
movzbl 0x18(%rcx),%ecx
or     %ecx,%eax
and    $0x36,%eax
mov    -0x40(%rbp),%ecx
mov    -0x20(%rbp),%rdx
movzbl 0x18(%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
sub    -0x48(%rbp),%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x28(%rax)
mov    -0x34(%rbp),%eax
xor    $0x51,%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
sar    $0x1,%ecx
and    $0x65,%ecx
add    $0x1a,%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x2c(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x530(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x530(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x1b,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x30(%rax)
mov    -0x20(%rbp),%rax
movb   $0x1b,0x34(%rax)
mov    -0x20(%rbp),%rax
movb   $0xc7,0x38(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    %eax,-0x504(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%ecx
mov    -0x20(%rbp),%rax
movzbl 0x18(%rax),%eax
or     %eax,%ecx
and    $0xb1,%ecx
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    -0x20(%rbp),%rdx
movzbl 0x18(%rdx),%edx
and    %edx,%eax
or     %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,-0x528(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x528(%rbp),%rax
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
and    $0xb1,%eax
or     $0xb0,%eax
mov    %eax,-0x51c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x518(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x51c(%rbp),%eax
mov    %edx,%esi
mov    -0x518(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
and    $0xfffffffc,%edx
or     %edx,%eax
and    %eax,%ecx
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    -0x20(%rbp),%rdx
movzbl 0x18(%rdx),%edx
and    %edx,%eax
mov    -0x20(%rbp),%rdx
movzbl 0x28(%rdx),%edx
mov    -0x20(%rbp),%rsi
movzbl 0x18(%rsi),%esi
or     %esi,%edx
and    $0xb1,%edx
or     %edx,%eax
and    $0xc7,%eax
mov    %eax,-0x500(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x510(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x510(%rbp),%rax
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%esi
and    $0x1,%esi
add    $0xb0,%esi
mov    -0x28(%rbp),%rdi
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x15,%r8d
cltd
idiv   %r8d
mov    -0x504(%rbp),%eax
mov    %edx,%r8d
mov    -0x500(%rbp),%edx
movslq %r8d,%r8
movzbl (%rdi,%r8,1),%edi
and    $0xfffffffc,%edi
or     %edi,%esi
mov    -0x20(%rbp),%rdi
movzbl 0x38(%rdi),%edi
and    %edi,%esi
or     %esi,%edx
or     %edx,%ecx
mov    -0x20(%rbp),%rdx
movzbl 0x34(%rdx),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
mov    -0x20(%rbp),%rdx
movzbl 0x30(%rdx),%edx
or     %edx,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x40(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x1a(%rax),%edx
mov    -0x18(%rbp),%rax
movzbl 0x21(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x21(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%edx
xor    $0x85,%edx
mov    -0x10(%rbp),%rax
movzbl 0x6a(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x6a(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
and    $0xf7,%ecx
or     $0x113,%ecx
sub    %ecx,%eax
mov    %eax,-0x4fc(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x7a(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x4fc(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1e(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x4f8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5a(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x4f8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x5f,%eax
or     $0x44,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x16(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x4f0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x24(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x4f0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xb8,%eax
mov    %eax,-0x4e4(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x2c(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x4e4(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0xffffff47,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edx
imul   -0x38(%rbp),%edx
imul   -0x38(%rbp),%edx
shr    $0x1,%edx
mov    -0x18(%rbp),%rax
movzbl 0x12(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x12(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x4e0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5c(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x4e0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x18(%rbp),%rax
movzbl 0x5(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x5(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x29(%rax),%eax
and    $0xffffffe7,%eax
mov    %eax,-0x4d8(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xb7(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x4d8(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0x18,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x10(%rcx),%ecx
add    $0x35,%ecx
and    %ecx,%eax
mov    %eax,-0x4d4(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %rax,-0x4d0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x4d4(%rbp),%eax
mov    %edx,%esi
mov    -0x4d0(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
mov    -0x20(%rbp),%rcx
movzbl 0x2c(%rcx),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x4c4(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x3b(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x4c4(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x20(%rbp),%rdx
movzbl 0x2c(%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%edx
imul   -0x3c(%rbp),%edx
mov    -0x18(%rbp),%rax
movzbl 0x12(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x12(%rax)
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%edi
mov    -0x18(%rbp),%rax
mov    %rax,-0x4c0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1c(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x4c0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%esi
and    $0x7,%esi
mov    $0x0,%al
call   1070 <weird_ror8@plt>
and    $0x7,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x4b8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5d(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x4b8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x8(%rbp),%rcx
movzbl 0xe(%rcx),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    -0x8(%rbp),%rcx
movzbl 0xe(%rcx),%ecx
and    $0x96,%ecx
or     %ecx,%eax
and    $0xffffffe3,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
and    $0x1c,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x4a4(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x4b0(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x4b0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x38(%rbp),%esi
mov    $0x0,%al
call   1030 <weird_rol8@plt>
mov    %eax,%ecx
mov    -0x4a4(%rbp),%eax
or     %ecx,%eax
mov    -0x18(%rbp),%rcx
movzbl 0x21(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x494(%rbp)
mov    -0x3c(%rbp),%eax
mov    %eax,-0x498(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x4a0(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x4a0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x38(%rbp),%esi
mov    $0x0,%al
call   1030 <weird_rol8@plt>
mov    -0x498(%rbp),%ecx
mov    %eax,%edx
mov    -0x494(%rbp),%eax
and    %edx,%ecx
or     %ecx,%eax
add    $0x4a,%eax
and    $0xff,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x16(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x488(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x490(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x27(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x490(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
xor    $0xd9,%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x488(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%edx
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
or     %eax,%edx
and    $0xd6,%edx
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
and    %ecx,%eax
or     %eax,%edx
and    -0x38(%rbp),%edx
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
or     %ecx,%eax
and    $0xd6,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x14(%rcx),%ecx
mov    -0x20(%rbp),%rsi
movzbl (%rsi),%esi
and    %esi,%ecx
or     %ecx,%eax
or     -0x38(%rbp),%eax
mov    -0x20(%rbp),%rcx
movzbl 0x20(%rcx),%ecx
and    %ecx,%eax
or     %eax,%edx
mov    -0x8(%rbp),%rax
movzbl 0xf(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0xf(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x480(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x39(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x480(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x474(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x474(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    %ecx,%eax
mov    %eax,-0x464(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x470(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x470(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x18(%rbp),%rax
mov    %rax,-0x460(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x39(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x464(%rbp),%eax
mov    %edx,%esi
mov    -0x460(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
or     %edx,%ecx
and    $0x5f,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x40(%rcx),%ecx
and    $0x2d,%ecx
or     %ecx,%eax
or     $0x52,%eax
and    $0x20,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x458(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x39(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x458(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x44c(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x44c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    %ecx,%eax
mov    %eax,-0x43c(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x448(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x39(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x448(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x8(%rbp),%rax
mov    %rax,-0x438(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x43c(%rbp),%eax
mov    %edx,%esi
mov    -0x438(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
or     %edx,%ecx
and    $0x5f,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x40(%rcx),%ecx
and    $0x2d,%ecx
or     $0x52,%ecx
and    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movzbl (%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x20(%rbp),%rcx
movzbl 0x40(%rcx),%ecx
mov    -0x10(%rbp),%rdx
movzbl 0x16(%rdx),%edx
or     %edx,%ecx
sub    %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x1c(%rcx),%ecx
add    $0x3e,%ecx
xor    %ecx,%eax
mov    -0x3c(%rbp),%ecx
or     -0x40(%rbp),%ecx
xor    %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x430(%rbp)
mov    -0x44(%rbp),%eax
and    $0xff,%eax
mov    $0x14,%ecx
xor    %edx,%edx
div    %ecx
mov    -0x430(%rbp),%rax
mov    %edx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x428(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x63(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x428(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x420(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x63(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x420(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0x41c(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x63(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x41c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0x418(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x63(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x418(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0x414(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x414(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x44(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x410(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x32(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x410(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x70(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x408(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x8a(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x408(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x78(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x400(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x27(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x400(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x3f8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x3f8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x80(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x3f0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xca(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x3f0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x84(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x3e8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x97(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x3e8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x74(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x3e0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xe(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x3e0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x3d8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x91(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x3d8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x64(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x3d0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x44(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x3d0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x3c4(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xd1(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x3c4(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    %ecx,%eax
mov    %eax,-0x3b4(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x3c0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x44(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x3c0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x8(%rbp),%rax
mov    %rax,-0x3b0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xd1(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x3b4(%rbp),%eax
mov    %edx,%esi
mov    -0x3b0(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
or     %edx,%ecx
and    $0x18,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x3a8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x7f(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x3a8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x18(%rbp),%rax
mov    %rax,-0x3a0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x44(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x3a0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%esi
and    $0x7,%esi
mov    $0x0,%al
call   1030 <weird_rol8@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x8(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
and    %ecx,%eax
mov    -0x3c(%rbp),%ecx
mov    -0x8(%rbp),%rdx
movzbl 0xa(%rdx),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x390(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x398(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x24(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x398(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x390(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x1,%eax
xor    $0x7,%eax
mov    %eax,-0x44(%rbp)
mov    -0x40(%rbp),%eax
and    $0x47,%eax
mov    -0x44(%rbp),%ecx
and    $0xffffffb8,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x48(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x388(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x388(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x1,%eax
and    $0x9f,%eax
mov    %eax,-0x37c(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xbe(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x37c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0xffffff60,%ecx
or     %ecx,%eax
mov    %eax,-0x36c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x378(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x378(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0x6e,%eax
mov    %eax,-0x370(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x19(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x370(%rbp),%eax
mov    %edx,%esi
mov    -0x36c(%rbp),%edx
movslq %esi,%rsi
movzbl (%rcx,%rsi,1),%ecx
and    $0xffffff91,%ecx
or     %ecx,%eax
and    $0xffffff69,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x19(%rcx),%ecx
and    $0x96,%ecx
or     %ecx,%eax
and    %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x368(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x368(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x35c(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x48(%rax),%eax
mov    %eax,-0x360(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x64(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x360(%rbp),%eax
mov    %edx,%esi
mov    -0x35c(%rbp),%edx
movslq %esi,%rsi
movzbl (%rcx,%rsi,1),%ecx
xor    %ecx,%eax
and    %eax,%edx
and    $0xffffffdd,%edx
mov    -0x10(%rbp),%rax
movzbl 0x61(%rax),%eax
and    $0x22,%eax
or     %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0xe(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0xe(%rax)
mov    -0x8(%rbp),%rax
movb   $0x73,0x11(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x358(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x358(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x34c(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x34c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x48(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x33c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x348(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x348(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x8(%rbp),%rax
mov    %rax,-0x338(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x33c(%rbp),%eax
mov    %edx,%esi
mov    -0x338(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x32c(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x32(%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x32c(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0x300(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x328(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x328(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x31c(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x31c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x48(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x30c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x318(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x318(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x8(%rbp),%rax
mov    %rax,-0x308(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x30c(%rbp),%eax
mov    %edx,%esi
mov    -0x308(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x2fc(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x32(%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    -0x300(%rbp),%edx
mov    %eax,%ecx
mov    -0x2fc(%rbp),%eax
or     %ecx,%eax
and    $0xf6,%eax
or     %eax,%edx
shl    $0x1,%edx
mov    -0x10(%rbp),%rax
movzbl 0x17(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x17(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x2f8(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x2f8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
or     %ecx,%eax
and    $0x52,%eax
mov    %eax,-0x2f0(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x2f0(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
movzbl 0xa(%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
and    $0xd1,%eax
mov    %eax,-0x2ec(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x27(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x2ec(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x1,%ecx
and    $0x2e,%ecx
or     %ecx,%eax
sar    $0x1,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0xd(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x71(%rax),%edx
and    $0x9,%edx
mov    -0x18(%rbp),%rax
movzbl 0x21(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x21(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x6e(%rax),%edx
and    $0xde,%edx
or     $0x2,%edx
sar    $0x1,%edx
and    $0xffffff20,%edx
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
and    $0xdf,%eax
or     %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0x1c(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x1c(%rax)
mov    -0x74(%rbp),%edi
or     -0x84(%rbp),%edi
mov    -0x70(%rbp),%esi
and    $0x7,%esi
mov    $0x0,%al
call   1030 <weird_rol8@plt>
mov    %eax,-0x50(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x10(%rax),%eax
and    -0x6c(%rbp),%eax
mov    -0x78(%rbp),%ecx
mov    -0x18(%rbp),%rdx
movzbl 0x10(%rdx),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x21(%rax),%eax
and    $0x11,%eax
mov    -0x7c(%rbp),%ecx
and    $0xffffffee,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x80(%rbp),%eax
mov    %eax,-0x2e8(%rbp)
mov    -0x38(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    $0x5,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
mov    -0x2e8(%rbp),%eax
or     %ecx,%eax
and    $0x93,%eax
mov    %eax,-0x2e4(%rbp)
mov    -0x80(%rbp),%ecx
mov    -0x38(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    $0x5,%esi
xor    %edx,%edx
div    %esi
mov    %eax,%edx
mov    -0x2e4(%rbp),%eax
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    %eax,-0x2e0(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x8(%rax),%eax
add    -0x50(%rbp),%eax
add    -0x48(%rbp),%eax
and    $0xff,%eax
mov    $0x15,%esi
xor    %edx,%edx
div    %esi
mov    -0x2e0(%rbp),%eax
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
and    %ecx,%eax
mov    %eax,-0x2dc(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,-0x2d8(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x8(%rax),%eax
add    -0x50(%rbp),%eax
add    -0x48(%rbp),%eax
and    $0xff,%eax
mov    $0x15,%esi
xor    %edx,%edx
div    %esi
mov    -0x2dc(%rbp),%eax
mov    %edx,%esi
mov    -0x2d8(%rbp),%rdx
mov    %esi,%esi
movzbl (%rdx,%rsi,1),%edx
or     %edx,%ecx
mov    -0x18(%rbp),%rdx
movzbl 0x17(%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x2d0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x2d0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xb8(%rcx),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x2c4(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x2c4(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    $0x30,%ecx
and    $0xbd,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0xb8(%rcx),%ecx
xor    $0xffffffff,%ecx
and    $0xbd,%ecx
or     %ecx,%eax
mov    -0x4c(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
and    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0xf(%rax)
mov    -0x10(%rbp),%rax
movzbl 0xb7(%rax),%edx
mov    -0x18(%rbp),%rax
movzbl 0x16(%rax),%ecx
add    %edx,%ecx
mov    %cl,0x16(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x2c0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x2c0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
imul   $0x3,%eax,%eax
mov    -0x20(%rbp),%rcx
movzbl (%rcx),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x4c(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x2b8(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    -0x50(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    %ecx,%eax
and    $0xff,%eax
mov    $0x23,%ecx
xor    %edx,%edx
div    %ecx
mov    -0x2b8(%rbp),%rax
mov    %edx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x38(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x2b0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb2(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x2b0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    -0x38(%rbp),%eax
mov    %eax,-0x2a4(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xb2(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x2a4(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
or     -0x38(%rbp),%ecx
and    $0xd1,%ecx
or     %ecx,%eax
mov    %eax,-0x2a0(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xd(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x2a0(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0x29c(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x1a(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x29c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sar    $0x1,%ecx
imul   %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
add    $0x733ffff9,%eax
imul   $0xc6,%eax,%eax
mov    -0x58(%rbp),%ecx
add    $0x733ffff9,%ecx
imul   $0x18c,%ecx,%ecx
add    $0xd4,%ecx
and    $0xd4,%ecx
sub    %ecx,%eax
add    $0x55,%eax
mov    %eax,-0x54(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x24(%rax),%eax
mov    -0x54(%rbp),%ecx
xor    $0x94,%ecx
add    %ecx,%eax
mov    -0x54(%rbp),%ecx
xor    $0x6b,%ecx
shl    $0x1,%ecx
add    %ecx,%eax
sub    $0x7f,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x50(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x298(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x298(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xf5,%eax
mov    %eax,-0x28c(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0x28c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0xa,%ecx
or     %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x54(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x288(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x44(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x288(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
or     $0x51,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
mov    -0x8(%rbp),%rcx
movzbl 0xf(%rcx),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    %eax,-0x280(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x50(%rax),%eax
mov    $0xf,%ecx
cltd
idiv   %ecx
mov    -0x280(%rbp),%edx
mov    -0x8(%rbp),%rcx
movzbl 0xf(%rcx),%ecx
and    %ecx,%eax
or     %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0x12(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x12(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x8(%rax),%eax
add    -0x50(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x27c(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0xa0(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x27c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %eax,-0x264(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x270(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x278(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x8(%rax),%eax
add    -0x50(%rbp),%eax
add    -0x48(%rbp),%eax
and    $0xff,%eax
mov    $0x14,%ecx
xor    %edx,%edx
div    %ecx
mov    -0x278(%rbp),%rax
mov    %edx,%ecx
movzbl (%rax,%rcx,1),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x270(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x264(%rbp),%eax
add    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x58(%rax)
mov    -0x64(%rbp),%eax
mov    -0x20(%rbp),%rcx
movzbl 0x48(%rcx),%ecx
xor    %ecx,%eax
and    $0xffffff39,%eax
mov    -0x68(%rbp),%ecx
imul   -0x68(%rbp),%ecx
and    $0xc6,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x260(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x45(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x260(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzbl 0xac(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x254(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x45(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x254(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
movzbl 0xac(%rdx),%edx
or     %edx,%ecx
mov    -0x20(%rbp),%rdx
movzbl 0xc(%rdx),%edx
sub    -0x3c(%rbp),%edx
add    $0x4d,%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x48(%rax),%ecx
mov    -0x58(%rbp),%eax
and    $0xfb,%eax
or     $0x1,%eax
and    %eax,%ecx
mov    -0x58(%rbp),%eax
and    $0xfa,%eax
mov    -0x20(%rbp),%rdx
movzbl 0x48(%rdx),%edx
or     %edx,%eax
and    $0xc6,%eax
or     %eax,%ecx
mov    $0x93,%eax
sub    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x10(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x250(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xa8(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x250(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x244(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x1d(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x244(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    %ecx,%eax
and    $0x7,%eax
mov    %eax,-0x234(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x240(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xa8(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x240(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x8(%rbp),%rax
mov    %rax,-0x230(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1d(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x234(%rbp),%eax
mov    %edx,%esi
mov    -0x230(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
or     %edx,%ecx
and    $0x6,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x228(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x9b(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x228(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x69(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x21c(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x9b(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x21c(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    -0x10(%rbp),%rdx
movzbl 0x69(%rdx),%edx
or     %edx,%ecx
and    $0x8d,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x218(%rbp)
mov    -0x58(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    $0x0,%al
call   1050 <weird_rol32@plt>
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x218(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edx
mov    -0x8(%rbp),%rax
movzbl 0x3(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x3(%rax)
mov    -0x8(%rbp),%rax
movzbl 0xc(%rax),%edi
mov    -0x8(%rbp),%rax
mov    %rax,-0x210(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3d(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x210(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    $0x5,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
and    $0x7,%esi
mov    $0x0,%al
call   1070 <weird_ror8@plt>
mov    %eax,-0x1fc(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x208(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x54(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x208(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
xor    $0xffffffff,%eax
and    $0xffffffff,%eax
mov    $0x5,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
mov    -0x1fc(%rbp),%eax
xor    %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x5(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%edx
mov    -0x10(%rbp),%rax
movzbl 0xc6(%rax),%ecx
add    %edx,%ecx
mov    %cl,0xc6(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x1f8(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x1f8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
or     $0xa2,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
imul   -0x38(%rbp),%eax
mov    $0x5,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%edx
mov    -0x10(%rbp),%rax
movzbl 0xa4(%rax),%ecx
add    %edx,%ecx
mov    %cl,0xa4(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x50(%rax),%esi
and    $0x7,%esi
mov    $0x8b,%edi
mov    $0x0,%al
call   1070 <weird_ror8@plt>
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x1f0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x1e4(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x1e4(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0x1e0(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x1e0(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
and    $0x5f,%eax
mov    %eax,-0x1dc(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x1dc(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0xffffffa0,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x54(%rbp),%eax
and    $0xc,%eax
mov    %eax,-0x1d8(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x1d8(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0xc,%ecx
or     %ecx,%eax
mov    %eax,-0x1d4(%rbp)
mov    -0x54(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x1d4(%rbp),%eax
mov    %edx,%esi
mov    -0x1d0(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
and    %edx,%ecx
or     %ecx,%eax
or     -0x40(%rbp),%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x5c(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x67(%rax),%eax
and    $0x20,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x5c(%rcx),%ecx
mov    -0x10(%rbp),%rdx
movzbl 0x67(%rdx),%edx
or     $0x3c,%edx
and    %edx,%ecx
or     %ecx,%eax
or     $0x10,%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0xc(%rax),%ecx
add    %edx,%ecx
mov    %cl,0xc(%rax)
mov    -0x10(%rbp),%rax
mov    0x8f(%rax),%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x60(%rax)
mov    -0x20(%rbp),%rax
movb   $0x1b,0x64(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x23(%rcx),%ecx
mov    -0x18(%rbp),%rdx
movzbl 0x8(%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x40(%rcx),%ecx
and    %ecx,%eax
xor    $0x77,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x68(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
xor    $0xffffffff,%ecx
and    %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x23(%rcx),%ecx
mov    -0x18(%rbp),%rdx
movzbl 0x8(%rdx),%edx
and    %edx,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x40(%rcx),%ecx
and    %ecx,%eax
shl    $0x1,%eax
and    $0xee,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x6c(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x1c4(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x54(%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1c4(%rbp),%eax
and    %ecx,%eax
xor    $0x31,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x70(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
xor    $0xffffffff,%eax
mov    %eax,-0x1c0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x54(%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1c0(%rbp),%eax
and    %ecx,%eax
shl    $0x1,%eax
and    $0x62,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x74(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x23(%rax),%eax
mov    -0x18(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
and    %ecx,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x28(%rcx),%ecx
mov    -0x18(%rbp),%rdx
movzbl 0x8(%rdx),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x20(%rbp),%rcx
movzbl 0x40(%rcx),%ecx
and    %ecx,%eax
mov    %eax,-0x1bc(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x54(%rax),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x1bc(%rbp),%eax
mov    -0x20(%rbp),%rdx
movzbl 0x40(%rdx),%edx
xor    $0xffffffff,%edx
and    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x60(%rax),%eax
mov    %eax,-0x1b4(%rbp)
mov    -0x3c(%rbp),%ecx
mov    -0x10(%rbp),%rax
movzbl 0xac(%rax),%eax
and    $0x40,%eax
sar    $0x1,%eax
add    $0x56,%eax
and    %eax,%ecx
mov    -0x10(%rbp),%rax
movzbl 0xac(%rax),%eax
and    $0x41,%eax
sar    $0x1,%eax
xor    $0x56,%eax
mov    %eax,-0x1b8(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%esi
xor    $0xffffffff,%esi
mov    -0x20(%rbp),%rax
movzbl 0x54(%rax),%eax
mov    $0x3,%edi
cltd
idiv   %edi
mov    -0x1b8(%rbp),%edx
mov    %eax,%edi
mov    -0x1b4(%rbp),%eax
and    %edi,%esi
mov    -0x20(%rbp),%rdi
movzbl 0x28(%rdi),%edi
mov    -0x18(%rbp),%r8
movzbl 0x8(%r8),%r8d
xor    $0xffffffff,%r8d
and    %r8d,%edi
mov    -0x10(%rbp),%r8
movzbl 0x23(%r8),%r8d
mov    -0x18(%rbp),%r9
movzbl 0x8(%r9),%r9d
and    %r9d,%r8d
or     %r8d,%edi
mov    -0x20(%rbp),%r8
movzbl 0x40(%r8),%r8d
and    %r8d,%edi
or     %edi,%esi
or     %esi,%edx
mov    -0x20(%rbp),%rsi
movzbl 0x64(%rsi),%esi
and    %esi,%edx
or     %edx,%ecx
sub    %ecx,%eax
mov    %al,%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x8f(%rax)
mov    -0x18(%rbp),%rax
movb   $0xa2,0x1d(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x58(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x1b0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xa0,%eax
mov    %eax,-0x1a4(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%rax
movzbl 0x7d(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x1a4(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0x5f,%ecx
or     %ecx,%eax
sar    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x95(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x1a0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x2b(%rcx),%ecx
mov    -0x10(%rbp),%rdx
movzbl 0x2b(%rdx),%edx
imul   %edx,%ecx
xor    %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%edx
and    -0x38(%rbp),%edx
mov    -0x38(%rbp),%eax
or     -0x3c(%rbp),%eax
and    $0x73,%eax
or     %eax,%edx
mov    -0x8(%rbp),%rax
movzbl 0xf(%rax),%ecx
add    %edx,%ecx
mov    %cl,0xf(%rax)
mov    -0x20(%rbp),%rax
movzbl 0x40(%rax),%eax
mov    %eax,-0x194(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0x194(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
sub    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x78(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x14(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x190(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x10(%rbp),%rax
mov    %cl,0x5f(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x188(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x50(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x188(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%edi
mov    -0x18(%rbp),%rax
mov    %rax,-0x180(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x180(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%esi
mov    -0x18(%rbp),%rax
mov    %rax,-0x178(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x178(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
imul   %eax,%esi
mov    -0x18(%rbp),%rax
mov    %rax,-0x170(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x11(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x170(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
imul   %eax,%esi
and    $0x7,%esi
mov    $0x0,%al
call   1070 <weird_ror8@plt>
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edx
imul   -0x38(%rbp),%edx
mov    -0x8(%rbp),%rax
movzbl 0x7(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x7(%rax)
mov    -0x18(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    -0x10(%rbp),%rcx
movzbl 0xb8(%rcx),%ecx
sub    %ecx,%eax
mov    %eax,-0x154(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x168(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xca(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x168(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x28(%rbp),%rax
mov    %rax,-0x160(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xca(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x160(%rbp),%rax
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
imul   %eax,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xca(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x154(%rbp),%eax
mov    %edx,%esi
mov    -0x150(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    %rax,-0x148(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x66(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0x148(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x1,%eax
and    $0x84,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x10(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x140(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
sar    $0x1,%eax
mov    -0x20(%rbp),%rcx
movzbl 0x44(%rcx),%ecx
xor    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x7c(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x138(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xbf(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x138(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x11c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x130(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x50(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x130(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x1,%eax
and    $0xffffff4e,%eax
mov    %eax,-0x120(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,-0x128(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x58(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x128(%rbp),%rax
movslq %edx,%rdx
movzbl (%rax,%rdx,1),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0x120(%rbp),%eax
mov    %edx,%esi
mov    -0x11c(%rbp),%edx
movslq %esi,%rsi
movzbl (%rcx,%rsi,1),%ecx
and    $0xb1,%ecx
or     %ecx,%eax
sub    %eax,%edx
mov    -0x8(%rbp),%rax
movzbl 0x7(%rax),%ecx
sub    %edx,%ecx
mov    %cl,0x7(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x118(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x77(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x118(%rbp),%rax
movslq %edx,%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x6(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,-0x110(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xbe(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x110(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xffffff2e,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x76(%rcx),%ecx
and    $0xd1,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x108(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x78(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x108(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xfc(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x78(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0xfc(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x54(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0xf8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xe4(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x47(%rax),%eax
mov    $0x23,%ecx
cltd
idiv   %ecx
mov    -0xf0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%ecx
mov    -0x18(%rbp),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xf(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0xe4(%rbp),%eax
mov    %edx,%esi
mov    -0xe0(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
xor    %ecx,%eax
mov    -0x38(%rbp),%ecx
and    -0x3c(%rbp),%ecx
mov    -0x38(%rbp),%edx
or     -0x3c(%rbp),%edx
and    $0x1b,%edx
or     %edx,%ecx
and    %ecx,%eax
mov    %al,%cl
mov    -0x8(%rbp),%rax
mov    %cl,0xc(%rax)
mov    -0x10(%rbp),%rax
movzbl 0x20(%rax),%eax
mov    %eax,-0xd8(%rbp)
mov    -0x18(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x58(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0xd8(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    %ecx,%eax
mov    %eax,-0xd4(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x20(%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x58(%rax),%eax
mov    $0x23,%esi
cltd
idiv   %esi
mov    -0xd4(%rbp),%eax
mov    %edx,%esi
mov    -0xd0(%rbp),%rdx
movslq %esi,%rsi
movzbl (%rdx,%rsi,1),%edx
or     %edx,%ecx
and    $0x17,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x39(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0xc8(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
imul   $0xe7,%eax,%eax
and    $0xa9,%eax
mov    -0x3c(%rbp),%ecx
and    $0x56,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x52(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0xc0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
and    $0xffffffe2,%eax
mov    %eax,-0xb8(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x7c(%rax),%eax
mov    $0x15,%esi
cltd
idiv   %esi
mov    -0xb8(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
and    $0x1d,%ecx
or     %ecx,%eax
and    $0xbe,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x44(%rbp),%eax
mov    $0x5,%esi
xor    %edx,%edx
div    %esi
mov    $0x15,%esi
xor    %edx,%edx
div    %esi
mov    -0xb4(%rbp),%eax
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
and    $0xffffff41,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0xb0(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0xa4(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0xa4(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x8(%rbp),%rcx
mov    -0x20(%rbp),%rax
movzbl 0x28(%rax),%eax
mov    $0x14,%esi
cltd
idiv   %esi
mov    -0xa0(%rbp),%eax
movslq %edx,%rdx
movzbl (%rcx,%rdx,1),%ecx
imul   %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
mov    -0x10(%rbp),%rcx
movzbl 0x52(%rcx),%ecx
and    %ecx,%eax
mov    -0x5c(%rbp),%ecx
and    $0x5c,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x52(%rcx),%ecx
and    $0x5c,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x58(%rbp),%eax
and    -0x60(%rbp),%eax
mov    -0x58(%rbp),%ecx
or     -0x60(%rbp),%ecx
and    $0xc0,%ecx
or     %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x5,%ecx
xor    %edx,%edx
div    %ecx
mov    %eax,%ecx
mov    -0x9c(%rbp),%eax
xor    %ecx,%eax
mov    %al,%cl
mov    -0x20(%rbp),%rax
mov    %cl,0x80(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x78(%rax),%eax
mov    $0x14,%ecx
cltd
idiv   %ecx
mov    -0x98(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%eax
shl    $0x1,%eax
mov    -0x10(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
imul   %ecx,%eax
mov    %eax,-0x88(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x4c(%rax),%edi
mov    -0x28(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x20(%rbp),%rax
movzbl 0x7c(%rax),%eax
mov    $0x15,%ecx
cltd
idiv   %ecx
mov    -0x90(%rbp),%rax
movslq %edx,%rcx
movzbl (%rax,%rcx,1),%esi
and    $0x7,%esi
mov    $0x0,%al
call   1030 <weird_rol8@plt>
mov    -0x88(%rbp),%edx
mov    -0x20(%rbp),%rcx
movzbl 0x14(%rcx),%ecx
add    $0x6e,%ecx
and    %ecx,%eax
sub    %eax,%edx
mov    -0x18(%rbp),%rax
movzbl 0x19(%rax),%ecx
xor    %edx,%ecx
mov    %cl,0x19(%rax)
add    $0x710,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<garble>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r8,%rbx
mov    %rcx,%r15
mov    %rdx,%r14
mov    %rsi,%r12
mov    %rdi,%r13
mov    0x40(%rsi),%al
and    $0x5c,%al
movzbl 0x63(%rsi),%ecx
imul   $0xab,%ecx,%ebp
shr    $0x9,%ebp
and    $0x23,%bpl
or     %al,%bpl
movzbl 0xce(%rsi),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r8,%rax,1),%edi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <rol8x@plt>
cltq
imul   $0x30c30c31,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rcx
sar    $0x2,%ecx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %ecx,%eax
cltq
and    (%rbx,%rax,1),%bpl
add    $0x14,%bpl
mov    %bpl,0xc(%r14)
movzbl 0x63(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
mov    %ecx,%eax
mul    %cl
add    %al,%al
mov    %al,0x4(%r12)
movb   $0xb8,0x22(%r14)
movzbl 0xcb(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
mul    %al
mulb   0xbe(%r12)
xor    %al,0x99(%r12)
movzbl 0xcd(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%rbx,%rax,1),%al
shr    %al
and    $0x10,%al
mov    0x3(%r13),%cl
sub    %al,%cl
add    $0xc0,%cl
mov    %cl,0x3(%r13)
movb   $0x93,0x10(%r13)
movb   $0x62,0xd(%r13)
movzbl 0x24(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%rbx,%rax,1),%al
mov    %rbx,%rbp
and    $0xf6,%al
sub    %al,0x21(%r12)
movzbl 0x43(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%eax
mov    %eax,0x10(%rsp)
movb   $0x7,0xc(%r14)
movzbl 0xb5(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%r13,%rax,1),%eax
mov    %eax,0xc(%rsp)
addb   $0xc0,0x2(%r12)
movzbl 0x3a(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%rbx,%rax,1),%al
mov    %al,0x13(%r13)
movzbl 0x20(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    $0x5c,%cl
sub    (%r14,%rax,1),%cl
mov    %cl,(%r15)
movzbl 0xf(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
add    $0x9e,%al
mov    %al,0x4(%r15)
movzbl 0xf(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
add    $0x9e,%al
movzbl %al,%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%rbx,%rax,1),%eax
imul   $0xcd,%eax,%eax
shr    $0xa,%eax
add    %al,0x22(%r12)
movzbl 0x4(%r15),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
shr    %al
and    $0x66,%al
mov    0x13(%r13),%cl
sub    %al,%cl
add    $0xe6,%cl
mov    %cl,0x13(%r13)
mov    0x48(%r12),%dil
movzbl 0xbe(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%ebx
sub    %cl,%bl
shr    %bl
add    %cl,%bl
shr    $0x4,%bl
movzbl %bl,%ecx
lea    (%rcx,%rcx,4),%esi
lea    (%rcx,%rsi,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%rbp,%rax,1),%al
mov    %eax,%ecx
and    $0x7,%cl
mov    %edi,%edx
shr    %cl,%dl
neg    %al
and    $0x7,%al
mov    %eax,%ecx
shl    %cl,%dil
xor    %dl,%dil
movzbl 0x7e(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%rbp,%rax,1),%eax
mov    %rbp,0x20(%rsp)
lea    (%rax,%rax,2),%eax
neg    %eax
add    %dil,%al
movzbl %al,%eax
lea    (%rax,%rax,2),%eax
xor    %al,0xf(%r12)
movzbl 0xb5(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%cl
mov    %ecx,%eax
mul    %cl
mul    %cl
xor    %al,0xf(%r13)
movzbl 0xca(%r12),%eax
imul   $0xab,%eax,%eax
shr    $0x9,%eax
xor    %al,0x4(%r14)
movzbl (%r15),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%r13,%rax,1),%eax
mov    $0x5c,%ecx
sub    %eax,%ecx
movzbl 0x69(%r12),%eax
not    %eax
mov    %ecx,%edx
or     %eax,%edx
and    $0xc6,%edx
and    %ecx,%eax
or     %edx,%eax
mov    %eax,%ecx
imul   %eax,%ecx
imul   %eax,%ecx
add    %cl,0x1(%r14)
movzbl 0x5c(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%rbp,%rax,1),%eax
and    $0x1b,%eax
or     $0xe0,%eax
movzbl 0x29(%r12),%ecx
imul   $0xeb,%ecx,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%cl
movzbl %cl,%ecx
movzbl (%r14,%rcx,1),%ecx
imul   %eax,%ecx
imul   $0xaaab,%ecx,%eax
shr    $0x11,%eax
xor    %al,0x13(%r13)
movzbl 0x5(%r12),%esi
and    $0x7,%esi
mov    $0x5c,%edi
xor    %eax,%eax
call   1070 <weird_ror8@plt>
add    %al,0x8c(%r12)
movzbl 0xc(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
xor    0x4(%r12),%al
movzbl %al,%eax
not    %eax
movzbl 0xb6(%r12),%ecx
mov    %eax,%edx
or     %ecx,%edx
and    $0xc0,%edx
and    %ecx,%eax
or     %edx,%eax
add    %al,0xc(%r14)
addb   $0x7d,0x24(%r12)
movzbl 0x8a(%r12),%eax
mov    %eax,%ecx
and    $0x4a,%ecx
or     $0x4a,%eax
movzbl 0xf(%r13),%edi
and    %eax,%edi
or     %ecx,%edi
movzbl 0x2b(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%r13,%rax,1),%eax
mov    %edi,%ecx
and    %eax,%ecx
or     %eax,%edi
and    $0x5f,%edi
or     %ecx,%edi
mov    $0x4,%esi
xor    %eax,%eax
call   1040 <rol8x@plt>
mov    %al,0x7c(%r12)
movzbl 0x4(%r15),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%ebp
movzbl 0x44(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%ebx
sub    %cl,%bl
shr    %bl
add    %cl,%bl
shr    $0x4,%bl
movzbl %bl,%ecx
lea    (%rcx,%rcx,4),%esi
lea    (%rcx,%rsi,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x20(%rsp),%rdx
mov    (%rdx,%rax,1),%al
add    %al,%al
and    0x0(%r13,%rbp,1),%al
not    %al
and    $0x4c,%al
mov    %al,0x8(%r15)
movzbl 0xb1(%r12),%eax
movzbl 0x4f(%r12),%ecx
imul   $0x87,%ecx,%esi
shr    $0x8,%esi
mov    %ecx,%ebx
sub    %sil,%bl
shr    %bl
add    %sil,%bl
shr    $0x4,%bl
movzbl %bl,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rsi,%rdi,4),%esi
sub    %sil,%cl
movzbl %cl,%ecx
movzbl (%rdx,%rcx,1),%ecx
mov    %rdx,%r8
add    %eax,%ecx
shr    %ecx
movzbl 0x94(%r12),%eax
imul   $0x26667,%eax,%eax
shr    $0x12,%eax
mov    %ecx,%esi
or     %eax,%esi
movzbl 0x1(%r14),%edi
and    %esi,%edi
and    %ecx,%eax
or     %edi,%eax
mov    $0xde,%cl
sub    %al,%cl
mov    %cl,0xc(%r15)
mov    0x16(%r14),%cl
mov    %ecx,%eax
neg    %cl
mov    0x21(%r12),%bl
and    $0x7,%cl
mov    %ebx,%edx
shr    %cl,%dl
and    $0x7,%al
mov    %eax,%ecx
shl    %cl,%bl
mov    0x10(%r14),%al
xor    %dl,%bl
movzbl (%r15),%ecx
imul   $0xeb,%ecx,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    (%r14,%rcx,1),%cl
and    $0x97,%cl
or     0x0(%r13,%rbp,1),%cl
or     $0x8,%cl
or     $0x80,%bl
sub    %bl,%al
add    %cl,%al
mov    %al,0x10(%r14)
movzbl 0xc(%r15),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
xor    %al,0xe(%r13)
movzbl 0xc9(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%r13,%rax,1),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    %r8,%rbx
movzbl (%r8,%rax,1),%edi
movzbl 0x70(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%esi
add    %esi,%esi
and    $0x6,%esi
xor    %eax,%eax
call   1030 <weird_rol8@plt>
movzbl 0xd0(%r12),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    0x0(%r13,%rcx,1),%cl
and    $0x83,%cl
movzbl 0xa4(%r12),%edx
imul   $0xcd,%edx,%esi
shr    $0xa,%esi
and    $0xfffffffc,%esi
lea    (%rsi,%rsi,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
mov    0x0(%r13,%rdx,1),%dl
and    $0x7c,%dl
or     %cl,%dl
movzbl %dl,%ecx
imul   $0xcd,%ecx,%ecx
shr    $0xa,%ecx
mov    %eax,%edx
and    %ecx,%edx
or     %eax,%ecx
and    $0x25,%ecx
or     %edx,%ecx
add    %cl,0x13(%r12)
movzbl 0x2d(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%rbx,%rax,1),%esi
add    $0x5c,%esi
imul   %esi,%esi
and    $0x7,%esi
mov    $0x8c,%edi
xor    %eax,%eax
call   1070 <weird_ror8@plt>
mov    %al,0x8(%r14)
movb   $0x38,0xbe(%r12)
mov    (%r15),%al
xor    %al,0x8(%r14)
movzbl 0x53(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%r13,%rax,1),%eax
or     $0xcc,%eax
imul   $0xcd,%eax,%eax
shr    $0xa,%eax
not    %al
mov    %al,0x35(%r12)
movzbl 0x29(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
add    %al,0xd(%r13)
movzbl (%r15),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
mov    0x2(%r12),%cl
mov    %ecx,%edx
and    %al,%dl
or     %al,%cl
and    0xc(%r15),%cl
or     %dl,%cl
movzbl %cl,%eax
imul   $0x89,%eax,%eax
shr    $0xb,%eax
mov    %al,0xa(%r13)
movzbl 0x2(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%rbx,%rax,1),%al
and    $0x44,%al
movzbl 0x8(%r15),%ecx
imul   $0xeb,%ecx,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%cl
movzbl %cl,%ecx
or     $0x12,%al
and    (%r14,%rcx,1),%al
or     $0x28,%al
mul    %al
lea    0x6e(%rax),%ecx
mov    %cl,0x10(%r15)
mov    $0x5c,%cl
sub    %al,%cl
mov    %cl,0x14(%r15)
mov    0x97(%r12),%al
mov    %al,0x18(%r15)
movzbl (%r15),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%rbx,%rax,1),%al
mov    %rbx,%rdi
xor    %al,0xd(%r14)
movzbl 0xb3(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%eax
add    $0xffffffda,%eax
movzbl 0xc(%r15),%ecx
mov    %eax,%edx
or     %ecx,%edx
and    $0xb1,%edx
and    %ecx,%eax
or     %edx,%eax
imul   %eax,%eax
lea    0x1e(%rax),%ecx
mov    %cl,0x1c(%r15)
add    $0x5c,%al
mov    %al,0x20(%r15)
movzbl 0x14(%r15),%edx
movzbl (%r15),%eax
mov    %eax,%ecx
and    $0x4a,%ecx
add    %edx,%ecx
imul   $0x87,%eax,%edx
shr    $0x8,%edx
mov    %eax,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
mov    %eax,%ebx
sub    %dl,%bl
movzbl %bl,%edx
movzbl (%rdi,%rdx,1),%ebp
mov    %rdi,%rbx
not    %ebp
mov    %ecx,%edx
or     %ebp,%edx
and    $0x79,%edx
and    %ecx,%ebp
or     %edx,%ebp
mov    %ebp,%ecx
xor    $0xffffffa6,%ecx
mov    %ecx,%edx
or     %eax,%edx
and    $0x4,%edx
and    %eax,%ecx
or     %edx,%ecx
movzbl 0x59(%r12),%eax
imul   $0xeb,%eax,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%al
movzbl %al,%eax
add    (%r14,%rax,1),%cl
xor    %cl,0x2f(%r12)
mov    0xc(%rsp),%edi
and    $0xffffffb3,%edi
or     $0x44,%edi
mov    $0x2,%esi
xor    %eax,%eax
call   1060 <rol8@plt>
movzbl 0x3(%r13),%ecx
mov    0x10(%rsp),%edx
xor    %edx,%eax
and    %ecx,%eax
xor    %edx,%eax
add    $0xf1,%al
mov    %al,0x24(%r15)
xorb   $0xdd,0x7b(%r12)
movzbl (%r15),%edx
imul   $0x87,%edx,%eax
shr    $0x8,%eax
mov    %edx,%ecx
sub    %al,%cl
shr    %cl
add    %al,%cl
shr    $0x4,%cl
movzbl %cl,%eax
lea    (%rax,%rax,4),%ecx
lea    (%rax,%rcx,4),%eax
mov    %edx,%ecx
sub    %al,%cl
movzbl %cl,%r8d
mov    %rbx,%rsi
movzbl (%rbx,%r8,1),%eax
imul   $0xab,%eax,%eax
shr    $0x9,%eax
movzbl 0x4(%r15),%r10d
imul   $0xeb,%r10d,%edi
shr    $0xd,%edi
imul   $0x23,%edi,%edi
mov    %r10d,%ebx
sub    %dil,%bl
movzbl %bl,%edi
mov    %edx,%ecx
and    $0xaa,%cl
or     $0x54,%cl
mov    0x18(%r15),%r9b
mov    %r9d,%ebx
or     %cl,%bl
and    $0x36,%bl
and    %r9b,%cl
or     %bl,%cl
add    (%r14,%rdi,1),%cl
sub    %cl,%al
mov    %al,0x28(%r15)
shr    %dl
or     $0x1a,%dl
xor    %dl,%bpl
xor    $0x51,%bpl
mov    %bpl,0x2c(%r15)
mov    (%r14,%rdi,1),%dl
and    $0x1b,%dl
mov    %dl,0x30(%r15)
movb   $0x1b,0x34(%r15)
movb   $0xc7,0x38(%r15)
mov    %eax,%ecx
or     %r9b,%cl
and    $0x20,%cl
and    %r9b,%al
mov    (%rsi,%r8,1),%dil
mov    %eax,%ebx
or     %dil,%al
or     $0x20,%dil
and    $0x64,%bl
or     %cl,%bl
and    %dil,%bl
and    $0x44,%al
or     %bl,%al
add    %r10b,%dl
add    %al,%dl
add    $0x80,%dl
mov    %dl,0x40(%r15)
mov    0x1a(%r12),%al
xor    %al,0x21(%r14)
mov    0x14(%r15),%al
xor    0x6a(%r12),%al
xor    $0x85,%al
mov    %al,0x6a(%r12)
movzbl 0x40(%r15),%eax
imul   $0xab,%eax,%eax
shr    $0x9,%eax
mov    (%r15),%cl
and    $0xe4,%cl
sub    %cl,%al
add    $0xed,%al
movzbl 0x7a(%r12),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
xor    0x0(%r13,%rcx,1),%al
mov    %al,0x1e(%r14)
movzbl 0x5a(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
and    $0x1b,%al
or     $0x44,%al
mov    %al,0x16(%r12)
movzbl 0x24(%r15),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    %rsi,%rdi
movzbl (%rsi,%rax,1),%eax
and    $0xffffffb8,%eax
movzbl 0x2c(%r15),%ecx
imul   $0xeb,%ecx,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%cl
movzbl %cl,%ecx
movzbl (%r14,%rcx,1),%edx
and    $0x47,%edx
or     %eax,%edx
mov    %edx,%ecx
imul   %edx,%ecx
imul   %edx,%ecx
shr    %ecx
add    0x12(%r14),%cl
mov    %cl,0x12(%r14)
mov    %r14,%rbp
movzbl 0x5c(%r12),%eax
imul   $0x87,%eax,%edx
shr    $0x8,%edx
mov    %eax,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%al
movzbl %al,%eax
mov    (%rdi,%rax,1),%al
sub    %al,0x5(%r14)
mov    0x11(%r12),%dl
mov    0x29(%r12),%al
and    $0xe7,%al
movzbl 0xb7(%r12),%esi
imul   $0xeb,%esi,%edi
shr    $0xd,%edi
imul   $0x23,%edi,%edi
sub    %dil,%sil
movzbl %sil,%esi
mov    (%r14,%rsi,1),%bl
and    $0x18,%bl
or     %al,%bl
mov    0x10(%r15),%al
add    $0x35,%al
and    %bl,%al
movzbl 0x14(%r15),%esi
imul   $0xeb,%esi,%edi
shr    $0xd,%edi
imul   $0x23,%edi,%edi
mov    %esi,%ebx
sub    %dil,%bl
movzbl %bl,%edi
mov    (%r14,%rdi,1),%bl
and    %sil,%bl
or     %al,%bl
movzbl 0x3b(%r12),%eax
imul   $0xcd,%eax,%esi
shr    $0xa,%esi
and    $0xfffffffc,%esi
lea    (%rsi,%rsi,4),%esi
sub    %sil,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
xor    %dl,%al
and    0x2c(%r15),%al
xor    %dl,%al
mul    %bl
xor    %cl,%al
mov    %al,0x12(%r14)
movzbl 0xb(%r12),%edi
movzbl 0x1c(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%esi
and    $0x7,%esi
xor    %eax,%eax
call   1070 <weird_ror8@plt>
mov    %eax,%r14d
and    $0x7,%r14d
movzbl 0x5d(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    %r13,0x18(%rsp)
movzbl 0x0(%r13,%rax,1),%eax
movzbl 0xe(%r13),%ecx
mov    %ecx,%edx
not    %edx
and    %eax,%edx
and    $0xffffff82,%ecx
and    $0xe3,%edx
or     %ecx,%edx
movzbl 0x7(%r12),%ebx
and    $0x1c,%ebx
or     %edx,%ebx
movzbl (%r15),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%rbp,%rax,1),%edi
mov    %r14d,%esi
xor    %eax,%eax
call   1030 <weird_rol8@plt>
or     %ebx,%eax
movzbl 0x21(%rbp),%r13d
and    %eax,%r13d
movzbl (%r15),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%rbp,%rax,1),%edi
mov    %r14d,%esi
xor    %eax,%eax
call   1030 <weird_rol8@plt>
and    %ebx,%eax
or     %r13d,%eax
add    $0x4a,%al
mov    %al,0x16(%rbp)
movzbl 0x27(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x18(%rsp),%rdi
movzbl (%rdi,%rax,1),%eax
xor    $0xd9,%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,1),%al
mov    (%r15),%cl
mov    0x14(%r15),%dl
mov    %ecx,%ebx
or     %dl,%bl
and    $0xd6,%bl
and    %dl,%cl
or     %bl,%cl
mov    %ecx,%edx
and    %al,%dl
or     %al,%cl
and    0x20(%r15),%cl
or     %dl,%cl
sub    %cl,0xf(%rdi)
movzbl 0x39(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%rbp,%rax,1),%al
mov    %rbp,0x38(%rsp)
movzbl 0x40(%r15),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
mov    %ecx,%ebx
sub    %dl,%bl
movzbl %bl,%edx
mov    (%rdi,%rdx,1),%dl
mov    %edx,%ebx
and    %al,%bl
or     %al,%dl
and    $0x5f,%dl
or     %bl,%dl
mov    %ecx,%eax
and    $0x2d,%al
or     %cl,%bl
and    $0x20,%bl
or     $0x52,%al
and    %dl,%al
or     %bl,%al
movzbl (%r15),%edx
imul   $0xab,%edx,%edx
shr    $0x9,%edx
movzbl 0x16(%r12),%esi
or     %ecx,%esi
sub    %esi,%edx
movzbl 0x1c(%r15),%esi
mov    %r15,0x40(%rsp)
add    $0x3e,%esi
xor    %edx,%esi
movzbl %al,%eax
movzbl %sil,%edx
xor    %eax,%edx
mov    $0xcccccccd,%esi
mov    %rdx,%rax
imul   %rsi,%rax
shr    $0x24,%rax
shl    $0x2,%eax
lea    (%rax,%rax,4),%eax
sub    %eax,%edx
mov    (%rdi,%rdx,1),%al
mov    %al,0xb(%rsp)
movzbl 0x63(%r12),%eax
imul   $0xcd,%eax,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%al
movzbl %al,%eax
mov    (%rdi,%rax,1),%al
mul    %al
mul    %al
imul   $0xeb,%ecx,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%cl
movzbl %cl,%ecx
or     0x0(%rbp,%rcx,1),%al
mov    %al,0x44(%r15)
movzbl 0x32(%r12),%edx
imul   $0xcd,%edx,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%dl
mov    %edx,0x10(%rsp)
movzbl 0x8a(%r12),%r9d
imul   $0xeb,%r9d,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%r9b
movzbl 0x27(%r12),%r11d
imul   $0x87,%r11d,%ecx
shr    $0x8,%ecx
mov    %r11d,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%r11b
movzbl 0x4(%r12),%r10d
imul   $0xcd,%r10d,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%r10b
movzbl 0xca(%r12),%r14d
imul   $0x87,%r14d,%ecx
shr    $0x8,%ecx
mov    %r14d,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%r14b
movzbl 0x97(%r12),%r8d
imul   $0xcd,%r8d,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%r8b
movzbl 0xe(%r12),%edx
imul   $0xeb,%edx,%edi
shr    $0xd,%edi
imul   $0x23,%edi,%edi
sub    %dil,%dl
movzbl 0x91(%r12),%edi
imul   $0xcd,%edi,%ebx
shr    $0xa,%ebx
and    $0xfffffffc,%ebx
lea    (%rbx,%rbx,4),%ebx
sub    %bl,%dil
movzbl %al,%eax
imul   $0xeb,%eax,%ebx
shr    $0xd,%ebx
imul   $0x23,%ebx,%ebx
sub    %bl,%al
movzbl 0xd1(%r12),%ebx
imul   $0xcd,%ebx,%ebp
shr    $0xa,%ebp
and    $0xfffffffc,%ebp
lea    0x0(%rbp,%rbp,4),%ebp
sub    %bpl,%bl
movzbl 0x7f(%r12),%ebp
imul   $0x87,%ebp,%esi
shr    $0x8,%esi
mov    %ebp,%r13d
sub    %sil,%r13b
shr    %r13b
add    %sil,%r13b
shr    $0x4,%r13b
movzbl %r13b,%esi
lea    (%rsi,%rsi,4),%ecx
lea    (%rsi,%rcx,4),%ecx
sub    %cl,%bpl
movzbl %r8b,%ecx
mov    0x18(%rsp),%r8
mov    (%r8,%rcx,1),%sil
movzbl %r14b,%ecx
mov    0x20(%rsp),%r13
or     0x0(%r13,%rcx,1),%sil
mov    %sil,0xa(%rsp)
movzbl %dil,%ecx
mov    (%r8,%rcx,1),%cl
mov    %cl,0xc(%rsp)
movzbl 0x10(%rsp),%ecx
movzbl (%r8,%rcx,1),%ecx
mov    %ecx,0x2c(%rsp)
movzbl %r9b,%ecx
mov    0x38(%rsp),%r15
movzbl (%r15,%rcx,1),%ecx
mov    %ecx,0x30(%rsp)
movzbl %r11b,%ecx
movzbl %r10b,%esi
movzbl (%r8,%rsi,1),%esi
mov    %esi,0x34(%rsp)
movzbl %dl,%edx
movzbl (%r15,%rdx,1),%edx
mov    %rdx,0x10(%rsp)
movzbl %al,%eax
movzbl (%r15,%rax,1),%esi
movzbl %bl,%eax
movzbl (%r8,%rax,1),%ebx
mov    %r8,%r14
and    %esi,%ebx
movzbl %bpl,%eax
movzbl 0x0(%r13,%rax,1),%edi
and    $0x7,%esi
movzbl 0x0(%r13,%rcx,1),%ebp
xor    %eax,%eax
call   1030 <weird_rol8@plt>
movzbl 0xa(%r14),%ecx
mov    %r14,%rdi
xor    %eax,%ebx
and    %ecx,%ebx
xor    %eax,%ebx
mov    0x40(%rsp),%rsi
movzbl 0x24(%rsi),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r15,%rax,1),%eax
mov    %r15,%r14
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%r13,%rax,1),%eax
and    $0x47,%ebx
and    $0x5c,%eax
lea    (%rbx,%rax,2),%eax
mov    %rsi,%r15
mov    %al,0x48(%rsi)
movzbl 0x14(%rsi),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%rdi,%rax,1),%cl
add    %cl,%cl
and    $0x9e,%cl
movzbl 0xbe(%r12),%eax
imul   $0x87,%eax,%edx
shr    $0x8,%edx
mov    %eax,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
and    $0x60,%al
or     %cl,%al
movzbl 0x40(%r15),%ecx
imul   $0x87,%ecx,%edx
shr    $0x8,%edx
mov    %ecx,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    0x0(%r13,%rcx,1),%cl
and    $0x68,%cl
mov    0x19(%r12),%dl
and    $0x96,%dl
or     %cl,%dl
and    %al,%dl
add    %dl,0x2(%r14)
movzbl 0x14(%r15),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x64(%r12),%ecx
imul   $0xeb,%ecx,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    (%r14,%rcx,1),%cl
xor    0x48(%r15),%cl
and    (%r14,%rax,1),%cl
and    $0xdd,%cl
mov    0x61(%r12),%al
and    $0x22,%al
or     %cl,%al
sub    %al,0xe(%r14)
movb   $0x73,0x11(%rdi)
movzbl 0x11(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
movzbl 0x14(%r15),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    (%rdi,%rcx,1),%cl
mov    %ecx,%edx
or     %al,%dl
and    0x48(%r15),%dl
and    %al,%cl
or     %dl,%cl
movzbl 0x32(%r12),%eax
imul   $0xab,%eax,%eax
shr    $0x9,%eax
mov    %ecx,%edx
and    %al,%dl
or     %al,%cl
and    $0x76,%cl
or     %dl,%cl
add    %cl,%cl
xor    %cl,0x17(%r12)
movzbl 0x28(%r15),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%rdi,%rax,1),%al
mov    0xa(%r12),%cl
mov    %ecx,%edx
or     %al,%dl
and    $0x50,%dl
and    %cl,%al
and    $0xd0,%al
or     %dl,%al
movzbl 0x27(%r12),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    (%rdi,%rcx,1),%cl
add    %cl,%cl
and    $0x2e,%cl
or     %al,%cl
shr    %cl
mov    %cl,0xd(%rdi)
mov    0x71(%r12),%al
and    $0x9,%al
sub    %al,0x21(%r14)
mov    0x6e(%r12),%al
shr    %al
and    $0x20,%al
mov    0x14(%r15),%cl
and    $0xdf,%cl
or     %al,%cl
sub    %cl,0x1c(%r14)
movzbl 0xa(%rsp),%edi
mov    0x2c(%rsp),%esi
and    $0x7,%esi
xor    %eax,%eax
call   1030 <weird_rol8@plt>
movzbl 0x10(%r14),%ecx
mov    0xb(%rsp),%dl
and    %cl,%dl
movzbl %dl,%edx
not    %ecx
and    0x30(%rsp),%ecx
or     %edx,%ecx
movzbl 0x21(%r12),%edx
and    $0x11,%edx
and    $0xffffffee,%ebp
or     %edx,%ebp
add    %ecx,%ebp
mov    $0xcccccccd,%ecx
imul   %rcx,%rbp
shr    $0x22,%rbp
mov    %ebp,%ecx
mov    0x34(%rsp),%edx
or     %edx,%ecx
and    $0x93,%ecx
and    %edx,%ebp
or     %ecx,%ebp
mov    0x28(%r15),%cl
add    %eax,%ebp
mov    0x8(%r15),%al
add    %bpl,%al
movzbl %al,%eax
imul   $0x87,%eax,%edx
shr    $0x8,%edx
mov    %eax,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
mov    %eax,%edx
and    %cl,%dl
or     %cl,%al
and    0x17(%r14),%al
or     %dl,%al
movzbl %al,%eax
movzbl 0x14(%r15),%ecx
imul   $0x87,%ecx,%edx
shr    $0x8,%edx
mov    %ecx,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
movzbl 0x0(%r13,%rcx,1),%ecx
add    $0xd0,%ecx
movzbl 0xb8(%r12),%edx
not    %edx
mov    %edx,%esi
or     $0xbd,%esi
and    %ecx,%esi
and    $0xbd,%edx
or     %esi,%edx
mov    %eax,%ecx
imul   %eax,%ecx
imul   %eax,%ecx
and    %edx,%ecx
mov    0x18(%rsp),%r8
mov    %cl,0xf(%r8)
mov    0xb7(%r12),%al
add    %al,0x16(%r14)
movzbl 0x1(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%r13,%rax,1),%eax
lea    (%rax,%rax,2),%eax
xor    (%r15),%al
mov    %al,0x4c(%r15)
mov    0x8(%r15),%al
add    %bpl,%al
movzbl %al,%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
movzbl 0xb2(%r12),%ecx
imul   $0x87,%ecx,%edx
shr    $0x8,%edx
mov    %ecx,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    0x0(%r13,%rcx,1),%cl
mov    %ecx,%edx
and    %al,%dl
or     %al,%cl
and    $0xd1,%cl
or     %dl,%cl
movzbl %cl,%eax
movzbl 0xd(%r12),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
movzbl (%r8,%rcx,1),%ecx
movzbl 0x1a(%r12),%edx
imul   $0x87,%edx,%esi
shr    $0x8,%esi
mov    %edx,%ebx
sub    %sil,%bl
shr    %bl
add    %sil,%bl
shr    $0x4,%bl
movzbl %bl,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rsi,%rdi,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
movzbl 0x0(%r13,%rdx,1),%esi
shr    %esi
imul   %ecx,%esi
imul   %eax,%esi
add    $0x733ffff9,%esi
imul   $0xc6,%esi,%edx
imul   $0x18c,%esi,%eax
add    $0xd4,%eax
and    $0xd4,%eax
sub    %eax,%edx
add    $0x55,%edx
movzbl 0x24(%r15),%eax
mov    %edx,%ecx
xor    $0x94,%ecx
add    %eax,%ecx
xor    $0x6b,%edx
add    %edx,%edx
add    %ecx,%edx
add    $0x81,%dl
mov    %dl,0x50(%r15)
movzbl 0x40(%r15),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
and    $0xf5,%al
movzbl 0x14(%r15),%ecx
imul   $0xeb,%ecx,%esi
shr    $0xd,%esi
imul   $0x23,%esi,%esi
sub    %sil,%cl
movzbl %cl,%ecx
mov    (%r14,%rcx,1),%cl
mov    %r14,%rsi
and    $0xa,%cl
or     %al,%cl
mov    %cl,0x54(%r15)
movzbl 0x44(%r15),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    %r8,%r14
mov    (%r8,%rax,1),%cl
or     $0x51,%cl
mov    %ecx,%eax
mul    %cl
mul    %cl
movzbl %dl,%ecx
imul   $0x89,%ecx,%ecx
shr    $0xb,%ecx
xor    %al,%cl
and    0xf(%r8),%cl
xor    %al,%cl
sub    %cl,0x12(%rsi)
movzbl 0xa0(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
add    0x8(%r15),%bpl
movzbl %bpl,%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
mov    %ecx,%ebx
sub    %dl,%bl
movzbl %bl,%edx
movzbl (%r8,%rdx,1),%edx
imul   $0x87,%edx,%esi
shr    $0x8,%esi
mov    %edx,%ebx
sub    %sil,%bl
shr    %bl
add    %sil,%bl
shr    $0x4,%bl
movzbl %bl,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rsi,%rdi,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
movzbl 0x0(%r13,%rdx,1),%edx
imul   $0xab,%edx,%edx
shr    $0x9,%edx
sub    (%r8,%rax,1),%cl
add    %dl,%cl
mov    %cl,0x58(%r15)
movzbl 0x48(%r15),%eax
mov    0xc(%rsp),%cl
xor    %al,%cl
and    $0x39,%cl
movzbl %cl,%ecx
mov    0x10(%rsp),%rdi
imul   %edi,%edi
and    $0xc6,%edi
or     %ecx,%edi
movzbl 0x45(%r12),%ecx
imul   $0x87,%ecx,%edx
shr    $0x8,%edx
mov    %ecx,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    0x0(%r13,%rcx,1),%cl
mov    %r13,%rbp
mov    0xac(%r12),%bl
mov    %ebx,%edx
and    %cl,%dl
movzbl %dl,%edx
or     %cl,%bl
movzbl %bl,%ecx
movzbl 0xc(%r15),%esi
neg    %edi
add    %edi,%esi
add    $0x4d,%esi
and    %ecx,%esi
or     %edx,%esi
mov    %esi,%ecx
and    $0xfffffffa,%ecx
or     $0x1,%ecx
and    %eax,%ecx
and    $0xffffffc2,%esi
and    $0xffffffc6,%eax
or     %esi,%eax
or     %ecx,%eax
mov    $0x93,%cl
sub    %al,%cl
mov    %cl,0x10(%r8)
movzbl 0xa8(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
movzbl 0x1d(%r12),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    (%r8,%rcx,1),%cl
mov    %eax,%edx
and    %cl,%dl
and    $0x7,%dl
or     %al,%cl
and    $0x6,%cl
or     %dl,%cl
movzbl %cl,%esi
movzbl 0x9b(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
mov    0x69(%r12),%cl
mov    %ecx,%edx
and    %al,%dl
or     %al,%cl
and    $0x8d,%cl
or     %dl,%cl
movzbl %cl,%edi
xor    %eax,%eax
call   1050 <weird_rol32@plt>
cltq
imul   $0x30c30c31,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rcx
sar    $0x2,%ecx
add    %edx,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %ecx,%eax
cltq
mov    0x0(%r13,%rax,1),%al
sub    %al,0x3(%r14)
movzbl 0xc(%r14),%edi
mov    %r14,%r13
movzbl 0x3d(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%eax
imul   $0xcd,%eax,%esi
shr    $0xa,%esi
and    $0x7,%esi
xor    %eax,%eax
call   1070 <weird_ror8@plt>
movzbl 0x54(%r15),%ecx
imul   $0xeb,%ecx,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    0x38(%rsp),%r14
movzbl (%r14,%rcx,1),%ecx
not    %ecx
mov    $0xcccccccd,%edx
imul   %rdx,%rcx
shr    $0x22,%rcx
xor    %eax,%ecx
mov    %cl,0x5(%r12)
mov    0x3(%r12),%al
add    %al,0xc6(%r12)
movzbl 0x40(%r15),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%eax
or     $0xa2,%eax
imul   %eax,%eax
imul   $0xcccd,%eax,%eax
shr    $0x12,%eax
add    %al,0xa4(%r12)
movzbl 0x50(%r15),%esi
and    $0x7,%esi
mov    $0x8b,%edi
xor    %eax,%eax
call   1070 <weird_ror8@plt>
movzbl 0x40(%r15),%ecx
imul   $0x87,%ecx,%edx
shr    $0x8,%edx
mov    %ecx,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
movzbl 0x0(%rbp,%rcx,1),%ecx
mov    %ecx,%edx
imul   %ecx,%edx
imul   %ecx,%edx
and    $0x5f,%edx
movzbl 0x28(%r15),%ecx
imul   $0xcd,%ecx,%esi
shr    $0xa,%esi
and    $0xfffffffc,%esi
lea    (%rsi,%rsi,4),%esi
sub    %sil,%cl
movzbl %cl,%ecx
movzbl 0x0(%r13,%rcx,1),%ecx
and    $0xffffffa0,%ecx
or     %edx,%ecx
movzbl 0x14(%r15),%edx
imul   $0xcd,%edx,%esi
shr    $0xa,%esi
and    $0xfffffffc,%esi
lea    (%rsi,%rsi,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
movzbl 0x0(%r13,%rdx,1),%edx
mov    %eax,%esi
or     %edx,%esi
and    $0xc,%esi
and    %edx,%eax
or     %esi,%eax
or     %ecx,%eax
mov    %al,0x5c(%r15)
movzbl 0x67(%r12),%ecx
mov    %ecx,%edx
and    $0x20,%edx
or     $0x2c,%ecx
and    %eax,%ecx
or     %edx,%ecx
or     $0x10,%ecx
mov    $0xaaaaaaab,%eax
imul   %rcx,%rax
shr    $0x21,%rax
add    %al,0xc(%r14)
mov    0x8f(%r12),%sil
mov    %sil,0x60(%r15)
movb   $0x1b,0x64(%r15)
mov    0x28(%r15),%dl
mov    0x40(%r15),%al
mov    0x23(%r12),%bl
xor    %dl,%bl
and    0x8(%r14),%bl
xor    %dl,%bl
and    %al,%bl
xor    $0x77,%bl
mov    %bl,0x68(%r15)
mov    0x23(%r12),%bl
xor    %dl,%bl
and    0x8(%r14),%bl
xor    %dl,%bl
and    %al,%bl
add    %bl,%bl
and    $0xee,%bl
mov    %bl,0x6c(%r15)
mov    %eax,%ecx
not    %cl
movzbl 0x54(%r15),%edi
imul   $0xab,%edi,%edi
shr    $0x9,%edi
and    %cl,%dil
mov    %edi,%ecx
xor    $0x31,%cl
mov    %cl,0x70(%r15)
lea    (%rdi,%rdi,1),%ecx
and    $0x62,%cl
mov    %cl,0x74(%r15)
mov    0x23(%r12),%cl
xor    %dl,%cl
and    0x8(%r14),%cl
xor    %dl,%cl
and    %al,%cl
or     %dil,%cl
mov    0xac(%r12),%al
shr    %al
or     $0x4d,%al
and    %cl,%al
or     $0x12,%al
sub    %al,%sil
mov    %sil,0x8f(%r12)
movb   $0xa2,0x1d(%r14)
movzbl 0x58(%r15),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%rbp,%rax,1),%eax
and    $0xffffffa0,%eax
movzbl 0x7d(%r12),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
movzbl 0x0(%r13,%rcx,1),%ecx
and    $0x5e,%ecx
or     %eax,%ecx
shr    %ecx
movzbl 0x95(%r12),%eax
imul   $0xeb,%eax,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%eax
movzbl 0x2b(%r12),%edx
imul   %edx,%edx
xor    %eax,%edx
mov    %edx,%eax
and    %ecx,%eax
or     %ecx,%edx
and    $0x73,%edx
or     %eax,%edx
add    %dl,0xf(%r13)
mov    0x40(%r15),%al
movzbl 0x28(%r15),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
sub    0x0(%r13,%rcx,1),%al
mov    %al,0x78(%r15)
movzbl 0x14(%r15),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%rbp,%rax,1),%al
mov    %al,0x5f(%r12)
movzbl 0x50(%r15),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%edi
movzbl 0x11(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl (%r14,%rax,1),%eax
mov    %eax,%esi
imul   %eax,%esi
imul   %eax,%esi
and    $0x7,%esi
xor    %eax,%eax
call   1070 <weird_ror8@plt>
imul   %eax,%eax
sub    %al,0x7(%r13)
mov    0x8(%r14),%dl
sub    0xb8(%r12),%dl
movzbl 0xca(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%ebx
sub    %cl,%bl
shr    %bl
add    %cl,%bl
shr    $0x4,%bl
movzbl %bl,%ecx
lea    (%rcx,%rcx,4),%esi
lea    (%rcx,%rsi,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%rbp,%rax,1),%cl
mov    %ecx,%eax
mul    %cl
mul    %cl
add    %dl,%al
mov    %al,0x8(%r14)
movzbl 0x66(%r12),%eax
imul   $0xeb,%eax,%ecx
shr    $0xd,%ecx
imul   $0x23,%ecx,%ecx
sub    %cl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%al
add    %al,%al
and    $0x84,%al
mov    %al,0x10(%r13)
movzbl 0x28(%r15),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%rbp,%rax,1),%al
shr    %al
xor    0x44(%r15),%al
mov    %al,0x7c(%r15)
movzbl 0xbf(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x50(%r12),%ecx
imul   $0x87,%ecx,%edx
shr    $0x8,%edx
mov    %ecx,%ebx
sub    %dl,%bl
shr    %bl
add    %dl,%bl
shr    $0x4,%bl
movzbl %bl,%edx
lea    (%rdx,%rdx,4),%esi
lea    (%rdx,%rsi,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
mov    0x0(%rbp,%rcx,1),%cl
add    %cl,%cl
and    $0x4e,%cl
movzbl 0x58(%r15),%edx
imul   $0x87,%edx,%esi
shr    $0x8,%esi
mov    %edx,%ebx
sub    %sil,%bl
shr    %bl
add    %sil,%bl
shr    $0x4,%bl
movzbl %bl,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rsi,%rdi,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
movzbl 0x0(%rbp,%rdx,1),%edx
imul   $0x87,%edx,%esi
shr    $0x8,%esi
mov    %edx,%ebx
sub    %sil,%bl
shr    %bl
add    %sil,%bl
shr    $0x4,%bl
movzbl %bl,%esi
lea    (%rsi,%rsi,4),%edi
lea    (%rsi,%rdi,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
mov    0x0(%rbp,%rdx,1),%dl
and    $0xb1,%dl
sub    0x0(%r13,%rax,1),%cl
add    %dl,%cl
add    %cl,0x7(%r13)
movzbl 0x77(%r12),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
mov    0x0(%r13,%rax,1),%al
mov    %al,0x6(%r13)
movzbl 0xbe(%r12),%eax
imul   $0x87,%eax,%ecx
shr    $0x8,%ecx
mov    %eax,%edx
sub    %cl,%dl
shr    %dl
add    %cl,%dl
shr    $0x4,%dl
movzbl %dl,%ecx
lea    (%rcx,%rcx,4),%edx
lea    (%rcx,%rdx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%rbp,%rax,1),%ecx
mov    %rbp,%r9
and    $0x2e,%ecx
movzbl 0x76(%r12),%eax
and    $0xffffffd1,%eax
or     %ecx,%eax
movzbl 0x78(%r15),%ecx
imul   $0xcd,%ecx,%edx
shr    $0xa,%edx
and    $0xfffffffc,%edx
lea    (%rdx,%rdx,4),%edx
sub    %dl,%cl
movzbl %cl,%ecx
movzbl 0x0(%r13,%rcx,1),%ecx
imul   %ecx,%ecx
movzbl 0x54(%r15),%edx
imul   $0xcd,%edx,%esi
shr    $0xa,%esi
and    $0xfffffffc,%esi
lea    (%rsi,%rsi,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
movzbl 0x0(%r13,%rdx,1),%edx
movzbl 0x47(%r12),%esi
imul   $0xeb,%esi,%edi
shr    $0xd,%edi
imul   $0x23,%edi,%edi
sub    %dil,%sil
movzbl %sil,%esi
movzbl (%r14,%rsi,1),%esi
movzbl 0xf(%r12),%edi
imul   $0xeb,%edi,%ebp
shr    $0xd,%ebp
imul   $0x23,%ebp,%ebp
sub    %bpl,%dil
movzbl %dil,%edi
movzbl (%r14,%rdi,1),%edi
add    %esi,%edi
xor    %edx,%edi
mov    %ecx,%edx
and    %eax,%edx
or     %eax,%ecx
and    $0x1b,%ecx
or     %edx,%ecx
and    %edi,%ecx
mov    %cl,0xc(%r13)
mov    0x20(%r12),%cl
movzbl 0x58(%r15),%eax
imul   $0xeb,%eax,%edx
shr    $0xd,%edx
imul   $0x23,%edx,%edx
sub    %dl,%al
movzbl %al,%eax
mov    (%r14,%rax,1),%dl
mov    %edx,%eax
or     %cl,%al
and    $0x16,%al
movzbl 0x39(%r12),%esi
imul   $0x87,%esi,%edi
shr    $0x8,%edi
mov    %esi,%ebx
sub    %dil,%bl
shr    %bl
add    %dil,%bl
shr    $0x4,%bl
movzbl %bl,%edi
lea    (%rdi,%rdi,4),%ebp
lea    (%rdi,%rbp,4),%edi
sub    %dil,%sil
movzbl %sil,%esi
movzbl (%r9,%rsi,1),%esi
imul   $0xffffffe7,%esi,%esi
and    $0xa9,%sil
and    %dl,%cl
and    $0x56,%cl
or     %al,%cl
or     %sil,%cl
movzbl 0x52(%r12),%edx
movzwl %dx,%r8d
imul   $0xcd,%edx,%esi
shr    $0xa,%esi
and    $0xfffffffc,%esi
lea    (%rsi,%rsi,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
movzbl 0x0(%r13,%rdx,1),%edi
and    $0xffffffa2,%edi
movzbl 0x7c(%r15),%edx
imul   $0x87,%edx,%esi
shr    $0x8,%esi
mov    %edx,%ebx
sub    %sil,%bl
shr    %bl
add    %sil,%bl
shr    $0x4,%bl
movzbl %bl,%esi
lea    (%rsi,%rsi,4),%ebp
lea    (%rsi,%rbp,4),%esi
sub    %sil,%dl
movzbl %dl,%edx
movzbl (%r9,%rdx,1),%esi
and    $0x1c,%esi
or     %edi,%esi
movzbl %cl,%ecx
imul   $0xcd,%ecx,%ecx
shr    $0xa,%ecx
imul   $0x87,%ecx,%edi
shr    $0x8,%edi
mov    %ecx,%ebx
sub    %dil,%bl
shr    %bl
add    %dil,%bl
shr    $0x4,%bl
movzbl %bl,%edi
lea    (%rdi,%rdi,4),%ebp
lea    (%rdi,%rbp,4),%edi
mov    %ecx,%ebx
sub    %dil,%bl
movzbl %bl,%edi
movzbl (%r9,%rdi,1),%edi
and    $0x41,%edi
or     %esi,%edi
movzbl 0x28(%r15),%esi
imul   $0xcd,%esi,%ebp
shr    $0xa,%ebp
and    $0xfffffffc,%ebp
lea    0x0(%rbp,%rbp,4),%ebp
sub    %bpl,%sil
movzbl %sil,%esi
movzbl 0x0(%r13,%rsi,1),%ebp
mov    %ebp,%esi
imul   %ebp,%esi
imul   %ebp,%esi
mov    %r8d,%eax
or     $0x5c,%eax
and    %esi,%eax
and    $0x5c,%r8d
or     %eax,%r8d
mov    %r8d,%eax
and    %edi,%eax
or     %edi,%r8d
and    $0xc0,%r8d
or     %eax,%r8d
xor    %ecx,%r8d
mov    %r8b,0x80(%r15)
movzbl 0x78(%r15),%eax
imul   $0xcd,%eax,%ecx
shr    $0xa,%ecx
and    $0xfffffffc,%ecx
lea    (%rcx,%rcx,4),%ecx
sub    %cl,%al
movzbl %al,%eax
movzbl 0x0(%r13,%rax,1),%eax
movzbl 0x5(%r12),%ebx
imul   %eax,%ebx
add    %ebx,%ebx
movzbl 0x4c(%r15),%edi
movzbl (%r9,%rdx,1),%esi
and    $0x7,%esi
xor    %eax,%eax
call   1030 <weird_rol8@plt>
movzbl 0x14(%r15),%ecx
add    $0x6e,%ecx
and    %eax,%ecx
sub    %ecx,%ebx
xor    %bl,0x19(%r14)
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @garble(i8* %0, i8* %1, i8* %2, i8* %3, i8* %4) {
%6 = getelementptr inbounds i8, i8* %1, i64 64
%7 = load i8, i8* %6
%8 = and i8 %7, 92
%9 = getelementptr inbounds i8, i8* %1, i64 99
%10 = load i8, i8* %9
%11 = udiv i8 %10, 3
%12 = and i8 %11, 35
%13 = or i8 %12, %8
%14 = getelementptr inbounds i8, i8* %1, i64 206
%15 = load i8, i8* %14
%16 = urem i8 %15, 21
%17 = zext i8 %16 to i64
%18 = getelementptr inbounds i8, i8* %4, i64 %17
%19 = load i8, i8* %18
%20 = zext i8 %19 to i32
%21 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @rol8x to i32 (i32, i32, ...)*)(i32 %20, i32 4)
%22 = srem i32 %21, 21
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %4, i64 %23
%25 = load i8, i8* %24
%26 = and i8 %25, %13
%27 = add nuw i8 %26, 20
%28 = getelementptr inbounds i8, i8* %2, i64 12
store i8 %27, i8* %28
%29 = load i8, i8* %9
%30 = udiv i8 %29, 5
%31 = shl nuw nsw i8 %30, 1
%32 = mul i8 %31, %30
%33 = getelementptr inbounds i8, i8* %1, i64 4
store i8 %32, i8* %33
%34 = getelementptr inbounds i8, i8* %2, i64 34
store i8 -72, i8* %34
%35 = getelementptr inbounds i8, i8* %1, i64 203
%36 = load i8, i8* %35
%37 = urem i8 %36, 35
%38 = zext i8 %37 to i64
%39 = getelementptr inbounds i8, i8* %2, i64 %38
%40 = load i8, i8* %39
%41 = mul i8 %40, %40
%42 = getelementptr inbounds i8, i8* %1, i64 190
%43 = load i8, i8* %42
%44 = mul i8 %41, %43
%45 = getelementptr inbounds i8, i8* %1, i64 153
%46 = load i8, i8* %45
%47 = xor i8 %44, %46
store i8 %47, i8* %45
%48 = getelementptr inbounds i8, i8* %1, i64 205
%49 = load i8, i8* %48
%50 = urem i8 %49, 21
%51 = zext i8 %50 to i64
%52 = getelementptr inbounds i8, i8* %4, i64 %51
%53 = load i8, i8* %52
%54 = lshr i8 %53, 1
%55 = and i8 %54, 16
%56 = getelementptr inbounds i8, i8* %0, i64 3
%57 = load i8, i8* %56
%58 = add i8 %57, -64
%59 = sub i8 %58, %55
store i8 %59, i8* %56
%60 = getelementptr inbounds i8, i8* %0, i64 16
store i8 -109, i8* %60
%61 = getelementptr inbounds i8, i8* %0, i64 13
store i8 98, i8* %61
%62 = getelementptr inbounds i8, i8* %1, i64 36
%63 = load i8, i8* %62
%64 = urem i8 %63, 21
%65 = zext i8 %64 to i64
%66 = getelementptr inbounds i8, i8* %4, i64 %65
%67 = load i8, i8* %66
%68 = and i8 %67, -10
%69 = getelementptr inbounds i8, i8* %1, i64 33
%70 = load i8, i8* %69
%71 = sub i8 %70, %68
store i8 %71, i8* %69
%72 = getelementptr inbounds i8, i8* %1, i64 67
%73 = load i8, i8* %72
%74 = urem i8 %73, 35
%75 = zext i8 %74 to i64
%76 = getelementptr inbounds i8, i8* %2, i64 %75
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
store i8 7, i8* %28
%79 = getelementptr inbounds i8, i8* %1, i64 181
%80 = load i8, i8* %79
%81 = urem i8 %80, 20
%82 = zext i8 %81 to i64
%83 = getelementptr inbounds i8, i8* %0, i64 %82
%84 = load i8, i8* %83
%85 = getelementptr inbounds i8, i8* %1, i64 2
%86 = load i8, i8* %85
%87 = add i8 %86, -64
store i8 %87, i8* %85
%88 = getelementptr inbounds i8, i8* %1, i64 58
%89 = load i8, i8* %88
%90 = urem i8 %89, 21
%91 = zext i8 %90 to i64
%92 = getelementptr inbounds i8, i8* %4, i64 %91
%93 = load i8, i8* %92
%94 = getelementptr inbounds i8, i8* %0, i64 19
store i8 %93, i8* %94
%95 = getelementptr inbounds i8, i8* %1, i64 32
%96 = load i8, i8* %95
%97 = urem i8 %96, 35
%98 = zext i8 %97 to i64
%99 = getelementptr inbounds i8, i8* %2, i64 %98
%100 = load i8, i8* %99
%101 = sub i8 92, %100
store i8 %101, i8* %3
%102 = getelementptr inbounds i8, i8* %1, i64 15
%103 = load i8, i8* %102
%104 = urem i8 %103, 35
%105 = zext i8 %104 to i64
%106 = getelementptr inbounds i8, i8* %2, i64 %105
%107 = load i8, i8* %106
%108 = add i8 %107, -98
%109 = getelementptr inbounds i8, i8* %3, i64 4
store i8 %108, i8* %109
%110 = load i8, i8* %102
%111 = urem i8 %110, 35
%112 = zext i8 %111 to i64
%113 = getelementptr inbounds i8, i8* %2, i64 %112
%114 = load i8, i8* %113
%115 = add i8 %114, -98
%116 = urem i8 %115, 21
%117 = zext i8 %116 to i64
%118 = getelementptr inbounds i8, i8* %4, i64 %117
%119 = load i8, i8* %118
%120 = udiv i8 %119, 5
%121 = getelementptr inbounds i8, i8* %1, i64 34
%122 = load i8, i8* %121
%123 = add i8 %122, %120
store i8 %123, i8* %121
%124 = load i8, i8* %109
%125 = urem i8 %124, 20
%126 = zext i8 %125 to i64
%127 = getelementptr inbounds i8, i8* %0, i64 %126
%128 = load i8, i8* %127
%129 = lshr i8 %128, 1
%130 = and i8 %129, 102
%131 = load i8, i8* %94
%132 = add i8 %131, -26
%133 = sub i8 %132, %130
store i8 %133, i8* %94
%134 = getelementptr inbounds i8, i8* %1, i64 72
%135 = load i8, i8* %134
%136 = load i8, i8* %42
%137 = urem i8 %136, 21
%138 = zext i8 %137 to i64
%139 = getelementptr inbounds i8, i8* %4, i64 %138
%140 = load i8, i8* %139
%141 = and i8 %140, 7
%142 = lshr i8 %135, %141
%143 = sub i8 0, %140
%144 = and i8 %143, 7
%145 = shl i8 %135, %144
%146 = xor i8 %142, %145
%147 = getelementptr inbounds i8, i8* %1, i64 126
%148 = load i8, i8* %147
%149 = urem i8 %148, 21
%150 = zext i8 %149 to i64
%151 = getelementptr inbounds i8, i8* %4, i64 %150
%152 = load i8, i8* %151
%153 = mul i8 %152, -3
%154 = add i8 %153, %146
%155 = mul i8 %154, 3
%156 = load i8, i8* %102
%157 = xor i8 %155, %156
store i8 %157, i8* %102
%158 = load i8, i8* %79
%159 = urem i8 %158, 35
%160 = zext i8 %159 to i64
%161 = getelementptr inbounds i8, i8* %2, i64 %160
%162 = load i8, i8* %161
%163 = mul i8 %162, %162
%164 = mul i8 %163, %162
%165 = getelementptr inbounds i8, i8* %0, i64 15
%166 = load i8, i8* %165
%167 = xor i8 %164, %166
store i8 %167, i8* %165
%168 = getelementptr inbounds i8, i8* %1, i64 202
%169 = load i8, i8* %168
%170 = udiv i8 %169, 3
%171 = getelementptr inbounds i8, i8* %2, i64 4
%172 = load i8, i8* %171
%173 = xor i8 %172, %170
store i8 %173, i8* %171
%174 = load i8, i8* %3
%175 = urem i8 %174, 20
%176 = zext i8 %175 to i64
%177 = getelementptr inbounds i8, i8* %0, i64 %176
%178 = load i8, i8* %177
%179 = zext i8 %178 to i32
%180 = sub nsw i32 92, %179
%181 = getelementptr inbounds i8, i8* %1, i64 105
%182 = load i8, i8* %181
%183 = zext i8 %182 to i32
%184 = xor i32 %183, -1
%185 = or i32 %180, %184
%186 = and i32 %185, 198
%187 = and i32 %180, %184
%188 = or i32 %186, %187
%189 = mul nsw i32 %188, %188
%190 = mul nsw i32 %189, %188
%191 = getelementptr inbounds i8, i8* %2, i64 1
%192 = load i8, i8* %191
%193 = trunc i32 %190 to i8
%194 = add i8 %192, %193
store i8 %194, i8* %191
%195 = getelementptr inbounds i8, i8* %1, i64 92
%196 = load i8, i8* %195
%197 = urem i8 %196, 21
%198 = zext i8 %197 to i64
%199 = getelementptr inbounds i8, i8* %4, i64 %198
%200 = load i8, i8* %199
%201 = and i8 %200, 27
%202 = or i8 %201, -32
%203 = zext i8 %202 to i16
%204 = getelementptr inbounds i8, i8* %1, i64 41
%205 = load i8, i8* %204
%206 = urem i8 %205, 35
%207 = zext i8 %206 to i64
%208 = getelementptr inbounds i8, i8* %2, i64 %207
%209 = load i8, i8* %208
%210 = zext i8 %209 to i16
%211 = mul nuw i16 %203, %210
%212 = udiv i16 %211, 3
%213 = load i8, i8* %94
%214 = trunc i16 %212 to i8
%215 = xor i8 %213, %214
store i8 %215, i8* %94
%216 = getelementptr inbounds i8, i8* %1, i64 5
%217 = load i8, i8* %216
%218 = and i8 %217, 7
%219 = zext i8 %218 to i32
%220 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_ror8 to i32 (i32, i32, ...)*)(i32 92, i32 %219)
%221 = getelementptr inbounds i8, i8* %1, i64 140
%222 = load i8, i8* %221
%223 = trunc i32 %220 to i8
%224 = add i8 %222, %223
store i8 %224, i8* %221
%225 = load i8, i8* %33
%226 = getelementptr inbounds i8, i8* %1, i64 12
%227 = load i8, i8* %226
%228 = urem i8 %227, 35
%229 = zext i8 %228 to i64
%230 = getelementptr inbounds i8, i8* %2, i64 %229
%231 = load i8, i8* %230
%232 = xor i8 %231, %225
%233 = zext i8 %232 to i32
%234 = xor i32 %233, -1
%235 = getelementptr inbounds i8, i8* %1, i64 182
%236 = load i8, i8* %235
%237 = zext i8 %236 to i32
%238 = or i32 %234, %237
%239 = and i32 %238, 192
%240 = and i32 %234, %237
%241 = or i32 %239, %240
%242 = load i8, i8* %28
%243 = trunc i32 %241 to i8
%244 = add i8 %242, %243
store i8 %244, i8* %28
%245 = load i8, i8* %62
%246 = add i8 %245, 125
store i8 %246, i8* %62
%247 = getelementptr inbounds i8, i8* %1, i64 138
%248 = load i8, i8* %247
%249 = zext i8 %248 to i32
%250 = and i32 %249, 74
%251 = or i32 %249, 74
%252 = load i8, i8* %165
%253 = zext i8 %252 to i32
%254 = and i32 %251, %253
%255 = or i32 %254, %250
%256 = getelementptr inbounds i8, i8* %1, i64 43
%257 = load i8, i8* %256
%258 = urem i8 %257, 20
%259 = zext i8 %258 to i64
%260 = getelementptr inbounds i8, i8* %0, i64 %259
%261 = load i8, i8* %260
%262 = zext i8 %261 to i32
%263 = and i32 %255, %262
%264 = or i32 %255, %262
%265 = and i32 %264, 95
%266 = or i32 %265, %263
%267 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @rol8x to i32 (i32, i32, ...)*)(i32 %266, i32 4)
%268 = trunc i32 %267 to i8
%269 = getelementptr inbounds i8, i8* %1, i64 124
store i8 %268, i8* %269
%270 = load i8, i8* %109
%271 = urem i8 %270, 20
%272 = zext i8 %271 to i64
%273 = getelementptr inbounds i8, i8* %0, i64 %272
%274 = load i8, i8* %273
%275 = getelementptr inbounds i8, i8* %1, i64 68
%276 = load i8, i8* %275
%277 = urem i8 %276, 21
%278 = zext i8 %277 to i64
%279 = getelementptr inbounds i8, i8* %4, i64 %278
%280 = load i8, i8* %279
%281 = shl i8 %280, 1
%282 = and i8 %274, 76
%283 = and i8 %282, %281
%284 = xor i8 %283, 76
%285 = getelementptr inbounds i8, i8* %3, i64 8
store i8 %284, i8* %285
%286 = getelementptr inbounds i8, i8* %1, i64 177
%287 = load i8, i8* %286
%288 = zext i8 %287 to i32
%289 = getelementptr inbounds i8, i8* %1, i64 79
%290 = load i8, i8* %289
%291 = urem i8 %290, 21
%292 = zext i8 %291 to i64
%293 = getelementptr inbounds i8, i8* %4, i64 %292
%294 = load i8, i8* %293
%295 = zext i8 %294 to i32
%296 = add nuw nsw i32 %295, %288
%297 = lshr i32 %296, 1
%298 = getelementptr inbounds i8, i8* %1, i64 148
%299 = load i8, i8* %298
%300 = zext i8 %299 to i16
%301 = mul nuw nsw i16 %300, 3
%302 = udiv i16 %301, 5
%303 = zext i16 %302 to i32
%304 = or i32 %297, %303
%305 = load i8, i8* %191
%306 = zext i8 %305 to i32
%307 = and i32 %304, %306
%308 = and i32 %297, %303
%309 = or i32 %307, %308
%310 = trunc i32 %309 to i8
%311 = sub i8 -34, %310
%312 = getelementptr inbounds i8, i8* %3, i64 12
store i8 %311, i8* %312
%313 = getelementptr inbounds i8, i8* %2, i64 22
%314 = load i8, i8* %313
%315 = and i8 %314, 7
%316 = sub i8 0, %314
%317 = load i8, i8* %69
%318 = and i8 %316, 7
%319 = lshr i8 %317, %318
%320 = shl i8 %317, %315
%321 = load i8, i8* %3
%322 = urem i8 %321, 35
%323 = zext i8 %322 to i64
%324 = getelementptr inbounds i8, i8* %2, i64 %323
%325 = load i8, i8* %324
%326 = and i8 %325, -105
%327 = load i8, i8* %273
%328 = or i8 %327, %326
%329 = or i8 %328, 8
%330 = xor i8 %319, %320
%331 = or i8 %330, -128
%332 = getelementptr inbounds i8, i8* %2, i64 16
%333 = load i8, i8* %332
%334 = sub i8 %333, %331
%335 = add i8 %334, %329
store i8 %335, i8* %332
%336 = load i8, i8* %312
%337 = urem i8 %336, 35
%338 = zext i8 %337 to i64
%339 = getelementptr inbounds i8, i8* %2, i64 %338
%340 = load i8, i8* %339
%341 = getelementptr inbounds i8, i8* %0, i64 14
%342 = load i8, i8* %341
%343 = xor i8 %342, %340
store i8 %343, i8* %341
%344 = getelementptr inbounds i8, i8* %1, i64 201
%345 = load i8, i8* %344
%346 = urem i8 %345, 20
%347 = zext i8 %346 to i64
%348 = getelementptr inbounds i8, i8* %0, i64 %347
%349 = load i8, i8* %348
%350 = urem i8 %349, 21
%351 = zext i8 %350 to i64
%352 = getelementptr inbounds i8, i8* %4, i64 %351
%353 = load i8, i8* %352
%354 = zext i8 %353 to i32
%355 = getelementptr inbounds i8, i8* %1, i64 112
%356 = load i8, i8* %355
%357 = urem i8 %356, 35
%358 = zext i8 %357 to i64
%359 = getelementptr inbounds i8, i8* %2, i64 %358
%360 = load i8, i8* %359
%361 = zext i8 %360 to i32
%362 = shl nuw nsw i32 %361, 1
%363 = and i32 %362, 6
%364 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_rol8 to i32 (i32, i32, ...)*)(i32 %354, i32 %363)
%365 = getelementptr inbounds i8, i8* %1, i64 208
%366 = load i8, i8* %365
%367 = urem i8 %366, 20
%368 = zext i8 %367 to i64
%369 = getelementptr inbounds i8, i8* %0, i64 %368
%370 = load i8, i8* %369
%371 = and i8 %370, -125
%372 = getelementptr inbounds i8, i8* %1, i64 164
%373 = load i8, i8* %372
%374 = urem i8 %373, 20
%375 = zext i8 %374 to i64
%376 = getelementptr inbounds i8, i8* %0, i64 %375
%377 = load i8, i8* %376
%378 = and i8 %377, 124
%379 = or i8 %378, %371
%380 = udiv i8 %379, 5
%381 = zext i8 %380 to i32
%382 = and i32 %364, %381
%383 = or i32 %364, %381
%384 = and i32 %383, 37
%385 = or i32 %384, %382
%386 = getelementptr inbounds i8, i8* %1, i64 19
%387 = load i8, i8* %386
%388 = trunc i32 %385 to i8
%389 = add i8 %387, %388
store i8 %389, i8* %386
%390 = getelementptr inbounds i8, i8* %1, i64 45
%391 = load i8, i8* %390
%392 = urem i8 %391, 21
%393 = zext i8 %392 to i64
%394 = getelementptr inbounds i8, i8* %4, i64 %393
%395 = load i8, i8* %394
%396 = zext i8 %395 to i32
%397 = add nuw nsw i32 %396, 92
%398 = mul nuw nsw i32 %397, %397
%399 = and i32 %398, 7
%400 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_ror8 to i32 (i32, i32, ...)*)(i32 140, i32 %399)
%401 = trunc i32 %400 to i8
%402 = getelementptr inbounds i8, i8* %2, i64 8
store i8 %401, i8* %402
store i8 56, i8* %42
%403 = load i8, i8* %3
%404 = load i8, i8* %402
%405 = xor i8 %404, %403
store i8 %405, i8* %402
%406 = getelementptr inbounds i8, i8* %1, i64 83
%407 = load i8, i8* %406
%408 = urem i8 %407, 20
%409 = zext i8 %408 to i64
%410 = getelementptr inbounds i8, i8* %0, i64 %409
%411 = load i8, i8* %410
%412 = or i8 %411, -52
%413 = udiv i8 %412, 5
%414 = xor i8 %413, -1
%415 = getelementptr inbounds i8, i8* %1, i64 53
store i8 %414, i8* %415
%416 = load i8, i8* %204
%417 = urem i8 %416, 20
%418 = zext i8 %417 to i64
%419 = getelementptr inbounds i8, i8* %0, i64 %418
%420 = load i8, i8* %419
%421 = load i8, i8* %61
%422 = add i8 %421, %420
store i8 %422, i8* %61
%423 = load i8, i8* %3
%424 = urem i8 %423, 35
%425 = zext i8 %424 to i64
%426 = getelementptr inbounds i8, i8* %2, i64 %425
%427 = load i8, i8* %426
%428 = load i8, i8* %85
%429 = and i8 %428, %427
%430 = or i8 %428, %427
%431 = load i8, i8* %312
%432 = and i8 %430, %431
%433 = or i8 %432, %429
%434 = udiv i8 %433, 15
%435 = getelementptr inbounds i8, i8* %0, i64 10
store i8 %434, i8* %435
%436 = load i8, i8* %85
%437 = urem i8 %436, 21
%438 = zext i8 %437 to i64
%439 = getelementptr inbounds i8, i8* %4, i64 %438
%440 = load i8, i8* %439
%441 = and i8 %440, 68
%442 = load i8, i8* %285
%443 = urem i8 %442, 35
%444 = zext i8 %443 to i64
%445 = getelementptr inbounds i8, i8* %2, i64 %444
%446 = load i8, i8* %445
%447 = or i8 %441, 18
%448 = and i8 %446, %447
%449 = or i8 %448, 40
%450 = mul i8 %449, %449
%451 = add i8 %450, 110
%452 = getelementptr inbounds i8, i8* %3, i64 16
store i8 %451, i8* %452
%453 = sub i8 92, %450
%454 = getelementptr inbounds i8, i8* %3, i64 20
store i8 %453, i8* %454
%455 = getelementptr inbounds i8, i8* %1, i64 151
%456 = load i8, i8* %455
%457 = getelementptr inbounds i8, i8* %3, i64 24
store i8 %456, i8* %457
%458 = load i8, i8* %3
%459 = urem i8 %458, 21
%460 = zext i8 %459 to i64
%461 = getelementptr inbounds i8, i8* %4, i64 %460
%462 = load i8, i8* %461
%463 = getelementptr inbounds i8, i8* %2, i64 13
%464 = load i8, i8* %463
%465 = xor i8 %464, %462
store i8 %465, i8* %463
%466 = getelementptr inbounds i8, i8* %1, i64 179
%467 = load i8, i8* %466
%468 = urem i8 %467, 35
%469 = zext i8 %468 to i64
%470 = getelementptr inbounds i8, i8* %2, i64 %469
%471 = load i8, i8* %470
%472 = zext i8 %471 to i32
%473 = add nsw i32 %472, -38
%474 = load i8, i8* %312
%475 = zext i8 %474 to i32
%476 = or i32 %473, %475
%477 = and i32 %476, 177
%478 = and i32 %473, %475
%479 = or i32 %477, %478
%480 = mul nuw nsw i32 %479, %479
%481 = trunc i32 %480 to i8
%482 = add i8 %481, 30
%483 = getelementptr inbounds i8, i8* %3, i64 28
store i8 %482, i8* %483
%484 = add i8 %481, 92
%485 = getelementptr inbounds i8, i8* %3, i64 32
store i8 %484, i8* %485
%486 = load i8, i8* %454
%487 = zext i8 %486 to i32
%488 = load i8, i8* %3
%489 = zext i8 %488 to i32
%490 = and i32 %489, 74
%491 = add nuw nsw i32 %490, %487
%492 = urem i8 %488, 21
%493 = zext i8 %492 to i64
%494 = getelementptr inbounds i8, i8* %4, i64 %493
%495 = load i8, i8* %494
%496 = zext i8 %495 to i32
%497 = xor i32 %496, -1
%498 = or i32 %491, %497
%499 = and i32 %498, 121
%500 = and i32 %491, %497
%501 = or i32 %499, %500
%502 = xor i32 %501, -90
%503 = or i32 %502, %489
%504 = and i32 %503, 4
%505 = and i32 %502, %489
%506 = or i32 %504, %505
%507 = getelementptr inbounds i8, i8* %1, i64 89
%508 = load i8, i8* %507
%509 = urem i8 %508, 35
%510 = zext i8 %509 to i64
%511 = getelementptr inbounds i8, i8* %2, i64 %510
%512 = load i8, i8* %511
%513 = getelementptr inbounds i8, i8* %1, i64 47
%514 = load i8, i8* %513
%515 = trunc i32 %506 to i8
%516 = add i8 %512, %515
%517 = xor i8 %516, %514
store i8 %517, i8* %513
%518 = and i8 %84, -77
%519 = or i8 %518, 68
%520 = zext i8 %519 to i32
%521 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @rol8 to i32 (i32, i32, ...)*)(i32 %520, i32 2)
%522 = load i8, i8* %56
%523 = zext i8 %522 to i32
%524 = and i32 %521, %523
%525 = xor i32 %523, -1
%526 = and i32 %525, %78
%527 = or i32 %524, %526
%528 = trunc i32 %527 to i8
%529 = add i8 %528, -15
%530 = getelementptr inbounds i8, i8* %3, i64 36
store i8 %529, i8* %530
%531 = getelementptr inbounds i8, i8* %1, i64 123
%532 = load i8, i8* %531
%533 = xor i8 %532, -35
store i8 %533, i8* %531
%534 = load i8, i8* %3
%535 = urem i8 %534, 21
%536 = zext i8 %535 to i64
%537 = getelementptr inbounds i8, i8* %4, i64 %536
%538 = load i8, i8* %537
%539 = udiv i8 %538, 3
%540 = load i8, i8* %109
%541 = urem i8 %540, 35
%542 = zext i8 %541 to i64
%543 = getelementptr inbounds i8, i8* %2, i64 %542
%544 = load i8, i8* %543
%545 = and i8 %534, -86
%546 = or i8 %545, 84
%547 = load i8, i8* %457
%548 = or i8 %547, %546
%549 = and i8 %548, 54
%550 = and i8 %547, %546
%551 = or i8 %549, %550
%552 = add i8 %544, %551
%553 = sub i8 %539, %552
%554 = getelementptr inbounds i8, i8* %3, i64 40
store i8 %553, i8* %554
%555 = lshr i8 %534, 1
%556 = or i8 %555, 26
%557 = trunc i32 %501 to i8
%558 = xor i8 %556, %557
%559 = xor i8 %558, 81
%560 = getelementptr inbounds i8, i8* %3, i64 44
store i8 %559, i8* %560
%561 = load i8, i8* %543
%562 = and i8 %561, 27
%563 = getelementptr inbounds i8, i8* %3, i64 48
store i8 %562, i8* %563
%564 = getelementptr inbounds i8, i8* %3, i64 52
store i8 27, i8* %564
%565 = getelementptr inbounds i8, i8* %3, i64 56
store i8 -57, i8* %565
%566 = or i8 %553, %547
%567 = and i8 %566, 32
%568 = and i8 %553, %547
%569 = load i8, i8* %537
%570 = or i8 %569, 32
%571 = and i8 %568, 100
%572 = or i8 %567, %571
%573 = and i8 %572, %570
%574 = or i8 %568, %569
%575 = and i8 %574, 68
%576 = or i8 %575, %573
%577 = or i8 %576, -128
%578 = add i8 %562, %540
%579 = add i8 %578, %577
%580 = getelementptr inbounds i8, i8* %3, i64 64
store i8 %579, i8* %580
%581 = getelementptr inbounds i8, i8* %1, i64 26
%582 = load i8, i8* %581
%583 = getelementptr inbounds i8, i8* %2, i64 33
%584 = load i8, i8* %583
%585 = xor i8 %584, %582
store i8 %585, i8* %583
%586 = load i8, i8* %454
%587 = getelementptr inbounds i8, i8* %1, i64 106
%588 = load i8, i8* %587
%589 = xor i8 %586, %588
%590 = xor i8 %589, -123
store i8 %590, i8* %587
%591 = load i8, i8* %580
%592 = udiv i8 %591, 3
%593 = load i8, i8* %3
%594 = and i8 %593, -28
%595 = add nsw i8 %592, -19
%596 = sub i8 %595, %594
%597 = getelementptr inbounds i8, i8* %1, i64 122
%598 = load i8, i8* %597
%599 = urem i8 %598, 20
%600 = zext i8 %599 to i64
%601 = getelementptr inbounds i8, i8* %0, i64 %600
%602 = load i8, i8* %601
%603 = xor i8 %596, %602
%604 = getelementptr inbounds i8, i8* %2, i64 30
store i8 %603, i8* %604
%605 = getelementptr inbounds i8, i8* %1, i64 90
%606 = load i8, i8* %605
%607 = urem i8 %606, 35
%608 = zext i8 %607 to i64
%609 = getelementptr inbounds i8, i8* %2, i64 %608
%610 = load i8, i8* %609
%611 = and i8 %610, 27
%612 = or i8 %611, 68
%613 = getelementptr inbounds i8, i8* %1, i64 22
store i8 %612, i8* %613
%614 = load i8, i8* %530
%615 = urem i8 %614, 21
%616 = zext i8 %615 to i64
%617 = getelementptr inbounds i8, i8* %4, i64 %616
%618 = load i8, i8* %617
%619 = and i8 %618, -72
%620 = load i8, i8* %560
%621 = urem i8 %620, 35
%622 = zext i8 %621 to i64
%623 = getelementptr inbounds i8, i8* %2, i64 %622
%624 = load i8, i8* %623
%625 = and i8 %624, 71
%626 = or i8 %625, %619
%627 = zext i8 %626 to i32
%628 = mul nuw nsw i32 %627, %627
%629 = mul nuw nsw i32 %628, %627
%630 = lshr i32 %629, 1
%631 = getelementptr inbounds i8, i8* %2, i64 18
%632 = load i8, i8* %631
%633 = trunc i32 %630 to i8
%634 = add i8 %632, %633
store i8 %634, i8* %631
%635 = load i8, i8* %195
%636 = urem i8 %635, 21
%637 = zext i8 %636 to i64
%638 = getelementptr inbounds i8, i8* %4, i64 %637
%639 = load i8, i8* %638
%640 = getelementptr inbounds i8, i8* %2, i64 5
%641 = load i8, i8* %640
%642 = sub i8 %641, %639
store i8 %642, i8* %640
%643 = load i8, i8* %204
%644 = and i8 %643, -25
%645 = getelementptr inbounds i8, i8* %1, i64 183
%646 = load i8, i8* %645
%647 = urem i8 %646, 35
%648 = zext i8 %647 to i64
%649 = getelementptr inbounds i8, i8* %2, i64 %648
%650 = load i8, i8* %649
%651 = and i8 %650, 24
%652 = or i8 %651, %644
%653 = load i8, i8* %452
%654 = add i8 %653, 53
%655 = and i8 %654, %652
%656 = load i8, i8* %454
%657 = urem i8 %656, 35
%658 = zext i8 %657 to i64
%659 = getelementptr inbounds i8, i8* %2, i64 %658
%660 = load i8, i8* %659
%661 = and i8 %660, %656
%662 = or i8 %661, %655
%663 = getelementptr inbounds i8, i8* %1, i64 17
%664 = load i8, i8* %663
%665 = load i8, i8* %560
%666 = xor i8 %665, -1
%667 = and i8 %664, %666
%668 = getelementptr inbounds i8, i8* %1, i64 59
%669 = load i8, i8* %668
%670 = urem i8 %669, 20
%671 = zext i8 %670 to i64
%672 = getelementptr inbounds i8, i8* %0, i64 %671
%673 = load i8, i8* %672
%674 = and i8 %673, %665
%675 = or i8 %674, %667
%676 = mul i8 %675, %662
%677 = xor i8 %676, %634
store i8 %677, i8* %631
%678 = getelementptr inbounds i8, i8* %1, i64 11
%679 = load i8, i8* %678
%680 = zext i8 %679 to i32
%681 = getelementptr inbounds i8, i8* %1, i64 28
%682 = load i8, i8* %681
%683 = urem i8 %682, 35
%684 = zext i8 %683 to i64
%685 = getelementptr inbounds i8, i8* %2, i64 %684
%686 = load i8, i8* %685
%687 = and i8 %686, 7
%688 = zext i8 %687 to i32
%689 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_ror8 to i32 (i32, i32, ...)*)(i32 %680, i32 %688)
%690 = and i32 %689, 7
%691 = getelementptr inbounds i8, i8* %1, i64 93
%692 = load i8, i8* %691
%693 = urem i8 %692, 20
%694 = zext i8 %693 to i64
%695 = getelementptr inbounds i8, i8* %0, i64 %694
%696 = load i8, i8* %695
%697 = load i8, i8* %341
%698 = zext i8 %697 to i32
%699 = xor i32 %698, -1
%700 = and i32 %698, 130
%701 = and i8 %696, -29
%702 = zext i8 %701 to i32
%703 = and i32 %702, %699
%704 = or i32 %703, %700
%705 = getelementptr inbounds i8, i8* %1, i64 7
%706 = load i8, i8* %705
%707 = and i8 %706, 28
%708 = zext i8 %707 to i32
%709 = or i32 %704, %708
%710 = load i8, i8* %3
%711 = urem i8 %710, 35
%712 = zext i8 %711 to i64
%713 = getelementptr inbounds i8, i8* %2, i64 %712
%714 = load i8, i8* %713
%715 = zext i8 %714 to i32
%716 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_rol8 to i32 (i32, i32, ...)*)(i32 %715, i32 %690)
%717 = or i32 %709, %716
%718 = load i8, i8* %583
%719 = zext i8 %718 to i32
%720 = and i32 %717, %719
%721 = load i8, i8* %3
%722 = urem i8 %721, 35
%723 = zext i8 %722 to i64
%724 = getelementptr inbounds i8, i8* %2, i64 %723
%725 = load i8, i8* %724
%726 = zext i8 %725 to i32
%727 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_rol8 to i32 (i32, i32, ...)*)(i32 %726, i32 %690)
%728 = and i32 %727, %709
%729 = or i32 %728, %720
%730 = trunc i32 %729 to i8
%731 = add i8 %730, 74
store i8 %731, i8* %313
%732 = getelementptr inbounds i8, i8* %1, i64 39
%733 = load i8, i8* %732
%734 = urem i8 %733, 20
%735 = zext i8 %734 to i64
%736 = getelementptr inbounds i8, i8* %0, i64 %735
%737 = load i8, i8* %736
%738 = xor i8 %737, -39
%739 = urem i8 %738, 21
%740 = zext i8 %739 to i64
%741 = getelementptr inbounds i8, i8* %4, i64 %740
%742 = load i8, i8* %741
%743 = load i8, i8* %454
%744 = load i8, i8* %3
%745 = or i8 %744, %743
%746 = and i8 %745, -42
%747 = and i8 %744, %743
%748 = or i8 %746, %747
%749 = and i8 %748, %742
%750 = or i8 %748, %742
%751 = load i8, i8* %485
%752 = and i8 %750, %751
%753 = or i8 %752, %749
%754 = load i8, i8* %165
%755 = sub i8 %754, %753
store i8 %755, i8* %165
%756 = getelementptr inbounds i8, i8* %1, i64 57
%757 = load i8, i8* %756
%758 = urem i8 %757, 35
%759 = zext i8 %758 to i64
%760 = getelementptr inbounds i8, i8* %2, i64 %759
%761 = load i8, i8* %760
%762 = load i8, i8* %580
%763 = urem i8 %762, 20
%764 = zext i8 %763 to i64
%765 = getelementptr inbounds i8, i8* %0, i64 %764
%766 = load i8, i8* %765
%767 = and i8 %766, %761
%768 = or i8 %766, %761
%769 = and i8 %768, 95
%770 = or i8 %769, %767
%771 = and i8 %762, 45
%772 = or i8 %767, %762
%773 = and i8 %772, 32
%774 = or i8 %771, 82
%775 = and i8 %770, %774
%776 = load i8, i8* %3
%777 = udiv i8 %776, 3
%778 = zext i8 %777 to i32
%779 = load i8, i8* %613
%780 = or i8 %779, %762
%781 = zext i8 %780 to i32
%782 = sub nsw i32 %778, %781
%783 = load i8, i8* %483
%784 = zext i8 %783 to i32
%785 = add nuw nsw i32 %784, 62
%786 = xor i32 %782, %785
%787 = or i8 %775, %773
%788 = zext i8 %787 to i32
%789 = and i32 %786, 255
%790 = xor i32 %789, %788
%791 = urem i32 %790, 20
%792 = zext i32 %791 to i64
%793 = getelementptr inbounds i8, i8* %0, i64 %792
%794 = load i8, i8* %793
%795 = load i8, i8* %9
%796 = urem i8 %795, 20
%797 = zext i8 %796 to i64
%798 = getelementptr inbounds i8, i8* %0, i64 %797
%799 = load i8, i8* %798
%800 = mul i8 %799, %799
%801 = mul i8 %800, %800
%802 = urem i8 %762, 35
%803 = zext i8 %802 to i64
%804 = getelementptr inbounds i8, i8* %2, i64 %803
%805 = load i8, i8* %804
%806 = or i8 %801, %805
%807 = getelementptr inbounds i8, i8* %3, i64 68
store i8 %806, i8* %807
%808 = getelementptr inbounds i8, i8* %1, i64 50
%809 = load i8, i8* %808
%810 = urem i8 %809, 20
%811 = zext i8 %810 to i64
%812 = getelementptr inbounds i8, i8* %0, i64 %811
%813 = load i8, i8* %812
%814 = load i8, i8* %247
%815 = urem i8 %814, 35
%816 = zext i8 %815 to i64
%817 = getelementptr inbounds i8, i8* %2, i64 %816
%818 = load i8, i8* %817
%819 = zext i8 %818 to i32
%820 = load i8, i8* %732
%821 = urem i8 %820, 21
%822 = zext i8 %821 to i64
%823 = getelementptr inbounds i8, i8* %4, i64 %822
%824 = load i8, i8* %823
%825 = load i8, i8* %33
%826 = urem i8 %825, 20
%827 = zext i8 %826 to i64
%828 = getelementptr inbounds i8, i8* %0, i64 %827
%829 = load i8, i8* %828
%830 = zext i8 %829 to i32
%831 = load i8, i8* %168
%832 = urem i8 %831, 21
%833 = zext i8 %832 to i64
%834 = getelementptr inbounds i8, i8* %4, i64 %833
%835 = load i8, i8* %834
%836 = load i8, i8* %455
%837 = urem i8 %836, 20
%838 = zext i8 %837 to i64
%839 = getelementptr inbounds i8, i8* %0, i64 %838
%840 = load i8, i8* %839
%841 = getelementptr inbounds i8, i8* %1, i64 14
%842 = load i8, i8* %841
%843 = urem i8 %842, 35
%844 = zext i8 %843 to i64
%845 = getelementptr inbounds i8, i8* %2, i64 %844
%846 = load i8, i8* %845
%847 = zext i8 %846 to i32
%848 = getelementptr inbounds i8, i8* %1, i64 145
%849 = load i8, i8* %848
%850 = urem i8 %849, 20
%851 = zext i8 %850 to i64
%852 = getelementptr inbounds i8, i8* %0, i64 %851
%853 = load i8, i8* %852
%854 = urem i8 %806, 35
%855 = zext i8 %854 to i64
%856 = getelementptr inbounds i8, i8* %2, i64 %855
%857 = load i8, i8* %856
%858 = getelementptr inbounds i8, i8* %1, i64 209
%859 = load i8, i8* %858
%860 = urem i8 %859, 20
%861 = zext i8 %860 to i64
%862 = getelementptr inbounds i8, i8* %0, i64 %861
%863 = load i8, i8* %862
%864 = and i8 %863, %857
%865 = getelementptr inbounds i8, i8* %1, i64 127
%866 = load i8, i8* %865
%867 = urem i8 %866, 21
%868 = zext i8 %867 to i64
%869 = getelementptr inbounds i8, i8* %4, i64 %868
%870 = load i8, i8* %869
%871 = zext i8 %870 to i32
%872 = and i8 %857, 7
%873 = zext i8 %872 to i32
%874 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_rol8 to i32 (i32, i32, ...)*)(i32 %871, i32 %873)
%875 = load i8, i8* %435
%876 = zext i8 %875 to i32
%877 = and i8 %864, %875
%878 = zext i8 %877 to i32
%879 = xor i32 %876, -1
%880 = and i32 %874, %879
%881 = or i32 %880, %878
%882 = load i8, i8* %530
%883 = urem i8 %882, 35
%884 = zext i8 %883 to i64
%885 = getelementptr inbounds i8, i8* %2, i64 %884
%886 = load i8, i8* %885
%887 = urem i8 %886, 21
%888 = zext i8 %887 to i64
%889 = getelementptr inbounds i8, i8* %4, i64 %888
%890 = load i8, i8* %889
%891 = zext i8 %890 to i32
%892 = shl nuw nsw i32 %891, 1
%893 = and i32 %881, 71
%894 = and i32 %892, 184
%895 = or i32 %894, %893
%896 = trunc i32 %895 to i8
%897 = getelementptr inbounds i8, i8* %3, i64 72
store i8 %896, i8* %897
%898 = load i8, i8* %454
%899 = urem i8 %898, 20
%900 = zext i8 %899 to i64
%901 = getelementptr inbounds i8, i8* %0, i64 %900
%902 = load i8, i8* %901
%903 = shl i8 %902, 1
%904 = and i8 %903, -98
%905 = load i8, i8* %42
%906 = urem i8 %905, 21
%907 = zext i8 %906 to i64
%908 = getelementptr inbounds i8, i8* %4, i64 %907
%909 = load i8, i8* %908
%910 = and i8 %909, 96
%911 = or i8 %910, %904
%912 = load i8, i8* %580
%913 = urem i8 %912, 21
%914 = zext i8 %913 to i64
%915 = getelementptr inbounds i8, i8* %4, i64 %914
%916 = load i8, i8* %915
%917 = and i8 %916, 104
%918 = getelementptr inbounds i8, i8* %1, i64 25
%919 = load i8, i8* %918
%920 = and i8 %919, -106
%921 = or i8 %920, %917
%922 = and i8 %921, %911
%923 = getelementptr inbounds i8, i8* %2, i64 2
%924 = load i8, i8* %923
%925 = add i8 %922, %924
store i8 %925, i8* %923
%926 = load i8, i8* %454
%927 = urem i8 %926, 35
%928 = zext i8 %927 to i64
%929 = getelementptr inbounds i8, i8* %2, i64 %928
%930 = load i8, i8* %929
%931 = load i8, i8* %897
%932 = getelementptr inbounds i8, i8* %1, i64 100
%933 = load i8, i8* %932
%934 = urem i8 %933, 35
%935 = zext i8 %934 to i64
%936 = getelementptr inbounds i8, i8* %2, i64 %935
%937 = load i8, i8* %936
%938 = xor i8 %937, %931
%939 = and i8 %930, -35
%940 = and i8 %939, %938
%941 = getelementptr inbounds i8, i8* %1, i64 97
%942 = load i8, i8* %941
%943 = and i8 %942, 34
%944 = getelementptr inbounds i8, i8* %2, i64 14
%945 = load i8, i8* %944
%946 = or i8 %940, %943
%947 = sub i8 %945, %946
store i8 %947, i8* %944
%948 = getelementptr inbounds i8, i8* %0, i64 17
store i8 115, i8* %948
%949 = load i8, i8* %663
%950 = urem i8 %949, 21
%951 = zext i8 %950 to i64
%952 = getelementptr inbounds i8, i8* %4, i64 %951
%953 = load i8, i8* %952
%954 = load i8, i8* %454
%955 = urem i8 %954, 20
%956 = zext i8 %955 to i64
%957 = getelementptr inbounds i8, i8* %0, i64 %956
%958 = load i8, i8* %957
%959 = or i8 %958, %953
%960 = load i8, i8* %897
%961 = and i8 %959, %960
%962 = and i8 %958, %953
%963 = or i8 %961, %962
%964 = load i8, i8* %808
%965 = udiv i8 %964, 3
%966 = and i8 %963, %965
%967 = or i8 %963, %965
%968 = and i8 %967, 118
%969 = or i8 %968, %966
%970 = shl nuw i8 %969, 1
%971 = getelementptr inbounds i8, i8* %1, i64 23
%972 = load i8, i8* %971
%973 = xor i8 %970, %972
store i8 %973, i8* %971
%974 = load i8, i8* %554
%975 = urem i8 %974, 20
%976 = zext i8 %975 to i64
%977 = getelementptr inbounds i8, i8* %0, i64 %976
%978 = load i8, i8* %977
%979 = getelementptr inbounds i8, i8* %1, i64 10
%980 = load i8, i8* %979
%981 = or i8 %980, %978
%982 = and i8 %981, 80
%983 = and i8 %978, -48
%984 = and i8 %983, %980
%985 = or i8 %982, %984
%986 = load i8, i8* %732
%987 = urem i8 %986, 20
%988 = zext i8 %987 to i64
%989 = getelementptr inbounds i8, i8* %0, i64 %988
%990 = load i8, i8* %989
%991 = shl i8 %990, 1
%992 = and i8 %991, 46
%993 = or i8 %985, %992
%994 = lshr exact i8 %993, 1
store i8 %994, i8* %61
%995 = getelementptr inbounds i8, i8* %1, i64 113
%996 = load i8, i8* %995
%997 = and i8 %996, 9
%998 = load i8, i8* %583
%999 = sub i8 %998, %997
store i8 %999, i8* %583
%1000 = getelementptr inbounds i8, i8* %1, i64 110
%1001 = load i8, i8* %1000
%1002 = lshr i8 %1001, 1
%1003 = and i8 %1002, 32
%1004 = load i8, i8* %454
%1005 = and i8 %1004, -33
%1006 = getelementptr inbounds i8, i8* %2, i64 28
%1007 = load i8, i8* %1006
%1008 = or i8 %1003, %1005
%1009 = sub i8 %1007, %1008
store i8 %1009, i8* %1006
%1010 = or i8 %840, %835
%1011 = zext i8 %1010 to i32
%1012 = and i8 %813, 7
%1013 = zext i8 %1012 to i32
%1014 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_rol8 to i32 (i32, i32, ...)*)(i32 %1011, i32 %1013)
%1015 = load i8, i8* %332
%1016 = zext i8 %1015 to i32
%1017 = and i8 %1015, %794
%1018 = zext i8 %1017 to i32
%1019 = xor i32 %1016, -1
%1020 = and i32 %1019, %819
%1021 = or i32 %1020, %1018
%1022 = load i8, i8* %69
%1023 = and i8 %1022, 17
%1024 = and i8 %824, -18
%1025 = or i8 %1023, %1024
%1026 = zext i8 %1025 to i32
%1027 = add nuw nsw i32 %1021, %1026
%1028 = udiv i32 %1027, 5
%1029 = or i32 %1028, %830
%1030 = and i32 %1029, 147
%1031 = and i32 %1028, %830
%1032 = or i32 %1030, %1031
%1033 = load i8, i8* %554
%1034 = load i8, i8* %285
%1035 = add i32 %1032, %1014
%1036 = trunc i32 %1035 to i8
%1037 = add i8 %1034, %1036
%1038 = urem i8 %1037, 21
%1039 = zext i8 %1038 to i64
%1040 = getelementptr inbounds i8, i8* %4, i64 %1039
%1041 = load i8, i8* %1040
%1042 = and i8 %1041, %1033
%1043 = or i8 %1041, %1033
%1044 = getelementptr inbounds i8, i8* %2, i64 23
%1045 = load i8, i8* %1044
%1046 = and i8 %1043, %1045
%1047 = or i8 %1046, %1042
%1048 = zext i8 %1047 to i32
%1049 = load i8, i8* %454
%1050 = urem i8 %1049, 21
%1051 = zext i8 %1050 to i64
%1052 = getelementptr inbounds i8, i8* %4, i64 %1051
%1053 = load i8, i8* %1052
%1054 = zext i8 %1053 to i32
%1055 = add nuw nsw i32 %1054, 208
%1056 = getelementptr inbounds i8, i8* %1, i64 184
%1057 = load i8, i8* %1056
%1058 = zext i8 %1057 to i32
%1059 = xor i32 %1058, -1
%1060 = or i32 %1059, 189
%1061 = and i32 %1060, %1055
%1062 = and i32 %1059, 189
%1063 = or i32 %1061, %1062
%1064 = mul nuw nsw i32 %1048, %1048
%1065 = mul nuw nsw i32 %1064, %1048
%1066 = and i32 %1063, %1065
%1067 = trunc i32 %1066 to i8
store i8 %1067, i8* %165
%1068 = load i8, i8* %645
%1069 = load i8, i8* %313
%1070 = add i8 %1069, %1068
store i8 %1070, i8* %313
%1071 = getelementptr inbounds i8, i8* %1, i64 1
%1072 = load i8, i8* %1071
%1073 = urem i8 %1072, 21
%1074 = zext i8 %1073 to i64
%1075 = getelementptr inbounds i8, i8* %4, i64 %1074
%1076 = load i8, i8* %1075
%1077 = mul i8 %1076, 3
%1078 = load i8, i8* %3
%1079 = xor i8 %1077, %1078
%1080 = getelementptr inbounds i8, i8* %3, i64 76
store i8 %1079, i8* %1080
%1081 = load i8, i8* %285
%1082 = add i8 %1081, %1036
%1083 = urem i8 %1082, 35
%1084 = zext i8 %1083 to i64
%1085 = getelementptr inbounds i8, i8* %2, i64 %1084
%1086 = load i8, i8* %1085
%1087 = getelementptr inbounds i8, i8* %1, i64 178
%1088 = load i8, i8* %1087
%1089 = urem i8 %1088, 21
%1090 = zext i8 %1089 to i64
%1091 = getelementptr inbounds i8, i8* %4, i64 %1090
%1092 = load i8, i8* %1091
%1093 = and i8 %1092, %1086
%1094 = or i8 %1092, %1086
%1095 = and i8 %1094, -47
%1096 = or i8 %1095, %1093
%1097 = zext i8 %1096 to i32
%1098 = getelementptr inbounds i8, i8* %1, i64 13
%1099 = load i8, i8* %1098
%1100 = urem i8 %1099, 20
%1101 = zext i8 %1100 to i64
%1102 = getelementptr inbounds i8, i8* %0, i64 %1101
%1103 = load i8, i8* %1102
%1104 = zext i8 %1103 to i32
%1105 = mul nuw nsw i32 %1097, %1104
%1106 = load i8, i8* %581
%1107 = urem i8 %1106, 21
%1108 = zext i8 %1107 to i64
%1109 = getelementptr inbounds i8, i8* %4, i64 %1108
%1110 = load i8, i8* %1109
%1111 = lshr i8 %1110, 1
%1112 = zext i8 %1111 to i32
%1113 = mul nuw nsw i32 %1105, %1112
%1114 = add nuw nsw i32 %1113, 1933574137
%1115 = mul i32 %1114, 198
%1116 = mul i32 %1114, 396
%1117 = add i32 %1116, 212
%1118 = and i32 %1117, 212
%1119 = sub nuw i32 %1115, %1118
%1120 = add nuw i32 %1119, 85
%1121 = load i8, i8* %530
%1122 = zext i8 %1121 to i32
%1123 = xor i32 %1120, 148
%1124 = add i32 %1123, %1122
%1125 = shl i32 %1120, 1
%1126 = xor i32 %1125, 214
%1127 = add i32 %1124, %1126
%1128 = trunc i32 %1127 to i8
%1129 = add i8 %1128, -127
%1130 = getelementptr inbounds i8, i8* %3, i64 80
store i8 %1129, i8* %1130
%1131 = load i8, i8* %580
%1132 = urem i8 %1131, 35
%1133 = zext i8 %1132 to i64
%1134 = getelementptr inbounds i8, i8* %2, i64 %1133
%1135 = load i8, i8* %1134
%1136 = and i8 %1135, -11
%1137 = load i8, i8* %454
%1138 = urem i8 %1137, 35
%1139 = zext i8 %1138 to i64
%1140 = getelementptr inbounds i8, i8* %2, i64 %1139
%1141 = load i8, i8* %1140
%1142 = and i8 %1141, 10
%1143 = or i8 %1142, %1136
%1144 = getelementptr inbounds i8, i8* %3, i64 84
store i8 %1143, i8* %1144
%1145 = load i8, i8* %807
%1146 = urem i8 %1145, 20
%1147 = zext i8 %1146 to i64
%1148 = getelementptr inbounds i8, i8* %0, i64 %1147
%1149 = load i8, i8* %1148
%1150 = or i8 %1149, 81
%1151 = mul i8 %1150, %1150
%1152 = mul i8 %1151, %1150
%1153 = load i8, i8* %165
%1154 = xor i8 %1153, -1
%1155 = and i8 %1152, %1154
%1156 = udiv i8 %1129, 15
%1157 = and i8 %1156, %1153
%1158 = load i8, i8* %631
%1159 = or i8 %1155, %1157
%1160 = sub i8 %1158, %1159
store i8 %1160, i8* %631
%1161 = load i8, i8* %285
%1162 = getelementptr inbounds i8, i8* %1, i64 160
%1163 = load i8, i8* %1162
%1164 = urem i8 %1163, 20
%1165 = zext i8 %1164 to i64
%1166 = getelementptr inbounds i8, i8* %0, i64 %1165
%1167 = load i8, i8* %1166
%1168 = trunc i32 %1035 to i8
%1169 = add i8 %1161, %1168
%1170 = urem i8 %1169, 20
%1171 = zext i8 %1170 to i64
%1172 = getelementptr inbounds i8, i8* %0, i64 %1171
%1173 = load i8, i8* %1172
%1174 = urem i8 %1173, 21
%1175 = zext i8 %1174 to i64
%1176 = getelementptr inbounds i8, i8* %4, i64 %1175
%1177 = load i8, i8* %1176
%1178 = udiv i8 %1177, 3
%1179 = sub i8 %1169, %1167
%1180 = add i8 %1179, %1178
%1181 = getelementptr inbounds i8, i8* %3, i64 88
store i8 %1180, i8* %1181
%1182 = load i8, i8* %897
%1183 = zext i8 %1182 to i32
%1184 = xor i8 %1182, %853
%1185 = and i8 %1184, 57
%1186 = zext i8 %1185 to i32
%1187 = mul nuw nsw i32 %847, %847
%1188 = and i32 %1187, 198
%1189 = getelementptr inbounds i8, i8* %1, i64 69
%1190 = load i8, i8* %1189
%1191 = urem i8 %1190, 21
%1192 = zext i8 %1191 to i64
%1193 = getelementptr inbounds i8, i8* %4, i64 %1192
%1194 = load i8, i8* %1193
%1195 = getelementptr inbounds i8, i8* %1, i64 172
%1196 = load i8, i8* %1195
%1197 = and i8 %1196, %1194
%1198 = zext i8 %1197 to i32
%1199 = or i8 %1196, %1194
%1200 = zext i8 %1199 to i32
%1201 = load i8, i8* %312
%1202 = zext i8 %1201 to i32
%1203 = or i32 %1188, %1186
%1204 = sub nsw i32 77, %1203
%1205 = add nsw i32 %1204, %1202
%1206 = and i32 %1205, %1200
%1207 = or i32 %1206, %1198
%1208 = and i32 %1207, 250
%1209 = or i32 %1208, 1
%1210 = and i32 %1209, %1183
%1211 = and i32 %1207, 194
%1212 = and i32 %1183, 198
%1213 = or i32 %1211, %1212
%1214 = or i32 %1213, %1210
%1215 = trunc i32 %1214 to i8
%1216 = sub i8 -109, %1215
store i8 %1216, i8* %60
%1217 = getelementptr inbounds i8, i8* %1, i64 168
%1218 = load i8, i8* %1217
%1219 = urem i8 %1218, 21
%1220 = zext i8 %1219 to i64
%1221 = getelementptr inbounds i8, i8* %4, i64 %1220
%1222 = load i8, i8* %1221
%1223 = getelementptr inbounds i8, i8* %1, i64 29
%1224 = load i8, i8* %1223
%1225 = urem i8 %1224, 20
%1226 = zext i8 %1225 to i64
%1227 = getelementptr inbounds i8, i8* %0, i64 %1226
%1228 = load i8, i8* %1227
%1229 = and i8 %1222, 7
%1230 = and i8 %1229, %1228
%1231 = or i8 %1228, %1222
%1232 = and i8 %1231, 6
%1233 = or i8 %1232, %1230
%1234 = zext i8 %1233 to i32
%1235 = getelementptr inbounds i8, i8* %1, i64 155
%1236 = load i8, i8* %1235
%1237 = urem i8 %1236, 21
%1238 = zext i8 %1237 to i64
%1239 = getelementptr inbounds i8, i8* %4, i64 %1238
%1240 = load i8, i8* %1239
%1241 = load i8, i8* %181
%1242 = and i8 %1241, %1240
%1243 = or i8 %1241, %1240
%1244 = and i8 %1243, -115
%1245 = or i8 %1244, %1242
%1246 = zext i8 %1245 to i32
%1247 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_rol32 to i32 (i32, i32, ...)*)(i32 %1246, i32 %1234)
%1248 = srem i32 %1247, 21
%1249 = sext i32 %1248 to i64
%1250 = getelementptr inbounds i8, i8* %4, i64 %1249
%1251 = load i8, i8* %1250
%1252 = load i8, i8* %56
%1253 = sub i8 %1252, %1251
store i8 %1253, i8* %56
%1254 = getelementptr inbounds i8, i8* %0, i64 12
%1255 = load i8, i8* %1254
%1256 = zext i8 %1255 to i32
%1257 = getelementptr inbounds i8, i8* %1, i64 61
%1258 = load i8, i8* %1257
%1259 = urem i8 %1258, 20
%1260 = zext i8 %1259 to i64
%1261 = getelementptr inbounds i8, i8* %0, i64 %1260
%1262 = load i8, i8* %1261
%1263 = udiv i8 %1262, 5
%1264 = and i8 %1263, 7
%1265 = zext i8 %1264 to i32
%1266 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_ror8 to i32 (i32, i32, ...)*)(i32 %1256, i32 %1265)
%1267 = load i8, i8* %1144
%1268 = urem i8 %1267, 35
%1269 = zext i8 %1268 to i64
%1270 = getelementptr inbounds i8, i8* %2, i64 %1269
%1271 = load i8, i8* %1270
%1272 = zext i8 %1271 to i32
%1273 = xor i32 %1272, -1
%1274 = udiv i32 %1273, 5
%1275 = xor i32 %1274, %1266
%1276 = trunc i32 %1275 to i8
store i8 %1276, i8* %216
%1277 = getelementptr inbounds i8, i8* %1, i64 3
%1278 = load i8, i8* %1277
%1279 = getelementptr inbounds i8, i8* %1, i64 198
%1280 = load i8, i8* %1279
%1281 = add i8 %1280, %1278
store i8 %1281, i8* %1279
%1282 = load i8, i8* %580
%1283 = urem i8 %1282, 35
%1284 = zext i8 %1283 to i64
%1285 = getelementptr inbounds i8, i8* %2, i64 %1284
%1286 = load i8, i8* %1285
%1287 = or i8 %1286, -94
%1288 = zext i8 %1287 to i32
%1289 = mul nuw nsw i32 %1288, %1288
%1290 = trunc i32 %1289 to i16
%1291 = udiv i16 %1290, 5
%1292 = load i8, i8* %372
%1293 = trunc i16 %1291 to i8
%1294 = add i8 %1292, %1293
store i8 %1294, i8* %372
%1295 = load i8, i8* %1130
%1296 = and i8 %1295, 7
%1297 = zext i8 %1296 to i32
%1298 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_ror8 to i32 (i32, i32, ...)*)(i32 139, i32 %1297)
%1299 = load i8, i8* %580
%1300 = urem i8 %1299, 21
%1301 = zext i8 %1300 to i64
%1302 = getelementptr inbounds i8, i8* %4, i64 %1301
%1303 = load i8, i8* %1302
%1304 = zext i8 %1303 to i32
%1305 = mul nuw nsw i32 %1304, %1304
%1306 = mul nuw nsw i32 %1305, %1304
%1307 = and i32 %1306, 95
%1308 = load i8, i8* %554
%1309 = urem i8 %1308, 20
%1310 = zext i8 %1309 to i64
%1311 = getelementptr inbounds i8, i8* %0, i64 %1310
%1312 = load i8, i8* %1311
%1313 = and i8 %1312, -96
%1314 = zext i8 %1313 to i32
%1315 = load i8, i8* %454
%1316 = urem i8 %1315, 20
%1317 = zext i8 %1316 to i64
%1318 = getelementptr inbounds i8, i8* %0, i64 %1317
%1319 = load i8, i8* %1318
%1320 = zext i8 %1319 to i32
%1321 = or i32 %1298, %1320
%1322 = and i32 %1321, 12
%1323 = and i32 %1298, %1320
%1324 = or i32 %1307, %1314
%1325 = or i32 %1324, %1323
%1326 = or i32 %1325, %1322
%1327 = trunc i32 %1326 to i8
%1328 = getelementptr inbounds i8, i8* %3, i64 92
store i8 %1327, i8* %1328
%1329 = getelementptr inbounds i8, i8* %1, i64 103
%1330 = load i8, i8* %1329
%1331 = zext i8 %1330 to i32
%1332 = and i32 %1331, 32
%1333 = or i32 %1331, 44
%1334 = and i32 %1326, %1333
%1335 = or i32 %1332, %1334
%1336 = or i32 %1335, 16
%1337 = udiv i32 %1336, 3
%1338 = load i8, i8* %28
%1339 = trunc i32 %1337 to i8
%1340 = add i8 %1338, %1339
store i8 %1340, i8* %28
%1341 = getelementptr inbounds i8, i8* %1, i64 143
%1342 = load i8, i8* %1341
%1343 = getelementptr inbounds i8, i8* %3, i64 96
store i8 %1342, i8* %1343
%1344 = getelementptr inbounds i8, i8* %3, i64 100
store i8 27, i8* %1344
%1345 = load i8, i8* %554
%1346 = load i8, i8* %402
%1347 = xor i8 %1346, -1
%1348 = and i8 %1345, %1347
%1349 = getelementptr inbounds i8, i8* %1, i64 35
%1350 = load i8, i8* %1349
%1351 = and i8 %1350, %1346
%1352 = or i8 %1351, %1348
%1353 = load i8, i8* %580
%1354 = and i8 %1352, %1353
%1355 = xor i8 %1354, 119
%1356 = getelementptr inbounds i8, i8* %3, i64 104
store i8 %1355, i8* %1356
%1357 = load i8, i8* %402
%1358 = xor i8 %1357, -1
%1359 = and i8 %1345, %1358
%1360 = load i8, i8* %1349
%1361 = and i8 %1360, %1357
%1362 = or i8 %1361, %1359
%1363 = and i8 %1362, %1353
%1364 = shl i8 %1363, 1
%1365 = and i8 %1364, -18
%1366 = getelementptr inbounds i8, i8* %3, i64 108
store i8 %1365, i8* %1366
%1367 = xor i8 %1353, -1
%1368 = load i8, i8* %1144
%1369 = udiv i8 %1368, 3
%1370 = and i8 %1369, %1367
%1371 = xor i8 %1370, 49
%1372 = getelementptr inbounds i8, i8* %3, i64 112
store i8 %1371, i8* %1372
%1373 = shl nuw i8 %1370, 1
%1374 = and i8 %1373, 98
%1375 = getelementptr inbounds i8, i8* %3, i64 116
store i8 %1374, i8* %1375
%1376 = load i8, i8* %1349
%1377 = load i8, i8* %402
%1378 = and i8 %1377, %1376
%1379 = xor i8 %1377, -1
%1380 = and i8 %1345, %1379
%1381 = or i8 %1380, %1378
%1382 = and i8 %1381, %1353
%1383 = or i8 %1382, %1370
%1384 = load i8, i8* %1195
%1385 = lshr i8 %1384, 1
%1386 = or i8 %1385, 77
%1387 = and i8 %1383, %1386
%1388 = or i8 %1387, 18
%1389 = sub i8 %1342, %1388
store i8 %1389, i8* %1341
%1390 = getelementptr inbounds i8, i8* %2, i64 29
store i8 -94, i8* %1390
%1391 = load i8, i8* %1181
%1392 = urem i8 %1391, 21
%1393 = zext i8 %1392 to i64
%1394 = getelementptr inbounds i8, i8* %4, i64 %1393
%1395 = load i8, i8* %1394
%1396 = and i8 %1395, -96
%1397 = getelementptr inbounds i8, i8* %1, i64 125
%1398 = load i8, i8* %1397
%1399 = urem i8 %1398, 20
%1400 = zext i8 %1399 to i64
%1401 = getelementptr inbounds i8, i8* %0, i64 %1400
%1402 = load i8, i8* %1401
%1403 = and i8 %1402, 94
%1404 = or i8 %1403, %1396
%1405 = lshr exact i8 %1404, 1
%1406 = zext i8 %1405 to i32
%1407 = getelementptr inbounds i8, i8* %1, i64 149
%1408 = load i8, i8* %1407
%1409 = urem i8 %1408, 35
%1410 = zext i8 %1409 to i64
%1411 = getelementptr inbounds i8, i8* %2, i64 %1410
%1412 = load i8, i8* %1411
%1413 = zext i8 %1412 to i32
%1414 = load i8, i8* %256
%1415 = zext i8 %1414 to i32
%1416 = mul nuw nsw i32 %1415, %1415
%1417 = xor i32 %1416, %1413
%1418 = and i32 %1417, %1406
%1419 = or i32 %1417, %1406
%1420 = and i32 %1419, 115
%1421 = or i32 %1420, %1418
%1422 = load i8, i8* %165
%1423 = trunc i32 %1421 to i8
%1424 = add i8 %1422, %1423
store i8 %1424, i8* %165
%1425 = load i8, i8* %580
%1426 = load i8, i8* %554
%1427 = urem i8 %1426, 20
%1428 = zext i8 %1427 to i64
%1429 = getelementptr inbounds i8, i8* %0, i64 %1428
%1430 = load i8, i8* %1429
%1431 = sub i8 %1425, %1430
%1432 = getelementptr inbounds i8, i8* %3, i64 120
store i8 %1431, i8* %1432
%1433 = load i8, i8* %454
%1434 = urem i8 %1433, 21
%1435 = zext i8 %1434 to i64
%1436 = getelementptr inbounds i8, i8* %4, i64 %1435
%1437 = load i8, i8* %1436
%1438 = getelementptr inbounds i8, i8* %1, i64 95
store i8 %1437, i8* %1438
%1439 = load i8, i8* %1130
%1440 = urem i8 %1439, 35
%1441 = zext i8 %1440 to i64
%1442 = getelementptr inbounds i8, i8* %2, i64 %1441
%1443 = load i8, i8* %1442
%1444 = zext i8 %1443 to i32
%1445 = load i8, i8* %663
%1446 = urem i8 %1445, 35
%1447 = zext i8 %1446 to i64
%1448 = getelementptr inbounds i8, i8* %2, i64 %1447
%1449 = load i8, i8* %1448
%1450 = zext i8 %1449 to i32
%1451 = mul nuw nsw i32 %1450, %1450
%1452 = mul nuw nsw i32 %1451, %1450
%1453 = and i32 %1452, 7
%1454 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_ror8 to i32 (i32, i32, ...)*)(i32 %1444, i32 %1453)
%1455 = mul i32 %1454, %1454
%1456 = getelementptr inbounds i8, i8* %0, i64 7
%1457 = load i8, i8* %1456
%1458 = trunc i32 %1455 to i8
%1459 = sub i8 %1457, %1458
store i8 %1459, i8* %1456
%1460 = load i8, i8* %402
%1461 = load i8, i8* %1056
%1462 = sub i8 %1460, %1461
%1463 = load i8, i8* %168
%1464 = urem i8 %1463, 21
%1465 = zext i8 %1464 to i64
%1466 = getelementptr inbounds i8, i8* %4, i64 %1465
%1467 = load i8, i8* %1466
%1468 = mul i8 %1467, %1467
%1469 = mul i8 %1468, %1467
%1470 = add i8 %1462, %1469
store i8 %1470, i8* %402
%1471 = getelementptr inbounds i8, i8* %1, i64 102
%1472 = load i8, i8* %1471
%1473 = urem i8 %1472, 35
%1474 = zext i8 %1473 to i64
%1475 = getelementptr inbounds i8, i8* %2, i64 %1474
%1476 = load i8, i8* %1475
%1477 = shl i8 %1476, 1
%1478 = and i8 %1477, -124
store i8 %1478, i8* %60
%1479 = load i8, i8* %554
%1480 = urem i8 %1479, 21
%1481 = zext i8 %1480 to i64
%1482 = getelementptr inbounds i8, i8* %4, i64 %1481
%1483 = load i8, i8* %1482
%1484 = lshr i8 %1483, 1
%1485 = load i8, i8* %807
%1486 = xor i8 %1484, %1485
%1487 = getelementptr inbounds i8, i8* %3, i64 124
store i8 %1486, i8* %1487
%1488 = getelementptr inbounds i8, i8* %1, i64 191
%1489 = load i8, i8* %1488
%1490 = urem i8 %1489, 20
%1491 = zext i8 %1490 to i64
%1492 = getelementptr inbounds i8, i8* %0, i64 %1491
%1493 = load i8, i8* %1492
%1494 = getelementptr inbounds i8, i8* %1, i64 80
%1495 = load i8, i8* %1494
%1496 = urem i8 %1495, 21
%1497 = zext i8 %1496 to i64
%1498 = getelementptr inbounds i8, i8* %4, i64 %1497
%1499 = load i8, i8* %1498
%1500 = shl i8 %1499, 1
%1501 = and i8 %1500, 78
%1502 = load i8, i8* %1181
%1503 = urem i8 %1502, 21
%1504 = zext i8 %1503 to i64
%1505 = getelementptr inbounds i8, i8* %4, i64 %1504
%1506 = load i8, i8* %1505
%1507 = urem i8 %1506, 21
%1508 = zext i8 %1507 to i64
%1509 = getelementptr inbounds i8, i8* %4, i64 %1508
%1510 = load i8, i8* %1509
%1511 = and i8 %1510, -79
%1512 = load i8, i8* %1456
%1513 = sub i8 %1501, %1493
%1514 = add i8 %1513, %1511
%1515 = add i8 %1514, %1512
store i8 %1515, i8* %1456
%1516 = getelementptr inbounds i8, i8* %1, i64 119
%1517 = load i8, i8* %1516
%1518 = urem i8 %1517, 20
%1519 = zext i8 %1518 to i64
%1520 = getelementptr inbounds i8, i8* %0, i64 %1519
%1521 = load i8, i8* %1520
%1522 = getelementptr inbounds i8, i8* %0, i64 6
store i8 %1521, i8* %1522
%1523 = load i8, i8* %42
%1524 = urem i8 %1523, 21
%1525 = zext i8 %1524 to i64
%1526 = getelementptr inbounds i8, i8* %4, i64 %1525
%1527 = load i8, i8* %1526
%1528 = and i8 %1527, 46
%1529 = getelementptr inbounds i8, i8* %1, i64 118
%1530 = load i8, i8* %1529
%1531 = and i8 %1530, -47
%1532 = or i8 %1531, %1528
%1533 = zext i8 %1532 to i32
%1534 = load i8, i8* %1432
%1535 = urem i8 %1534, 20
%1536 = zext i8 %1535 to i64
%1537 = getelementptr inbounds i8, i8* %0, i64 %1536
%1538 = load i8, i8* %1537
%1539 = zext i8 %1538 to i32
%1540 = mul nuw nsw i32 %1539, %1539
%1541 = load i8, i8* %1144
%1542 = urem i8 %1541, 20
%1543 = zext i8 %1542 to i64
%1544 = getelementptr inbounds i8, i8* %0, i64 %1543
%1545 = load i8, i8* %1544
%1546 = zext i8 %1545 to i32
%1547 = getelementptr inbounds i8, i8* %1, i64 71
%1548 = load i8, i8* %1547
%1549 = urem i8 %1548, 35
%1550 = zext i8 %1549 to i64
%1551 = getelementptr inbounds i8, i8* %2, i64 %1550
%1552 = load i8, i8* %1551
%1553 = zext i8 %1552 to i32
%1554 = load i8, i8* %102
%1555 = urem i8 %1554, 35
%1556 = zext i8 %1555 to i64
%1557 = getelementptr inbounds i8, i8* %2, i64 %1556
%1558 = load i8, i8* %1557
%1559 = zext i8 %1558 to i32
%1560 = add nuw nsw i32 %1559, %1553
%1561 = xor i32 %1560, %1546
%1562 = and i32 %1540, %1533
%1563 = or i32 %1540, %1533
%1564 = and i32 %1563, 27
%1565 = or i32 %1564, %1562
%1566 = and i32 %1561, %1565
%1567 = trunc i32 %1566 to i8
store i8 %1567, i8* %1254
%1568 = load i8, i8* %95
%1569 = load i8, i8* %1181
%1570 = urem i8 %1569, 35
%1571 = zext i8 %1570 to i64
%1572 = getelementptr inbounds i8, i8* %2, i64 %1571
%1573 = load i8, i8* %1572
%1574 = or i8 %1573, %1568
%1575 = and i8 %1574, 22
%1576 = load i8, i8* %756
%1577 = urem i8 %1576, 21
%1578 = zext i8 %1577 to i64
%1579 = getelementptr inbounds i8, i8* %4, i64 %1578
%1580 = load i8, i8* %1579
%1581 = mul i8 %1580, -25
%1582 = and i8 %1581, -87
%1583 = and i8 %1568, 86
%1584 = and i8 %1583, %1573
%1585 = or i8 %1575, %1584
%1586 = or i8 %1585, %1582
%1587 = getelementptr inbounds i8, i8* %1, i64 82
%1588 = load i8, i8* %1587
%1589 = zext i8 %1588 to i32
%1590 = urem i8 %1588, 20
%1591 = zext i8 %1590 to i64
%1592 = getelementptr inbounds i8, i8* %0, i64 %1591
%1593 = load i8, i8* %1592
%1594 = and i8 %1593, -94
%1595 = load i8, i8* %1487
%1596 = urem i8 %1595, 21
%1597 = zext i8 %1596 to i64
%1598 = getelementptr inbounds i8, i8* %4, i64 %1597
%1599 = load i8, i8* %1598
%1600 = and i8 %1599, 28
%1601 = or i8 %1600, %1594
%1602 = udiv i8 %1586, 5
%1603 = urem i8 %1602, 21
%1604 = zext i8 %1603 to i64
%1605 = getelementptr inbounds i8, i8* %4, i64 %1604
%1606 = load i8, i8* %1605
%1607 = and i8 %1606, 65
%1608 = or i8 %1601, %1607
%1609 = zext i8 %1608 to i32
%1610 = load i8, i8* %554
%1611 = urem i8 %1610, 20
%1612 = zext i8 %1611 to i64
%1613 = getelementptr inbounds i8, i8* %0, i64 %1612
%1614 = load i8, i8* %1613
%1615 = zext i8 %1614 to i32
%1616 = mul nuw nsw i32 %1615, %1615
%1617 = mul nuw nsw i32 %1616, %1615
%1618 = or i32 %1589, 92
%1619 = and i32 %1617, %1618
%1620 = and i32 %1589, 92
%1621 = or i32 %1619, %1620
%1622 = and i32 %1621, %1609
%1623 = or i32 %1621, %1609
%1624 = and i32 %1623, 192
%1625 = or i32 %1624, %1622
%1626 = trunc i32 %1625 to i8
%1627 = xor i8 %1602, %1626
%1628 = getelementptr inbounds i8, i8* %3, i64 128
store i8 %1627, i8* %1628
%1629 = load i8, i8* %1432
%1630 = urem i8 %1629, 20
%1631 = zext i8 %1630 to i64
%1632 = getelementptr inbounds i8, i8* %0, i64 %1631
%1633 = load i8, i8* %1632
%1634 = zext i8 %1633 to i32
%1635 = shl nuw nsw i32 %1634, 1
%1636 = load i8, i8* %216
%1637 = zext i8 %1636 to i32
%1638 = mul nuw nsw i32 %1635, %1637
%1639 = load i8, i8* %1080
%1640 = zext i8 %1639 to i32
%1641 = load i8, i8* %1598
%1642 = and i8 %1641, 7
%1643 = zext i8 %1642 to i32
%1644 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @weird_rol8 to i32 (i32, i32, ...)*)(i32 %1640, i32 %1643)
%1645 = load i8, i8* %454
%1646 = zext i8 %1645 to i32
%1647 = add nuw nsw i32 %1646, 110
%1648 = and i32 %1647, %1644
%1649 = sub nsw i32 %1638, %1648
%1650 = getelementptr inbounds i8, i8* %2, i64 25
%1651 = load i8, i8* %1650
%1652 = trunc i32 %1649 to i8
%1653 = xor i8 %1651, %1652
store i8 %1653, i8* %1650
ret void
}