#include <iostream.h>
#include <fstream.h>
#include <windows.h>

const long bytemask3[]  = { 0x1F, 4, 5, 0x10, 0xC, 0x18, 2, 0x1E, 0x11, 0xB, 9, 8, 0x13, 1, 0, 0x1A, 0x1C, 0xF, 0x14, 7, 0x1D, 6, 0xA, 0x1B };
const long jarray[]     = { 5, 0xE9, 0x46, 0xEA, 0xC0, 0x45, 0xE0, 0x11, 0xE1, 0x80, 6, 0xEB, 0x18, 0xC1, 4, 0x47, 0x23, 0xE2,
							0xF3, 0x1C, 0x84,  0xF, 0xCA, 0x17, 0xCD, 0x4A, 0xED, 7, 0xE3, 0x40, 0x22, 0x13, 0x4B, 0xD, 0xA5,
							0x48, 0xC4, 0x16, 0xE, 0xE4, 0x65, 0xB, 0x15, 0xA, 0x49, 0xC2, 0x1B, 0xE8, 0xE5, 0xF2, 0x25, 0x44,
							0xC7, 9, 8, 0xE6, 0xF1, 0x21, 0xA2, 2, 3, 0x83, 0x4C, 0x63, 0x26, 0xF0, 0x43, 0xA0, 0x20, 0x27, 0x82,
							0x62, 0xEC, 0xA1, 0, 0x41, 0x81, 0xC9, 1, 0x4D, 0x2A, 0x1E, 0xCF, 0x1D, 0x4F, 0xC6, 0x29, 0x61, 0x1F,
							0x2C, 0x28, 0x10, 0xEF, 0x24, 0xC5, 0x42, 0xEE, 0x19, 0xCC, 0x64, 0x12, 0x85, 0xE7, 0x14, 0xC8, 0xA3,
							0x1A, 0x4E, 0xC3, 0xC, 0xCB, 0xA4, 0, 0, 0, 0, 0, 0xCE, 0x2B, 0x60};

long R0, R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11, R12, LR;
long inkey[25], serialmod[16], SECID[16];
char buff[32];

char applymask1(long buff)
{
 if (buff == 0x52) return(0x00);     // 0x52 ; R
 if (buff == 0x50) return(0x01);     // 0x50 ; P
 if (buff == 0x44) return(0x02);     // 0x44 ; D
 if (buff == 0x35) return(0x03);     // 0x35 ; 5
 if (buff == 0x54) return(0x04);     // 0x54 ; T
 if (buff == 0x4E) return(0x05);     // 0x4E ; N
 if (buff == 0x57) return(0x06);     // 0x57 ; W
 if (buff == 0x39) return(0x07);     // 0x39 ; 9
 if (buff == 0x4A) return(0x08);     // 0x4A ; J
 if (buff == 0x59) return(0x09);     // 0x59 ; Y
 if (buff == 0x32) return(0x0A);     // 0x32 ; 2
 if (buff == 0x5A) return(0x0B);     // 0x5A ; Z
 if (buff == 0x55) return(0x0C);     // 0x55 ; U
 if (buff == 0x53) return(0x0D);     // 0x53 ; S
 if (buff == 0x43) return(0x0E);     // 0x43 ; C
 if (buff == 0x36) return(0x0F);     // 0x36 ; 6
 if (buff == 0x48) return(0x10);     // 0x48 ; H
 if (buff == 0x41) return(0x11);     // 0x41 ; A
 if (buff == 0x38) return(0x12);     // 0x38 ; 8
 if (buff == 0x4B) return(0x13);     // 0x4B ; K
 if (buff == 0x34) return(0x14);     // 0x34 ; 4
 if (buff == 0x45) return(0x15);     // 0x45 ; E
 if (buff == 0x33) return(0x16);     // 0x33 ; 3
 if (buff == 0x46) return(0x17);     // 0x46 ; F
 if (buff == 0x47) return(0x18);     // 0x47 ; G
 if (buff == 0x4D) return(0x19);     // 0x4D ; M
 if (buff == 0x58) return(0x1A);     // 0x58 ; X
 if (buff == 0x37) return(0x1B);     // 0x37 ; 7
 if (buff == 0x42) return(0x1C);     // 0x42 ; B
 if (buff == 0x4C) return(0x1D);     // 0x4C ; L
 if (buff == 0x56) return(0x1E);     // 0x56 ; V
 if (buff == 0x51) return(0x1F);     // 0x51 ; Q
 return 0;
}


