444 lines
20 KiB
C
444 lines
20 KiB
C
#include <stdint.h>
|
|
#include <stdio.h>
|
|
|
|
#define printf(...) (void)0;
|
|
|
|
uint8_t rol8(uint8_t x, int y);
|
|
uint32_t rol8x(uint8_t x, int y);
|
|
|
|
uint32_t weird_ror8(uint8_t input, int count)
|
|
{
|
|
if (count == 0)
|
|
return 0;
|
|
return ((input >> count) & 0xff) | (input & 0xff) << (8-count);
|
|
|
|
}
|
|
|
|
uint32_t weird_rol8(uint8_t input, int count)
|
|
{
|
|
if (count == 0)
|
|
return 0;
|
|
return ((input << count) & 0xff) | (input & 0xff) >> (8-count);
|
|
}
|
|
|
|
uint32_t weird_rol32(uint8_t input, int count)
|
|
{
|
|
if (count == 0)
|
|
return 0;
|
|
return (input << count) ^ (input >> (8 - count));
|
|
}
|
|
|
|
// I do not know why it is doing all of this, and there is still a possibility for a gremlin or two to be lurking in the background
|
|
// I DO know it is not trivial. It could be purely random garbage, of course.
|
|
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;
|
|
// buffer1[64] = A
|
|
// (buffer1[99] / 3) = B
|
|
// 0ABAAABB
|
|
// Then we AND with a complex expression, and add 20 just for good measure
|
|
buffer2[12] = 0x14 + (((buffer1[64] & 92) | ((buffer1[99] / 3) & 35)) & buffer4[rol8x(buffer4[(buffer1[206] % 21)],4) % 21]);
|
|
printf("buffer2[12] = %02x\n", buffer2[12]);
|
|
|
|
// This is a bit simpler: 2*B*B/25
|
|
buffer1[4] = (buffer1[99] / 5) * (buffer1[99] / 5) * 2;
|
|
printf("buffer1[4] = %02x\n", buffer1[4]);
|
|
|
|
// Simpler still!
|
|
buffer2[34] = 0xb8;
|
|
printf("buffer2[34] = %02x\n", buffer2[34]);
|
|
|
|
// ...
|
|
buffer1[153] ^= (buffer2[buffer1[203] % 35] * buffer2[buffer1[203] % 35] * buffer1[190]);
|
|
printf("buffer1[153] = %02x\n", buffer1[153]);
|
|
|
|
// This one looks simple, but wow was it not :(
|
|
buffer0[3] -= (((buffer4[buffer1[205] % 21]>>1) & 80) | 0xe6440);
|
|
printf("buffer0[3] = %02x\n", buffer0[3]);
|
|
|
|
// This is always 0x93
|
|
buffer0[16] = 0x93;
|
|
printf("buffer0[16] = %02x\n", buffer0[16]);
|
|
|
|
// This is always 0x62
|
|
buffer0[13] = 0x62;
|
|
printf("buffer0[13] = %02x\n", buffer0[13]);
|
|
|
|
buffer1[33] -= (buffer4[buffer1[36] % 21] & 0xf6);
|
|
printf("buffer1[33] = %02x\n", buffer1[33]);
|
|
|
|
// This is always 7
|
|
tmp2 = buffer2[buffer1[67] % 35];
|
|
buffer2[12] = 0x07;
|
|
printf("buffer2[12] = %02x\n", buffer2[12]);
|
|
|
|
// This is pretty easy!
|
|
tmp = buffer0[buffer1[181] % 20];
|
|
buffer1[2] -= 3136;
|
|
printf("buffer1[2] = %02x\n", buffer1[2]);
|
|
|
|
buffer0[19] = buffer4[buffer1[58] % 21];
|
|
printf("buffer0[19] = %02x\n", buffer0[19]);
|
|
|
|
buffer3[0] = 92 - buffer2[buffer1[32] % 35];
|
|
printf("buffer3[0] = %02x\n", buffer3[0]);
|
|
|
|
buffer3[4] = buffer2[buffer1[15] % 35] + 0x9e;
|
|
printf("buffer3[4] = %02x\n", buffer3[4]);
|
|
|
|
buffer1[34] += (buffer4[((buffer2[buffer1[15] % 35] + 0x9e) & 0xff) % 21] / 5);
|
|
printf("buffer1[34] = %02x\n", buffer1[34]);
|
|
|
|
buffer0[19] += 0xfffffee6 - ((buffer0[buffer3[4] % 20]>>1) & 102);
|
|
printf("buffer0[19] = %02x\n", buffer0[19]);
|
|
|
|
// This LOOKS like it should be a rol8x, but it just doesnt work out because if the shift amount is 0, then the output is 0 too :(
|
|
// FIXME: Switch to weird_ror8
|
|
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];
|
|
printf("buffer1[15] = %02x\n", buffer1[15]);
|
|
|
|
buffer0[15] ^= buffer2[buffer1[181] % 35] * buffer2[buffer1[181] % 35] * buffer2[buffer1[181] % 35];
|
|
printf("buffer0[15] = %02x\n", buffer0[15]);
|
|
|
|
buffer2[4] ^= buffer1[202]/3;
|
|
printf("buffer2[4] = %02x\n", buffer2[4]);
|
|
|
|
// This could probably be quite a bit simpler.
|
|
A = 92 - buffer0[buffer3[0] % 20];
|
|
E = (A & 0xc6) | (~buffer1[105] & 0xc6) | (A & (~buffer1[105]));
|
|
buffer2[1] += (E*E*E);
|
|
printf("buffer2[1] = %02x\n", buffer2[1]);
|
|
|
|
buffer0[19] ^= ((224 | (buffer4[buffer1[92] % 21] & 27)) * buffer2[buffer1[41] % 35]) / 3;
|
|
printf("buffer0[19] = %02x\n", buffer0[19]);
|
|
|
|
buffer1[140] += weird_ror8(92, buffer1[5] & 7);
|
|
printf("buffer1[140] = %02x\n", buffer1[140]);
|
|
|
|
// Is this as simple as it could be?
|
|
buffer2[12] += ((((~buffer1[4]) ^ buffer2[buffer1[12] % 35]) | buffer1[182]) & 192) | (((~buffer1[4]) ^ buffer2[buffer1[12] % 35]) & buffer1[182]);
|
|
printf("buffer2[12] = %02x\n", buffer2[12]);
|
|
|
|
buffer1[36] += 125;
|
|
printf("buffer1[36] = %02x\n", buffer1[36]);
|
|
|
|
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);
|
|
printf("buffer1[124] = %02x\n", buffer1[124]);
|
|
|
|
buffer3[8] = ((((buffer0[buffer3[4] % 20] & 95)) & ((buffer4[buffer1[68] % 21] & 46) << 1)) | 16) ^ 92;
|
|
printf("buffer3[8] = %02x\n", buffer3[8]);
|
|
|
|
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));
|
|
printf("buffer3[12] = %02x\n", buffer3[12]);
|
|
|
|
A = 8 - ((buffer2[22] & 7)); // FIXME: buffer2[22] = 74, so A is always 6 and B^C is just ror8(buffer1[33], 6)
|
|
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);
|
|
printf("buffer2[16] = %02x\n", buffer2[16]);
|
|
|
|
// This one was very easy so I just skipped ahead and did it
|
|
buffer0[14] ^= buffer2[buffer3[12] % 35];
|
|
printf("buffer0[14] = %02x\n", buffer0[14]);
|
|
|
|
// Monster goes here
|
|
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);
|
|
printf("buffer1[19] = %02x\n", buffer1[19]);
|
|
|
|
buffer2[8] = weird_ror8(140, ((buffer4[buffer1[45] % 21] + 92) * (buffer4[buffer1[45] % 21] + 92)) & 7);
|
|
printf("buffer2[8] = %02x\n", buffer2[8]);
|
|
|
|
buffer1[190] = 56;
|
|
printf("buffer1[190] = %02x\n", buffer1[190]);
|
|
|
|
buffer2[8] ^= buffer3[0];
|
|
printf("buffer2[8] = %02x\n", buffer2[8]);
|
|
|
|
buffer1[53] = ~((buffer0[buffer1[83] % 20] | 204)/5);
|
|
printf("buffer1[53] = %02x\n", buffer1[53]);
|
|
|
|
buffer0[13] += buffer0[buffer1[41] % 20];
|
|
printf("buffer0[13] = %02x\n", buffer0[13]);
|
|
|
|
buffer0[10] = ((buffer2[buffer3[0] % 35] & buffer1[2]) | ((buffer2[buffer3[0] % 35] | buffer1[2]) & buffer3[12])) / 15;
|
|
printf("buffer0[10] = %02x\n", buffer0[10]);
|
|
|
|
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;
|
|
printf("buffer3[16] = %02x\n", buffer3[16]);
|
|
|
|
buffer3[20] = 202 - buffer3[16];
|
|
printf("buffer3[20] = %02x\n", buffer3[20]);
|
|
|
|
buffer3[24] = buffer1[151];
|
|
printf("buffer3[24] = %02x\n", buffer3[24]);
|
|
|
|
buffer2[13] ^= buffer4[buffer3[0] % 21];
|
|
printf("buffer2[13] = %02x\n", buffer2[13]);
|
|
|
|
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));
|
|
printf("buffer3[28] = %02x\n", buffer3[28]);
|
|
|
|
buffer3[32] = buffer3[28] + 62;
|
|
printf("buffer3[32] = %02x\n", buffer3[32]);
|
|
|
|
// eek
|
|
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];
|
|
printf("buffer1[47] = %02x\n", buffer1[47]);
|
|
|
|
buffer3[36] = ((rol8((tmp & 179) + 68, 2) & buffer0[3]) | (tmp2 & ~buffer0[3])) - 15;
|
|
printf("buffer3[36] = %02x\n", buffer3[36]);
|
|
|
|
buffer1[123] ^= 221;
|
|
printf("buffer1[123] = %02x\n", buffer1[123]);
|
|
|
|
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;
|
|
printf("buffer3[40] = %02x\n", buffer3[40]);
|
|
|
|
buffer3[44] = tmp3 ^ 81 ^ (((buffer3[0] >> 1) & 101) + 26);
|
|
printf("buffer3[44] = %02x\n", buffer3[44]);
|
|
|
|
buffer3[48] = buffer2[buffer3[4] % 35] & 27;
|
|
printf("buffer3[48] = %02x\n", buffer3[48]);
|
|
buffer3[52] = 27;
|
|
printf("buffer3[52] = %02x\n", buffer3[52]);
|
|
buffer3[56] = 199;
|
|
printf("buffer3[56] = %02x\n", buffer3[56]);
|
|
|
|
// caffeine
|
|
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]);
|
|
printf("buffer3[64] = %02x (want E7)\n", buffer3[64]);
|
|
|
|
buffer2[33] ^= buffer1[26];
|
|
printf("buffer2[33] = %02x\n", buffer2[33]);
|
|
|
|
buffer1[106] ^= buffer3[20] ^ 133;
|
|
printf("buffer1[106] = %02x\n", buffer1[106]);
|
|
|
|
buffer2[30] = ((buffer3[64] / 3) - (275 | (buffer3[0] & 247))) ^ buffer0[buffer1[122] % 20];
|
|
printf("buffer2[130] = %02x\n", buffer2[30]);
|
|
|
|
buffer1[22] = (buffer2[buffer1[90] % 35] & 95) | 68;
|
|
printf("buffer1[22] = %02x\n", buffer1[22]);
|
|
|
|
A = (buffer4[buffer3[36] % 21] & 184) | (buffer2[buffer3[44] % 35] & ~184);
|
|
buffer2[18] += ((A*A*A) >> 1);
|
|
printf("buffer2[18] = %02x\n", buffer2[18]);
|
|
|
|
buffer2[5] -= buffer4[buffer1[92] % 21];
|
|
printf("buffer2[5] = %02x\n", buffer2[5]);
|
|
|
|
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);
|
|
printf("buffer2[18] = %02x\n", buffer2[18]);
|
|
|
|
|
|
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);
|
|
printf("buffer2[22] = %02x\n", buffer2[22]);
|
|
|
|
A = buffer4[(buffer0[buffer1[39] % 20] ^ 217) % 21]; // X5
|
|
buffer0[15] -= ((((buffer3[20] | buffer3[0]) & 214) | (buffer3[20] & buffer3[0])) & A) | ((((buffer3[20] | buffer3[0]) & 214) | (buffer3[20] & buffer3[0]) | A) & buffer3[32]);
|
|
printf("buffer0[15] = %02x\n", buffer0[15]);
|
|
|
|
// We need to save T here, and boy is it complicated to calculate!
|
|
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];
|
|
printf("buffer3[68] = %02x\n", buffer3[68]);
|
|
|
|
U = buffer0[buffer1[50] % 20]; // this is also v100
|
|
W = buffer2[buffer1[138] % 35];
|
|
X = buffer4[buffer1[39] % 21];
|
|
Y = buffer0[buffer1[4] % 20]; // this is also v120
|
|
Z = buffer4[buffer1[202] % 21]; // also v124
|
|
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);
|
|
printf("buffer3[72] = %02x\n", buffer3[72]);
|
|
|
|
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));
|
|
printf("buffer2[2] = %02x\n", buffer2[2]);
|
|
|
|
buffer2[14] -= ((buffer2[buffer3[20] % 35] & (buffer3[72] ^ buffer2[buffer1[100] % 35])) & ~34) | (buffer1[97] & 34);
|
|
printf("buffer2[14] = %02x\n", buffer2[14]);
|
|
|
|
buffer0[17] = 115;
|
|
printf("buffer0[17] = %02x\n", buffer0[17]);
|
|
|
|
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);
|
|
printf("buffer1[23] = %02x\n", buffer1[23]);
|
|
|
|
buffer0[13] = ((((((buffer0[buffer3[40] % 20] | buffer1[10]) & 82) | (buffer0[buffer3[40] % 20] & buffer1[10])) & 209) |
|
|
((buffer0[buffer1[39] % 20] << 1) & 46)) >> 1);
|
|
printf("buffer0[13] = %02x\n", buffer0[13]);
|
|
|
|
buffer2[33] -= buffer1[113] & 9;
|
|
printf("buffer2[33] = %02x\n", buffer2[33]);
|
|
|
|
buffer2[28] -= ((((2 | (buffer1[110] & 222)) >> 1) & ~223) | (buffer3[20] & 223));
|
|
printf("buffer2[28] = %02x\n", buffer2[28]);
|
|
|
|
J = weird_rol8((V | Z), (U & 7)); // OK
|
|
A = (buffer2[16] & T) | (W & (~buffer2[16]));
|
|
B = (buffer1[33] & 17) | (X & ~17);
|
|
E = ((Y | ((A+B) / 5)) & 147) |
|
|
(Y & ((A+B) / 5)); // OK
|
|
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);
|
|
printf("buffer0[15] = %02x\n", buffer0[15]);
|
|
|
|
buffer2[22] += buffer1[183];
|
|
printf("buffer2[22] = %02x\n", buffer2[22]);
|
|
|
|
buffer3[76] = (3 * buffer4[buffer1[1] % 21]) ^ buffer3[0];
|
|
printf("buffer3[76] = %02x\n", buffer3[76]);
|
|
|
|
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;
|
|
printf("buffer3[80] = %02x\n", buffer3[80]);
|
|
|
|
buffer3[84] = ((buffer2[buffer3[64] % 35]) & 245) | (buffer2[buffer3[20] % 35] & 10);
|
|
printf("buffer3[84] = %02x\n", buffer3[84]);
|
|
|
|
A = buffer0[buffer3[68] % 20] | 81;
|
|
buffer2[18] -= ((A*A*A) & ~buffer0[15]) | ((buffer3[80] / 15) & buffer0[15]);
|
|
printf("buffer2[18] = %02x\n", buffer2[18]);
|
|
|
|
buffer3[88] = buffer3[8] + J + E - buffer0[buffer1[160] % 20] + (buffer4[buffer0[((buffer3[8] + J + E) & 255) % 20] % 21] / 3);
|
|
printf("buffer3[88] = %02x\n", buffer3[88]);
|
|
|
|
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));
|
|
printf("buffer0[16] = %02x\n", buffer0[16]);
|
|
|
|
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];
|
|
printf("buffer0[3] = %02x\n", buffer0[3]);
|
|
|
|
buffer1[5] = weird_ror8(buffer0[12], ((buffer0[buffer1[61] % 20] / 5) & 7)) ^ (((~buffer2[buffer3[84] % 35]) & 0xffffffff) / 5);
|
|
printf("buffer1[5] = %02x\n", buffer1[5]);
|
|
|
|
buffer1[198] += buffer1[3];
|
|
printf("buffer1[198] = %02x\n", buffer1[198]);
|
|
|
|
A = (162 | buffer2[buffer3[64] % 35]);
|
|
buffer1[164] += ((A*A)/5);
|
|
printf("buffer1[164] = %02x\n", buffer1[164]);
|
|
|
|
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;
|
|
printf("buffer3[92] = %02x\n", buffer3[92]);
|
|
|
|
buffer2[12] += ((buffer1[103] & 32) | (buffer3[92] & ((buffer1[103] | 60))) | 16)/3;
|
|
printf("buffer2[12] = %02x\n", buffer2[12]);
|
|
|
|
buffer3[96] = buffer1[143];
|
|
printf("buffer3[96] = %02x\n", buffer3[96]);
|
|
|
|
buffer3[100] = 27;
|
|
printf("buffer3[100] = %02x\n", buffer3[100]);
|
|
|
|
buffer3[104] = (((buffer3[40] & ~buffer2[8]) | (buffer1[35] & buffer2[8])) & buffer3[64]) ^ 119;
|
|
printf("buffer3[104] = %02x\n", buffer3[104]);
|
|
|
|
buffer3[108] = 238 & ((((buffer3[40] & ~buffer2[8]) | (buffer1[35] & buffer2[8])) & buffer3[64]) << 1);
|
|
printf("buffer3[108] = %02x\n", buffer3[108]);
|
|
|
|
buffer3[112] = (~buffer3[64] & (buffer3[84] / 3)) ^ 49;
|
|
printf("buffer3[112] = %02x\n", buffer3[112]);
|
|
|
|
buffer3[116] = 98 & ((~buffer3[64] & (buffer3[84] / 3)) << 1);
|
|
printf("buffer3[116] = %02x\n", buffer3[116]);
|
|
|
|
// finale
|
|
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]));
|
|
printf("buffer1[143] = %02x\n", buffer1[143]);
|
|
|
|
buffer2[29] = 162;
|
|
printf("buffer2[29] = %02x\n", buffer2[29]);
|
|
|
|
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);
|
|
printf("buffer0[15] = %02x\n", buffer0[15]);
|
|
|
|
buffer3[120] = buffer3[64] - buffer0[buffer3[40] % 20];
|
|
printf("buffer3[120] = %02x\n", buffer3[120]);
|
|
|
|
buffer1[95] = buffer4[buffer3[20] % 21];
|
|
printf("buffer1[95] = %02x\n", buffer1[95]);
|
|
|
|
A = weird_ror8(buffer2[buffer3[80] % 35], (buffer2[buffer1[17] % 35] * buffer2[buffer1[17] % 35] * buffer2[buffer1[17] % 35]) & 7);
|
|
buffer0[7] -= (A*A);
|
|
printf("buffer0[7] = %02x\n", buffer0[7]);
|
|
|
|
buffer2[8] = buffer2[8] - buffer1[184] + (buffer4[buffer1[202] % 21] * buffer4[buffer1[202] % 21] * buffer4[buffer1[202] % 21]);
|
|
printf("buffer2[8] = %02x\n", buffer2[8]);
|
|
|
|
buffer0[16] = (buffer2[buffer1[102] % 35] << 1) & 132;
|
|
printf("buffer0[16] = %02x\n", buffer0[16]);
|
|
|
|
buffer3[124] = (buffer4[buffer3[40] % 21] >> 1) ^ buffer3[68];
|
|
printf("buffer3[124] = %02x\n", buffer3[124]);
|
|
|
|
buffer0[7] -= (buffer0[buffer1[191] % 20] - (((buffer4[buffer1[80] % 21] << 1) & ~177) | (buffer4[buffer4[buffer3[88] % 21] % 21] & 177)));
|
|
printf("buffer0[7] = %02x\n", buffer0[7]);
|
|
|
|
buffer0[6] = buffer0[buffer1[119] % 20];
|
|
printf("buffer0[6] = %02x\n", buffer0[6]);
|
|
|
|
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));
|
|
printf("buffer0[12] = %02x\n", buffer0[12]);
|
|
|
|
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);
|
|
printf("buffer3[128] = %02x\n", buffer3[128]);
|
|
|
|
buffer2[25] ^= ((buffer0[buffer3[120] % 20] << 1) * buffer1[5]) - (weird_rol8(buffer3[76], (buffer4[buffer3[124] % 21] & 7)) & (buffer3[20] + 110));
|
|
printf("buffer2[25] = %02x\n", buffer2[25]);
|
|
//exit(0);
|
|
|
|
}
|