char applymask2(long buff)
{
 if (buff == 0x1F) return(0x00);
 if (buff == 0x14) return(0x01);
 if (buff == 0x16) return(0x02);
 if (buff == 0x0B) return(0x03);
 if (buff == 0x0C) return(0x04);
 if (buff == 0x15) return(0x05);
 if (buff == 0x0A) return(0x06);
 if (buff == 0x13) return(0x07);
 if (buff == 0x00) return(0x08);
 if (buff == 0x18) return(0x09);
 if (buff == 0x08) return(0x0A);
 if (buff == 0x0F) return(0x0B);
 if (buff == 0x1B) return(0x0C);
 if (buff == 0x02) return(0x0D);
 if (buff == 0x12) return(0x0E);
 if (buff == 0x11) return(0x0F);
 if (buff == 0x01) return(0x10);
 if (buff == 0x1A) return(0x11);
 if (buff == 0x06) return(0x12);
 if (buff == 0x19) return(0x13);
 if (buff == 0x04) return(0x14);
 if (buff == 0x1E) return(0x15);
 if (buff == 0x1C) return(0x16);
 if (buff == 0x09) return(0x17);
 if (buff == 0x03) return(0x18);
 if (buff == 0x0D) return(0x19);
 if (buff == 0x05) return(0x1A);
 if (buff == 0x17) return(0x1B);
 if (buff == 0x1D) return(0x1C);
 if (buff == 0x10) return(0x1D);
 if (buff == 0x07) return(0x1E);
 if (buff == 0x0E) return(0x1F);
 return 0;
}


int main()

{
ifstream inputfile;
inputfile.open("sw.unl", ios::in);
if (!inputfile.good()) { cout << "Unable to open SW.UNL\n";
						 system("PAUSE");
						 exit(1); }

inputfile.read(buff, 32);
if (strlen(buff) != 25)  { cout << "Your SW.UNL does not contain a valid unlock key\n";
						   system("PAUSE");
						   exit(1); }

for (int i = 0; i < 25; i++) { inkey[i] = static_cast<long>(buff[i]); }

//loop 1 (byte mask1)
for (int i = 0; i < 25; i++) inkey[i] = applymask1(inkey[i]);

//loop 2 (byte mask2)
for (int i = 0; i < 24; i++) inkey[i] = applymask2(inkey[i]);

R1 = (inkey[24] << 24);
R2 = (R1 >> 24);
R0 = (R2 << 24);
R6 = (R0 >> 24);

long shmask = ((R6 << 24) >> 24);
//loop 3 (byte mask3)
for (int i = 0; i < 24; i++) { R0 = ((inkey[i] - shmask) -  bytemask3[i]);
							   inkey[i] = R0 & 0x1F; }

long r2flag = (inkey[23] << 24) >> 24;  // we need this later after loop4 completes
R2 = (inkey[0] << 24)  >> 24;

inkey[23] = 0;
//halfword to inkey[24];

LR = 0x66666667;
R0 = (R2 << 3);
R1 = (R0 << 24);
R2 = (R1 >> 24);
inkey[0] = R2;

R4, R6 = 0;
R7 = 1, R8 = 1;
ZeroMemory(serialmod, 128);

//loop 4
while (R6 != 24) {   if ((inkey[R6] & 0x80) == NULL) { R0 = 0;
													   R1 = 0; }
					 else R1 = 1;
					 R1 = serialmod[R4] | R1;
					 R0 = R7 >> 2;
					 R3 = R1 & 0xFF;
					 R1 = R7 + (R0 >> 29);
					 serialmod[R4] = R3;

					 R2 = R1 >> 3;
					 if ( (R7 - (R2 << 3)) == 0)    { R3 = 0;
													  R7 = 0;
													  R4++; }
					 else                           { R0 = R3 & 0xFF;
													  R1 = R0 << 1;
													  R3 = 0;
													  R2 = R1 & 0xFF;
													  serialmod[R4] = R1; }
					 __int64 Rx8 = R8;
					 __int64 LxR = LR;
					 __int64 Rx0 = (Rx8 * LxR);
					 R1 = Rx0 >> 32;
					 R0 = R1  >>  1;
					 R1 = R0 + (R0 >> 31);
					 R2 = R1 + (R1 << 2);

					 if ((R8 - R2) == 0) { R6++;
										   R8 = R3;
										   R1 = inkey[R6] << 2;
										   R2 = R1 << 24;
										   R0 = R2 >> 24;
										   inkey[R6] = R0;
										 }
					 R7++;  R8++;
					 R1 = inkey[R6] << 1;
					 R2 = R1 << 24;
					 R0 = R2 >> 24;
					 inkey[R6] = R0;
				   }

R9 = 0, LR = 0;
if (r2flag == 1) R9 = 1;

R2 = R1 >> 5;
R0 = R1 & 0x1F;
R3 = R9 << R0;

R11 = 0;   //pointer to the 1st byte in SECID struct
R5  = 14;  //pointer to the last byte in serialmod array)
R6  = 119; //the next loop repeats 120 times
ZeroMemory(SECID, 256);

while (R6 >= 0) { R2 = jarray[R6] >> 5;
				  R0 = jarray[R6] & 0x1F;
				  R3 = R9 << R0;

				  switch (R2) { case 0: if ((serialmod[R5] & 0x80) == NULL) R3 = LR;
											 R1 = SECID[R11] + R3;
											 SECID[R11] = R1;
											 goto case7;

								case 1: if ((serialmod[R5] & 0x80) == NULL) R3 = LR;
											 R1 = SECID[R11 + 4] + R3;
											 SECID[R11 + 4] = R1;
											 goto case7;

								case 2: if ((serialmod[R5] & 0x80) == NULL) R3 = LR;
											 R1 = SECID[R11 + 8] + R3;
											 SECID[R11 + 8] = R1;
											 goto case7;

								case 3: if ((serialmod[R5] & 0x80) == NULL) R3 = LR;
											 R1 = SECID[R11 + 12] + R3;
											 SECID[R11 + 12] = R1;
											 goto case7;

								case 4: if ((serialmod[R5] & 0x80) == NULL) R3 = LR;
											 R1 = SECID[R11 + 16] + R3;
											 SECID[R11 + 16] = R1;
											 goto case7;

								case 5: if ((serialmod[R5] & 0x80) == NULL) R3 = LR;
											 R1 = SECID[R11 + 20] + R3;
											 SECID[R11 + 20] = R1;
											 goto case7;

								case 6: if ((serialmod[R5] & 0x80) == NULL) R3 = LR;
										    //tmpvar =  tmpvar + R3; //this piece of code doesn't seems to have sense.

								case 7:     case7:
											R0 = R6 >> 2;
											R1 = R6 + ( R0 >> 29 );
											R2 = R1 >> 3;
											R0 = R6 - (R2 << 3);
											if (R0 != NULL) { R1 = serialmod[R5] << 1;
															  R2 = R1 & 0xFF;
															  serialmod[R5] = R1; }
											else R5--;
								default:
									   ;
								}
					R6--;
				 }
char tmpbuff[128];
sprintf(tmpbuff, "According your SW.UNL your Unlock ESN is: %i\n\n", SECID[0]);
cout << tmpbuff;

//kfile.open("sw.unl", ios::out, ios::binary);
//kfile << inkey;
//kfile.close();
//kfile.clear();

system("pause");

return 0;
}