/* ForgePayLoad(&PayL);

	printf("-> TransID : 0x%2X%2X\n-> FuncID : 0x%X\n-> IV : 0x%X\n-> CRC32 : 0x%X\n", *((unsigned char *)&PayL.TransID), *((unsigned char *)&PayL.TransID + 1), PayL.FuncID, PayL.IV, PayL.Crc32);

	SendDatagram(&PayL, Hosts[BytesRandomWord() % NB_HARD_HOST]);
	printf("\n\n");

	UnCipher(CipheredGetNack, sizeof(CipheredGetNack), "0.0.0.0", "85.168.206.18");
	UnCipher(CipheredProbeReject, sizeof(CipheredProbeReject), "195.215.8.145" , "62.39.9.251");

*/

unsigned char SendBuffer[] = {0x66, 0xD8, 0xFA, 0xCA, 0x95, 0x75, 0xD9, 0xF6, 0xAE, 0x3C, 0xC0, 0x38, 0x4D, 0xEF, 0x5D, 0x19, 0x30, 0xE5, 0x6F, 0x98};
unsigned char CipheredGetNack[] = {0xDC, 0xCE, 0x02, 0xD0, 0x08, 0x0E, 0xC3, 0x83, 0xBF, 0xB5, 0x1A, 0x61, 0x71, 0xD4, 0x79, 0x79,
								   0x23, 0xB5, 0x44, 0x54, 0xBE};
unsigned char CipheredProbeReject[] = {
	0xCD, 0x1A, 0x02, 0x99, 0xCB, 0xB3, 0x34, 0x23, 0xB5, 0x53, 0xCB, 0xFE, 0xB5, 0xFD, 0xFC, 0x33, 
	0xA1, 0x86, 0x9D, 0xB1, 0x4B, 0xD3, 0x63, 0xAC, 0x88, 0xDB, 0x56, 0x0A, 0xD3, 0x38, 0xD6, 0xA4, 
	0x43, 0xA7, 0x71, 0x22, 0x4D, 0xAA, 0x80, 0xB1, 0x76, 0x87, 0xF9, 0xC5, 0xB4, 0xC8, 0xC1, 0x76, 
	0xBD, 0x04, 0xAB, 0x77, 0xEE
};

void		ForgePayLoad(PayLoad *PayL)
{
	ZeroMemory(PayL, sizeof(PayLoad));
	PayL->TransID = BytesRandomWord();
	PayL->FuncID = 0x2;
	PayL->IV = GenIV();
	PayL->Crc32 = crc32(SendBuffer, sizeof(SendBuffer), -1);
	PayL->DatasLen = sizeof(SendBuffer);
	PayL->Datas = SendBuffer;
}

void		SendDatagram(PayLoad *PayL, Host HardH)
{
	SOCKET			sock;
	sockaddr_in		SendrAddr;
	sockaddr_in		RecvrAddr;
	int				RecvBufferSz, data_idx;
	unsigned char	RecvBuffer[65536];
	unsigned char	*SendBuffer;
 
	RecvBufferSz = 65536;
	SendBuffer = (unsigned char *)malloc(PayL->DatasLen + PLD_HEADER_SZ(PayL));
	ZeroMemory(SendBuffer, PayL->DatasLen + PLD_HEADER_SZ(PayL));
	memcpy(SendBuffer, PayL, PLD_HEADER_SZ(PayL));
	memcpy(SendBuffer + PLD_HEADER_SZ(PayL), PayL->Datas, PayL->DatasLen);

	sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if (sock == INVALID_SOCKET)
	{
		printf("UDPSocket Error : <%d>\n", WSAGetLastError());
		ExitProcess(0xBADF00D);
	}
	SendrAddr.sin_family = AF_INET;
	SendrAddr.sin_port = htons(HardH.port);
	SendrAddr.sin_addr.s_addr = inet_addr(HardH.ip);
	printf("Sending datagram to host : %s..\n", HardH.ip);
	printf("%d Bytes sent..\n", sendto(sock, (const char *)SendBuffer, PLD_HEADER_SZ(PayL) + PayL->DatasLen, 0, (SOCKADDR *) &SendrAddr, sizeof(SendrAddr)));
		
	Sleep(500);
		
	RecvrAddr.sin_family = AF_INET;
	printf("%d Bytes in response..\n-> ", recvfrom(sock, (char *)&RecvBuffer[0], RecvBufferSz, 0, (SOCKADDR *) &RecvrAddr, &RecvBufferSz));

	for (data_idx = 0; data_idx < RecvBufferSz - 1; data_idx++)
		printf("%#2x, ", RecvBuffer[data_idx]);
	printf("%#2x\n", RecvBuffer[data_idx]);

	closesocket(sock);
}

define	 PLD_HEADER_SZ(P)	sizeof((P)->TransID) + sizeof((P)->FuncID) + sizeof((P)->IV) + sizeof((P)->Crc32)

#pragma	pack(1)
typedef struct
{
	unsigned short TransID;
	unsigned char  FuncID;
	unsigned int   IV;
	unsigned int   Crc32;
	unsigned int   DatasLen;
	unsigned char  *Datas;
}		PayLoad;

				
#include <tinyxml.h>

//using namespace std;

#define	CONFIG_FNAME	"config.xml"
#define	EMPTY_XML		"<?xml version=\"1.0\"?>\r\n<HostCache>\r\n</HostCache>\r\n"

void	CreateEmptyConfig()
{
	FILE	*config_file;

	fopen_s(&config_file, CONFIG_FNAME, "wb");
	fwrite(EMPTY_XML, strlen(EMPTY_XML), 1, config_file);
	fclose(config_file);
}

TiXmlDocument Config(CONFIG_FNAME);
	if(!Config.LoadFile())
	{
		CreateEmptyConfig();
		Config.LoadFile();
	}
	
printf("-> SEED : 0x%X\n", seed);
	printf("-> TransID : 0x%2X%2X\n-> FuncID : 0x%X\n-> IV : 0x%X\n-> CRC32 : 0x%X\n", *((unsigned char *)&Header->TransID), *((unsigned char *)&(Header->TransID) + 1), Header->FuncID, Header->IV, Header->Crc32);
	
	//PBody->PayLoadLen = 0x15;
	
	//PBody->Unknown_COOKIE = 0x42;
	
	//memcpy((void *)PBody->PayLoad, PayLoad, sizeof(PayLoad));
	
	/*printf("REQ LEN : %2x\n", Packet->PayLoadLen);
	printf("REQ CMD : %x\n", *(uchar *)&Packet->Cmd);
	printf("REQ ID : %2x%2x\n", *(uchar *)&Packet->RequestID, *((uchar *)&(Packet->RequestID) + 1));*/
	
HANDLE	 hProcess = 0;
LPVOID   RemoteAddr, KeyAddr;
int	     Size;

void	__declspec(naked) InjectedCode()
{
__asm
	{
		jmp BeginOCode
//KeyAddr:
		INT 3
		INT 3
		INT 3
		INT 3
KeyAddrGet:
		_emit 0xE8
		_emit 0x00
		_emit 0x00
		_emit 0x00
		_emit 0x00
		pop eax
		sub eax, 0x09
		mov eax, dword ptr [eax]
		ret
//Seed:
		INT 3
		INT 3
		INT 3
		INT 3
SeedGet:
		_emit 0xE8
		_emit 0x00
		_emit 0x00
		_emit 0x00
		_emit 0x00
		pop eax
		sub eax, 0x09
		mov eax, dword ptr [eax]
		ret
BeginOCode:
		call KeyAddrGet
		mov ecx, eax
		call SeedGet
		mov edx, eax
		mov eax, 0x0075D470
		call eax
		mov eax, 0x7C80C058
		call eax

		DEC ECX		//I
		DEC ESI		//N
		DEC EDX		//J
		INC EBP		//E
		INC EBX		//C
		PUSH ESP	//T
		DEC ECX		//I
		DEC EDI		//O
		DEC ESI		//N
		POP EDI		//_
		INC EBP		//E
		DEC ESI		//N
		INC ESP		//D
	}
}

int				SizeOfCode()
{
	int			Size;
	char		*Proc;
	char		Buffer[14] = {0};

	Size = 0;
	Proc = (char *)InjectedCode;
	do
	{
		memcpy(Buffer, Proc, 13);
        Size++;
        Proc++;
	}
    while (strcmp(Buffer, "INJECTION_END"));
    return (Size - 1);
}

DWORD				GetSkypeProcessHandle()
{
	HANDLE			hProcessSnap;
	PROCESSENTRY32	PE32;
	DWORD			SkypeProcess;

	SkypeProcess = -1;
    hProcessSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
	if (hProcessSnap == INVALID_HANDLE_VALUE)
	{
		printf("Error : CreateToolhelp32Snapshot (of processes) failed..\n");
		return (-1);
	}
	PE32.dwSize = sizeof(PROCESSENTRY32);
	if (!Process32First(hProcessSnap, &PE32))
	{
		printf("Error : Process32First failed..\n" );
		CloseHandle(hProcessSnap);
		return (-1);
	}
	do
	{
		if (strcmp("Skype.exe", PE32.szExeFile) == 0)
		{
			SkypeProcess = PE32.th32ProcessID;
			break;
		}
	}
	while (Process32Next(hProcessSnap, &PE32));

	CloseHandle(hProcessSnap);
	return (SkypeProcess);
}

int						Seed2Key(unsigned char *Key, unsigned int seed)
{
	/* FIXME */
	/* For the moment based on Skype.exe process in memory. Pick the proc Appart !*/
	DWORD				NbWritten, ThID;
	HANDLE				hThread;
	unsigned char		*CodeBuffer;

	if (!WriteProcessMemory(hProcess, KeyAddr, (LPCVOID)Key, RC4_KLEN, (SIZE_T *)&NbWritten))
	{
		printf("Skype Process WriteProcessMemory (Key) failed.. Aborting..\n");
		return (0);
	}	
	
	CodeBuffer = (unsigned char *)malloc(Size);
	memcpy(CodeBuffer, (void *)InjectedCode, Size);
	memcpy(CodeBuffer + 2, (void *)&KeyAddr, 4);
	memcpy(CodeBuffer + 18, (void *)&seed, 4);
	
	if (!WriteProcessMemory(hProcess, RemoteAddr, (LPCVOID)CodeBuffer, Size, (SIZE_T *)&NbWritten))
	{
		printf("Skype Process WriteProcessMemory (Code) failed.. Aborting..\n");
		return (0);
	}
	
	free(CodeBuffer);

	hThread = CreateRemoteThread(hProcess, NULL, NULL, (LPTHREAD_START_ROUTINE)RemoteAddr, NULL, NULL, (LPDWORD)&ThID);
	if (!hThread)
	{
		printf("Skype Process CreateRemoteThread failed.. Aborting..\n");
		return (0);
	}

	WaitForSingleObject(hThread, INFINITE);

	if (!ReadProcessMemory(hProcess, KeyAddr, (LPVOID)Key, RC4_KLEN, (SIZE_T *)&NbWritten))
	{
		printf("Skype Process ReadProcessMemory (Key) failed.. Aborting..\n");
		return (0);
	}
	
	return (1);
}

int		InitProc()
{
	STARTUPINFO Si;
	PROCESS_INFORMATION Pi; 

	ZeroMemory(&Si, sizeof(Si));
	ZeroMemory(&Pi, sizeof(Pi));
	Si.cb = sizeof(Si);
	//CREATE_SUSPENDED
	
	/*if(!CreateProcessA("SkypeKeyServer.exe", "SkypeKeyServer.exe", NULL, NULL, FALSE, NULL, NULL, NULL, (LPSTARTUPINFOA)&Si, &Pi))
	{
		printf("Error creating process..\n");
		return (0);
	}

	hProcess = Pi.hProcess;*/

	hProcess = OpenProcess(PROCESS_ALL_ACCESS, NULL, GetSkypeProcessHandle());

	if (!hProcess)
	{
		printf("Failed Opening process..\n");
		return (0);
	}

	KeyAddr = VirtualAllocEx(hProcess, NULL, RC4_KLEN, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
	if (!KeyAddr)
	{
		printf("Skype Process VirtualAllocEx (Key) failed.. Aborting..\n");
		return (0);
	}
	
	Size = SizeOfCode();
	RemoteAddr = VirtualAllocEx(hProcess, NULL, Size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
	if (!RemoteAddr)
	{
		printf("Skype Process VirtualAllocEx (Code) failed.. Aborting..\n");
		return (0);
	}

	return (1);
}

void	EndProc()
{
	VirtualFreeEx(hProcess, KeyAddr, 0, MEM_RELEASE);
	VirtualFreeEx(hProcess, RemoteAddr, 0, MEM_RELEASE);

	CloseHandle(hProcess);
}

unsigned char sent_1[] = {
	0xCB, 0xA2, 0xA4, 0xEB, 0x18, 0x0D, 0x7F, 0x60, 0x37, 0x7A, 0x99, 0xEC, 0x56, 0x79, 0x32, 0xAE, 
	0xF1, 0x47, 0x9B, 0x56, 0xE3, 0xCF, 0x2E, 0xF3, 0xFE, 0x8B, 0xE2, 0x5E, 0x69, 0x94, 0x92, 0xB3, 
	0xF4, 0x99, 0xE8, 0x8D
};

unsigned char response_1[] = {
	0x46, 0xB6, 0x52, 0x2E, 0x21, 0x48, 0x23, 0xAF, 0xC6, 0xB1, 0x8A, 0xA1, 0xEF, 0x3C, 0x4F, 0x0C, 
	0x6E, 0xB5, 0x85, 0xA8, 0x23, 0x67, 0x10, 0x9B, 0x8A, 0x35, 0xA5, 0xE2, 0x59, 0x63, 0x2F, 0xAA, 
	0x33, 0xD7, 0xE6, 0x9D, 0x4F, 0x44, 0xF9, 0xBA, 0x7A, 0xD8, 0xF6, 0x88, 0xD2, 0xAA, 0x7C, 0x0D, 
	0xD9, 0x03, 0x47, 0x93, 0x75, 0xE2, 0x50, 0xAD, 0x0C, 0x1B, 0x5D, 0x04, 0x04, 0xA9, 0x3F, 0x42, 
	0xF7, 0x52, 0x68, 0x62, 0x89
};

unsigned char sent_2[] = {
	0xE6, 0xEE, 0xC2, 0xFB, 0x17, 0xFE, 0xF5, 0x8C, 0x9A, 0x14, 0xBC, 0x56, 0xD5, 0x7F, 0xCF, 0x6D, 
	0xB2, 0x72, 0xE4, 0xF1, 0x8A, 0x2B, 0x0B, 0xAB, 0xD1, 0x18, 0xB7
};

unsigned char response_2[] = {
	0x9E, 0xAA, 0x7B, 0x50, 0x73, 0x80, 0xCA, 0x7D, 0x77, 0x44, 0xCF, 0xBC, 0x1D, 0x92, 0x66, 0x60, 
	0x98, 0x17, 0xE3, 0x55, 0xEE, 0x02, 0xE8, 0x1A, 0x75, 0xE7, 0xC2, 0xB8, 0xC3, 0xCE, 0x7C, 0x16, 
	0xAE, 0xA6, 0x9F, 0x0B, 0x0C, 0xFF, 0xBA, 0x13, 0x9C, 0x5A, 0xD9, 0x67, 0xA5, 0xD1, 0x11, 0x80, 
	0x21, 0xA9, 0x53, 0x5B, 0x91, 0x68, 0x92, 0x7E, 0xB9, 0xEE, 0x67, 0xD1, 0x0A, 0x07, 0x13, 0x88, 
	0xCA, 0x9C, 0xB7, 0x5A, 0x32, 0x01, 0x17, 0x35, 0xC6, 0xA2, 0x81
};

unsigned char sent[] = {
	0x5D, 0x55, 0x02, 0xC8, 0x8B, 0x24, 0x11, 0x35, 0xEB, 0x3B, 0x5F, 0x65, 0x12, 0x15, 0x22, 0xBE, 
	0x7E, 0x61, 0x5E, 0x58, 0xB4, 0xC5, 0x83, 0x98, 0xED, 0xDB, 0x3E, 0x07, 0xE6, 0x9A, 0x56, 0x59, 
	0x3E, 0x40, 0x58
};

unsigned char response[] = {
	0xCA, 0x64, 0xD6, 0x4A, 0xAE, 0x11, 0x15, 0x71, 0xBD, 0x2E, 0xE3, 0x7E, 0xBB, 0x86, 0x42, 0xA1, 
	0x8C, 0x87, 0xD2, 0x7B, 0x56, 0x1C, 0x50, 0x25, 0xB1, 0x73, 0x72, 0xC0, 0xB5, 0x3E, 0x81, 0x09, 
	0xEE, 0xA8, 0x46, 0xBA, 0x8E, 0x09, 0x25, 0x1D, 0x44, 0x52, 0x42, 0xB3, 0x2F, 0xBD, 0x9A, 0xB4, 
	0x44, 0xD0, 0x92, 0xA9, 0x73, 0x43, 0x3D, 0x16, 0x2D, 0x54, 0xDC, 0xC1, 0x60, 0x34, 0x62, 0x73, 
	0x2D, 0x45, 0x1A, 0x33, 0xCA, 0x01
};

unsigned char data[] = {
	0x8C, 0xEB, 0xB1, 0xF6, 0xF0, 0x3B, 0x16, 0x0F, 0x2D, 0x4D, 0x87, 0x0B, 0xB8, 0xDA, 0x26, 0x60, 
	0x4C, 0x26, 0xFC, 0x9D, 0xAA, 0xB1, 0x00, 0xCE, 0x74, 0xDC, 0xC0
};

/*printf("Send #1\n");
	UncipherObfuscatedTCP(sent_1, sizeof(sent_1));
	showmem(sent_1, sizeof(sent_1));
	printf("\n\n");

	printf("Response #1\n");
	UncipherObfuscatedTCP(response_1, sizeof(response_1));
	showmem(response_1, sizeof(response_1));
	printf("\n\n");

	printf("Send #2\n");
	UncipherObfuscatedTCP(sent_2, sizeof(sent_2));
	showmem(sent_2, sizeof(sent_2));
	printf("\n\n");

	printf("Response #2\n");
	UncipherObfuscatedTCP(response_2, sizeof(response_2));
	showmem(response_2, sizeof(response_2));
	printf("\n\n");

	printf("Send\n");
	UncipherObfuscatedTCP(sent, sizeof(sent));
	showmem(sent, sizeof(sent));
	printf("\n\n");

	printf("Response\n");
	UncipherObfuscatedTCP(response, sizeof(response));
	showmem(response, sizeof(response));
	printf("\n\n");

	printf("DATA\n");
	UncipherObfuscatedTCP(data, sizeof(data));
	showmem(data, sizeof(data));
	printf("\n\n");
*/

/*printf("Send #1\n");
	UncipherObfuscatedTCPCtrlP(sent_1, sizeof(sent_1));
	showmem(sent_1, sizeof(sent_1));
	printf("\n\n");*/

	printf("Response #1\n");
	UncipherObfuscatedTCPCtrlP(response_1, sizeof(response_1));
	showmem(response_1, sizeof(response_1));
	printf("\n\n");

	/*printf("Send #2\n");
	UncipherObfuscatedTCP(sent_2, sizeof(sent_2), htonl(*(unsigned int *)sent_1));
	showmem(sent_2, sizeof(sent_2));
	printf("\n\n");*/

	/*printf("Send #2\n");
	UncipherObfuscatedTCP(sent_2, sizeof(sent_2), htonl(*(unsigned int *)response_1));
	showmem(sent_2, sizeof(sent_2));
	printf("\n\n");*/

	printf("Response #2\n");
	UncipherObfuscatedTCP(response_2, sizeof(response_2), htonl(*(unsigned int *)response_1));
	showmem(response_2, sizeof(response_2));
	printf("\n\n");

	/*printf("Response #2\n");
	UncipherObfuscatedTCP(response_2, sizeof(response_2), htonl(*(unsigned int *)response_1));
	showmem(response_2, sizeof(response_2));
	printf("\n\n");*/
	
unsigned char sent_1[] = {
	0xCB, 0xA2, 0xA4, 0xEB, 0x18, 0x0D, 0x7F, 0x60, 0x37, 0x7A, 0x99, 0xEC, 0x56, 0x79, 0x32, 0xAE, 
	0xF1, 0x47, 0x9B, 0x56, 0xE3, 0xCF, 0x2E, 0xF3, 0xFE, 0x8B, 0xE2, 0x5E, 0x69, 0x94, 0x92, 0xB3, 
	0xF4, 0x99, 0xE8, 0x8D
};

unsigned char response_1[] = {
	0x46, 0xB6, 0x52, 0x2E, 0x21, 0x48, 0x23, 0xAF, 0xC6, 0xB1, 0x8A, 0xA1, 0xEF, 0x3C, 0x4F, 0x0C, 
	0x6E, 0xB5, 0x85, 0xA8, 0x23, 0x67, 0x10, 0x9B, 0x8A, 0x35, 0xA5, 0xE2, 0x59, 0x63, 0x2F, 0xAA, 
	0x33, 0xD7, 0xE6, 0x9D, 0x4F, 0x44, 0xF9, 0xBA, 0x7A, 0xD8, 0xF6, 0x88, 0xD2, 0xAA, 0x7C, 0x0D, 
	0xD9, 0x03, 0x47, 0x93, 0x75, 0xE2, 0x50, 0xAD, 0x0C, 0x1B, 0x5D, 0x04, 0x04, 0xA9, 0x3F, 0x42, 
	0xF7, 0x52, 0x68, 0x62, 0x89
};

unsigned char sent_2[] = {
	0xE6, 0xEE, 0xC2, 0xFB, 0x17, 0xFE, 0xF5, 0x8C, 0x9A, 0x14, 0xBC, 0x56, 0xD5, 0x7F, 0xCF, 0x6D, 
	0xB2, 0x72, 0xE4, 0xF1, 0x8A, 0x2B, 0x0B, 0xAB, 0xD1, 0x18, 0xB7
};

unsigned char response_2[] = {
	0x9E, 0xAA, 0x7B, 0x50, 0x73, 0x80, 0xCA, 0x7D, 0x77, 0x44, 0xCF, 0xBC, 0x1D, 0x92, 0x66, 0x60, 
	0x98, 0x17, 0xE3, 0x55, 0xEE, 0x02, 0xE8, 0x1A, 0x75, 0xE7, 0xC2, 0xB8, 0xC3, 0xCE, 0x7C, 0x16, 
	0xAE, 0xA6, 0x9F, 0x0B, 0x0C, 0xFF, 0xBA, 0x13, 0x9C, 0x5A, 0xD9, 0x67, 0xA5, 0xD1, 0x11, 0x80, 
	0x21, 0xA9, 0x53, 0x5B, 0x91, 0x68, 0x92, 0x7E, 0xB9, 0xEE, 0x67, 0xD1, 0x0A, 0x07, 0x13, 0x88, 
	0xCA, 0x9C, 0xB7, 0x5A, 0x32, 0x01, 0x17, 0x35, 0xC6, 0xA2, 0x81
};

//{"127.0.0.1", 50024},
				   //{"127.0.0.1", 443},
				   //{"86.69.202.238", 18466},
				   

/*Idx = 0;
	while (Idx < Size - 16)
	{
		ZeroMemory(AesTmp, 16);
		AES_encrypt(MarkObjL + Idx, AesTmp, &AesKey);
		memcpy_s(MarkObjL + Idx, Size - Idx, AesTmp, 16);
		Idx += 16;
	}
	AES_encrypt(MarkObjL + Idx, AesTmp, &AesKey);
	memcpy_s(MarkObjL + Idx, Size - Idx, AesTmp, ((Size % 16) != 0) ? (Size % 16) : 16);*/
	
	/*AES_ofb128_encrypt(MarkObjL, MarkObjL, Size, &AesKey, AesTmp, (int *)&Idx);
	printf("->%d\n", Idx);*/
	
	/*uchar	iv[EVP_MAX_IV_LENGTH];
	EVP_CIPHER_CTX *ctx;

	ZeroMemory(iv, EVP_MAX_IV_LENGTH);

	ctx = (EVP_CIPHER_CTX *)malloc(sizeof(EVP_CIPHER_CTX));
	EVP_CIPHER_CTX_init(ctx);
	EVP_EncryptInit_ex(ctx, EVP_aes_256_ctr( ), 0, SHAResult, iv);
	EVP_EncryptUpdate(ctx, MarkObjL, (int *)&Idx, MarkObjL, Size);

	int i;
	Idx = 0;
	while (Idx + 16 < Size)
	{
		ZeroMemory(AesTmp, 16);
		*(int *)(AesTmp + 12) = Idx / 16;
		showmem(AesTmp, 16);
		AES_set_encrypt_key(SHAResult, 256, &AesKey);
		AES_encrypt(AesTmp, AesTmp, &AesKey);
		showmem(AesTmp, 16);
		for (i = 0; i < 16; i++)
		{
			MarkObjL[Idx + i] ^= AesTmp[i];
		}
		Idx += 16;
	}*/
	
	

	ZeroMemory(ivec, AES_BLOCK_SIZE);
	ZeroMemory(ecount_buf, AES_BLOCK_SIZE);
	
	unsigned char presence_s[] = {
	0x59, 0x82, 0x02, 0xF1, 0x93, 0xB5, 0xF2, 0x16, 0x7F, 0x92, 0xB5, 0x3B, 0xA5, 0x23, 0x6F, 0x58, 
	0xF1, 0xC1, 0x09, 0xE3, 0x07, 0xF4, 0xBD, 0x2C, 0x4B, 0x45, 0xA4, 0x3F, 0x60, 0xA9, 0x85, 0x63, 
	0xE9, 0x1E, 0x8B, 0x62, 0x3C, 0xA9, 0x13, 0xDB, 0x76, 0x0A, 0xF2, 0x75, 0x68, 0x61, 0x71, 0x23, 
	0x8A, 0x48, 0x43, 0x9F
	};

	unsigned char presence_r[] = {
	0xD8, 0xEE, 0x02, 0x2A, 0x06, 0xFB, 0x7D, 0xC2, 0x8A, 0xEC, 0xD7, 0x15, 0x1B, 0x76, 0x54, 0xF9, 
	0xF0, 0x4F, 0xC5, 0x4A, 0x43, 0xB2
	};
	
	struct in_addr	PublicIP;

	PublicIP.S_un.S_addr = my_public_ip;
	printf("%d -> \n" , UnCipherObfuscated(presence_s, sizeof(presence_s), "212.72.49.142", inet_ntoa(PublicIP)));
	showmem(presence_s, sizeof(presence_s));

/*void	SendAuthentificationBlob(Host CurLS, char *User, char *Pass)
{
	uchar	MD5Result[MD5_DIGEST_LENGTH] = {0};
	MD5_CTX	Context;
	RSA		*Keys;

	unsigned char Blob[] = {
	0x16, 0x03, 0x01, 0x00, 0xCD, 0x41, 0x03, 0x00, 0x09, 0x80, 0x40, 0x04, 0x08, 0xC0, 0x01, 0x67, 
	0xEA, 0x04, 0x7E, 0x74, 0x97, 0xDC, 0x01, 0xB2, 0xC4, 0xE9, 0xA0, 0x26, 0xDA, 0x74, 0x46, 0xF8, 
	0xD0, 0x71, 0x8E, 0x09, 0xC7, 0x91, 0x61, 0x7F, 0x75, 0x5B, 0xB7, 0x88, 0x59, 0xD2, 0xC7, 0xF0, 
	0x06, 0x5B, 0xB8, 0x25, 0xEE, 0x95, 0x6E, 0xE9, 0x65, 0xC0, 0x75, 0x6E, 0x93, 0xC1, 0xCD, 0xD6, 
	0xD9, 0x04, 0x04, 0xE3, 0x99, 0xB7, 0x6F, 0x4D, 0x0F, 0xFC, 0x26, 0x25, 0x26, 0xD1, 0x7C, 0x4F, 
	0x76, 0x94, 0xD4, 0xB0, 0x85, 0xFC, 0xFA, 0xD0, 0xF7, 0x1B, 0xF3, 0x5C, 0x05, 0x4A, 0x6A, 0x64, 
	0x9D, 0x21, 0xFD, 0x95, 0xF1, 0x30, 0xAC, 0xD0, 0x22, 0x8C, 0x29, 0xB3, 0x91, 0x13, 0x09, 0xC9, 
	0x0B, 0xCC, 0x33, 0xC4, 0xD2, 0xDE, 0x67, 0xF6, 0x1D, 0x04, 0xA8, 0x31, 0x26, 0xF2, 0xDC, 0x49, 
	0x7C, 0x20, 0xAA, 0x8A, 0x99, 0xCE, 0x6E, 0xD1, 0x05, 0xDD, 0xEB, 0x8E, 0x63, 0xC2, 0x8B, 0x7D, 
	0x74, 0x93, 0xC5, 0xD5, 0x05, 0x6D, 0xF6, 0x3A, 0x3A, 0x5A, 0xCD, 0x39, 0xC3, 0xEF, 0xBF, 0xA0, 
	0xE6, 0x4F, 0x55, 0x9D, 0x97, 0x9C, 0x73, 0xA3, 0x42, 0x35, 0xCA, 0x9A, 0x7A, 0x9D, 0x97, 0x33, 
	0x4E, 0x94, 0x5F, 0xE6, 0xE5, 0xB1, 0xC1, 0x55, 0xB7, 0xBE, 0xF9, 0x9B, 0x76, 0x34, 0xEF, 0xE8, 
	0x5F, 0x1E, 0xA0, 0x3C, 0xE4, 0x3D, 0xDF, 0xB1, 0x66, 0x2D, 0xC9, 0x4B, 0x96, 0x28, 0x47, 0x00, 
	0x0C, 0x01, 0x17, 0x03, 0x01, 0x00, 0xE8, 0x85, 0x1A, 0x3D, 0x7D, 0xBA, 0xCF, 0x79, 0x0C, 0x2D, 
	0x7C, 0xBE, 0x2D, 0x3D, 0x8E, 0xC1, 0xFD, 0xC9, 0x3D, 0xCB, 0xBA, 0xB1, 0x2D, 0x10, 0xC6, 0xBF, 
	0xCC, 0xD6, 0xF1, 0x5E, 0x98, 0xD9, 0x4D, 0xB8, 0xE8, 0x40, 0x5F, 0x6A, 0x87, 0xC7, 0x90, 0x68, 
	0x96, 0x9A, 0xCF, 0xC6, 0x39, 0x22, 0x57, 0xDB, 0x51, 0x12, 0x59, 0x4E, 0x97, 0xE0, 0x63, 0x6F, 
	0xE8, 0x04, 0x84, 0xB1, 0x01, 0xC9, 0x09, 0x5D, 0xFD, 0x76, 0xE1, 0xA7, 0x8C, 0x77, 0xAF, 0x12, 
	0x30, 0xA8, 0x53, 0x42, 0xA1, 0xBF, 0xB3, 0xD1, 0x13, 0x2F, 0xE7, 0x33, 0x7B, 0x6A, 0xED, 0xAF, 
	0xD4, 0xF0, 0x19, 0x09, 0x4F, 0x66, 0x7B, 0x06, 0x98, 0x80, 0x09, 0x5E, 0x18, 0x70, 0x59, 0xFD, 
	0xEF, 0x3C, 0x1D, 0x86, 0x8E, 0xA1, 0x39, 0x34, 0xC4, 0xCB, 0x2C, 0xBE, 0x0B, 0xE2, 0x53, 0x3F, 
	0xC6, 0x34, 0x6F, 0xB0, 0xA4, 0x89, 0x6F, 0xB0, 0xA0, 0x33, 0x2F, 0x17, 0x8D, 0x07, 0xEC, 0x29, 
	0x02, 0x81, 0x54, 0x26, 0xA5, 0xB2, 0xD0, 0x85, 0x2D, 0x2F, 0x8C, 0xB7, 0xAA, 0x9A, 0x46, 0xE1, 
	0x3D, 0x36, 0xCE, 0x9D, 0xDD, 0x22, 0x69, 0xCE, 0x1E, 0xB1, 0xAA, 0xC7, 0x70, 0xC8, 0x8C, 0x49, 
	0xA0, 0x1E, 0x4C, 0xBD, 0x81, 0x1E, 0xF1, 0x64, 0x4D, 0xC6, 0x43, 0x32, 0x85, 0x73, 0x08, 0xB9, 
	0x4F, 0xA1, 0x00, 0x12, 0xAA, 0x45, 0x1A, 0xF3, 0x23, 0xDF, 0x65, 0x0D, 0xC3, 0x58, 0xB4, 0x36, 
	0x67, 0x61, 0x52, 0x5A, 0x4B, 0x88, 0xAB, 0xDD, 0x54, 0x16, 0x4B, 0xD3, 0xF1, 0x69, 0xBA, 0x3D, 
	0x67, 0x7B, 0x95, 0x8B, 0x1A, 0x6A, 0xC5, 0x7B, 0x0B, 0x0F, 0xED, 0xED, 0xC1, 0xF6, 0x5D
	};

	MD5_Init(&Context);
	MD5_Update(&Context, User, strlen(User));
	MD5_Update(&Context, CONCAT_SALT, strlen(CONCAT_SALT));
	MD5_Update(&Context, Pass, strlen(Pass));
	MD5_Final(MD5Result, &Context);

	printf("Shared Secret : ");
	showmem(MD5Result, MD5_DIGEST_LENGTH);
	printf("\n\n");

	printf("Generating RSA Keys Pair (Size = %d Bits)..\n", KEYSZ);
	Keys = RSA_generate_key(KEYSZ, RSA_F4, NULL, NULL);
	if (Keys == NULL)
	{
		printf("Error generating Keys..\n\n");
	}
	else
	{
		printf("Keys Generated..\n");
		printf("RSA Size = %d\n", RSA_size(Keys));
		printf("Public Modulus (N):\n");
        printf("%s\n",BN_bn2hex(Keys->n));
        printf("Public Exponent (E):\n");
        printf("%s\n",BN_bn2hex(Keys->e));
        printf("Private Exponent (D):\n");
        printf("%s\n",BN_bn2hex(Keys->d));
		printf("\n\n");
	}

	if (SendPacketTCP(LSSock, CurLS, Blob, sizeof(Blob), HTTPS_PORT, &Connected))
	{
		printf("Auth Response..\n\n");
		showmem(RecvBuffer, RecvBufferSz);
		printf("\n\n");
	}
	else
		printf(":'(..\n");	
}*/

unsigned char data_login[] = {
	0x38, 0x22, 0x40, 0x17, 0xFB, 0x01, 0xF0, 0xF3, 0x42, 0xB1, 0x25, 0x75, 0x95, 0x77, 0x98, 0x12, 
	0x18, 0x7C, 0x10, 0x0D, 0xC7, 0xBF, 0x88, 0xFB, 0x09, 0x27, 0x3E, 0x0F, 0x74, 0x58, 0x22, 0x41, 
	0x07, 0x59, 0x42, 0xB0, 0x9F, 0x30, 0x2B, 0xEE, 0xA1, 0x1E, 0xF9, 0x02, 0x42, 0xF6, 0x43, 0x86, 
	0x84, 0x3D, 0x87, 0xE5, 0x14, 0x2D, 0xEB, 0x3B, 0xD9, 0xD0, 0x4B, 0x43, 0xCD, 0x66, 0x27, 0x5F, 
	0x0C, 0x34, 0xB3, 0xB8, 0xC4, 0x17, 0x84, 0x86, 0x88, 0xFD
};

/*unsigned char data[37] = {
	0x42, 0xFB, 0x9E, 0xFD, 0x77, 0x9D, 0xB3, 0x39, 0x6D, 0xA4, 0x55, 0x56, 0xDD, 0x4C, 0xF0, 0xCB, 
	0x3E, 0xE4, 0x92, 0x45, 0x34, 0xA7, 0x3E, 0x51, 0xC3, 0x26, 0x6A, 0xC3, 0x54, 0x2C, 0xFB, 0xC5, 
	0xDF, 0xC1, 0x54, 0x96, 0x07
};*/

unsigned char data_ips[] = {
	0x38, 0x22, 0x40, 0x27, 0xFB, 0x01, 0xF0, 0xF3, 0x42, 0xFB, 0x9E, 0xFD, 0x77, 0x9D, 0xB3, 0x39, 0x6D, 0xA4, 0x55, 0x56, 0xDD, 0x4C, 0xF0, 0xCB, 
	0x3E, 0xE4, 0x92, 0x45, 0x34, 0xA7, 0x3E, 0x51, 0xC3, 0x26, 0x6A, 0xC3, 0x54, 0x2C, 0xFB, 0xC5, 
	0xDF, 0xC1, 0x54, 0x96, 0x07
};

unsigned char data_string[] = {
	0x38, 0x22, 0x40, 0xB5, 0x09, 0xFB, 0x01, 0xF0, 0xF3, 0x42, 0xFC, 0xDF, 0x96, 0xB8, 0xB2, 0xCD, 0xCA,
	0x01, 0xEF, 0x6E, 0x1F, 0xB7, 0x5B, 0xC2, 0x0F, 
	0x2B, 0xDF, 0x66, 0xAC, 0x3E, 0xC4, 0x39, 0x83, 0x18, 0xA3, 0x9E, 0xB0, 0x3D, 0xAD, 0xD3, 0x34, 
	0x7D, 0x00, 0xC9, 0x2F, 0x65, 0xF4, 0x1D, 0x04, 0xBF, 0x75, 0x38, 0xF3, 0x8A, 0x0F, 0x28, 0x0A, 
	0x3F, 0xDA, 0xC6, 0xB2, 0xB8, 0xEB, 0x8E, 0xF2, 0x99, 0xC4, 0xD1, 0xDF, 0x57, 0x7A, 0xC5, 0x18, 
	0xD2, 0x2A, 0x6D, 0xC7, 0x83, 0xB1, 0x5A, 0x4B, 0x0B, 0x54, 0x5C, 0xB6, 0x30, 0x0E, 0x3B, 0x90, 
	0xD5, 0x25, 0xD5, 0x85, 0x02, 0x7F, 0xBC, 0xF5, 0xC2, 0x1B, 0x4C, 0xFD, 0xD5, 0xE4, 0x63, 0xA0, 
	0xC9, 0x47, 0x3C, 0x7E, 0x40, 0x10, 0x2B, 0x01, 0x0F, 0x9D, 0xCD, 0x18, 0x55, 0x03, 0xB3, 0x5D, 
	0x3E, 0x26, 0xB4, 0xDB, 0x96, 0x1E, 0xC9, 0x4E, 0x3A, 0x5D, 0x35, 0xA1, 0x37, 0xEE, 0x29, 0x96, 
	0x30, 0x35, 0x12, 0x17, 0x76, 0x68, 0x3C, 0x3E, 0x41, 0xDB, 0x87, 0x6B, 0x00, 0xD7, 0x6C, 0xF5, 
	0x5F, 0xB8, 0x24, 0xE6, 0x00, 0x22, 0x7C, 0x68, 0xA5, 0x88, 0x6F, 0x90, 0x5F, 0xE7, 0x90, 0x4F, 
	0x7D, 0x22, 0xF4, 0x6F, 0x7E, 0xE3, 0x4B, 0xDB, 0x57, 0x0B, 0x85, 0x8F, 0x7D, 0x85, 0x72, 0xBB, 
	0xD0, 0x45, 0x2F, 0xF9, 0x9E, 0xCB, 0x65, 0x29, 0x3B, 0x83, 0x97, 0x7E, 0xBD, 0xE5, 0x6A, 0xB1, 
	0xDC, 0x80, 0x66, 0x25, 0x2F, 0x27, 0x3B, 0xD8, 0xA4, 0x02, 0xEF, 0x94, 0xC8, 0xB1, 0x6F, 0xFE, 
	0x2A, 0x3A, 0x6E, 0x4E, 0x75, 0x0B, 0x7A, 0xD6, 0xD6, 0x09, 0xAD, 0x03, 0x9A, 0xCA, 0x2F, 0xD8, 
	0xCB, 0x8A, 0x26, 0x3E, 0xEF, 0x78, 0x43, 0xA4, 0x19, 0x8C, 0xA3, 0x22, 0xC9, 0xDA, 0x99, 0x8A, 
	0xF0, 0x5F, 0x53, 0x3A, 0x5B, 0x32, 0x66, 0x48, 0x34, 0xEB, 0x55, 0xD9, 0x0F, 0x7B, 0x4E, 0x2D, 
	0xBF, 0x86, 0x67, 0x99, 0x4B, 0xF9, 0x96, 0xD7, 0xC3, 0x3C, 0xFB, 0x0F, 0xBC, 0x00, 0xCF, 0xEE, 
	0xE3, 0xF1, 0xD4, 0x32, 0xC4, 0x71, 0x95, 0x68, 0x31, 0xF4, 0x47, 0xB2, 0x08, 0x95, 0x53, 0xC3, 
	0xB2, 0xCC, 0x86, 0x65, 0x52, 0xA1, 0x86, 0xBD, 0xBC, 0xD7, 0x66, 0xC4, 0x8B, 0x20, 0x4E, 0xA1, 
	0x93, 0xAC, 0xD6, 0x32, 0x49, 0x77, 0xDA, 0x4F, 0x73, 0xE6, 0x09, 0x07, 0xF6, 0xA1, 0x53, 0x88, 
	0x0B, 0x0E, 0x1C, 0xE9, 0x71, 0x89, 0xB6, 0xB7, 0xDB, 0x77, 0xB2, 0xEF, 0x2F, 0x76, 0xF2, 0x5F, 
	0x59, 0x81, 0x95, 0x0A, 0x0E, 0x2B, 0x25, 0xF1, 0x3C, 0xEC, 0x50, 0xE2, 0x84, 0x89, 0xD7, 0xB8, 
	0xD3, 0x7B, 0xCD, 0x8E, 0x02, 0x96, 0x0D, 0x92, 0x9C, 0x72, 0x19, 0xDC, 0x18, 0x70, 0xA6, 0x67, 
	0xB8, 0x12, 0x4A, 0xE5, 0x4A, 0x8B, 0x70, 0x31, 0x15, 0xEB, 0xAB, 0xE2, 0x4F, 0x48, 0x1A, 0x1E, 
	0xAD, 0x44, 0x06, 0xCF, 0xE0, 0xB5, 0x8F, 0x2C, 0xC4, 0xBF, 0xBC, 0x69, 0xBC, 0xE2, 0x6D, 0x68, 
	0xBE, 0x2C, 0xD0, 0x72, 0xFB, 0xC2, 0x8B, 0x23, 0x13, 0x5B, 0x01, 0xA9, 0x8A, 0x04, 0xD7, 0x6E, 
	0x8A, 0xC0, 0x8F, 0xE1, 0xDD, 0x5A, 0x11, 0x25, 0x56, 0xC3, 0xFA, 0xE9, 0x0E, 0x52, 0xD2, 0x3A, 
	0xF2, 0x5D, 0xE4, 0x99, 0x5D, 0x9B, 0x71, 0x21, 0x8E, 0x93, 0x83, 0x62, 0x24, 0x03, 0xF1, 0x5A, 
	0x16, 0xB1, 0x40, 0xBC, 0x73, 0x71, 0x44, 0x55, 0x5B, 0xDD, 0xC1, 0x43, 0xB0, 0x78, 0x28, 0x12, 
	0xB9, 0x9F, 0x94, 0x28, 0xB0, 0x08, 0xCF, 0x75, 0x1B, 0xDF, 0x02, 0x9F, 0x5E, 0x30, 0x10, 0xEB, 
	0xCB, 0x9F, 0x86, 0x23, 0x1B, 0x06, 0x64, 0x48, 0x15, 0xEA, 0x84, 0x21, 0x3E, 0x77, 0x49, 0x40, 
	0xE5, 0xDF, 0x91, 0x36, 0x95, 0xCC, 0x0C, 0x2A, 0x67, 0xE9, 0x82, 0x3A, 0x00, 0x36, 0xFC, 0x6A, 
	0x9D, 0x3A, 0x05, 0x0B, 0x3E, 0xE2, 0x1F, 0xDD, 0x4D, 0xF0, 0x93, 0x97, 0x73, 0xF5, 0x49, 0xB6, 
	0x65, 0x3A, 0x07, 0x7E, 0x09, 0x65, 0x57, 0x60, 0xD9, 0xFD, 0x5B, 0x35, 0x10, 0xDC, 0x67, 0xB7, 
	0xDA, 0x19, 0x9D, 0xA8, 0x4B, 0x1A, 0x0A, 0x3B, 0x3F, 0xFD, 0xC7, 0xAA, 0x77, 0x0A, 0x98, 0x85, 
	0x9D, 0x79, 0x6F, 0x8A, 0x5D, 0x91, 0x45, 0x7B, 0x4F, 0x00, 0xE3, 0x65, 0x5B, 0x58, 0x22, 0x0B, 
	0x18, 0x25, 0x42, 0x9C, 0xAD, 0x28, 0xEC, 0x4F, 0x45, 0x17, 0x12, 0xA7, 0xF6, 0x97, 0xE1, 0x4D, 
	0xC7, 0x08, 0x5F, 0x7C, 0x9C, 0x18, 0x69, 0xBC, 0x54, 0xD6, 0xC4, 0x15, 0xC0, 0x5E, 0x40, 0x7B, 
	0x25, 0x84, 0xFE, 0xBD, 0x99, 0x0B, 0xD8, 0x7B, 0xB1, 0xDE, 0x1A, 0x00, 0x49, 0x45, 0x66, 0x95, 
	0x19, 0xA5, 0xA3, 0xE0, 0x27, 0x1E, 0x88, 0xD1, 0x3D, 0x81, 0x3B, 0x47, 0x29, 0x4D, 0x68, 0xB2, 
	0x23, 0xE1, 0xF5, 0xB3, 0x86, 0x0E, 0x20, 0xA2, 0xEC, 0xA5, 0x0A, 0xB3, 0x08, 0x4E, 0x00, 0x08, 
	0x2D, 0x91, 0xF2, 0xD8, 0x66, 0x1D, 0x08, 0x24, 0xBF, 0x0D, 0x13, 0x6B, 0x14, 0x35, 0x04, 0xC2, 
	0xFA, 0xC6, 0xD3, 0xFE, 0x13, 0xF9, 0x5F, 0x73, 0xD6, 0x23, 0xB8, 0xAC, 0x85, 0x1C, 0x4E, 0xE4, 
	0xD1, 0xC1, 0x28, 0x22, 0xE6, 0x13, 0xF4, 0xA6, 0xAC, 0xBF, 0x31, 0x02, 0x6F, 0x8D, 0xD5, 0x12, 
	0xFA, 0xBB, 0xDC, 0xDB, 0x7E, 0x5F, 0xCE, 0x6D, 0x58, 0x15, 0x0B, 0xE4, 0xD9, 0xA7, 0x00, 0x51, 
	0xF0, 0xD3, 0x1C, 0x5D, 0x94, 0x97, 0xC3, 0xBC, 0x8B, 0xD0, 0x74, 0xC4, 0xD5, 0xB6, 0x70, 0x16, 
	0x6A, 0x3C, 0x36, 0xEE, 0x2D, 0x65, 0x17, 0x9F, 0xE7, 0x6F, 0x91, 0x24, 0x16, 0x85, 0x2B, 0xF5, 
	0xD5, 0x0F, 0x41, 0x27, 0xD2, 0xB4, 0x0D, 0x02, 0x1D, 0xBC, 0xAB, 0x55, 0x2B, 0x41, 0x10, 0x8E, 
	0x75, 0x81, 0xAF, 0x04, 0xEE, 0x00, 0x07, 0x6B, 0xEA, 0x8C, 0x76, 0xA7, 0x2C, 0x74, 0xED, 0x3A, 
	0x30, 0x03, 0x24, 0x34, 0x23, 0x8E, 0xF1, 0x6B, 0x14, 0x7D, 0x2D, 0x9A, 0x86, 0xAD, 0xB7, 0x6C, 
	0x0E, 0xDF, 0x26, 0x77, 0x22, 0x21, 0xEA, 0x6C, 0xEB, 0xDC, 0xFE, 0x22, 0x73, 0xD1, 0x8E, 0x36, 
	0x32, 0xD8, 0x77, 0x9A, 0x90, 0x1B, 0x87, 0x4C, 0x4B, 0xE4, 0xAE, 0xFF, 0xC2, 0xCF, 0xFC, 0x94, 
	0xF1, 0x4C, 0x2F, 0xC2, 0x9E, 0xBC, 0xF7, 0xD6, 0xEC, 0x2A, 0x05, 0x7C, 0xC7, 0xAD, 0x22, 0xBB, 
	0xFB, 0xD2, 0xED, 0x96, 0x36, 0x76, 0x9C, 0xBD, 0xC0, 0xA1, 0x4B, 0x19, 0x99, 0x89, 0x39, 0x1D, 
	0xFB, 0x4F, 0x5C, 0xBC, 0x3C, 0x3E, 0x99, 0x00, 0x08, 0xEB, 0x34, 0x99, 0xC0, 0x96, 0x91, 0xA9, 
	0x03, 0xFA, 0x66, 0x41, 0xA7, 0x8D, 0x99, 0x61, 0xCD, 0xE0, 0xDA, 0xFB, 0xF3, 0xA0, 0x8D, 0x7C, 
	0xD8, 0x3A, 0x0D, 0xB8, 0xF8, 0xB4, 0x95, 0x03, 0x26, 0x50, 0xB5, 0x52, 0xEE, 0x4E, 0x05, 0x3F, 
	0xFF, 0x76, 0xD6, 0x29, 0x12, 0xE5, 0x2A, 0x6E, 0x41, 0xD6, 0xC8, 0xDC, 0x42, 0x88, 0x85, 0x74, 
	0x41, 0x8A, 0xFC, 0xE8, 0xEA, 0x27, 0x1F, 0xF9, 0x19, 0xD5, 0xF5, 0x7D, 0x36, 0x4D, 0xD5, 0x08, 
	0x41, 0xA9, 0xFF, 0x01, 0x37, 0xC8, 0x3B, 0x9A, 0x5F, 0xA2, 0x93, 0x91, 0xE0, 0xF1, 0x38, 0x9D, 
	0x69, 0x40, 0xFA, 0x9B, 0xF2, 0x87, 0xF5, 0x50, 0xB7, 0x59, 0x3D, 0xF4, 0xD0, 0xA1, 0xA7, 0x4C, 
	0x6E, 0x61, 0xCD, 0x19, 0x2D, 0xB8, 0x32, 0x52, 0x39, 0xF4, 0xB8, 0x1F, 0xA7, 0xE5, 0x2B, 0x0B, 
	0x41, 0x75, 0x71, 0x00, 0x6E, 0x15, 0xFA, 0x9B, 0xFE, 0x33, 0x27, 0xFA, 0xEC, 0x64, 0x40, 0x6E, 
	0xE7, 0x3A, 0x9D, 0x9C, 0x3A, 0x74, 0x89, 0x3C, 0xD1, 0xC1, 0xCC, 0x24, 0xDD, 0xF0, 0x26, 0xDB, 
	0xAF, 0x5E, 0x2A, 0x7F, 0xF2, 0x9D, 0xF9, 0xB8, 0x51, 0xC2, 0x21, 0x3F, 0xD5, 0xDE, 0x8D, 0x4F, 
	0xE9, 0x49, 0x54, 0x87, 0x1C, 0x03, 0x5A, 0xAB, 0x90, 0x53, 0xC9, 0x04, 0xA6, 0xEB, 0x6B, 0x1B, 
	0x9C, 0x3A, 0xDE, 0xD8, 0xFE, 0xE2, 0x99, 0x52, 0x0B, 0x12, 0x90, 0x3A, 0xF8, 0x78, 0x27, 0x53, 
	0x72, 0xFC, 0xC5, 0x0E, 0x69, 0x8E, 0x4F, 0x7C, 0x00, 0x85, 0x38, 0x9D, 0x16, 0x83, 0x47, 0xC4, 
	0x4C, 0xE5, 0x3A, 0xD8, 0x96, 0x45, 0x15, 0xB2, 0x27, 0x15, 0xC5, 0x1D, 0xA5, 0xF2, 0xA7, 0xA6, 
	0x89, 0x71, 0xCC, 0xC8, 0x05, 0xDF, 0xFF, 0xAA, 0xA7, 0xE0, 0xD9, 0x4B, 0x04, 0x27, 0x90, 0x9E, 
	0xCA, 0x58, 0x99, 0xE1, 0xED, 0x64, 0xCB, 0xD7, 0xA4, 0xAD, 0xF2, 0x8A, 0xD5, 0x67, 0x8A, 0xD5, 
	0xF0, 0x69, 0x3A, 0xB7, 0x92, 0x1F, 0xB3, 0x25, 0xD5, 0x8A, 0xAD, 0xE1, 0x8C, 0x95, 0x5A, 0x0B, 
	0xC9, 0x04, 0x1B, 0x7B, 0xD9, 0x26, 0x8F, 0xDE, 0x44, 0x55, 0xC1, 0x13, 0x5B, 0x50, 0x48, 0x95, 
	0x5B, 0x28, 0x76, 0x85, 0xB1, 0xF4, 0x35, 0xE0, 0xD1, 0xA6, 0x77, 0x18, 0xC5, 0x1A, 0x1C, 0x5E, 
	0x07, 0x99, 0xAC, 0x5F, 0x86, 0x67, 0xF7, 0x68, 0x1C, 0x35, 0xCA, 0x87, 0x54, 0x21, 0xC4, 0x04, 
	0x11, 0x2E, 0x7D
};

	SResponse Reponse;
	uchar	  *Buffer;
	uint	  Size, Idx;

	Buffer = data_login;
	Size = sizeof(data_login);
	TCPResponseManager(&Buffer, &Size, &Reponse);
	for (Idx = 0; Idx < Reponse.NbObj; Idx++)
	{
		DumpObj(Reponse.Objs[Idx]);
		printf("\n");
	}
	printf("Il reste : 0x%x\n\n", Size);

	Buffer = data_ips;
	Size = sizeof(data_ips);
	TCPResponseManager(&Buffer, &Size, &Reponse);
	for (Idx = 0; Idx < Reponse.NbObj; Idx++)
	{
		DumpObj(Reponse.Objs[Idx]);
		printf("\n");
	}
	printf("Il reste : 0x%x\n", Size);

	Buffer = data_string;
	Size = sizeof(data_string);
	TCPResponseManager(&Buffer, &Size, &Reponse);
	for (Idx = 0; Idx < Reponse.NbObj; Idx++)
	{
		DumpObj(Reponse.Objs[Idx]);
		printf("\n");
	}
	printf("Il reste : 0x%x\n", Size);
	
	/*for (uint HashIdx = 0; HashIdx < Response.Objs[Idx].Value.Memory.MsZ; HashIdx += 4)
					printf("->%x\n", htonl(*(uint *)(Response.Objs[Idx].Value.Memory.Memory + HashIdx)));*/
					
unsigned char data[238] = {
	0xFE, 0x02, 0xCE, 0x32, 0xB9, 0x01, 0xFB, 0x01, 0xC8, 0xBE, 0x42, 0xB1, 0x25, 0x87, 0x6E, 0x7E, 
	0x27, 0xAB, 0xAF, 0xAF, 0x0B, 0xA7, 0xC0, 0xC7, 0x20, 0x9D, 0xED, 0xEB, 0x5D, 0xD9, 0xEB, 0xDE, 
	0x43, 0x83, 0x3B, 0xA1, 0xE4, 0x15, 0xD8, 0x0F, 0x96, 0x8C, 0xF5, 0x19, 0xCF, 0x82, 0xFF, 0xDE, 
	0xD9, 0xF9, 0x2F, 0x44, 0x80, 0x46, 0xAD, 0xF1, 0x57, 0x47, 0xED, 0x18, 0x23, 0x97, 0x9D, 0xAC, 
	0x1A, 0x9D, 0x66, 0xE7, 0x94, 0xB0, 0xDC, 0x39, 0x96, 0x0D, 0x9C, 0xE6, 0xEA, 0x67, 0x83, 0x2C, 
	0x87, 0xD3, 0x5D, 0x2D, 0xA2, 0xC6, 0xA4, 0xB7, 0x4E, 0x48, 0x34, 0xCF, 0xFA, 0x5B, 0xE4, 0xA5, 
	0x0C, 0x33, 0x6E, 0x6C, 0x9D, 0x09, 0x9A, 0xB6, 0xFE, 0x54, 0x6C, 0x2E, 0x48, 0x87, 0xB6, 0x46, 
	0x4C, 0x0A, 0x41, 0xCA, 0x9A, 0xC6, 0xF9, 0x63, 0xDB, 0x15, 0xFC, 0xA1, 0x8A, 0xBF, 0x77, 0xEE, 
	0x6F, 0x99, 0xCB, 0xBC, 0xAA, 0x91, 0x2D, 0x9A, 0x1A, 0xFE, 0xF5, 0xD8, 0xE0, 0xA7, 0x97, 0x19, 
	0x2B, 0x37, 0x0B, 0x98, 0xEB, 0x50, 0x01, 0x68, 0xB9, 0xBD, 0x07, 0x58, 0x59, 0x62, 0x77, 0xBA, 
	0xFD, 0xC8, 0xB3, 0x74, 0x4A, 0x9D, 0x97, 0x63, 0xA1, 0xBE, 0x34, 0x98, 0x6E, 0x1A, 0x2B, 0xE4, 
	0x3D, 0x12, 0x3C, 0xFF, 0x87, 0x84, 0x28, 0x6F, 0x68, 0xA2, 0xD0, 0xFB, 0x09, 0x27, 0x3E, 0xE9, 
	0x36, 0x58, 0xCE, 0x33, 0x07, 0x59, 0x42, 0xB0, 0x9F, 0x5A, 0x3A, 0x91, 0x8C, 0x1E, 0xF9, 0x02, 
	0x42, 0xF6, 0x43, 0x86, 0x84, 0xC2, 0x32, 0x1C, 0x35, 0x2D, 0xEB, 0x3C, 0x03, 0xB0, 0xED, 0xB6, 
	0x17, 0x66, 0x27, 0x5F, 0x0C, 0x34, 0xB3, 0xB8, 0xC4, 0x17, 0x84, 0x86, 0xAF, 0x58
};

/*SResponse Reponse;
	uchar	  *Buffer;
	uint	  Size, Idx;

	Buffer = data;
	Size = sizeof(data);
	TCPResponseManager(&Buffer, &Size, &Reponse, 0);*/
					
					
unsigned char data[85] = {
	0x42, 0xB0, 0x9F, 0x5D, 0x40, 0xBB, 0x3A, 0x1E, 0xF9, 0x02, 0x42, 0xF6, 0x43, 0x86, 0x84, 0xC2, 
	0x32, 0x1C, 0x35, 0x2D, 0xEB, 0x3C, 0x04, 0xF8, 0xCD, 0xF6, 0x17, 0x66, 0x27, 0x5F, 0x0C, 0x34, 
	0xB3, 0xB8, 0xC4, 0x17, 0x84, 0x86, 0xAF, 0x58, 0x58, 0xAC, 0x5B, 0x07, 0x59, 0x42, 0xB0, 0x9F, 
	0x5D, 0x40, 0xBB, 0x3A, 0x1E, 0xF9, 0x02, 0x42, 0xF6, 0x43, 0x86, 0x84, 0xC2, 0x32, 0x1C, 0x35, 
	0x2D, 0xEB, 0x3C, 0x04, 0xF8, 0xCD, 0xF6, 0x17, 0x66, 0x27, 0x5F, 0x0C, 0x34, 0xB3, 0xB8, 0xC4, 
	0x17, 0x84, 0x86, 0xAF, 0x58
};

					

printf("BCM: #%d, version %d\n", BCM_id, BCM_ver);
							ZeroMemory(RecvCopy, 0xFFFF);
							memcpy_s(RecvCopy, 0xFFFF, RecvBuffer, RecvBufferSz);
							RecvSzCopy = RecvBufferSz;
							RequestBCM(CurHost, BCM_id);
							ZeroMemory(RecvBuffer, 0xFFFF);
							memcpy_s(RecvBuffer, 0xFFFF, RecvCopy, RecvSzCopy);
							RecvBufferSz = RecvSzCopy;
							
		
	SelRes = select(FD_SETSIZE, &m_UDPSockets, NULL, NULL, &Wait);
	if (SelRes)
	{
		Res = recvfrom(Socket, (char *)&RecvBuffer[0], RecvBufferSz, 0, (SOCKADDR *)&ReplyTo, &RptSz);
		printf("%d Bytes in response..\n", Res);
		RecvBufferSz = Res;
	}
	else
		printf("Nothing received from %s:%d..\n", CurHost.ip, CurHost.port);
		
queue<Host>		HostsCopy;

HostsCopy = Hosts;
	for (uint Iter = 0; Iter < 10; Iter++)
	{
		Hosts = HostsCopy;
		
		...
		
/*uint	MiscDatasEx[] = {0x00, 0x00, 0x00};
		ObjMiscDatas.Family = OBJ_FAMILY_INTLIST;
		ObjMiscDatas.Id = 0x02;
		ObjMiscDatas.Value.Memory.Memory = (uchar *)(&MiscDatasEx[0]);
		ObjMiscDatas.Value.Memory.MsZ = 0x03;
		WriteObject(&PRequest, ObjMiscDatas);*/
		
unsigned char data[] = {
	0x21, 0x72, 0x27, 0x60, 0x41, 
	0x02, 0x05, 0x00, 0x41, 0x03, 0x00, 0x02, 0x10, 0x00, 0x01, 0x00, 0x03, 0x00, 0x6F, 0x6A, 0x2E, 
	0x6D, 0x65, 0x64, 0x2E, 0x70, 0x65, 0x72, 0x6D, 0x00, 0x06, 0x01, 0x02, 0x10, 0x0B, 0x22, 0x72, 
	0x27, 0x62, 0x41, 0x02, 0x05, 0x00, 0x41, 0x03, 0x00, 0x02, 0x10, 0x00, 0x01, 0x00, 0x03, 0x00, 
	0x6F, 0x6A, 0x2E, 0x6D, 0x65, 0x64, 0x2E, 0x6C, 0x69, 0x6E, 0x75, 0x78, 0x00, 0x06, 0x01, 0x02, 
	0x10, 0x0B
	};
	
/*memcpy_s(PRequest, 0xFF, data, sizeof(data));
PRequest += sizeof(data);*/
		
showmem(AuthCert, BlobR.Objs[BIdx].Value.Memory.MsZ);
printf("-----\n\n");

unsigned char data[9] = {
	0x42, 0xB7, 0x3F, 0x1A, 0xE3, 0xDE, 0xD3, 0x52, 0x08
};

	uchar	  *Buffer;
	uint	  Size, Idx;
	SResponse Reponse;

	Buffer = data;
	Size = sizeof(data);
	ManageObjects(&Buffer, Size, &Reponse);
	for (Idx = 0; Idx < Reponse.NbObj; Idx++)
		DumpObj(Reponse.Objs[Idx]);
		
//FlushSocket(Session_SN.socket, Session_SN);

	//SearchContacts(Session_SN, User, User);
	//SearchContacts(Session_SN, User, "oj.med.perm");
	SearchContacts(Session_SN, User, "julien_barbier");
	//SearchContacts(Session_SN, User, "keytwho");
	//Listen2SN(Session_SN);
	
else if (LogRes == -1)
			{
				if (Connected)
					ResetLSSock();

				if (SendHandShake2LS(CurLS))
				{
					printf("Login Server %s OK ! Let's authenticate..\n", CurLS.ip);
					LogRes = SendAuthentificationBlobLS(CurLS, User, Pass);
				
					if (LogRes == 1)
					{
						closesocket(LSSock);
						return ;
					}
					else if (LogRes == -1)
					{
						if (Connected)
							ResetLSSock();

						if (SendHandShake2LS(CurLS))
						{
							printf("Login Server %s OK ! Let's authenticate..\n", CurLS.ip);
							LogRes = SendAuthentificationBlobLS(CurLS, User, Pass);

							if (LogRes == 1)
							{
								closesocket(LSSock);
								return ;
							}
						}
					}
				}
			}


unsigned char data[222] = {
	0x17, 0x03, 0x01, 0x00, 0xD9, 0x73, 0xC4, 0x06, 0x08, 0xFF, 0x1F, 0xFE, 0xED, 0x64, 0xB8, 0x49, 
	0x4D, 0xD8, 0xBE, 0xCD, 0xC9, 0xEF, 0x63, 0x74, 0x6D, 0x7F, 0x1D, 0x9B, 0xE6, 0x91, 0xFC, 0x14, 
	0xC6, 0x01, 0xDD, 0x79, 0xD6, 0xEA, 0x3B, 0xB3, 0xB6, 0x20, 0x03, 0x5E, 0x05, 0xEB, 0xFC, 0xAA, 
	0x46, 0x35, 0x7B, 0xAF, 0x5A, 0x59, 0x01, 0xFA, 0xBB, 0xB6, 0x1F, 0x81, 0x6D, 0x34, 0x85, 0x39, 
	0x93, 0xBB, 0x9B, 0x5B, 0xCC, 0x21, 0xD4, 0xCC, 0x85, 0x39, 0x27, 0x62, 0x69, 0xBC, 0x05, 0x48, 
	0xF2, 0x19, 0x88, 0xD3, 0x86, 0xD3, 0x10, 0x0D, 0xE1, 0x36, 0x08, 0x14, 0xC9, 0xC3, 0x52, 0x8B, 
	0x86, 0x42, 0x8D, 0x1F, 0x25, 0x02, 0x2E, 0x82, 0x48, 0xDC, 0x0C, 0x5C, 0x66, 0x5E, 0x34, 0x1A, 
	0x00, 0x3B, 0x4F, 0x6D, 0x54, 0x2E, 0x02, 0x91, 0x3E, 0xE1, 0xD7, 0x47, 0xC9, 0x04, 0xA0, 0xB2, 
	0xBD, 0x60, 0x49, 0xE1, 0xB8, 0x79, 0xB3, 0x1A, 0xE5, 0x14, 0x12, 0xC8, 0x0C, 0x37, 0xB3, 0x23, 
	0x2E, 0xBD, 0xD7, 0x9F, 0x47, 0xA3, 0xE1, 0xAD, 0x21, 0xEF, 0xF0, 0x79, 0x7E, 0x72, 0x28, 0x29, 
	0xCA, 0xAF, 0x29, 0xDD, 0xE4, 0xDC, 0x2C, 0x9C, 0x52, 0x07, 0xC5, 0x33, 0x9D, 0x65, 0xE3, 0x06, 
	0x14, 0x12, 0xEA, 0xF7, 0x7F, 0x1B, 0x79, 0xA2, 0x65, 0xA2, 0x5C, 0x68, 0x74, 0x13, 0x97, 0x41, 
	0xFE, 0x83, 0x2B, 0x13, 0x56, 0x56, 0x57, 0x1F, 0xCC, 0x65, 0xA0, 0x46, 0xEA, 0x0C, 0x18, 0x8B, 
	0x59, 0x9C, 0xE1, 0x9E, 0x59, 0x68, 0x43, 0x94, 0x2D, 0x1E, 0xC3, 0x4F, 0x7F, 0x04
	};

	ZeroMemory(RecvBuffer, sizeof(RecvBuffer));
	memcpy_s(RecvBuffer, sizeof(RecvBuffer), data, sizeof(data));
	
	/*unsigned char data[328] = {
	0x00, 0x00, 0x00, 0xC4, 0x00, 0x00, 0x00, 0x00, 0x2F, 0x48, 0x17, 0x98, 0xD3, 0x1F, 0x9C, 0x9C, 
	0x04, 0x0D, 0xC9, 0x28, 0x2B, 0x88, 0x78, 0x75, 0xF8, 0x3B, 0x65, 0x5F, 0x13, 0xFE, 0xC0, 0x25, 
	0x42, 0xCC, 0x71, 0x28, 0x4F, 0x1B, 0x46, 0xB6, 0x19, 0x47, 0x8F, 0x08, 0xC3, 0x54, 0x15, 0x41, 
	0xD1, 0xAB, 0xA7, 0x66, 0x3C, 0x7D, 0xFA, 0xDB, 0xD7, 0x6B, 0x67, 0xFD, 0x0D, 0x4C, 0xAE, 0xE3, 
	0x2A, 0x18, 0x9F, 0xD1, 0xF2, 0x76, 0xC2, 0xA1, 0x7B, 0xD2, 0x33, 0xAC, 0xB6, 0xE0, 0xF2, 0x39, 
	0x96, 0x72, 0x0C, 0x62, 0xB8, 0x18, 0x80, 0xCB, 0xF7, 0xB5, 0x17, 0x88, 0xD0, 0x8A, 0x76, 0xB0, 
	0xEB, 0xE8, 0x36, 0x6F, 0xCF, 0x5A, 0x3D, 0x09, 0xEA, 0xD3, 0x18, 0x9D, 0x3F, 0x01, 0x83, 0x3C, 
	0x70, 0x5A, 0xC0, 0xE0, 0x4C, 0x53, 0xE2, 0x50, 0x0A, 0x7C, 0x65, 0x80, 0x0B, 0x7D, 0x0F, 0x97, 
	0x10, 0x1C, 0xB3, 0xC8, 0x87, 0xD6, 0xD1, 0x84, 0x01, 0xD2, 0x26, 0xCF, 0x88, 0xD0, 0x4D, 0x8B, 
	0xAD, 0x6F, 0xA4, 0x06, 0x8C, 0x8D, 0x40, 0x4E, 0x6A, 0x26, 0xF3, 0x8C, 0xE9, 0xE2, 0xED, 0xCB, 
	0x25, 0x29, 0xD5, 0x6A, 0x7A, 0x66, 0xFA, 0xA7, 0x85, 0x3A, 0x4B, 0x08, 0x78, 0xA0, 0x9A, 0x7C, 
	0x7A, 0x2B, 0x9C, 0xA4, 0x46, 0xA6, 0x8A, 0xF9, 0x80, 0x68, 0xC2, 0xAD, 0xEA, 0xA9, 0x2C, 0x03, 
	0xC6, 0xD4, 0x0A, 0x0A, 0x4B, 0xF6, 0xB3, 0x90, 0x25, 0x49, 0x75, 0xB8, 0x46, 0x08, 0x89, 0xAC, 
	0x5F, 0x35, 0xFB, 0xA7, 0x79, 0xD3, 0x70, 0x4F, 0xFB, 0x5F, 0xFE, 0xE5, 0xB6, 0x76, 0x3A, 0x9C, 
	0x24, 0xBB, 0xDD, 0xC7, 0x76, 0x01, 0x23, 0xFF, 0x32, 0xBD, 0xBD, 0x5C, 0x88, 0xA1, 0xF1, 0x5D, 
	0xC9, 0x5C, 0x79, 0x7F, 0x5F, 0xE9, 0xEE, 0x3C, 0x13, 0x0A, 0x33, 0x97, 0xD6, 0x81, 0x39, 0xFF, 
	0x34, 0x50, 0x73, 0xD4, 0xAC, 0x2E, 0x3B, 0xDC, 0x8B, 0x23, 0xAC, 0x7E, 0xAC, 0x87, 0x9C, 0x2C, 
	0x97, 0xF2, 0x24, 0xF1, 0x13, 0x93, 0x7B, 0xB3, 0x89, 0xBC, 0x1F, 0xFB, 0xF8, 0xBE, 0x2F, 0x14, 
	0xCE, 0x54, 0x7E, 0xF6, 0x0D, 0x3B, 0xE9, 0xEC, 0xB0, 0xBE, 0x87, 0xA0, 0x04, 0x48, 0x93, 0x23, 
	0x63, 0x0B, 0x59, 0xD2, 0x96, 0x8A, 0x2E, 0x80, 0x68, 0x3C, 0xF4, 0x77, 0x4B, 0x98, 0x76, 0xBF, 
	0x07, 0x3D, 0x74, 0x85, 0x59, 0xAE, 0xBE, 0xB8
	};

	memcpy_s(DirBlob, 0x148, data, sizeof(data));*/

	printf("My %s DirBlob\n", User);
	showmem(DirBlob, 0x148);
	
	//Auto-Search To Verify Presence Brodcast
	Contact	UserC;

	ZeroMemory(&UserC, sizeof(UserC));
	UserC.Locations = new list<CLocation>;
	UserC.DisplayName = (uchar *)User;
	UserC.InternalName = (uchar *)User;
	UserC.BuddyStatus = 0;
	UserC.AuthCert = NULL;
	UserC.OnLineStatus = -1;
	Contacts.push(UserC);
	
	unsigned char data[347] = {
	0x00, 0x00, 0x00, 0xC4, 0x00, 0x00, 0x00, 0x00, 0xB1, 0x32, 0x04, 0x0E, 0x14, 0xFC, 0x4C, 0x6A, 
	0xD6, 0xE0, 0x6E, 0xA2, 0xAE, 0x20, 0x72, 0xC3, 0x62, 0xC4, 0x0D, 0x69, 0x52, 0x1E, 0xA2, 0x7E, 
	0x02, 0xD9, 0x76, 0xF0, 0xAE, 0x03, 0xF8, 0xB1, 0xE6, 0xC4, 0x20, 0x0E, 0xFB, 0x0D, 0x5E, 0x3F, 
	0x98, 0xB3, 0x71, 0xA8, 0x0B, 0x28, 0x97, 0x74, 0x65, 0xE2, 0xBD, 0xD0, 0x85, 0x12, 0xB6, 0xFD, 
	0xD3, 0xFA, 0xB6, 0x61, 0x42, 0x53, 0xFD, 0x08, 0xAA, 0xDF, 0xE1, 0xC7, 0x7C, 0x07, 0xDF, 0xC7, 
	0xF3, 0x75, 0xF4, 0x32, 0x92, 0xDB, 0xD0, 0x6B, 0x4A, 0xE0, 0xAF, 0x1E, 0xC2, 0x05, 0x14, 0x8C, 
	0x29, 0x65, 0xBF, 0x01, 0xEE, 0x55, 0x64, 0xD6, 0xF9, 0x3D, 0xC1, 0x20, 0x6A, 0x5A, 0x01, 0x74, 
	0x8D, 0x9A, 0xEA, 0x82, 0xF7, 0xB2, 0x45, 0x43, 0x15, 0x38, 0x88, 0x24, 0x1D, 0x88, 0x06, 0xB9, 
	0x4B, 0xA2, 0x44, 0xA2, 0xB2, 0x70, 0x19, 0xDC, 0x9C, 0x71, 0x32, 0xDF, 0xCE, 0x53, 0x9C, 0x8C, 
	0xB8, 0xBA, 0x48, 0xC2, 0xD9, 0x55, 0xA4, 0x84, 0x46, 0x8D, 0x82, 0x35, 0xD7, 0xBF, 0x80, 0x0A, 
	0xC6, 0x71, 0xA0, 0x5D, 0xCD, 0xCA, 0x87, 0x6F, 0xE0, 0x92, 0x66, 0x73, 0x61, 0xDE, 0x79, 0xC8, 
	0x3C, 0xFF, 0x7F, 0xA0, 0xCE, 0xDB, 0x9F, 0x9D, 0xE0, 0xD1, 0x30, 0x43, 0x0F, 0x54, 0x1E, 0xAC, 
	0x32, 0xE1, 0x20, 0xB7, 0x2A, 0x54, 0xD6, 0xE2, 0x40, 0x0B, 0x9A, 0xE1, 0x57, 0x7C, 0x97, 0x89, 
	0x66, 0x89, 0x62, 0x33, 0xBA, 0x8B, 0x73, 0xB6, 0xC4, 0x24, 0x88, 0x63, 0x16, 0x71, 0x2D, 0xFA, 
	0xDC, 0x1E, 0x0C, 0x56, 0x96, 0xF9, 0x5A, 0x08, 0x6E, 0x07, 0xFB, 0x45, 0x5B, 0x46, 0xD3, 0x86, 
	0xBF, 0x32, 0x2C, 0xDD, 0x3D, 0x51, 0x8C, 0x8C, 0x0D, 0xDA, 0xE4, 0xC1, 0x5A, 0xF6, 0x3C, 0xA4, 
	0xDF, 0x15, 0xE4, 0x26, 0x16, 0xA6, 0xF6, 0x38, 0xC9, 0x22, 0xCE, 0x88, 0xA7, 0xFB, 0x95, 0x02, 
	0x61, 0x99, 0xDE, 0xF3, 0xE9, 0xF8, 0x84, 0xF4, 0xF5, 0x68, 0xE1, 0xAD, 0xC0, 0x7F, 0x79, 0xFC, 
	0x04, 0x55, 0x43, 0xAF, 0x6F, 0x54, 0x2F, 0x83, 0x16, 0x06, 0x93, 0xFA, 0x0F, 0x83, 0x42, 0xDE, 
	0x64, 0x92, 0x79, 0x8D, 0x48, 0xAA, 0xC0, 0x07, 0xA5, 0x3B, 0x7B, 0xB6, 0x26, 0xA8, 0x6C, 0x07, 
	0x5E, 0x0D, 0xB3, 0x71, 0x97, 0xC2, 0xD6, 0xB6, 0x34, 0x62, 0x64, 0x66, 0x64, 0x36, 0x66, 0x30, 
	0x39, 0x32, 0x32, 0x00, 0x00, 0x4D, 0xDC, 0xA7, 0x9D, 0xB5, 0x04
	};
	
	DumpDirBlobMetaDatas(data, sizeof(data));
	
	unsigned char tdata[0x09] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x00};
	unsigned char RES[0x80] = {0};

	BuildUnFinalizedDatas(tdata, sizeof(tdata), RES);
	showmem(RES, 0x80);

	SHA_CTX	Context;
	uchar	Bufer[SHA_DIGEST_LENGTH] = {0};

	SHA1_Init(&Context);
	SHA1_Update(&Context, tdata, sizeof(tdata));
	SHA1_Final(Bufer, &Context);

	showmem(Bufer, SHA_DIGEST_LENGTH);

	ExitProcess(0);

	uint				Idx = 0;
	uchar				ivec[AES_BLOCK_SIZE] = {0};
	uchar				ecount_buf[AES_BLOCK_SIZE] = {0};
	uchar				SessionKey[SK_SZ] = {0};
	uchar				SHAResult[32] = {0};
	AES_KEY				AesKey;
	
	unsigned char data[601] = {
	0x10, 0x45, 0xC2, 0x3C, 0xE3, 0x4E, 0x89, 0x8A, 0x6C, 0x26, 0xA6, 0x15, 0x87, 0x4E, 0xAD, 0x5C, 
	0x3B, 0xEC, 0x43, 0x52, 0x0B, 0x44, 0x49, 0xB9, 0xA9, 0x62, 0xEA, 0x30, 0x96, 0x29, 0x20, 0x6E, 
	0xAD, 0x70, 0x41, 0x34, 0x75, 0x92, 0x6B, 0x11, 0xDC, 0xCB, 0xE5, 0xE5, 0xBA, 0xE8, 0x9A, 0x1D, 
	0x75, 0x21, 0x00, 0xC8, 0x3F, 0xFF, 0x66, 0x64, 0x00, 0x14, 0x62, 0x8E, 0x76, 0x8C, 0x6E, 0x8E, 
	0xCD, 0x4F, 0xB4, 0x2F, 0x0C, 0x49, 0xE3, 0x73, 0x59, 0xC5, 0x45, 0xAB, 0x01, 0x2F, 0x36, 0xF4, 
	0xE7, 0x20, 0xCB, 0xF1, 0x84, 0xBB, 0x69, 0x31, 0x61, 0x66, 0x1C, 0xE3, 0xB6, 0x80, 0x3B, 0x1F, 
	0xCE, 0xC2, 0x8F, 0x71, 0xDA, 0x3B, 0xB1, 0xC6, 0x63, 0x91, 0xA9, 0x03, 0x43, 0x91, 0x67, 0xA0, 
	0x78, 0xAF, 0x49, 0xB0, 0xC0, 0x4D, 0x07, 0x0A, 0x81, 0x6F, 0x32, 0x48, 0xC6, 0x4D, 0xF2, 0xDF, 
	0x96, 0xBB, 0xDA, 0xE9, 0x58, 0xF6, 0x3E, 0x46, 0xB8, 0x1D, 0x11, 0xDC, 0xD4, 0x34, 0x28, 0xBB, 
	0x73, 0x74, 0x1E, 0xD5, 0x0B, 0xF8, 0xE8, 0x4D, 0x1C, 0x9B, 0xC7, 0x49, 0xA8, 0xB3, 0x2F, 0x2A, 
	0xFD, 0x5A, 0x71, 0xEB, 0x4E, 0xD5, 0x93, 0x31, 0x3B, 0x46, 0x84, 0x6C, 0xAE, 0xAA, 0xF9, 0xA0, 
	0x4B, 0xCD, 0x79, 0x2F, 0x4B, 0x93, 0x99, 0x89, 0x3A, 0x7E, 0xAB, 0x94, 0x81, 0x1F, 0x88, 0x5D, 
	0x86, 0x2B, 0x20, 0x7E, 0xC0, 0xA7, 0xCF, 0xA8, 0x5F, 0x05, 0xF1, 0x55, 0xE1, 0x27, 0x5E, 0xEA, 
	0xD8, 0x0C, 0xBB, 0x70, 0x5D, 0x49, 0xCA, 0x78, 0x51, 0xC9, 0x05, 0xFF, 0x82, 0x65, 0x03, 0x7E, 
	0x72, 0xC0, 0x77, 0xC3, 0x36, 0x4B, 0x0D, 0x10, 0x0B, 0x59, 0x4A, 0x19, 0x17, 0xFA, 0xF3, 0x5C, 
	0xB9, 0x31, 0xEA, 0xE3, 0x53, 0x03, 0x0F, 0x42, 0x1B, 0x75, 0x61, 0x21, 0x45, 0x5A, 0xF4, 0x01, 
	0x68, 0x83, 0x5C, 0x82, 0x3E, 0xD4, 0x9F, 0x1E, 0xEC, 0x54, 0x88, 0x3F, 0xAC, 0x5F, 0x59, 0x37, 
	0xF0, 0x56, 0x79, 0x6B, 0x9E, 0xAD, 0xA9, 0x24, 0x13, 0xEE, 0xD7, 0x4A, 0x6C, 0xA1, 0xA4, 0xD9, 
	0x09, 0x8F, 0x21, 0x46, 0x6A, 0xC3, 0x5E, 0x9E, 0xD9, 0xC0, 0xC7, 0x91, 0x44, 0xCD, 0x4F, 0x59, 
	0xF0, 0xD4, 0x2B, 0xA6, 0x36, 0x0A, 0x33, 0xCD, 0x23, 0xA0, 0xAF, 0x14, 0x64, 0xE1, 0x4C, 0x92, 
	0x01, 0x05, 0xFA, 0x20, 0x18, 0x94, 0x1B, 0x16, 0x95, 0x21, 0xF7, 0x1B, 0x1D, 0xEE, 0xE2, 0xD2, 
	0x68, 0x5B, 0x20, 0xDE, 0x1E, 0xD4, 0x0D, 0x9E, 0x3A, 0xF7, 0x11, 0xBB, 0xC4, 0x6E, 0xAD, 0xD5, 
	0x87, 0x83, 0xAA, 0x4F, 0x29, 0x02, 0x66, 0x0C, 0xD1, 0x14, 0xCC, 0x69, 0x17, 0x94, 0xFB, 0xF8, 
	0xEE, 0xDB, 0xF4, 0xCB, 0xC1, 0x6F, 0xCD, 0xD5, 0xFA, 0x2A, 0x35, 0xF1, 0x58, 0x3C, 0x64, 0xE9, 
	0xCD, 0x2C, 0xCB, 0x6B, 0xDE, 0x7C, 0x7B, 0xA8, 0x0F, 0x96, 0x25, 0x14, 0x60, 0x84, 0x5D, 0x87, 
	0xCA, 0x76, 0xA0, 0xDA, 0xBC, 0xF1, 0x26, 0xCF, 0x07, 0xA3, 0xE9, 0x3A, 0xDD, 0x48, 0x0D, 0xAD, 
	0xC9, 0xC4, 0xE6, 0x10, 0x32, 0xDA, 0x21, 0x4B, 0x19, 0xAF, 0xAF, 0xDD, 0x26, 0x57, 0x1F, 0x97, 
	0xD5, 0x1B, 0x87, 0xDD, 0xFF, 0xB3, 0x43, 0x17, 0x8F, 0x15, 0xDB, 0x87, 0xEB, 0x71, 0xFF, 0xFB, 
	0xD3, 0xC2, 0x7D, 0xF8, 0x40, 0xEB, 0xBA, 0x61, 0x93, 0xD1, 0xB8, 0xC6, 0x7A, 0x48, 0x6D, 0xE3, 
	0x08, 0x2D, 0xB2, 0xF3, 0xCC, 0x60, 0x72, 0x17, 0x7B, 0x64, 0x58, 0xFC, 0x98, 0xFB, 0x6A, 0x19, 
	0x5E, 0x59, 0x71, 0x2C, 0x4F, 0x82, 0x68, 0xD9, 0x29, 0xB3, 0xCF, 0x34, 0xD1, 0x8B, 0xD5, 0x34, 
	0x72, 0xB7, 0x90, 0xC4, 0x76, 0x84, 0xCB, 0xC0, 0xD1, 0x1B, 0x1D, 0x2F, 0x50, 0x88, 0x5A, 0xEB, 
	0xEE, 0x18, 0x5B, 0xA4, 0x19, 0x2F, 0x9A, 0xC1, 0x59, 0xB0, 0xAA, 0x72, 0xCC, 0xB4, 0xD7, 0x21, 
	0x4D, 0xAC, 0xE9, 0x64, 0xA3, 0xB0, 0x92, 0xC3, 0x99, 0x43, 0xBF, 0x75, 0x25, 0x38, 0x6F, 0x8E, 
	0x95, 0x93, 0x4F, 0xC0, 0xA0, 0xC4, 0xD9, 0x45, 0x09, 0x36, 0xC9, 0x55, 0xBA, 0xB8, 0x96, 0xB2, 
	0x35, 0xA5, 0x21, 0x91, 0x31, 0x39, 0x13, 0x76, 0x54, 0x9D, 0x90, 0x8F, 0xD8, 0x72, 0x41, 0xAA, 
	0x76, 0xFD, 0x00, 0xB4, 0x54, 0x68, 0x96, 0x2C, 0xB2, 0x37, 0x18, 0xBB, 0x0B, 0xF7, 0xF9, 0xFF, 
	0x60, 0xEF, 0x60, 0xA3, 0xD0, 0xC5, 0x1E, 0x21, 0x39
	};

	/*unsigned char data[964] = {
	0x28, 0xF8, 0x85, 0x39, 0xAE, 0x40, 0x9F, 0x88, 0xAD, 0x52, 0xA3, 0x14, 0x8F, 0x5C, 0x21, 0x87, 
	0x4D, 0x0F, 0x8A, 0xF9, 0x3C, 0xD6, 0xAA, 0x48, 0xAA, 0x67, 0xB1, 0x39, 0xC6, 0xCB, 0x73, 0x8B, 
	0x0A, 0xA7, 0x40, 0x3D, 0x4D, 0xCB, 0xF5, 0x4F, 0x15, 0xE6, 0xC4, 0x55, 0x4A, 0x84, 0xF5, 0x8E, 
	0xE1, 0x7C, 0x9D, 0xD4, 0x63, 0x88, 0x3E, 0x3A, 0xE0, 0x47, 0x79, 0x2A, 0xB5, 0xD2, 0xD6, 0xBA, 
	0x59, 0x19, 0x14, 0xEA, 0x9F, 0xC0, 0x92, 0x4F, 0x34, 0x87, 0x2F, 0xA5, 0x38, 0x5A, 0x9E, 0x4E, 
	0x3E, 0x9C, 0x2D, 0xD8, 0x27, 0x64, 0x6C, 0x40, 0x28, 0xF0, 0x19, 0x9E, 0x5B, 0x91, 0xF9, 0x41, 
	0x81, 0xB7, 0x49, 0x95, 0x7B, 0x84, 0xC7, 0xD6, 0x58, 0x38, 0x88, 0xB4, 0xE2, 0x24, 0xA0, 0xBF, 
	0x90, 0xA0, 0xFE, 0x88, 0x4F, 0x95, 0x69, 0x49, 0x45, 0x3D, 0x99, 0x8F, 0x47, 0x3B, 0xB1, 0x1B, 
	0xB6, 0x9E, 0x62, 0x23, 0xAF, 0x0A, 0x69, 0x1B, 0xD9, 0x01, 0x0E, 0xF4, 0x32, 0x1A, 0x05, 0xE7, 
	0x21, 0xD6, 0x5E, 0x36, 0x51, 0xEF, 0x1E, 0x5D, 0x61, 0x77, 0x14, 0x1A, 0x0A, 0x71, 0x84, 0x1F, 
	0x3B, 0x25, 0x44, 0xCB, 0xCD, 0x61, 0x42, 0x10, 0xED, 0x7B, 0xD9, 0x4E, 0x0F, 0xB2, 0x59, 0xA3, 
	0xE2, 0xEC, 0x96, 0xDF, 0x68, 0xB8, 0x07, 0x0C, 0x19, 0xA4, 0x3D, 0x8E, 0x11, 0xCE, 0x51, 0x37, 
	0xF6, 0x28, 0x41, 0x31, 0x97, 0xD7, 0xB0, 0x62, 0xC0, 0xFB, 0x55, 0xF2, 0xA2, 0x2D, 0xC6, 0x03, 
	0xE2, 0xC4, 0x16, 0x7A, 0x26, 0x85, 0xD9, 0xE4, 0x81, 0x54, 0x95, 0x1A, 0xB9, 0x86, 0x45, 0xCB, 
	0xD3, 0x85, 0xFC, 0x7F, 0xA8, 0xC2, 0x0F, 0x25, 0xDA, 0x08, 0xA0, 0xE3, 0x62, 0xF1, 0x05, 0x70, 
	0x46, 0x99, 0xAA, 0x14, 0x8F, 0x00, 0xFD, 0x38, 0x47, 0xEA, 0xF4, 0x94, 0x16, 0xFB, 0xE5, 0xA1, 
	0x61, 0xF9, 0xF4, 0x67, 0x7F, 0xE3, 0xA3, 0xE6, 0x07, 0xFD, 0xA4, 0xA3, 0xA5, 0x22, 0x54, 0x80, 
	0x52, 0xA3, 0x46, 0x2A, 0x80, 0x93, 0xD5, 0xA0, 0x8C, 0xBB, 0xA6, 0x30, 0x8B, 0x46, 0x64, 0xB7, 
	0x3A, 0x35, 0xDB, 0x10, 0xE6, 0x4E, 0x64, 0x40, 0x06, 0x77, 0x8C, 0x02, 0x89, 0x44, 0xA6, 0xA5, 
	0x27, 0x12, 0xD4, 0xAC, 0x13, 0x24, 0xE0, 0x9B, 0x01, 0xAD, 0x2B, 0x29, 0x8A, 0xB8, 0xC4, 0x0F, 
	0xE7, 0x7F, 0xCD, 0x59, 0x09, 0x10, 0xDB, 0x4E, 0x33, 0x05, 0x3E, 0x78, 0x5D, 0x0E, 0x31, 0x59, 
	0xB7, 0xB2, 0xE5, 0x39, 0x22, 0x8D, 0x25, 0xC6, 0x94, 0x01, 0x4A, 0x0B, 0xCA, 0xF8, 0xE3, 0x23, 
	0x9D, 0xE8, 0x7E, 0x3C, 0xB9, 0x40, 0x20, 0xC9, 0x5B, 0xE0, 0x69, 0x9C, 0x15, 0x41, 0xF6, 0x07, 
	0x14, 0x43, 0xC0, 0xEE, 0xA6, 0xC0, 0x25, 0xAC, 0x63, 0x49, 0xF3, 0x9C, 0x08, 0x70, 0x7E, 0xA3, 
	0x03, 0xFF, 0x5F, 0x37, 0x99, 0x2E, 0x01, 0x8E, 0x3B, 0x1F, 0x94, 0x4D, 0x58, 0xE0, 0x70, 0x07, 
	0x2F, 0x4C, 0xF9, 0x93, 0xD1, 0x41, 0x19, 0x49, 0x55, 0xA0, 0xA3, 0x89, 0x51, 0xC0, 0x22, 0x7E, 
	0x65, 0xDC, 0xB6, 0x39, 0x63, 0x0A, 0xE5, 0x27, 0x49, 0x7A, 0x5B, 0x4D, 0x67, 0x2D, 0x24, 0x6D, 
	0x8C, 0xE9, 0x86, 0x9B, 0xB7, 0x74, 0x0D, 0xD3, 0x1D, 0xAB, 0x1A, 0xFB, 0xAA, 0x0D, 0x0D, 0x99, 
	0x26, 0x5E, 0x90, 0x51, 0xCA, 0xB3, 0x1F, 0x50, 0x7A, 0xD3, 0x89, 0xA9, 0x34, 0x31, 0x0C, 0x74, 
	0x7D, 0x93, 0x75, 0x1F, 0xCD, 0x91, 0xB7, 0xB6, 0x8C, 0xD8, 0xF7, 0x45, 0x60, 0xC7, 0x90, 0xF1, 
	0x3D, 0x34, 0x74, 0xE2, 0xA5, 0x95, 0xD8, 0x13, 0xB9, 0xCA, 0xBC, 0x5B, 0xB6, 0x37, 0xC9, 0x78, 
	0x8E, 0xFC, 0xB0, 0xF4, 0xD6, 0x24, 0xC7, 0xBD, 0x32, 0x39, 0xCF, 0xA7, 0xAE, 0x69, 0xD6, 0xFB, 
	0xF0, 0x15, 0x20, 0x0F, 0x1F, 0xDE, 0x55, 0xF6, 0x49, 0xBA, 0xFC, 0xCB, 0xA1, 0xD1, 0xEC, 0x74, 
	0xD7, 0xEE, 0x5A, 0x7A, 0x62, 0x64, 0xDC, 0xFD, 0x43, 0xCA, 0xA9, 0x71, 0xF6, 0x0C, 0x08, 0x0E, 
	0x10, 0x63, 0x69, 0xED, 0xEF, 0xF9, 0x1F, 0x74, 0x8C, 0x8F, 0xC5, 0x3B, 0x5B, 0x49, 0x59, 0xF9, 
	0xAE, 0xF3, 0x8E, 0x50, 0x58, 0x50, 0x68, 0x15, 0x36, 0x89, 0xC5, 0xFB, 0x0D, 0x56, 0xA8, 0xC9, 
	0x72, 0xAC, 0x7A, 0x7D, 0x33, 0x83, 0x3C, 0x72, 0xEE, 0x8B, 0x24, 0xFB, 0x7E, 0x80, 0xD4, 0x89, 
	0xA6, 0x10, 0xE7, 0x56, 0xD9, 0x53, 0x6C, 0x8C, 0x35, 0x9C, 0xDD, 0x6A, 0x89, 0xBE, 0x06, 0x17, 
	0x87, 0x9D, 0x21, 0x28, 0x41, 0x6F, 0x16, 0x4E, 0xD5, 0xF0, 0x18, 0x1E, 0x23, 0x04, 0xC6, 0x47, 
	0xF1, 0x38, 0xA9, 0xEE, 0x8D, 0xA5, 0xDF, 0x5C, 0x86, 0x22, 0xDC, 0xCE, 0x87, 0xE7, 0xA1, 0xB1, 
	0xEA, 0xB7, 0x60, 0x95, 0x86, 0xF6, 0x5D, 0xEA, 0x58, 0xE9, 0x1F, 0x9E, 0x8B, 0x27, 0xFD, 0xCC, 
	0x6E, 0xF3, 0x65, 0x3C, 0xCF, 0xBA, 0x46, 0xAE, 0x68, 0x82, 0xA9, 0x3C, 0x6C, 0xC8, 0xD1, 0x98, 
	0xF8, 0xE6, 0xDD, 0xB3, 0xA1, 0xDB, 0x51, 0x29, 0x5E, 0xE6, 0xD0, 0x07, 0xB3, 0xE2, 0xD9, 0x68, 
	0xAB, 0xA4, 0xD0, 0x42, 0x3D, 0x37, 0xD1, 0x7B, 0x6E, 0xAF, 0x77, 0xCE, 0x0E, 0x5C, 0x95, 0x6A, 
	0xD8, 0xCB, 0xC3, 0xDE, 0xBE, 0xDE, 0xA5, 0x17, 0x44, 0x7C, 0x42, 0x88, 0x23, 0xD4, 0xF4, 0xFE, 
	0x36, 0xF0, 0x65, 0xDA, 0x45, 0x60, 0x7C, 0x7A, 0x31, 0x09, 0xA2, 0xD0, 0x6E, 0x21, 0x65, 0x13, 
	0x40, 0xEC, 0xE8, 0x7A, 0x45, 0x38, 0xFF, 0x82, 0x9C, 0x63, 0x85, 0x9B, 0xE3, 0x65, 0xD0, 0x37, 
	0x5B, 0xFE, 0xAB, 0x34, 0xFB, 0x22, 0x48, 0x6F, 0xE0, 0x51, 0x16, 0x39, 0x55, 0x43, 0x70, 0xC9, 
	0x29, 0x76, 0x0E, 0xBD, 0x3A, 0x30, 0xF3, 0x16, 0xF0, 0x34, 0x7D, 0x50, 0xA6, 0x1D, 0x4E, 0xCD, 
	0x8F, 0x5C, 0x58, 0x52, 0xDB, 0xBB, 0x11, 0x03, 0x05, 0xC8, 0x25, 0x57, 0x94, 0xB1, 0xAC, 0x84, 
	0x88, 0x11, 0x34, 0x3F, 0x85, 0x8E, 0x48, 0x8F, 0x60, 0x5A, 0x79, 0x0C, 0x86, 0x7E, 0x39, 0xD0, 
	0xB9, 0x6C, 0xFC, 0x38, 0xD1, 0xA3, 0xBE, 0x45, 0xDC, 0xC8, 0x6C, 0x05, 0x95, 0x82, 0x38, 0xAE, 
	0x85, 0x22, 0xB7, 0x36, 0x2C, 0xE9, 0x9F, 0x10, 0xB5, 0x9C, 0xFB, 0xAA, 0xF0, 0x28, 0xF5, 0x0A, 
	0x79, 0x1E, 0xB9, 0xF8, 0x90, 0xDE, 0x06, 0xFF, 0xEF, 0x0C, 0x2D, 0xD2, 0xD3, 0x34, 0x4E, 0x45, 
	0x5D, 0xEB, 0x1E, 0xAE, 0x26, 0xBD, 0xDE, 0xE8, 0x33, 0x49, 0x9D, 0x9B, 0xF6, 0xDA, 0x0E, 0x88, 
	0x3E, 0xD5, 0xA1, 0x4B, 0x33, 0x89, 0x51, 0x16, 0x75, 0xD0, 0x96, 0xED, 0x6A, 0xBE, 0x41, 0x5F, 
	0xE6, 0xAA, 0x8A, 0x1E, 0xE7, 0xD4, 0x3E, 0x7E, 0x4B, 0x1E, 0x2D, 0xB1, 0x06, 0xD4, 0xCB, 0x21, 
	0x68, 0xE2, 0x87, 0x63, 0x40, 0xFC, 0x6B, 0xC5, 0x73, 0x1C, 0x53, 0xA7, 0xAE, 0x2E, 0xF5, 0x70, 
	0x22, 0xE2, 0x71, 0x6C, 0xF9, 0x6A, 0x85, 0x38, 0x45, 0xD6, 0xC0, 0x0F, 0x2A, 0x0A, 0xFB, 0xD4, 
	0x50, 0x25, 0x3A, 0xEB, 0x4A, 0x35, 0x3B, 0x9A, 0xE0, 0xDD, 0xAB, 0xFB, 0xDD, 0xDE, 0x70, 0x7E, 
	0x6B, 0x63, 0xBA, 0xB4
	};*/

	GetSessionKey(SessionKey);

	//SpecialSHA(SessionKey, 0xC0, SHAResult, 32);
	AES_set_encrypt_key(SHAResult, 256, &AesKey);

	Idx = 0;
	ZeroMemory(ivec, AES_BLOCK_SIZE);
	ZeroMemory(ecount_buf, AES_BLOCK_SIZE);
	AES_ctr128_encrypt(data, data, sizeof(data), &AesKey, ivec, ecount_buf, &Idx);

	//showmem(data, sizeof(data));
	//printf("\n");

	uchar		*Buffer;
	uchar		*DirBlob;
	uchar		*RSAeD;
	uint		Size, DbSz, RdSz;
	SResponse	Response;

	Buffer = data + 4;
	Size = sizeof(data) - 4;

	ZeroMemory(&Response, sizeof(Response));
	ManageObjects(&Buffer, Size, &Response);
	for (Idx = 0; Idx < Response.NbObj; Idx++)
	{
		DumpObj(Response.Objs[Idx]);
		if (Response.Objs[Idx].Id == 0x05)
		{
			DirBlob = MemDup(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
			DbSz = Response.Objs[Idx].Value.Memory.MsZ;
		}
		if (Response.Objs[Idx].Id == 0x0A)
		{
			RSAeD = MemDup(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
			RdSz = Response.Objs[Idx].Value.Memory.MsZ;
		}
	}
	printf("---\n");

	DumpDirBlobMetaDatas(DirBlob, DbSz);

	unsigned char RsaKey[128] = {
	0xAA, 0x6F, 0x53, 0xA0, 0x66, 0xC2, 0x8A, 0x85, 0x71, 0xB2, 0x8D, 0xB1, 0x34, 0x54, 0x0A, 0xE0, 
	0xE5, 0x6A, 0x1B, 0xB7, 0x03, 0x36, 0xAF, 0x3A, 0x24, 0x76, 0x42, 0x95, 0xBD, 0x6A, 0xED, 0x07, 
	0x41, 0x2C, 0xA9, 0x01, 0x13, 0x8C, 0xB0, 0xA2, 0x82, 0x9A, 0xF4, 0x27, 0x2C, 0x00, 0xC6, 0x45, 
	0x96, 0xFA, 0x95, 0x47, 0x40, 0x19, 0xD0, 0x53, 0xC2, 0xB1, 0xAE, 0x5F, 0x72, 0x3A, 0x1D, 0x03, 
	0x4D, 0x89, 0x8F, 0x9F, 0x15, 0xC9, 0x30, 0x34, 0x58, 0x98, 0x70, 0x68, 0x3D, 0x52, 0x22, 0x74, 
	0x7D, 0xC6, 0x02, 0x8D, 0x74, 0x3F, 0x2E, 0x9E, 0xFC, 0xC2, 0x88, 0x19, 0x41, 0x9D, 0x5A, 0xCA, 
	0xAA, 0x01, 0xA3, 0xCD, 0x7C, 0xEC, 0x93, 0xF7, 0x1C, 0x6C, 0xCF, 0x3B, 0xA0, 0xD3, 0x8E, 0xEB, 
	0xFA, 0x9A, 0x4A, 0xD7, 0x9F, 0x76, 0x07, 0x2B, 0x7A, 0x62, 0x93, 0x23, 0x41, 0x5F, 0xEE, 0xB1
	};

	uchar			UnRSA[0xFFF];
	RSA				*SkypeRSA;
	uchar			*PostProcessed;
	char			*Key;
	uint			PPsZ, KeyIdx, Save;
	int				Suite;

	SkypeRSA = RSA_new();
	BN_hex2bn(&(SkypeRSA->n), Bin2HexStr(RsaKey, MODULUS_SZ));
	BN_hex2bn(&(SkypeRSA->e), "10001");
	PPsZ = RdSz;
	RdSz -= PPsZ;
	Save = PPsZ;
	PPsZ = 0x80;
	ZeroMemory(UnRSA, 0xFFF);
	PPsZ = RSA_public_decrypt(PPsZ, RSAeD, UnRSA, SkypeRSA, RSA_NO_PADDING);
	RSA_free(SkypeRSA);

	Suite = Save - PPsZ;
	RSAeD += PPsZ;
	PostProcessed = FinalizeLoginDatas(UnRSA, &PPsZ, (Suite > 0) ? RSAeD : NULL, Suite);

	if (PostProcessed == NULL)
	{
		printf("Bad Datas [METADATAS] Finalization..\n");
		return 0;
	}

	//PostProcessed += SHA_DIGEST_LENGTH;
	//PPsZ -= SHA_DIGEST_LENGTH;

	printf("---\n");
	showmem(PostProcessed, PPsZ);

	unsigned char dataa[85] = {
	0xA6, 0x01, 0x5C, 0xCB, 0x4E, 0x9A, 0x04, 0x5C, 0xCA, 0x42, 0xDB, 0xD0, 0xA4, 0x89, 0xEB, 0x7A, 
	0xA3, 0x40, 0xB6, 0x68, 0xFD, 0x3D, 0x95, 0x72, 0xA8, 0x9B, 0x45, 0xBD, 0x52, 0x6E, 0x68, 0x9A, 
	0xD5, 0xCB, 0xBD, 0x1B, 0x96, 0x0A, 0x99, 0x59, 0x7B, 0x3F, 0x78, 0x14, 0xCC, 0xAB, 0x42, 0x20, 
	0xCB, 0x46, 0x2B, 0x4B, 0x01, 0xC0, 0xA8, 0x01, 0x83, 0x37, 0x2C, 0x55, 0x82, 0x96, 0x2E, 0x9D, 
	0x83, 0xD1, 0x10, 0x4C, 0x59, 0x97, 0xB6, 0x8F, 0x1C, 0x2D, 0x18, 0x23, 0x46, 0xB9, 0xCF, 0x92, 
	0xED, 0x59, 0x25, 0xE8, 0x28
	};

	DumpTCPPacketObjs(dataa, sizeof(dataa));

	ExitProcess(0);
	
	**********************************
	
	uint				Idx = 0;
	uchar				ivec[AES_BLOCK_SIZE] = {0};
	uchar				ecount_buf[AES_BLOCK_SIZE] = {0};
	uchar				SessionKey[SK_SZ] = {0};
	uchar				SHAResult[32] = {0};
	AES_KEY				AesKey;

	unsigned char data[568] = {
	0x9D, 0x9B, 0xC0, 0x7B, 0x74, 0x13, 0x8D, 0x88, 0xB8, 0xE9, 0x2C, 0x92, 0x8D, 0xE4, 0xD9, 0x82, 
	0x7B, 0x0E, 0xF5, 0xFB, 0xC7, 0x44, 0xF5, 0xD0, 0xE5, 0x15, 0xA3, 0xB9, 0xA1, 0xEA, 0x72, 0x82, 
	0xF1, 0xB7, 0xA9, 0x29, 0x0B, 0x7B, 0x98, 0x7B, 0x07, 0x55, 0xC2, 0xD6, 0xBD, 0xB2, 0x9E, 0x18, 
	0x71, 0xE9, 0x02, 0xCA, 0x27, 0xA3, 0x28, 0x7C, 0x80, 0x9A, 0x41, 0xA5, 0x24, 0xAD, 0x30, 0x89, 
	0x9C, 0x49, 0xB1, 0x2B, 0xEE, 0xDE, 0xE0, 0x7B, 0x51, 0xEB, 0x5B, 0x2C, 0x93, 0x06, 0x90, 0x38, 
	0xFA, 0x50, 0xCB, 0xF7, 0x80, 0xBB, 0x65, 0x31, 0x61, 0x61, 0x1D, 0xE3, 0xB5, 0x0C, 0x3A, 0x1D, 
	0x6E, 0x0A, 0x2B, 0xAB, 0x2E, 0xAC, 0x28, 0xFF, 0x62, 0x95, 0xAC, 0xE0, 0x85, 0x91, 0x67, 0xA0, 
	0xBC, 0x18, 0xF5, 0x62, 0xCF, 0xDB, 0xE0, 0x69, 0x15, 0x0A, 0x66, 0x98, 0xBA, 0x85, 0xC3, 0xE1, 
	0x6B, 0x4A, 0xF8, 0xA8, 0x9A, 0x9A, 0xE5, 0x2B, 0x55, 0x10, 0x96, 0x0D, 0x8A, 0x8F, 0x3F, 0xA2, 
	0xD1, 0x2B, 0xC7, 0x2C, 0x9B, 0x43, 0xD6, 0x29, 0x87, 0x0C, 0xD8, 0x13, 0xD4, 0x82, 0x5F, 0x5D, 
	0x8C, 0xCD, 0xBB, 0xC2, 0x11, 0xAE, 0x6A, 0xD0, 0xDB, 0x99, 0x98, 0x0D, 0x6E, 0xEB, 0x82, 0xF9, 
	0x63, 0x00, 0x46, 0xC3, 0x14, 0xCB, 0x92, 0xB9, 0xD6, 0x8B, 0xD5, 0xE7, 0x4B, 0x21, 0x85, 0x64, 
	0x60, 0x11, 0x63, 0x1C, 0x5D, 0xF8, 0x66, 0x6D, 0x45, 0x0C, 0x4C, 0xF1, 0x94, 0x75, 0x89, 0x56, 
	0x45, 0x67, 0xFD, 0x97, 0xA0, 0xC9, 0xF9, 0x20, 0xD0, 0x9D, 0x32, 0xF7, 0x8F, 0x01, 0x81, 0x69, 
	0xCA, 0x7E, 0xAD, 0x6D, 0xE7, 0x63, 0x5D, 0x2B, 0x47, 0xAA, 0xB4, 0xE7, 0xD6, 0x9E, 0xD1, 0xCC, 
	0x05, 0xDA, 0xB5, 0xAB, 0xB1, 0x43, 0x3D, 0xD2, 0x61, 0xBB, 0xA4, 0x36, 0x44, 0x8C, 0x43, 0x49, 
	0x53, 0x8B, 0xD8, 0x67, 0xE5, 0xF2, 0xF4, 0xC6, 0xFD, 0xE3, 0xC0, 0x54, 0x1A, 0x67, 0x3B, 0x3E, 
	0x68, 0x1D, 0xCC, 0xC2, 0x8B, 0x4A, 0xDC, 0x3D, 0xC8, 0xEB, 0x92, 0x44, 0x19, 0x80, 0xA3, 0x59, 
	0xC9, 0x17, 0x65, 0xF3, 0x92, 0xD4, 0xB7, 0x5E, 0xD1, 0x64, 0x1B, 0xD4, 0x41, 0xE8, 0x7C, 0x17, 
	0xEF, 0x60, 0x0B, 0x17, 0x60, 0x1B, 0x90, 0x8F, 0x0F, 0xD5, 0x2D, 0x61, 0x29, 0xE8, 0x49, 0x94, 
	0xA4, 0x1C, 0x8E, 0xB0, 0xD6, 0x2B, 0x45, 0x8F, 0x98, 0x28, 0xA3, 0x55, 0x9F, 0x3D, 0x6D, 0xF2, 
	0x78, 0x25, 0xA4, 0x05, 0xB8, 0xED, 0xDD, 0xD8, 0x69, 0x62, 0x54, 0x8D, 0x4A, 0x9B, 0x61, 0x12, 
	0x16, 0x1F, 0x63, 0xE0, 0xDE, 0x34, 0x05, 0x09, 0xE8, 0x62, 0xAC, 0xFF, 0xAB, 0x82, 0xAE, 0x9D, 
	0x7A, 0x03, 0xAD, 0xAB, 0xDD, 0x22, 0x5E, 0x8F, 0x61, 0xD4, 0x5A, 0x65, 0x3C, 0x9F, 0x62, 0x60, 
	0xFC, 0x01, 0xE1, 0xF5, 0x60, 0x39, 0x51, 0x55, 0x6C, 0x7A, 0x4D, 0xB9, 0xDC, 0xD5, 0xE5, 0x19, 
	0x0B, 0x06, 0x6B, 0x7D, 0xF4, 0x3E, 0x31, 0x5D, 0xFC, 0x5B, 0x43, 0x66, 0xFF, 0x8C, 0x0D, 0x5D, 
	0xC0, 0x3A, 0x11, 0x79, 0x51, 0x0B, 0xC8, 0xC3, 0x96, 0x8F, 0x60, 0x5C, 0x2D, 0xBE, 0x5B, 0x50, 
	0x3B, 0xB4, 0xBE, 0xDA, 0xD9, 0xDB, 0xF5, 0x23, 0xDA, 0x3B, 0x7D, 0x2B, 0xF2, 0xDC, 0x22, 0x64, 
	0x8F, 0x71, 0xA2, 0xCD, 0x94, 0x6E, 0xFE, 0x99, 0x12, 0xDF, 0x94, 0x49, 0x9C, 0x3C, 0xFD, 0x4F, 
	0xBB, 0x10, 0x18, 0x9E, 0x4E, 0x37, 0x51, 0x66, 0x3B, 0xD5, 0xCC, 0x52, 0xA5, 0xD3, 0x4E, 0x4F, 
	0xF2, 0x6E, 0x85, 0x63, 0xBB, 0x08, 0x86, 0x4F, 0x33, 0xDE, 0x55, 0xBF, 0xCE, 0x8F, 0xB7, 0x67, 
	0x53, 0x27, 0xF4, 0x4F, 0x10, 0xB7, 0x90, 0x1D, 0x54, 0x10, 0x1D, 0xF1, 0x67, 0xE5, 0xF0, 0x9E, 
	0x7A, 0x2D, 0x53, 0x13, 0x22, 0xB8, 0xE0, 0xC1, 0x25, 0x38, 0xDF, 0x05, 0xC5, 0x6F, 0x30, 0x50, 
	0x1F, 0x01, 0xA7, 0x1F, 0xC2, 0xB8, 0xF0, 0xB4, 0xB6, 0x13, 0xF5, 0x80, 0x11, 0x6B, 0x06, 0x15, 
	0xA2, 0x7F, 0x98, 0xD0, 0xCF, 0x3A, 0xB3, 0xEC, 0xA1, 0x24, 0xF2, 0x79, 0xBA, 0xBE, 0xF8, 0x7C, 
	0x3D, 0x21, 0xA0, 0xF2, 0xFA, 0x31, 0x15, 0x6F
	};
	
	GetSessionKey(SessionKey);

	//SpecialSHA(SessionKey, 0xC0, SHAResult, 32);
	AES_set_encrypt_key(SHAResult, 256, &AesKey);

	Idx = 0;
	ZeroMemory(ivec, AES_BLOCK_SIZE);
	ZeroMemory(ecount_buf, AES_BLOCK_SIZE);
	AES_ctr128_encrypt(data, data, sizeof(data), &AesKey, ivec, ecount_buf, &Idx);

	//showmem(data, sizeof(data));
	//printf("\n");

	uchar		*Buffer;
	uchar		*DirBlob;
	uchar		*RSAeD;
	uint		Size, DbSz, RdSz;
	SResponse	Response;

	Buffer = data;
	Size = sizeof(data);

	ZeroMemory(&Response, sizeof(Response));
	ManageObjects(&Buffer, Size, &Response);
	for (Idx = 0; Idx < Response.NbObj; Idx++)
	{
		DumpObj(Response.Objs[Idx]);
		if (Response.Objs[Idx].Id == 0x05)
		{
			DirBlob = MemDup(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
			DbSz = Response.Objs[Idx].Value.Memory.MsZ;
		}
		if (Response.Objs[Idx].Id == 0x0A)
		{
			RSAeD = MemDup(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
			RdSz = Response.Objs[Idx].Value.Memory.MsZ;
		}
	}
	printf("---\n");

	DumpDirBlobMetaDatas(DirBlob, DbSz);

	unsigned char RsaKey[128] = {
	0xC6, 0x31, 0x97, 0xDB, 0x55, 0x82, 0x39, 0x9D, 0xBC, 0xFB, 0x33, 0xF7, 0xB3, 0x6B, 0x6A, 0x92, 
	0x01, 0xFD, 0xC3, 0xA4, 0x17, 0x77, 0xFC, 0xA0, 0x40, 0x44, 0x54, 0x73, 0x2E, 0x55, 0x73, 0x7C, 
	0x0F, 0xAF, 0xC1, 0x42, 0x06, 0xF1, 0x37, 0x71, 0x92, 0x96, 0xBE, 0x1F, 0xDB, 0x52, 0xA8, 0x5C, 
	0x60, 0xAA, 0x67, 0xBD, 0x54, 0x5D, 0x4C, 0x63, 0x23, 0x60, 0x17, 0x21, 0xED, 0x00, 0x78, 0xD4, 
	0x8D, 0xE2, 0x61, 0x6C, 0xC8, 0xB5, 0x21, 0xAB, 0x48, 0x64, 0xE5, 0xF2, 0x2B, 0xB7, 0xE1, 0x02, 
	0xCA, 0x54, 0x8F, 0x86, 0x8D, 0xEA, 0xE9, 0xC8, 0xC3, 0xA3, 0xD2, 0x95, 0x23, 0x7B, 0x7A, 0x56, 
	0xEC, 0x34, 0x62, 0xFA, 0x4B, 0x55, 0x3B, 0x3F, 0x60, 0x5A, 0x50, 0xF0, 0xCB, 0x4E, 0xB0, 0x75, 
	0x8B, 0xFF, 0xB9, 0x2C, 0x4F, 0xDE, 0x2B, 0xFE, 0xC6, 0xD7, 0x15, 0x22, 0xF1, 0xB1, 0xD4, 0x79
	};

	uchar			UnRSA[0xFFF];
	RSA				*SkypeRSA;
	uchar			*PostProcessed;
	char			*Key;
	uint			PPsZ, KeyIdx, Save;
	int				Suite;

	SkypeRSA = RSA_new();
	BN_hex2bn(&(SkypeRSA->n), Bin2HexStr(RsaKey, MODULUS_SZ));
	BN_hex2bn(&(SkypeRSA->e), "10001");
	PPsZ = RdSz;
	RdSz -= PPsZ;
	Save = PPsZ;
	PPsZ = 0x80;
	ZeroMemory(UnRSA, 0xFFF);
	PPsZ = RSA_public_decrypt(PPsZ, RSAeD, UnRSA, SkypeRSA, RSA_NO_PADDING);
	RSA_free(SkypeRSA);

	Suite = Save - PPsZ;
	RSAeD += PPsZ;
	PostProcessed = FinalizeLoginDatas(UnRSA, &PPsZ, (Suite > 0) ? RSAeD : NULL, Suite);

	if (PostProcessed == NULL)
	{
		printf("Bad Datas [METADATAS] Finalization..\n");
		return 0;
	}

	//PostProcessed += SHA_DIGEST_LENGTH;
	//PPsZ -= SHA_DIGEST_LENGTH;

	printf("---\n");
	showmem(PostProcessed, PPsZ);

	ExitProcess(0);
	
	******************************************
	
		printf("-> 0x%x\n", Crc32);

	*Browser++ = *((uchar *)(&Crc32) + 0);
	*Browser++ = *((uchar *)(&Crc32) + 1);

	Size += 2;

	Crc32 = crc32(Mark, Size, -1);
	printf("-> 0x%x\n", Crc32);

unsigned char dataa[85] = {
	0xA6, 0x01, 0x5C, 0xCB, 0x4E, 0x9A, 0x04, 0x5C, 0xCA, 0x42, 0xDB, 0xD0, 0xA4, 0x89, 0xEB, 0x7A, 
	0xA3, 0x40, 0xB6, 0x68, 0xFD, 0x3D, 0x95, 0x72, 0xA8, 0x9B, 0x45, 0xBD, 0x52, 0x6E, 0x68, 0x9A, 
	0xD5, 0xCB, 0xBD, 0x1B, 0x96, 0x0A, 0x99, 0x59, 0x7B, 0x3F, 0x78, 0x14, 0xCC, 0xAB, 0x42, 0x20, 
	0xCB, 0x46, 0x2B, 0x4B, 0x01, 0xC0, 0xA8, 0x01, 0x83, 0x37, 0x2C, 0x55, 0x82, 0x96, 0x2E, 0x9D, 
	0x83, 0xD1, 0x10, 0x4C, 0x59, 0x97, 0xB6, 0x8F, 0x1C, 0x2D, 0x18, 0x23, 0x46, 0xB9, 0xCF, 0x92, 
	0xED, 0x59, 0x25, 0xE8, 0x28
	};

	//DumpTCPPacketObjs(dataa, sizeof(dataa));

	unsigned char data[5] = {
	0x42, 0x6A, 0xC2, 0xE2, 0xF9
	};

	uchar		*Buffer;
	uint		Size, Idx;
	SResponse	Response;

	Buffer = data;
	Size = sizeof(data);

	Response.Objs = NULL;
	Response.NbObj = 0;

	ManageObjects(&Buffer, Size, &Response);
	for (Idx = 0; Idx < Response.NbObj; Idx++)
	{
		DumpObj(Response.Objs[Idx]);
	}
	printf("\n");

	ExitProcess(0);
	
	*****************************************************************
	
	uint				Idx = 0;
	uchar				ivec[AES_BLOCK_SIZE] = {0};
	uchar				ecount_buf[AES_BLOCK_SIZE] = {0};
	uchar				SessionKey[SK_SZ] = {0};
	uchar				SHAResult[32] = {0};
	AES_KEY				AesKey;
	
	/*unsigned char data[601] = {
	0x10, 0x45, 0xC2, 0x3C, 0xE3, 0x4E, 0x89, 0x8A, 0x6C, 0x26, 0xA6, 0x15, 0x87, 0x4E, 0xAD, 0x5C, 
	0x3B, 0xEC, 0x43, 0x52, 0x0B, 0x44, 0x49, 0xB9, 0xA9, 0x62, 0xEA, 0x30, 0x96, 0x29, 0x20, 0x6E, 
	0xAD, 0x70, 0x41, 0x34, 0x75, 0x92, 0x6B, 0x11, 0xDC, 0xCB, 0xE5, 0xE5, 0xBA, 0xE8, 0x9A, 0x1D, 
	0x75, 0x21, 0x00, 0xC8, 0x3F, 0xFF, 0x66, 0x64, 0x00, 0x14, 0x62, 0x8E, 0x76, 0x8C, 0x6E, 0x8E, 
	0xCD, 0x4F, 0xB4, 0x2F, 0x0C, 0x49, 0xE3, 0x73, 0x59, 0xC5, 0x45, 0xAB, 0x01, 0x2F, 0x36, 0xF4, 
	0xE7, 0x20, 0xCB, 0xF1, 0x84, 0xBB, 0x69, 0x31, 0x61, 0x66, 0x1C, 0xE3, 0xB6, 0x80, 0x3B, 0x1F, 
	0xCE, 0xC2, 0x8F, 0x71, 0xDA, 0x3B, 0xB1, 0xC6, 0x63, 0x91, 0xA9, 0x03, 0x43, 0x91, 0x67, 0xA0, 
	0x78, 0xAF, 0x49, 0xB0, 0xC0, 0x4D, 0x07, 0x0A, 0x81, 0x6F, 0x32, 0x48, 0xC6, 0x4D, 0xF2, 0xDF, 
	0x96, 0xBB, 0xDA, 0xE9, 0x58, 0xF6, 0x3E, 0x46, 0xB8, 0x1D, 0x11, 0xDC, 0xD4, 0x34, 0x28, 0xBB, 
	0x73, 0x74, 0x1E, 0xD5, 0x0B, 0xF8, 0xE8, 0x4D, 0x1C, 0x9B, 0xC7, 0x49, 0xA8, 0xB3, 0x2F, 0x2A, 
	0xFD, 0x5A, 0x71, 0xEB, 0x4E, 0xD5, 0x93, 0x31, 0x3B, 0x46, 0x84, 0x6C, 0xAE, 0xAA, 0xF9, 0xA0, 
	0x4B, 0xCD, 0x79, 0x2F, 0x4B, 0x93, 0x99, 0x89, 0x3A, 0x7E, 0xAB, 0x94, 0x81, 0x1F, 0x88, 0x5D, 
	0x86, 0x2B, 0x20, 0x7E, 0xC0, 0xA7, 0xCF, 0xA8, 0x5F, 0x05, 0xF1, 0x55, 0xE1, 0x27, 0x5E, 0xEA, 
	0xD8, 0x0C, 0xBB, 0x70, 0x5D, 0x49, 0xCA, 0x78, 0x51, 0xC9, 0x05, 0xFF, 0x82, 0x65, 0x03, 0x7E, 
	0x72, 0xC0, 0x77, 0xC3, 0x36, 0x4B, 0x0D, 0x10, 0x0B, 0x59, 0x4A, 0x19, 0x17, 0xFA, 0xF3, 0x5C, 
	0xB9, 0x31, 0xEA, 0xE3, 0x53, 0x03, 0x0F, 0x42, 0x1B, 0x75, 0x61, 0x21, 0x45, 0x5A, 0xF4, 0x01, 
	0x68, 0x83, 0x5C, 0x82, 0x3E, 0xD4, 0x9F, 0x1E, 0xEC, 0x54, 0x88, 0x3F, 0xAC, 0x5F, 0x59, 0x37, 
	0xF0, 0x56, 0x79, 0x6B, 0x9E, 0xAD, 0xA9, 0x24, 0x13, 0xEE, 0xD7, 0x4A, 0x6C, 0xA1, 0xA4, 0xD9, 
	0x09, 0x8F, 0x21, 0x46, 0x6A, 0xC3, 0x5E, 0x9E, 0xD9, 0xC0, 0xC7, 0x91, 0x44, 0xCD, 0x4F, 0x59, 
	0xF0, 0xD4, 0x2B, 0xA6, 0x36, 0x0A, 0x33, 0xCD, 0x23, 0xA0, 0xAF, 0x14, 0x64, 0xE1, 0x4C, 0x92, 
	0x01, 0x05, 0xFA, 0x20, 0x18, 0x94, 0x1B, 0x16, 0x95, 0x21, 0xF7, 0x1B, 0x1D, 0xEE, 0xE2, 0xD2, 
	0x68, 0x5B, 0x20, 0xDE, 0x1E, 0xD4, 0x0D, 0x9E, 0x3A, 0xF7, 0x11, 0xBB, 0xC4, 0x6E, 0xAD, 0xD5, 
	0x87, 0x83, 0xAA, 0x4F, 0x29, 0x02, 0x66, 0x0C, 0xD1, 0x14, 0xCC, 0x69, 0x17, 0x94, 0xFB, 0xF8, 
	0xEE, 0xDB, 0xF4, 0xCB, 0xC1, 0x6F, 0xCD, 0xD5, 0xFA, 0x2A, 0x35, 0xF1, 0x58, 0x3C, 0x64, 0xE9, 
	0xCD, 0x2C, 0xCB, 0x6B, 0xDE, 0x7C, 0x7B, 0xA8, 0x0F, 0x96, 0x25, 0x14, 0x60, 0x84, 0x5D, 0x87, 
	0xCA, 0x76, 0xA0, 0xDA, 0xBC, 0xF1, 0x26, 0xCF, 0x07, 0xA3, 0xE9, 0x3A, 0xDD, 0x48, 0x0D, 0xAD, 
	0xC9, 0xC4, 0xE6, 0x10, 0x32, 0xDA, 0x21, 0x4B, 0x19, 0xAF, 0xAF, 0xDD, 0x26, 0x57, 0x1F, 0x97, 
	0xD5, 0x1B, 0x87, 0xDD, 0xFF, 0xB3, 0x43, 0x17, 0x8F, 0x15, 0xDB, 0x87, 0xEB, 0x71, 0xFF, 0xFB, 
	0xD3, 0xC2, 0x7D, 0xF8, 0x40, 0xEB, 0xBA, 0x61, 0x93, 0xD1, 0xB8, 0xC6, 0x7A, 0x48, 0x6D, 0xE3, 
	0x08, 0x2D, 0xB2, 0xF3, 0xCC, 0x60, 0x72, 0x17, 0x7B, 0x64, 0x58, 0xFC, 0x98, 0xFB, 0x6A, 0x19, 
	0x5E, 0x59, 0x71, 0x2C, 0x4F, 0x82, 0x68, 0xD9, 0x29, 0xB3, 0xCF, 0x34, 0xD1, 0x8B, 0xD5, 0x34, 
	0x72, 0xB7, 0x90, 0xC4, 0x76, 0x84, 0xCB, 0xC0, 0xD1, 0x1B, 0x1D, 0x2F, 0x50, 0x88, 0x5A, 0xEB, 
	0xEE, 0x18, 0x5B, 0xA4, 0x19, 0x2F, 0x9A, 0xC1, 0x59, 0xB0, 0xAA, 0x72, 0xCC, 0xB4, 0xD7, 0x21, 
	0x4D, 0xAC, 0xE9, 0x64, 0xA3, 0xB0, 0x92, 0xC3, 0x99, 0x43, 0xBF, 0x75, 0x25, 0x38, 0x6F, 0x8E, 
	0x95, 0x93, 0x4F, 0xC0, 0xA0, 0xC4, 0xD9, 0x45, 0x09, 0x36, 0xC9, 0x55, 0xBA, 0xB8, 0x96, 0xB2, 
	0x35, 0xA5, 0x21, 0x91, 0x31, 0x39, 0x13, 0x76, 0x54, 0x9D, 0x90, 0x8F, 0xD8, 0x72, 0x41, 0xAA, 
	0x76, 0xFD, 0x00, 0xB4, 0x54, 0x68, 0x96, 0x2C, 0xB2, 0x37, 0x18, 0xBB, 0x0B, 0xF7, 0xF9, 0xFF, 
	0x60, 0xEF, 0x60, 0xA3, 0xD0, 0xC5, 0x1E, 0x21, 0x39
	};*/

	/*unsigned char data[973] = {
	0x18, 0xCE, 0x85, 0x39, 0xAE, 0x40, 0x9F, 0x88, 0xAD, 0x52, 0xA3, 0x14, 0x8F, 0xE9, 0x20, 0x99, 
	0x53, 0x0F, 0x88, 0x00, 0x54, 0xD9, 0xC7, 0xBA, 0xAD, 0x66, 0x64, 0xF3, 0xC4, 0xCB, 0x73, 0x4F, 
	0xCE, 0xA7, 0x40, 0x3D, 0xD1, 0x14, 0x48, 0xF1, 0x83, 0xA2, 0x13, 0xFE, 0x61, 0x48, 0x5C, 0x4C, 
	0x8D, 0xB2, 0x3E, 0xFB, 0x97, 0x43, 0xA7, 0xB9, 0xE9, 0x81, 0x74, 0x4B, 0x11, 0x24, 0x9D, 0x4D, 
	0x10, 0xF4, 0x1B, 0x38, 0xE7, 0x1F, 0xDD, 0x9B, 0xA6, 0x78, 0xA9, 0x99, 0xFC, 0x3C, 0x31, 0xD0, 
	0x3B, 0xB7, 0xB5, 0xB6, 0x42, 0x9E, 0x7E, 0x75, 0x23, 0x7A, 0x8A, 0x02, 0xAB, 0x71, 0x04, 0x28, 
	0x0E, 0xEE, 0xEF, 0x05, 0xA0, 0xBE, 0x9A, 0xCF, 0x5D, 0xBF, 0xF0, 0x09, 0x54, 0xAD, 0x1A, 0xDD, 
	0x34, 0x8D, 0xF3, 0xC7, 0x22, 0xFB, 0x58, 0x45, 0x7D, 0x53, 0x1B, 0x5D, 0x24, 0x8D, 0x9F, 0x25, 
	0x68, 0x53, 0xB2, 0x80, 0x60, 0x52, 0xD1, 0x3E, 0x28, 0x84, 0xFF, 0x6A, 0x36, 0x97, 0x20, 0xB1, 
	0x78, 0xFD, 0x5C, 0x8E, 0x4A, 0xE5, 0x4F, 0x39, 0xC9, 0x1B, 0xA3, 0x1D, 0x59, 0xDE, 0xC8, 0x49, 
	0xF1, 0x5F, 0x4B, 0x77, 0x81, 0x28, 0xBE, 0xA0, 0xAC, 0xA5, 0x6F, 0x9D, 0x99, 0x18, 0xA5, 0x1C, 
	0x72, 0x02, 0x46, 0x91, 0xC5, 0xCD, 0xF4, 0x73, 0x5B, 0xD5, 0x87, 0xFA, 0xB1, 0x3E, 0xAF, 0xD4, 
	0xB0, 0x78, 0x83, 0xA8, 0x76, 0x93, 0xFD, 0x5E, 0xA1, 0x60, 0xB0, 0x51, 0x5D, 0x91, 0xF5, 0x1B, 
	0x1E, 0x6F, 0x4E, 0x98, 0xB5, 0x15, 0x1D, 0xA0, 0x80, 0xB6, 0xB5, 0x0C, 0x2B, 0x5B, 0xCF, 0xCC, 
	0x1B, 0xA0, 0x0F, 0xAD, 0x66, 0xEA, 0xFB, 0x0B, 0xB5, 0x42, 0x34, 0xD2, 0x22, 0x5B, 0x2D, 0x7B, 
	0x17, 0x0C, 0x5E, 0x8F, 0xF3, 0x69, 0xBF, 0xF2, 0x6C, 0xAE, 0x9D, 0x0F, 0x0E, 0xD4, 0x93, 0x3A, 
	0xDF, 0xF6, 0xEB, 0xE5, 0x96, 0x0B, 0x25, 0xB4, 0x89, 0x35, 0x8A, 0x3C, 0xBC, 0x1F, 0xF4, 0xC8, 
	0x26, 0x57, 0xB7, 0x42, 0x88, 0xB5, 0x2A, 0xB2, 0x9B, 0x20, 0xD1, 0x94, 0xD3, 0xFB, 0x8D, 0x73, 
	0xB5, 0x7E, 0xF7, 0x94, 0x88, 0xE2, 0x01, 0x86, 0xC6, 0x5D, 0xBC, 0x84, 0xC5, 0xCC, 0xBE, 0xB2, 
	0xA4, 0xB1, 0x76, 0xB6, 0x41, 0xD0, 0x5F, 0x0A, 0xE9, 0xBD, 0xD4, 0x20, 0x81, 0x87, 0x8A, 0x3D, 
	0x8D, 0x14, 0x66, 0xFB, 0x5F, 0xF1, 0x4E, 0x76, 0x33, 0x2F, 0xF3, 0xBA, 0x3C, 0xA7, 0x31, 0x7C, 
	0x23, 0xFF, 0x67, 0x56, 0x00, 0xD4, 0xC7, 0xC7, 0x33, 0xE5, 0x29, 0x14, 0x4E, 0xDD, 0x75, 0xEF, 
	0x8E, 0x63, 0x0B, 0x09, 0x12, 0x40, 0x60, 0x77, 0xD7, 0x51, 0x42, 0x99, 0x76, 0xCA, 0xF6, 0xA3, 
	0x60, 0x3D, 0xB6, 0xE1, 0x18, 0x93, 0xA3, 0xDE, 0x2E, 0x81, 0x87, 0xF9, 0xBE, 0x24, 0x12, 0x4F, 
	0xE2, 0x91, 0x91, 0x8B, 0x3A, 0xB4, 0x44, 0xBC, 0x0E, 0x12, 0xE1, 0xDB, 0xF0, 0x5E, 0x9A, 0x59, 
	0x34, 0x90, 0xDB, 0x1C, 0xD5, 0xC2, 0x67, 0xC8, 0xFC, 0x25, 0x98, 0x44, 0xAF, 0xBD, 0x5D, 0x59, 
	0x6D, 0xAF, 0x03, 0xD4, 0x8F, 0xF7, 0x79, 0xEC, 0x1D, 0x07, 0x8D, 0x3C, 0x65, 0xE4, 0xFF, 0x67, 
	0x7E, 0x2A, 0x9A, 0x22, 0x4B, 0x6A, 0x0C, 0xD8, 0x5D, 0x9C, 0xF2, 0xF3, 0x61, 0x24, 0x1F, 0x33, 
	0x17, 0x2F, 0xC2, 0x9B, 0x3B, 0x31, 0x94, 0xBC, 0x38, 0xF1, 0x1E, 0xEE, 0x62, 0x46, 0xB6, 0xC9, 
	0x91, 0x6D, 0x74, 0x91, 0x43, 0x59, 0x28, 0xC7, 0x64, 0xBD, 0x40, 0x63, 0x93, 0x71, 0x08, 0x35, 
	0xA0, 0x0C, 0x45, 0x9D, 0xE2, 0xDD, 0xD5, 0xE8, 0x76, 0x60, 0x84, 0xF9, 0xA4, 0x94, 0x86, 0xED, 
	0xB6, 0x34, 0xB2, 0xEB, 0x6F, 0xB5, 0x63, 0x26, 0x90, 0x40, 0x10, 0xBF, 0x65, 0x2B, 0x5D, 0xD5, 
	0x18, 0xCF, 0x2B, 0x46, 0x0D, 0xD3, 0xBD, 0xAB, 0xD6, 0xEE, 0x4D, 0x3C, 0x0E, 0x07, 0x81, 0xFF, 
	0x94, 0xED, 0x3E, 0x6D, 0xB4, 0x03, 0xDD, 0x80, 0xF2, 0xDF, 0xF3, 0x67, 0x76, 0x23, 0x93, 0xB7, 
	0xF4, 0xB2, 0x63, 0x92, 0xD5, 0xD9, 0x8E, 0x8C, 0x1D, 0x67, 0xA4, 0xD1, 0x8E, 0x02, 0xCD, 0x35, 
	0x68, 0x32, 0x84, 0x9E, 0x1D, 0xA8, 0xB9, 0x3B, 0xAD, 0xCC, 0xAD, 0x79, 0x6D, 0x5B, 0xA9, 0x95, 
	0x01, 0x5C, 0x65, 0xD8, 0xD3, 0x0D, 0xF9, 0x18, 0x7A, 0xAC, 0x2D, 0x5B, 0x7D, 0x9E, 0x92, 0x93, 
	0x0F, 0xBD, 0xCA, 0x70, 0x7E, 0x80, 0x82, 0x51, 0x95, 0x49, 0x3D, 0xCF, 0xB2, 0xBF, 0x7B, 0x98, 
	0x29, 0x5E, 0xE2, 0xA6, 0x81, 0x30, 0x08, 0x70, 0xD0, 0x6F, 0xAF, 0x3C, 0x13, 0x5C, 0x19, 0x87, 
	0x8E, 0x57, 0xD3, 0xE1, 0x56, 0xF2, 0xCD, 0xBC, 0x50, 0xC5, 0x1C, 0xDF, 0x4F, 0xE5, 0xA1, 0x1A, 
	0x19, 0xC1, 0x75, 0x7A, 0xFC, 0xE0, 0x25, 0x6B, 0x16, 0xF4, 0xDD, 0xB0, 0x37, 0xA8, 0x46, 0x49, 
	0x30, 0xC5, 0xE6, 0xAD, 0x2D, 0xAC, 0x73, 0xEA, 0x0D, 0x25, 0x9C, 0xD9, 0xF9, 0x08, 0x8F, 0x90, 
	0x93, 0xD1, 0x9E, 0xCA, 0x50, 0x02, 0xCB, 0x76, 0x68, 0x2E, 0x4A, 0xDB, 0xAE, 0x73, 0x90, 0x42, 
	0x39, 0xA7, 0x28, 0x4E, 0xC9, 0xA8, 0x5D, 0x04, 0x12, 0x5C, 0xCA, 0xFE, 0x32, 0x96, 0x82, 0x2E, 
	0x12, 0x1F, 0x8B, 0xF2, 0xE3, 0x97, 0xDF, 0x09, 0x2F, 0x65, 0xEA, 0xEC, 0xA3, 0x6C, 0x47, 0xB0, 
	0x6B, 0x46, 0xCE, 0xC2, 0x8B, 0x3C, 0xD0, 0xEE, 0x61, 0xF0, 0x2E, 0x64, 0x4A, 0xD2, 0x15, 0x35, 
	0x8F, 0xC6, 0xDA, 0x3C, 0x31, 0xF0, 0x9E, 0x1B, 0xF5, 0xDF, 0x14, 0x51, 0xA7, 0x08, 0x8A, 0xB3, 
	0xC6, 0xD3, 0x79, 0x98, 0x4F, 0xD0, 0xBB, 0x48, 0x83, 0x33, 0xF9, 0x9C, 0x74, 0x5D, 0x1C, 0x9A, 
	0x9B, 0x25, 0x77, 0x27, 0x75, 0x15, 0xFD, 0xBC, 0xD9, 0xCC, 0xDF, 0x49, 0x05, 0xE1, 0x0F, 0x8C, 
	0xF2, 0xBC, 0x25, 0x15, 0x96, 0x4D, 0xD1, 0x7E, 0x09, 0xE3, 0x8D, 0x4B, 0xF0, 0x55, 0xA3, 0x75, 
	0x44, 0xC7, 0xE2, 0xC7, 0x05, 0x4C, 0xF6, 0x27, 0x45, 0x8C, 0x20, 0x33, 0x90, 0xFF, 0x3D, 0x67, 
	0x80, 0x03, 0x2A, 0x2A, 0x46, 0xA4, 0xC4, 0xD6, 0xFA, 0xEF, 0x4B, 0x8C, 0x6F, 0xD8, 0x22, 0x47, 
	0x39, 0xDE, 0x61, 0xAE, 0x63, 0xCB, 0x0A, 0x17, 0x64, 0x99, 0xF4, 0x78, 0x53, 0x17, 0xD3, 0xFD, 
	0x69, 0x52, 0xA6, 0x14, 0xA7, 0x8A, 0xAE, 0x62, 0x4D, 0x07, 0x60, 0x5A, 0xB4, 0xB7, 0xBB, 0x67, 
	0xA9, 0xB0, 0xB1, 0x71, 0x2B, 0xC2, 0x74, 0xB3, 0x10, 0x53, 0x86, 0x0E, 0x0A, 0xE1, 0xEF, 0x2C, 
	0x63, 0x5D, 0xFB, 0x2B, 0xB9, 0xE1, 0x94, 0x40, 0x6F, 0x21, 0xCE, 0x5E, 0x9C, 0xAD, 0xA3, 0x6A, 
	0x7A, 0x7A, 0x1E, 0x1F, 0x28, 0x10, 0x11, 0xCF, 0xE7, 0x61, 0x11, 0x81, 0x74, 0x0E, 0x9B, 0x5C, 
	0xF4, 0xEE, 0xA1, 0x55, 0x3D, 0x3C, 0xFE, 0xB5, 0x1F, 0x26, 0x5D, 0xD6, 0x11, 0x3D, 0xA1, 0x5C, 
	0xA3, 0xCC, 0x82, 0x3B, 0xC2, 0x58, 0x83, 0xC6, 0x7E, 0x4B, 0xD6, 0xB0, 0x74, 0x78, 0x4D, 0xA8, 
	0x66, 0x67, 0x30, 0x30, 0xF9, 0x26, 0x6F, 0x62, 0x9B, 0x88, 0x4A, 0xA0, 0xC3, 0xE5, 0x52, 0x50, 
	0xDE, 0x8C, 0xEC, 0x3B, 0x77, 0x4E, 0xDB, 0xCC, 0xBC, 0xA2, 0x1A, 0x24, 0xA9
	};

	GetSessionKey(SessionKey);

	//SpecialSHA(SessionKey, 0xC0, SHAResult, 32);
	AES_set_encrypt_key(SHAResult, 256, &AesKey);

	Idx = 0;
	ZeroMemory(ivec, AES_BLOCK_SIZE);
	ZeroMemory(ecount_buf, AES_BLOCK_SIZE);
	AES_ctr128_encrypt(data, data, sizeof(data), &AesKey, ivec, ecount_buf, &Idx);

	showmem(data, sizeof(data));
	printf("\n");

	uchar		*Buffer;
	uchar		*DirBlob;
	uchar		*RSAeD;
	uchar		*AesPart;
	uint		Size, DbSz, RdSz, AeSz;
	SResponse	Response;

	Buffer = data + 3;
	Size = sizeof(data) - 3;

	ZeroMemory(&Response, sizeof(Response));
	ManageObjects(&Buffer, Size, &Response);
	for (Idx = 0; Idx < Response.NbObj; Idx++)
	{
		DumpObj(Response.Objs[Idx]);
		if (Response.Objs[Idx].Id == 0x05)
		{
			DirBlob = MemDup(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
			DbSz = Response.Objs[Idx].Value.Memory.MsZ;
		}
		if (Response.Objs[Idx].Id == 0x0A)
		{
			RSAeD = MemDup(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
			RdSz = Response.Objs[Idx].Value.Memory.MsZ;
		}
		if (Response.Objs[Idx].Id == 0x06)
		{
			AesPart = MemDup(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
			AeSz = Response.Objs[Idx].Value.Memory.MsZ;
		}
	}
	printf("---\n");

	DumpDirBlobMetaDatas(DirBlob, DbSz);*/

	/*unsigned char RsaKey[128] = {
	0x9A, 0x05, 0x28, 0xAB, 0x29, 0x59, 0xFC, 0x4A, 0x55, 0xA0, 0x13, 0x61, 0xD0, 0x56, 0xC7, 0xC1, 
	0x58, 0x64, 0x0A, 0x93, 0xEA, 0x78, 0x30, 0x0C, 0xC7, 0xAA, 0xB3, 0x7D, 0x76, 0x5F, 0x1C, 0xA8, 
	0xE4, 0xDA, 0xEC, 0xDF, 0xAC, 0x60, 0x44, 0xC9, 0xC4, 0x4F, 0xDE, 0x03, 0xBA, 0x33, 0x31, 0x58, 
	0x57, 0x39, 0x47, 0xC0, 0x14, 0xC9, 0x6D, 0xE3, 0xB9, 0x4E, 0xD2, 0x05, 0x49, 0xE9, 0xF8, 0x09, 
	0x51, 0xFC, 0xE3, 0xDD, 0x1D, 0xF9, 0xB4, 0x2A, 0x3A, 0x72, 0xF6, 0x0C, 0x8E, 0x4A, 0x66, 0x47, 
	0x83, 0x25, 0xD2, 0x7A, 0xF3, 0xB3, 0xF0, 0xFE, 0x57, 0x89, 0x6C, 0x92, 0x27, 0x4B, 0xB1, 0xC1, 
	0x15, 0x6F, 0x83, 0x6D, 0x5A, 0xB6, 0x61, 0xCA, 0x39, 0x6C, 0x0D, 0x90, 0x31, 0x47, 0xCD, 0x9C, 
	0x26, 0xC5, 0xD5, 0x2C, 0xFB, 0xBC, 0x9A, 0x5A, 0x8A, 0xAC, 0x8D, 0x11, 0xEF, 0xC6, 0x6B, 0xB9
	};

	uchar			UnRSA[0xFFF];
	RSA				*SkypeRSA;
	uchar			*PostProcessed;
	char			*Key;
	uint			PPsZ, KeyIdx, Save;
	int				Suite;

	SkypeRSA = RSA_new();
	BN_hex2bn(&(SkypeRSA->n), Bin2HexStr(RsaKey, MODULUS_SZ));
	//BN_hex2bn(&(SkypeRSA->n), SkypeModulus1536[1]);
	BN_hex2bn(&(SkypeRSA->e), "10001");
	PPsZ = AeSz;
	RdSz -= PPsZ;
	Save = PPsZ;
	PPsZ = 0x80;
	ZeroMemory(UnRSA, 0xFFF);
	PPsZ = RSA_public_decrypt(PPsZ, AesPart, UnRSA, SkypeRSA, RSA_NO_PADDING);
	RSA_free(SkypeRSA);

	Suite = Save - PPsZ;
	AesPart += PPsZ;
	PostProcessed = FinalizeLoginDatas(UnRSA, &PPsZ, (Suite > 0) ? AesPart : NULL, Suite);

	if (PostProcessed == NULL)
	{
		printf("Bad Datas [METADATAS] Finalization..\n");
		return 0;
	}

	//PostProcessed += SHA_DIGEST_LENGTH;
	//PPsZ -= SHA_DIGEST_LENGTH;

	printf("---\n");
	showmem(PostProcessed, PPsZ);

	ExitProcess(0);*/

	/*unsigned char dataa[603] = {
	0x10, 0x45, 0xC2, 0x3C, 0xE3, 0x4E, 0x89, 0x8A, 0x6C, 0x26, 0xA6, 0x15, 0x87, 0x4E, 0xAD, 0x5C, 
	0x3B, 0xEC, 0x43, 0x52, 0x0B, 0x44, 0x49, 0xB9, 0xA9, 0x62, 0xEA, 0x30, 0x96, 0x29, 0x20, 0x6E, 
	0xAD, 0x70, 0x41, 0x34, 0x75, 0x92, 0x6B, 0x11, 0xDC, 0xCB, 0xE5, 0xE5, 0xBA, 0xE8, 0x9A, 0x1D, 
	0x75, 0x21, 0x00, 0xC8, 0x3F, 0xFF, 0x66, 0x64, 0x00, 0x14, 0x62, 0x8E, 0x76, 0x8C, 0x6E, 0x8E, 
	0xCD, 0x4F, 0xB4, 0x2F, 0x0C, 0x49, 0xE3, 0x73, 0x59, 0xC5, 0x45, 0xAB, 0x01, 0x2F, 0x36, 0xF4, 
	0xE7, 0x20, 0xCB, 0xF1, 0x84, 0xBB, 0x69, 0x31, 0x61, 0x66, 0x1C, 0xE3, 0xB6, 0x80, 0x3B, 0x1F, 
	0xCE, 0xC2, 0x8F, 0x71, 0xDA, 0x3B, 0xB1, 0xC6, 0x63, 0x91, 0xA9, 0x03, 0x43, 0x91, 0x67, 0xA0, 
	0x78, 0xAF, 0x49, 0xB0, 0xC0, 0x4D, 0x07, 0x0A, 0x81, 0x6F, 0x32, 0x48, 0xC6, 0x4D, 0xF2, 0xDF, 
	0x96, 0xBB, 0xDA, 0xE9, 0x58, 0xF6, 0x3E, 0x46, 0xB8, 0x1D, 0x11, 0xDC, 0xD4, 0x34, 0x28, 0xBB, 
	0x73, 0x74, 0x1E, 0xD5, 0x0B, 0xF8, 0xE8, 0x4D, 0x1C, 0x9B, 0xC7, 0x49, 0xA8, 0xB3, 0x2F, 0x2A, 
	0xFD, 0x5A, 0x71, 0xEB, 0x4E, 0xD5, 0x93, 0x31, 0x3B, 0x46, 0x84, 0x6C, 0xAE, 0xAA, 0xF9, 0xA0, 
	0x4B, 0xCD, 0x79, 0x2F, 0x4B, 0x93, 0x99, 0x89, 0x3A, 0x7E, 0xAB, 0x94, 0x81, 0x1F, 0x88, 0x5D, 
	0x86, 0x2B, 0x20, 0x7E, 0xC0, 0xA7, 0xCF, 0xA8, 0x5F, 0x05, 0xF1, 0x55, 0xE1, 0x27, 0x5E, 0xEA, 
	0xD8, 0x0C, 0xBB, 0x70, 0x5D, 0x49, 0xCA, 0x78, 0x51, 0xC9, 0x05, 0xFF, 0x82, 0x65, 0x03, 0x7E, 
	0x72, 0xC0, 0x77, 0xC3, 0x36, 0x4B, 0x0D, 0x10, 0x0B, 0x59, 0x4A, 0x19, 0x17, 0xFA, 0xF3, 0x5C, 
	0xB9, 0x31, 0xEA, 0xE3, 0x53, 0x03, 0x0F, 0x42, 0x1B, 0x75, 0x61, 0x21, 0x45, 0x5A, 0xF4, 0x01, 
	0x68, 0x83, 0x5C, 0x82, 0x3E, 0xD4, 0x9F, 0x1E, 0xEC, 0x54, 0x88, 0x3F, 0xAC, 0x5F, 0x59, 0x37, 
	0xF0, 0x56, 0x79, 0x6B, 0x9E, 0xAD, 0xA9, 0x24, 0x13, 0xEE, 0xD7, 0x4A, 0x6C, 0xA1, 0xA4, 0xD9, 
	0x09, 0x8F, 0x21, 0x46, 0x6A, 0xC3, 0x5E, 0x9E, 0xD9, 0xC0, 0xC7, 0x91, 0x44, 0xCD, 0x4F, 0x59, 
	0xF0, 0xD4, 0x2B, 0xA6, 0x36, 0x0A, 0x33, 0xCD, 0x23, 0xA0, 0xAF, 0x14, 0x64, 0xE1, 0x4C, 0x92, 
	0x01, 0x05, 0xFA, 0x20, 0x18, 0x94, 0x1B, 0x16, 0x95, 0x21, 0xF7, 0x1B, 0x1D, 0xEE, 0xE2, 0xD2, 
	0x68, 0x5B, 0x20, 0xDE, 0x1E, 0xD4, 0x0D, 0x9E, 0x3A, 0xF7, 0x11, 0xBB, 0xC4, 0x6E, 0xAD, 0xD5, 
	0x87, 0x83, 0xAA, 0x4F, 0x29, 0x02, 0x66, 0x0C, 0xD1, 0x14, 0xCC, 0x69, 0x17, 0x94, 0xFB, 0xF8, 
	0xEE, 0xDB, 0xF4, 0xCB, 0xC1, 0x6F, 0xCD, 0xD5, 0xFA, 0x2A, 0x35, 0xF1, 0x58, 0x3C, 0x64, 0xE9, 
	0xCD, 0x2C, 0xCB, 0x6B, 0xDE, 0x7C, 0x7B, 0xA8, 0x0F, 0x96, 0x25, 0x14, 0x60, 0x84, 0x5D, 0x87, 
	0xCA, 0x76, 0xA0, 0xDA, 0xBC, 0xF1, 0x26, 0xCF, 0x07, 0xA3, 0xE9, 0x3A, 0xDD, 0x48, 0x0D, 0xAD, 
	0xC9, 0xC4, 0xE6, 0x10, 0x32, 0xDA, 0x21, 0x4B, 0x19, 0xAF, 0xAF, 0xDD, 0x26, 0x57, 0x1F, 0x97, 
	0xD5, 0x1B, 0x87, 0xDD, 0xFF, 0xB3, 0x43, 0x17, 0x8F, 0x15, 0xDB, 0x87, 0xEB, 0x71, 0xFF, 0xFB, 
	0xD3, 0xC2, 0x7D, 0xF8, 0x40, 0xEB, 0xBA, 0x61, 0x93, 0xD1, 0xB8, 0xC6, 0x7A, 0x48, 0x6D, 0xE3, 
	0x08, 0x2D, 0xB2, 0xF3, 0xCC, 0x60, 0x72, 0x17, 0x7B, 0x64, 0x58, 0xFC, 0x98, 0xFB, 0x6A, 0x19, 
	0x5E, 0x59, 0x71, 0x2C, 0x4F, 0x82, 0x68, 0xD9, 0x29, 0xB3, 0xCF, 0x34, 0xD1, 0x8B, 0xD5, 0x34, 
	0x72, 0xB7, 0x90, 0xC4, 0x76, 0x84, 0xCB, 0xC0, 0xD1, 0x1B, 0x1D, 0x2F, 0x50, 0x88, 0x5A, 0xEB, 
	0xEE, 0x18, 0x5B, 0xA4, 0x19, 0x2F, 0x9A, 0xC1, 0x59, 0xB0, 0xAA, 0x72, 0xCC, 0xB4, 0xD7, 0x21, 
	0x4D, 0xAC, 0xE9, 0x64, 0xA3, 0xB0, 0x92, 0xC3, 0x99, 0x43, 0xBF, 0x75, 0x25, 0x38, 0x6F, 0x8E, 
	0x95, 0x93, 0x4F, 0xC0, 0xA0, 0xC4, 0xD9, 0x45, 0x09, 0x36, 0xC9, 0x55, 0xBA, 0xB8, 0x96, 0xB2, 
	0x35, 0xA5, 0x21, 0x91, 0x31, 0x39, 0x13, 0x76, 0x54, 0x9D, 0x90, 0x8F, 0xD8, 0x72, 0x41, 0xAA, 
	0x76, 0xFD, 0x00, 0xB4, 0x54, 0x68, 0x96, 0x2C, 0xB2, 0x37, 0x18, 0xBB, 0x0B, 0xF7, 0xF9, 0xFF, 
	0x60, 0xEF, 0x60, 0xA3, 0xD0, 0xC5, 0x1E, 0x21, 0x39, 0x98, 0x7B
	};

	printf("-> 0x%x\n", crc32(dataa, sizeof(dataa), -1) ^ 0xF82C);

	char	data1[] = {0x01, 0x02, 0x03, 0x04};
	char	data2[] = {0x05, 0x06, 0x07, 0x08, 0x09};

	MemReverse((uchar *)data1, sizeof(data1));
	MemReverse((uchar *)data2, sizeof(data2));
	showmem((uchar *)data1, sizeof(data1));
	showmem((uchar *)data2, sizeof(data2));*/

	/*unsigned char pubkey[128] = {
	0xCE, 0x42, 0x33, 0x2F, 0xEC, 0x3C, 0xEA, 0x8A, 0x28, 0xD6, 0xCF, 0xFB, 0x54, 0xAD, 0x64, 0xD3, 
	0x6C, 0x75, 0xE2, 0x05, 0x60, 0x30, 0x83, 0x33, 0x30, 0x0E, 0xCE, 0x83, 0x72, 0x78, 0x5C, 0x7B, 
	0x3B, 0x63, 0x55, 0xF3, 0x3E, 0x79, 0x7B, 0xF0, 0x27, 0x05, 0xCD, 0x84, 0xBE, 0x95, 0xA8, 0x6B, 
	0x74, 0x6D, 0x1C, 0xB6, 0x30, 0x96, 0xC5, 0xBA, 0x1A, 0x52, 0xF4, 0x96, 0xEB, 0x80, 0xD3, 0x16, 
	0x1C, 0x4D, 0x22, 0xEE, 0xB3, 0x23, 0x45, 0x8F, 0x54, 0xAD, 0x11, 0x4B, 0xED, 0x79, 0x83, 0x80, 
	0x0B, 0x8F, 0x4A, 0x51, 0x5E, 0x0D, 0xE5, 0x7C, 0x61, 0x71, 0x0C, 0x0B, 0xC0, 0xC8, 0xC7, 0xB3, 
	0xA7, 0xE8, 0x95, 0xD1, 0x8C, 0x53, 0xAB, 0x08, 0xA7, 0xA3, 0xAA, 0xDB, 0x96, 0x26, 0x2E, 0xC5, 
	0x49, 0x1D, 0xF2, 0x38, 0x5C, 0xCD, 0x46, 0x8A, 0xDB, 0x67, 0x9B, 0x27, 0x78, 0x41, 0x7B, 0x29
	};

	unsigned char privkey[128] = {
	0xA4, 0xD4, 0xF6, 0xBF, 0x37, 0x95, 0xBF, 0x01, 0xC6, 0x7D, 0x55, 0x1C, 0xCF, 0xA0, 0xFA, 0x50, 
	0x93, 0xFE, 0xE9, 0x2F, 0xCE, 0x9D, 0x36, 0x5C, 0x73, 0xED, 0x81, 0x50, 0x3E, 0xEC, 0xBD, 0x4B, 
	0xA6, 0x3C, 0x4E, 0x75, 0xE3, 0xD9, 0x86, 0x18, 0x77, 0xB7, 0x05, 0x75, 0x2E, 0x31, 0xBF, 0xB4, 
	0x90, 0x08, 0x9A, 0xC7, 0x66, 0xB1, 0x37, 0x36, 0xF0, 0xCE, 0x96, 0xB4, 0xFD, 0x63, 0xA8, 0x4C, 
	0x35, 0xED, 0xFA, 0x1A, 0x47, 0xF3, 0x3F, 0x0D, 0x8C, 0x88, 0x7F, 0x18, 0x23, 0xC8, 0x85, 0xA3, 
	0x91, 0x99, 0x27, 0xD8, 0x64, 0x2D, 0x10, 0xB8, 0x3C, 0x0C, 0x03, 0x77, 0x33, 0x1E, 0x63, 0x43, 
	0xFF, 0x9E, 0xE9, 0xF7, 0x7A, 0x16, 0x68, 0xCE, 0xD3, 0xE4, 0xF5, 0xC4, 0xC1, 0x6E, 0x43, 0x05, 
	0xF0, 0x93, 0x3D, 0x23, 0x74, 0xE6, 0xEB, 0xE5, 0x7F, 0xC1, 0x0B, 0x8C, 0xC1, 0x6B, 0x6A, 0xD9
	};

	unsigned char data[128] = {
	0xA6, 0xAE, 0x24, 0xB2, 0xB4, 0xF3, 0x00, 0x43, 0x08, 0xEE, 0x32, 0x5D, 0x3E, 0xAE, 0x79, 0x40, 
	0x09, 0xFB, 0xBB, 0xA6, 0xE2, 0xE5, 0x17, 0x94, 0xEB, 0xDD, 0x64, 0x3D, 0x23, 0xD2, 0x42, 0x17, 
	0x61, 0xFE, 0x7A, 0xB3, 0x3D, 0x8A, 0xE0, 0xB7, 0x74, 0xEF, 0x2E, 0x05, 0xE6, 0xF9, 0x09, 0x06, 
	0x48, 0x62, 0x21, 0x8A, 0x26, 0xCE, 0xAE, 0xC1, 0xEB, 0x14, 0x96, 0x86, 0x1B, 0x12, 0x85, 0xE0, 
	0xB2, 0x2A, 0xD7, 0xF8, 0x0C, 0xD0, 0x6B, 0xF4, 0xCC, 0xE3, 0x9E, 0x5B, 0x5B, 0xA8, 0xA1, 0xD4, 
	0x49, 0x77, 0x60, 0x1F, 0xDD, 0x94, 0x06, 0x8C, 0x0D, 0xCF, 0xF7, 0x94, 0xD3, 0x72, 0x98, 0xA9, 
	0x26, 0x72, 0x24, 0x16, 0x22, 0x15, 0xD2, 0x70, 0x39, 0x9A, 0xBC, 0xCC, 0x86, 0x1A, 0xE0, 0x50, 
	0xC7, 0x9A, 0x24, 0x16, 0x9A, 0x6E, 0x23, 0xA5, 0x90, 0x10, 0x7B, 0xA7, 0xB1, 0x7A, 0x57, 0x0A
	};

	uchar			UnRSA[0xFFF];
	RSA				*SkypeRSA;
	uint			PPsZ;

	SkypeRSA = RSA_new();
	BN_hex2bn(&(SkypeRSA->n), Bin2HexStr(pubkey, MODULUS_SZ));
	BN_hex2bn(&(SkypeRSA->d), Bin2HexStr(privkey, MODULUS_SZ));
	BN_hex2bn(&(SkypeRSA->e), "10001");
	ZeroMemory(UnRSA, 0xFFF);
	PPsZ = RSA_private_decrypt(0x80, data, UnRSA, SkypeRSA, RSA_NO_PADDING);
	RSA_free(SkypeRSA);

	printf("-> 0x%x\n", PPsZ);
	if (PPsZ != 0xFFFFFFFF)
		showmem(UnRSA, PPsZ);

	unsigned char dataa[85] = {
	0xA6, 0x01, 0x5C, 0xCB, 0x4E, 0x9A, 0x04, 0x5C, 0xCA, 0x42, 0xDB, 0xD0, 0xA4, 0x89, 0xEB, 0x7A, 
	0xA3, 0x40, 0xB6, 0x68, 0xFD, 0x3D, 0x95, 0x72, 0xA8, 0x9B, 0x45, 0xBD, 0x52, 0x6E, 0x68, 0x9A, 
	0xD5, 0xCB, 0xBD, 0x1B, 0x96, 0x0A, 0x99, 0x59, 0x7B, 0x3F, 0x78, 0x14, 0xCC, 0xAB, 0x42, 0x20, 
	0xCB, 0x46, 0x2B, 0x4B, 0x01, 0xC0, 0xA8, 0x01, 0x83, 0x37, 0x2C, 0x55, 0x82, 0x96, 0x2E, 0x9D, 
	0x83, 0xD1, 0x10, 0x4C, 0x59, 0x97, 0xB6, 0x8F, 0x1C, 0x2D, 0x18, 0x23, 0x46, 0xB9, 0xCF, 0x92, 
	0xED, 0x59, 0x25, 0xE8, 0x28
	};

	DumpTCPPacketObjs(dataa, sizeof(dataa));

	ExitProcess(0);*/
	
	*******************************************************************
	
		unsigned char data0[608] = {
	0xBD, 0x09, 0x05, 0xF8, 0x2C, 0x10, 0x45, 0xC2, 0x3C, 0xE3, 0x4E, 0x89, 0x8A, 0x6C, 0x26, 0xA6, 
	0x15, 0x87, 0x4E, 0xAD, 0x5C, 0x3B, 0xEC, 0x43, 0x52, 0x0B, 0x44, 0x49, 0xB9, 0xA9, 0x62, 0xEA, 
	0x30, 0x96, 0x29, 0x20, 0x6E, 0xAD, 0x70, 0x41, 0x34, 0x75, 0x92, 0x6B, 0x11, 0xDC, 0xCB, 0xE5, 
	0xE5, 0xBA, 0xE8, 0x9A, 0x1D, 0x75, 0x21, 0x00, 0xC8, 0x3F, 0xFF, 0x66, 0x64, 0x00, 0x14, 0x62, 
	0x8E, 0x76, 0x8C, 0x6E, 0x8E, 0xCD, 0x4F, 0xB4, 0x2F, 0x0C, 0x49, 0xE3, 0x73, 0x59, 0xC5, 0x45, 
	0xAB, 0x01, 0x2F, 0x36, 0xF4, 0xE7, 0x20, 0xCB, 0xF1, 0x84, 0xBB, 0x69, 0x31, 0x61, 0x66, 0x1C, 
	0xE3, 0xB6, 0x80, 0x3B, 0x1F, 0xCE, 0xC2, 0x8F, 0x71, 0xDA, 0x3B, 0xB1, 0xC6, 0x63, 0x91, 0xA9, 
	0x03, 0x43, 0x91, 0x67, 0xA0, 0x78, 0xAF, 0x49, 0xB0, 0xC0, 0x4D, 0x07, 0x0A, 0x81, 0x6F, 0x32, 
	0x48, 0xC6, 0x4D, 0xF2, 0xDF, 0x96, 0xBB, 0xDA, 0xE9, 0x58, 0xF6, 0x3E, 0x46, 0xB8, 0x1D, 0x11, 
	0xDC, 0xD4, 0x34, 0x28, 0xBB, 0x73, 0x74, 0x1E, 0xD5, 0x0B, 0xF8, 0xE8, 0x4D, 0x1C, 0x9B, 0xC7, 
	0x49, 0xA8, 0xB3, 0x2F, 0x2A, 0xFD, 0x5A, 0x71, 0xEB, 0x4E, 0xD5, 0x93, 0x31, 0x3B, 0x46, 0x84, 
	0x6C, 0xAE, 0xAA, 0xF9, 0xA0, 0x4B, 0xCD, 0x79, 0x2F, 0x4B, 0x93, 0x99, 0x89, 0x3A, 0x7E, 0xAB, 
	0x94, 0x81, 0x1F, 0x88, 0x5D, 0x86, 0x2B, 0x20, 0x7E, 0xC0, 0xA7, 0xCF, 0xA8, 0x5F, 0x05, 0xF1, 
	0x55, 0xE1, 0x27, 0x5E, 0xEA, 0xD8, 0x0C, 0xBB, 0x70, 0x5D, 0x49, 0xCA, 0x78, 0x51, 0xC9, 0x05, 
	0xFF, 0x82, 0x65, 0x03, 0x7E, 0x72, 0xC0, 0x77, 0xC3, 0x36, 0x4B, 0x0D, 0x10, 0x0B, 0x59, 0x4A, 
	0x19, 0x17, 0xFA, 0xF3, 0x5C, 0xB9, 0x31, 0xEA, 0xE3, 0x53, 0x03, 0x0F, 0x42, 0x1B, 0x75, 0x61, 
	0x21, 0x45, 0x5A, 0xF4, 0x01, 0x68, 0x83, 0x5C, 0x82, 0x3E, 0xD4, 0x9F, 0x1E, 0xEC, 0x54, 0x88, 
	0x3F, 0xAC, 0x5F, 0x59, 0x37, 0xF0, 0x56, 0x79, 0x6B, 0x9E, 0xAD, 0xA9, 0x24, 0x13, 0xEE, 0xD7, 
	0x4A, 0x6C, 0xA1, 0xA4, 0xD9, 0x09, 0x8F, 0x21, 0x46, 0x6A, 0xC3, 0x5E, 0x9E, 0xD9, 0xC0, 0xC7, 
	0x91, 0x44, 0xCD, 0x4F, 0x59, 0xF0, 0xD4, 0x2B, 0xA6, 0x36, 0x0A, 0x33, 0xCD, 0x23, 0xA0, 0xAF, 
	0x14, 0x64, 0xE1, 0x4C, 0x92, 0x01, 0x05, 0xFA, 0x20, 0x18, 0x94, 0x1B, 0x16, 0x95, 0x21, 0xF7, 
	0x1B, 0x1D, 0xEE, 0xE2, 0xD2, 0x68, 0x5B, 0x20, 0xDE, 0x1E, 0xD4, 0x0D, 0x9E, 0x3A, 0xF7, 0x11, 
	0xBB, 0xC4, 0x6E, 0xAD, 0xD5, 0x87, 0x83, 0xAA, 0x4F, 0x29, 0x02, 0x66, 0x0C, 0xD1, 0x14, 0xCC, 
	0x69, 0x17, 0x94, 0xFB, 0xF8, 0xEE, 0xDB, 0xF4, 0xCB, 0xC1, 0x6F, 0xCD, 0xD5, 0xFA, 0x2A, 0x35, 
	0xF1, 0x58, 0x3C, 0x64, 0xE9, 0xCD, 0x2C, 0xCB, 0x6B, 0xDE, 0x7C, 0x7B, 0xA8, 0x0F, 0x96, 0x25, 
	0x14, 0x60, 0x84, 0x5D, 0x87, 0xCA, 0x76, 0xA0, 0xDA, 0xBC, 0xF1, 0x26, 0xCF, 0x07, 0xA3, 0xE9, 
	0x3A, 0xDD, 0x48, 0x0D, 0xAD, 0xC9, 0xC4, 0xE6, 0x10, 0x32, 0xDA, 0x21, 0x4B, 0x19, 0xAF, 0xAF, 
	0xDD, 0x26, 0x57, 0x1F, 0x97, 0xD5, 0x1B, 0x87, 0xDD, 0xFF, 0xB3, 0x43, 0x17, 0x8F, 0x15, 0xDB, 
	0x87, 0xEB, 0x71, 0xFF, 0xFB, 0xD3, 0xC2, 0x7D, 0xF8, 0x40, 0xEB, 0xBA, 0x61, 0x93, 0xD1, 0xB8, 
	0xC6, 0x7A, 0x48, 0x6D, 0xE3, 0x08, 0x2D, 0xB2, 0xF3, 0xCC, 0x60, 0x72, 0x17, 0x7B, 0x64, 0x58, 
	0xFC, 0x98, 0xFB, 0x6A, 0x19, 0x5E, 0x59, 0x71, 0x2C, 0x4F, 0x82, 0x68, 0xD9, 0x29, 0xB3, 0xCF, 
	0x34, 0xD1, 0x8B, 0xD5, 0x34, 0x72, 0xB7, 0x90, 0xC4, 0x76, 0x84, 0xCB, 0xC0, 0xD1, 0x1B, 0x1D, 
	0x2F, 0x50, 0x88, 0x5A, 0xEB, 0xEE, 0x18, 0x5B, 0xA4, 0x19, 0x2F, 0x9A, 0xC1, 0x59, 0xB0, 0xAA, 
	0x72, 0xCC, 0xB4, 0xD7, 0x21, 0x4D, 0xAC, 0xE9, 0x64, 0xA3, 0xB0, 0x92, 0xC3, 0x99, 0x43, 0xBF, 
	0x75, 0x25, 0x38, 0x6F, 0x8E, 0x95, 0x93, 0x4F, 0xC0, 0xA0, 0xC4, 0xD9, 0x45, 0x09, 0x36, 0xC9, 
	0x55, 0xBA, 0xB8, 0x96, 0xB2, 0x35, 0xA5, 0x21, 0x91, 0x31, 0x39, 0x13, 0x76, 0x54, 0x9D, 0x90, 
	0x8F, 0xD8, 0x72, 0x41, 0xAA, 0x76, 0xFD, 0x00, 0xB4, 0x54, 0x68, 0x96, 0x2C, 0xB2, 0x37, 0x18, 
	0xBB, 0x0B, 0xF7, 0xF9, 0xFF, 0x60, 0xEF, 0x60, 0xA3, 0xD0, 0xC5, 0x1E, 0x21, 0x39, 0x98, 0x7B
	};

	unsigned char data1[971] = {
	0x93, 0x0F, 0x05, 0x2B, 0x32, 0x28, 0xF8, 0x85, 0x39, 0xAE, 0x40, 0x9F, 0x88, 0xAD, 0x52, 0xA3, 
	0x14, 0x8F, 0x5C, 0x21, 0x87, 0x4D, 0x0F, 0x8A, 0xF9, 0x3C, 0xD6, 0xAA, 0x48, 0xAA, 0x67, 0xB1, 
	0x39, 0xC6, 0xCB, 0x73, 0x8B, 0x0A, 0xA7, 0x40, 0x3D, 0x4D, 0xCB, 0xF5, 0x4F, 0x15, 0xE6, 0xC4, 
	0x55, 0x4A, 0x84, 0xF5, 0x8E, 0xE1, 0x7C, 0x9D, 0xD4, 0x63, 0x88, 0x3E, 0x3A, 0xE0, 0x47, 0x79, 
	0x2A, 0xB5, 0xD2, 0xD6, 0xBA, 0x59, 0x19, 0x14, 0xEA, 0x9F, 0xC0, 0x92, 0x4F, 0x34, 0x87, 0x2F, 
	0xA5, 0x38, 0x5A, 0x9E, 0x4E, 0x3E, 0x9C, 0x2D, 0xD8, 0x27, 0x64, 0x6C, 0x40, 0x28, 0xF0, 0x19, 
	0x9E, 0x5B, 0x91, 0xF9, 0x41, 0x81, 0xB7, 0x49, 0x95, 0x7B, 0x84, 0xC7, 0xD6, 0x58, 0x38, 0x88, 
	0xB4, 0xE2, 0x24, 0xA0, 0xBF, 0x90, 0xA0, 0xFE, 0x88, 0x4F, 0x95, 0x69, 0x49, 0x45, 0x3D, 0x99, 
	0x8F, 0x47, 0x3B, 0xB1, 0x1B, 0xB6, 0x9E, 0x62, 0x23, 0xAF, 0x0A, 0x69, 0x1B, 0xD9, 0x01, 0x0E, 
	0xF4, 0x32, 0x1A, 0x05, 0xE7, 0x21, 0xD6, 0x5E, 0x36, 0x51, 0xEF, 0x1E, 0x5D, 0x61, 0x77, 0x14, 
	0x1A, 0x0A, 0x71, 0x84, 0x1F, 0x3B, 0x25, 0x44, 0xCB, 0xCD, 0x61, 0x42, 0x10, 0xED, 0x7B, 0xD9, 
	0x4E, 0x0F, 0xB2, 0x59, 0xA3, 0xE2, 0xEC, 0x96, 0xDF, 0x68, 0xB8, 0x07, 0x0C, 0x19, 0xA4, 0x3D, 
	0x8E, 0x11, 0xCE, 0x51, 0x37, 0xF6, 0x28, 0x41, 0x31, 0x97, 0xD7, 0xB0, 0x62, 0xC0, 0xFB, 0x55, 
	0xF2, 0xA2, 0x2D, 0xC6, 0x03, 0xE2, 0xC4, 0x16, 0x7A, 0x26, 0x85, 0xD9, 0xE4, 0x81, 0x54, 0x95, 
	0x1A, 0xB9, 0x86, 0x45, 0xCB, 0xD3, 0x85, 0xFC, 0x7F, 0xA8, 0xC2, 0x0F, 0x25, 0xDA, 0x08, 0xA0, 
	0xE3, 0x62, 0xF1, 0x05, 0x70, 0x46, 0x99, 0xAA, 0x14, 0x8F, 0x00, 0xFD, 0x38, 0x47, 0xEA, 0xF4, 
	0x94, 0x16, 0xFB, 0xE5, 0xA1, 0x61, 0xF9, 0xF4, 0x67, 0x7F, 0xE3, 0xA3, 0xE6, 0x07, 0xFD, 0xA4, 
	0xA3, 0xA5, 0x22, 0x54, 0x80, 0x52, 0xA3, 0x46, 0x2A, 0x80, 0x93, 0xD5, 0xA0, 0x8C, 0xBB, 0xA6, 
	0x30, 0x8B, 0x46, 0x64, 0xB7, 0x3A, 0x35, 0xDB, 0x10, 0xE6, 0x4E, 0x64, 0x40, 0x06, 0x77, 0x8C, 
	0x02, 0x89, 0x44, 0xA6, 0xA5, 0x27, 0x12, 0xD4, 0xAC, 0x13, 0x24, 0xE0, 0x9B, 0x01, 0xAD, 0x2B, 
	0x29, 0x8A, 0xB8, 0xC4, 0x0F, 0xE7, 0x7F, 0xCD, 0x59, 0x09, 0x10, 0xDB, 0x4E, 0x33, 0x05, 0x3E, 
	0x78, 0x5D, 0x0E, 0x31, 0x59, 0xB7, 0xB2, 0xE5, 0x39, 0x22, 0x8D, 0x25, 0xC6, 0x94, 0x01, 0x4A, 
	0x0B, 0xCA, 0xF8, 0xE3, 0x23, 0x9D, 0xE8, 0x7E, 0x3C, 0xB9, 0x40, 0x20, 0xC9, 0x5B, 0xE0, 0x69, 
	0x9C, 0x15, 0x41, 0xF6, 0x07, 0x14, 0x43, 0xC0, 0xEE, 0xA6, 0xC0, 0x25, 0xAC, 0x63, 0x49, 0xF3, 
	0x9C, 0x08, 0x70, 0x7E, 0xA3, 0x03, 0xFF, 0x5F, 0x37, 0x99, 0x2E, 0x01, 0x8E, 0x3B, 0x1F, 0x94, 
	0x4D, 0x58, 0xE0, 0x70, 0x07, 0x2F, 0x4C, 0xF9, 0x93, 0xD1, 0x41, 0x19, 0x49, 0x55, 0xA0, 0xA3, 
	0x89, 0x51, 0xC0, 0x22, 0x7E, 0x65, 0xDC, 0xB6, 0x39, 0x63, 0x0A, 0xE5, 0x27, 0x49, 0x7A, 0x5B, 
	0x4D, 0x67, 0x2D, 0x24, 0x6D, 0x8C, 0xE9, 0x86, 0x9B, 0xB7, 0x74, 0x0D, 0xD3, 0x1D, 0xAB, 0x1A, 
	0xFB, 0xAA, 0x0D, 0x0D, 0x99, 0x26, 0x5E, 0x90, 0x51, 0xCA, 0xB3, 0x1F, 0x50, 0x7A, 0xD3, 0x89, 
	0xA9, 0x34, 0x31, 0x0C, 0x74, 0x7D, 0x93, 0x75, 0x1F, 0xCD, 0x91, 0xB7, 0xB6, 0x8C, 0xD8, 0xF7, 
	0x45, 0x60, 0xC7, 0x90, 0xF1, 0x3D, 0x34, 0x74, 0xE2, 0xA5, 0x95, 0xD8, 0x13, 0xB9, 0xCA, 0xBC, 
	0x5B, 0xB6, 0x37, 0xC9, 0x78, 0x8E, 0xFC, 0xB0, 0xF4, 0xD6, 0x24, 0xC7, 0xBD, 0x32, 0x39, 0xCF, 
	0xA7, 0xAE, 0x69, 0xD6, 0xFB, 0xF0, 0x15, 0x20, 0x0F, 0x1F, 0xDE, 0x55, 0xF6, 0x49, 0xBA, 0xFC, 
	0xCB, 0xA1, 0xD1, 0xEC, 0x74, 0xD7, 0xEE, 0x5A, 0x7A, 0x62, 0x64, 0xDC, 0xFD, 0x43, 0xCA, 0xA9, 
	0x71, 0xF6, 0x0C, 0x08, 0x0E, 0x10, 0x63, 0x69, 0xED, 0xEF, 0xF9, 0x1F, 0x74, 0x8C, 0x8F, 0xC5, 
	0x3B, 0x5B, 0x49, 0x59, 0xF9, 0xAE, 0xF3, 0x8E, 0x50, 0x58, 0x50, 0x68, 0x15, 0x36, 0x89, 0xC5, 
	0xFB, 0x0D, 0x56, 0xA8, 0xC9, 0x72, 0xAC, 0x7A, 0x7D, 0x33, 0x83, 0x3C, 0x72, 0xEE, 0x8B, 0x24, 
	0xFB, 0x7E, 0x80, 0xD4, 0x89, 0xA6, 0x10, 0xE7, 0x56, 0xD9, 0x53, 0x6C, 0x8C, 0x35, 0x9C, 0xDD, 
	0x6A, 0x89, 0xBE, 0x06, 0x17, 0x87, 0x9D, 0x21, 0x28, 0x41, 0x6F, 0x16, 0x4E, 0xD5, 0xF0, 0x18, 
	0x1E, 0x23, 0x04, 0xC6, 0x47, 0xF1, 0x38, 0xA9, 0xEE, 0x8D, 0xA5, 0xDF, 0x5C, 0x86, 0x22, 0xDC, 
	0xCE, 0x87, 0xE7, 0xA1, 0xB1, 0xEA, 0xB7, 0x60, 0x95, 0x86, 0xF6, 0x5D, 0xEA, 0x58, 0xE9, 0x1F, 
	0x9E, 0x8B, 0x27, 0xFD, 0xCC, 0x6E, 0xF3, 0x65, 0x3C, 0xCF, 0xBA, 0x46, 0xAE, 0x68, 0x82, 0xA9, 
	0x3C, 0x6C, 0xC8, 0xD1, 0x98, 0xF8, 0xE6, 0xDD, 0xB3, 0xA1, 0xDB, 0x51, 0x29, 0x5E, 0xE6, 0xD0, 
	0x07, 0xB3, 0xE2, 0xD9, 0x68, 0xAB, 0xA4, 0xD0, 0x42, 0x3D, 0x37, 0xD1, 0x7B, 0x6E, 0xAF, 0x77, 
	0xCE, 0x0E, 0x5C, 0x95, 0x6A, 0xD8, 0xCB, 0xC3, 0xDE, 0xBE, 0xDE, 0xA5, 0x17, 0x44, 0x7C, 0x42, 
	0x88, 0x23, 0xD4, 0xF4, 0xFE, 0x36, 0xF0, 0x65, 0xDA, 0x45, 0x60, 0x7C, 0x7A, 0x31, 0x09, 0xA2, 
	0xD0, 0x6E, 0x21, 0x65, 0x13, 0x40, 0xEC, 0xE8, 0x7A, 0x45, 0x38, 0xFF, 0x82, 0x9C, 0x63, 0x85, 
	0x9B, 0xE3, 0x65, 0xD0, 0x37, 0x5B, 0xFE, 0xAB, 0x34, 0xFB, 0x22, 0x48, 0x6F, 0xE0, 0x51, 0x16, 
	0x39, 0x55, 0x43, 0x70, 0xC9, 0x29, 0x76, 0x0E, 0xBD, 0x3A, 0x30, 0xF3, 0x16, 0xF0, 0x34, 0x7D, 
	0x50, 0xA6, 0x1D, 0x4E, 0xCD, 0x8F, 0x5C, 0x58, 0x52, 0xDB, 0xBB, 0x11, 0x03, 0x05, 0xC8, 0x25, 
	0x57, 0x94, 0xB1, 0xAC, 0x84, 0x88, 0x11, 0x34, 0x3F, 0x85, 0x8E, 0x48, 0x8F, 0x60, 0x5A, 0x79, 
	0x0C, 0x86, 0x7E, 0x39, 0xD0, 0xB9, 0x6C, 0xFC, 0x38, 0xD1, 0xA3, 0xBE, 0x45, 0xDC, 0xC8, 0x6C, 
	0x05, 0x95, 0x82, 0x38, 0xAE, 0x85, 0x22, 0xB7, 0x36, 0x2C, 0xE9, 0x9F, 0x10, 0xB5, 0x9C, 0xFB, 
	0xAA, 0xF0, 0x28, 0xF5, 0x0A, 0x79, 0x1E, 0xB9, 0xF8, 0x90, 0xDE, 0x06, 0xFF, 0xEF, 0x0C, 0x2D, 
	0xD2, 0xD3, 0x34, 0x4E, 0x45, 0x5D, 0xEB, 0x1E, 0xAE, 0x26, 0xBD, 0xDE, 0xE8, 0x33, 0x49, 0x9D, 
	0x9B, 0xF6, 0xDA, 0x0E, 0x88, 0x3E, 0xD5, 0xA1, 0x4B, 0x33, 0x89, 0x51, 0x16, 0x75, 0xD0, 0x96, 
	0xED, 0x6A, 0xBE, 0x41, 0x5F, 0xE6, 0xAA, 0x8A, 0x1E, 0xE7, 0xD4, 0x3E, 0x7E, 0x4B, 0x1E, 0x2D, 
	0xB1, 0x06, 0xD4, 0xCB, 0x21, 0x68, 0xE2, 0x87, 0x63, 0x40, 0xFC, 0x6B, 0xC5, 0x73, 0x1C, 0x53, 
	0xA7, 0xAE, 0x2E, 0xF5, 0x70, 0x22, 0xE2, 0x71, 0x6C, 0xF9, 0x6A, 0x85, 0x38, 0x45, 0xD6, 0xC0, 
	0x0F, 0x2A, 0x0A, 0xFB, 0xD4, 0x50, 0x25, 0x3A, 0xEB, 0x4A, 0x35, 0x3B, 0x9A, 0xE0, 0xDD, 0xAB, 
	0xFB, 0xDD, 0xDE, 0x70, 0x7E, 0x6B, 0x63, 0xBA, 0xB4, 0x24, 0xEB
	};

	unsigned char data2[871] = {
	0xC7, 0x07, 0x05, 0x4E, 0x5B, 0xED, 0x8C, 0x33, 0xD6, 0x0C, 0xDC, 0xE9, 0x0E, 0xD8, 0x7E, 0x0B, 
	0xD1, 0x4D, 0x01, 0xC8, 0x46, 0xDC, 0x2A, 0x87, 0xBD, 0x1D, 0x35, 0x48, 0xC7, 0x25, 0xF1, 0x3E, 
	0x68, 0x59, 0xBD, 0x45, 0x0A, 0x36, 0xBA, 0xEA, 0xA3, 0xB9, 0x10, 0x85, 0x06, 0x03, 0x77, 0x30, 
	0x26, 0x98, 0x73, 0x8A, 0x5D, 0x6A, 0xB2, 0xB9, 0x16, 0x52, 0xD6, 0xB2, 0x0E, 0xA8, 0xFB, 0x8F, 
	0x8C, 0x3D, 0xB7, 0xFE, 0xFA, 0x25, 0xC9, 0xFF, 0x64, 0x29, 0xC9, 0xD5, 0x01, 0x40, 0xAB, 0xB0, 
	0xCE, 0xA3, 0x3F, 0x35, 0x46, 0x71, 0x41, 0xDE, 0x6A, 0x9D, 0x28, 0xCB, 0x6B, 0x71, 0x82, 0xCB, 
	0xE4, 0xDD, 0xBF, 0x23, 0x21, 0x05, 0x3A, 0x76, 0x8E, 0x17, 0x82, 0x07, 0x53, 0x30, 0x47, 0xDF, 
	0xED, 0xE6, 0x48, 0x2C, 0x41, 0x32, 0xF2, 0x81, 0xDB, 0xCC, 0x6F, 0x2F, 0xB8, 0x81, 0xCD, 0xD2, 
	0x55, 0x2F, 0x70, 0x67, 0x6D, 0xB8, 0x08, 0x62, 0x81, 0x4D, 0xB1, 0x40, 0xCD, 0x78, 0x74, 0x1D, 
	0xE2, 0x02, 0xFA, 0xED, 0xC2, 0xF6, 0x3D, 0x2F, 0xD4, 0xC2, 0x0C, 0x48, 0x82, 0xCF, 0xD3, 0xF0, 
	0xBC, 0xA4, 0x5B, 0x59, 0xA9, 0x7B, 0xD1, 0xCD, 0x0C, 0x17, 0xBA, 0xFE, 0xD4, 0xFF, 0x42, 0x5A, 
	0xAF, 0xC1, 0xB0, 0x2E, 0xD0, 0x28, 0x4F, 0xB5, 0x97, 0x3C, 0x54, 0xAD, 0xFD, 0x7D, 0x99, 0x4E, 
	0xE7, 0x36, 0xC0, 0x2C, 0xE5, 0x21, 0xAB, 0xFF, 0xD3, 0xCF, 0xFC, 0x62, 0x18, 0x38, 0x8D, 0x21, 
	0x38, 0x1A, 0xA6, 0xD7, 0x81, 0x68, 0x94, 0xEE, 0x5F, 0xEE, 0xCC, 0xF9, 0x06, 0x62, 0x06, 0x8F, 
	0xDF, 0x6F, 0xC2, 0xA3, 0x61, 0x17, 0x18, 0xF5, 0x38, 0xFB, 0x71, 0xB1, 0x32, 0xE6, 0x0A, 0x2C, 
	0x23, 0x5E, 0xA4, 0x19, 0x90, 0x32, 0x74, 0xD1, 0x51, 0xF3, 0x80, 0x97, 0xD9, 0x27, 0x29, 0x6C, 
	0x52, 0x99, 0x3F, 0x72, 0x0F, 0x06, 0xAC, 0x26, 0x21, 0xBB, 0x0B, 0xC7, 0xF8, 0xED, 0x0D, 0x68, 
	0x95, 0x5B, 0x2C, 0x36, 0x97, 0xA0, 0x42, 0xE9, 0xC7, 0xDC, 0x10, 0x0A, 0xF5, 0x5B, 0x54, 0x9C, 
	0xA6, 0xFA, 0x21, 0xB9, 0x28, 0x38, 0x21, 0xA6, 0xC2, 0xE2, 0x26, 0x1F, 0x26, 0x25, 0x5E, 0x3A, 
	0xC6, 0x52, 0x42, 0x3B, 0xFF, 0x2C, 0xB5, 0xE2, 0xE6, 0x4D, 0x7E, 0xDE, 0xC1, 0xEB, 0x7A, 0xF0, 
	0x6A, 0xBA, 0xA4, 0x50, 0xCB, 0x77, 0x15, 0x6C, 0x9B, 0xDD, 0x0F, 0xE8, 0x8E, 0x90, 0x4E, 0x63, 
	0xC9, 0xBB, 0x94, 0xF2, 0x45, 0x89, 0x93, 0x4B, 0xCE, 0x9D, 0x34, 0x9C, 0xA5, 0xB1, 0xEC, 0x72, 
	0x41, 0xDE, 0x0C, 0xF0, 0x1E, 0x39, 0xB0, 0x9A, 0xF0, 0x77, 0xF7, 0x94, 0x57, 0xA4, 0x48, 0x1A, 
	0x68, 0x0A, 0xF4, 0xE5, 0xBA, 0xB7, 0x83, 0x50, 0x07, 0x3B, 0x9B, 0x2C, 0x3C, 0xD7, 0xD7, 0xFD, 
	0x03, 0xA3, 0x9F, 0xCE, 0x27, 0xBB, 0x80, 0x14, 0xEF, 0xA2, 0xE0, 0x2F, 0x12, 0xD9, 0x80, 0xFE, 
	0xB3, 0x88, 0x69, 0x19, 0x0E, 0x83, 0x25, 0x9A, 0x99, 0x46, 0x51, 0x09, 0x9B, 0xEC, 0x95, 0xFE, 
	0xE9, 0xDD, 0xAB, 0x52, 0xBA, 0xDB, 0x18, 0xA1, 0x39, 0x5D, 0xCF, 0xA7, 0xC9, 0xE6, 0xCC, 0xE1, 
	0x65, 0x53, 0x38, 0x91, 0x87, 0x80, 0x73, 0x28, 0xAA, 0x43, 0x3D, 0x2E, 0x01, 0x9F, 0x7B, 0x7B, 
	0x25, 0x1D, 0x59, 0x0D, 0x05, 0x0E, 0x3A, 0xE2, 0x16, 0x87, 0x9F, 0x7F, 0xC1, 0xA2, 0x53, 0x2B, 
	0xDC, 0x81, 0x6C, 0x62, 0x40, 0x79, 0x91, 0x35, 0x3B, 0x95, 0x9F, 0x3F, 0x44, 0x1D, 0xF7, 0x1F, 
	0x2E, 0x83, 0xC7, 0x75, 0x0D, 0x21, 0x05, 0xE3, 0xCA, 0x57, 0x3B, 0x8B, 0x99, 0xC6, 0x83, 0x03, 
	0xB5, 0x90, 0x2C, 0xB8, 0x6E, 0x2E, 0x2D, 0x05, 0xAA, 0x8F, 0xA1, 0x3E, 0x2F, 0xED, 0xEC, 0x59, 
	0x92, 0xF6, 0xCC, 0x89, 0x29, 0x32, 0x7E, 0xFB, 0x6F, 0x43, 0xBD, 0x09, 0xD4, 0xB1, 0x05, 0x05, 
	0xED, 0x3D, 0x7D, 0x79, 0x01, 0x25, 0x3D, 0xF7, 0xBA, 0xA6, 0xEA, 0xE4, 0x36, 0x15, 0xD3, 0x8C, 
	0xDC, 0x7C, 0x19, 0xC0, 0x46, 0x8B, 0xF4, 0x93, 0x29, 0x3C, 0xB1, 0x60, 0xC1, 0xAD, 0xD8, 0xF1, 
	0xE1, 0x5B, 0x0C, 0x0A, 0x7E, 0x83, 0x87, 0xA6, 0x37, 0xD7, 0x0D, 0x32, 0x8C, 0x06, 0x4A, 0xE2, 
	0x42, 0xB2, 0xC9, 0x29, 0xDA, 0x71, 0xD5, 0x65, 0xCF, 0x63, 0x82, 0xD2, 0x2A, 0xF5, 0x1A, 0x23, 
	0xF6, 0x73, 0x07, 0x87, 0x8F, 0xB3, 0x9B, 0x46, 0xDC, 0x5F, 0x0E, 0x39, 0x88, 0x60, 0xE2, 0xB0, 
	0x2F, 0x11, 0x8E, 0x05, 0xAC, 0xD3, 0x0B, 0x8D, 0x43, 0xD1, 0x30, 0x93, 0xF3, 0xBC, 0xD7, 0x23, 
	0x53, 0xAA, 0x62, 0x40, 0xFC, 0xDF, 0xF9, 0xFD, 0x4E, 0xDB, 0x36, 0xFC, 0x68, 0x70, 0x96, 0x01, 
	0xF2, 0xE6, 0xA8, 0x1E, 0x34, 0x92, 0xF6, 0x48, 0x75, 0x44, 0xF7, 0x65, 0x0F, 0xCA, 0xA4, 0xBF, 
	0xAA, 0x91, 0xBD, 0xB4, 0x45, 0x80, 0x9C, 0xBA, 0x7C, 0x38, 0xD6, 0x5F, 0x6E, 0xF3, 0xF9, 0x88, 
	0x3B, 0x49, 0xBD, 0x44, 0x7F, 0x23, 0xA1, 0xC5, 0x6D, 0x0A, 0x31, 0x69, 0x89, 0xC3, 0xC3, 0xBA, 
	0x7F, 0xCA, 0xE3, 0x15, 0x13, 0xC2, 0x11, 0xAA, 0x53, 0xCE, 0xAE, 0xF5, 0xFE, 0xA4, 0x08, 0xD7, 
	0xBE, 0xBD, 0x7F, 0xD2, 0xF5, 0x28, 0x4C, 0xEF, 0x7D, 0x0B, 0x91, 0x0E, 0xB2, 0x38, 0xA4, 0xC2, 
	0x0F, 0x02, 0x29, 0x09, 0x31, 0xAB, 0x20, 0x68, 0xA4, 0x59, 0x62, 0x02, 0x6F, 0x96, 0xA2, 0xD6, 
	0xC5, 0xC9, 0x0F, 0x61, 0xE3, 0x42, 0xE7, 0x9B, 0x17, 0xEC, 0x3F, 0x05, 0xB9, 0xBB, 0xBF, 0x20, 
	0x38, 0xE8, 0xF5, 0x89, 0xC6, 0x9D, 0xC3, 0xF0, 0xF7, 0xF1, 0xC2, 0x23, 0x42, 0xFA, 0xDE, 0x5F, 
	0xC0, 0x08, 0xF0, 0x67, 0x9D, 0xC1, 0x72, 0x74, 0x11, 0xF6, 0xF6, 0x26, 0x75, 0x66, 0x64, 0x35, 
	0x1D, 0x50, 0x35, 0xED, 0xB7, 0xC8, 0x34, 0x22, 0x92, 0x1D, 0xD1, 0x45, 0xAD, 0x17, 0x85, 0x70, 
	0x36, 0x7F, 0x62, 0x94, 0x41, 0x0A, 0xC7, 0x84, 0xFA, 0x07, 0xC5, 0xFA, 0x53, 0x19, 0x87, 0x3D, 
	0x2B, 0xDF, 0xA7, 0xBC, 0xE6, 0x26, 0x3C, 0x77, 0x1E, 0xFE, 0xEE, 0x00, 0xBB, 0x2A, 0xA7, 0xF0, 
	0x92, 0xA7, 0xB0, 0x16, 0x42, 0xF1, 0x9B, 0xD6, 0x0D, 0xF3, 0x8F, 0x8E, 0xCF, 0x41, 0xE7, 0x8B, 
	0x64, 0xB0, 0x9C, 0x86, 0xA5, 0x5B, 0x2E, 0x10, 0x67, 0xB3, 0x36, 0x04, 0x34, 0xD1, 0x92, 0xC8, 
	0x18, 0xA2, 0xBA, 0x60, 0x11, 0x3B, 0xDB
	};

	unsigned char data3[581] = {
	0x29, 0x05, 0x07, 0x5C, 0x5F, 0xA4, 0xCA, 0x33, 0x2B, 0x51, 0x16, 0xDF, 0x38, 0x6E, 0x4A, 0x21, 
	0xB7, 0x80, 0x59, 0x75, 0xDB, 0x2D, 0x05, 0x0A, 0xA4, 0x82, 0xD3, 0x09, 0x19, 0xE7, 0x98, 0x7F, 
	0xF8, 0xC8, 0x7B, 0x44, 0xD8, 0x5E, 0xC3, 0x40, 0x3E, 0x8C, 0xAF, 0xFD, 0xB3, 0x05, 0x05, 0xBD, 
	0x36, 0x72, 0x97, 0x3B, 0x33, 0x28, 0x0A, 0x13, 0xA0, 0xA0, 0x3B, 0x3B, 0x17, 0x04, 0x73, 0xCE, 
	0x93, 0x19, 0xB2, 0x85, 0xEB, 0x95, 0x7E, 0x03, 0xDD, 0x19, 0x84, 0xFE, 0xBF, 0x60, 0xEF, 0xEE, 
	0x0D, 0x1F, 0x1D, 0x7D, 0x6A, 0x3C, 0x96, 0xEB, 0x5C, 0xCB, 0x2E, 0x01, 0x8A, 0xC6, 0x59, 0xFB, 
	0x5A, 0x62, 0xA5, 0xFD, 0xFA, 0x14, 0x9C, 0xAF, 0xFF, 0x26, 0xBE, 0x1C, 0x25, 0x6F, 0x4B, 0x16, 
	0x9D, 0x60, 0xCB, 0x6D, 0x24, 0x52, 0xCE, 0x09, 0x7C, 0x9B, 0xFA, 0x6E, 0xD0, 0xA3, 0x19, 0x83, 
	0x06, 0x85, 0x5E, 0x36, 0xB4, 0x48, 0xF5, 0x81, 0xE6, 0x19, 0x9F, 0x94, 0x22, 0x40, 0xF9, 0x79, 
	0x6F, 0x58, 0x4A, 0x65, 0x14, 0x7A, 0xBD, 0x54, 0xE6, 0x7C, 0xC7, 0x60, 0x61, 0x4F, 0xF2, 0x6B, 
	0x50, 0x55, 0x50, 0x1B, 0x2E, 0x87, 0xEA, 0xE2, 0x17, 0x59, 0xF1, 0xD9, 0x85, 0x6E, 0x3E, 0x9E, 
	0xA3, 0x07, 0x61, 0x51, 0xF6, 0x41, 0x4C, 0x01, 0x01, 0x42, 0xDF, 0x05, 0xBC, 0x04, 0xCF, 0x3F, 
	0x82, 0x9D, 0xF6, 0x2D, 0x69, 0x1D, 0x16, 0xE2, 0x11, 0x68, 0x25, 0xA4, 0x86, 0xB3, 0x19, 0x03, 
	0x3B, 0x84, 0xD8, 0xC9, 0x9E, 0xB6, 0x71, 0x8B, 0x30, 0xC3, 0x8D, 0xFC, 0x6F, 0xE7, 0x41, 0x1A, 
	0x3F, 0x52, 0xF3, 0xD0, 0xD9, 0x95, 0x8B, 0xC7, 0x7F, 0xE6, 0xB7, 0x2D, 0x64, 0x39, 0x46, 0x77, 
	0x51, 0x5F, 0x72, 0x65, 0x52, 0xCC, 0xB5, 0x0E, 0x92, 0x1C, 0x74, 0x7E, 0x33, 0xB3, 0x91, 0x7A, 
	0xBD, 0x3E, 0x12, 0x13, 0x67, 0x5B, 0x76, 0x26, 0x79, 0x7C, 0xFD, 0x7E, 0x42, 0x51, 0x46, 0xE9, 
	0xFD, 0x8F, 0xDB, 0x97, 0x21, 0x95, 0xFE, 0xB9, 0xEA, 0x66, 0xF1, 0xD4, 0x78, 0xDF, 0x9B, 0x31, 
	0xBA, 0xFC, 0x0A, 0xA4, 0x32, 0xFC, 0x32, 0xFA, 0x34, 0x6D, 0xB3, 0x6A, 0x7E, 0xBC, 0xE5, 0x20, 
	0x75, 0x06, 0xEA, 0xBB, 0xAA, 0x9E, 0x52, 0x46, 0xE0, 0x9A, 0x2A, 0x2B, 0x92, 0x10, 0x9F, 0x63, 
	0xF9, 0xC0, 0x60, 0xAD, 0xA7, 0x58, 0x52, 0x15, 0x7D, 0x92, 0x41, 0xDA, 0xA0, 0x98, 0x5C, 0xBC, 
	0xBC, 0xD8, 0xB2, 0xCA, 0xEE, 0x82, 0xFF, 0x1F, 0xCF, 0x56, 0xDB, 0x3F, 0xE6, 0x29, 0xCA, 0x3C, 
	0x74, 0x08, 0x7F, 0x7B, 0xCE, 0x34, 0x54, 0x94, 0x5F, 0x19, 0x14, 0xA2, 0x36, 0x08, 0xAE, 0xDA, 
	0xB1, 0x5E, 0x60, 0x63, 0x58, 0xF4, 0xB5, 0x7B, 0x46, 0x16, 0x0B, 0xFA, 0x57, 0xCA, 0xD4, 0x7F, 
	0x25, 0xA9, 0x73, 0x57, 0xBC, 0x59, 0x20, 0xA7, 0x01, 0x05, 0x33, 0xF8, 0x3A, 0x2B, 0x9E, 0x46, 
	0xA9, 0xA8, 0x81, 0x0C, 0x17, 0x66, 0x79, 0x73, 0x70, 0x1D, 0x79, 0xAA, 0x7F, 0x05, 0x03, 0xD5, 
	0x04, 0x6F, 0xD6, 0x5B, 0xAB, 0xCC, 0x92, 0x1A, 0xB4, 0x2B, 0xD0, 0xBF, 0x08, 0x51, 0x6C, 0x66, 
	0xD2, 0x26, 0x8A, 0xAC, 0x23, 0x44, 0x86, 0x8D, 0xAC, 0x58, 0x99, 0xD2, 0x12, 0x81, 0x22, 0x82, 
	0x3E, 0x77, 0x47, 0x63, 0x2A, 0xA7, 0xE8, 0x3E, 0x03, 0x95, 0x80, 0x20, 0xB4, 0x46, 0x46, 0x0D, 
	0x89, 0xF7, 0x30, 0xA5, 0x6F, 0xF4, 0x7B, 0x72, 0x91, 0xA1, 0x14, 0x77, 0x1B, 0x05, 0x2D, 0x58, 
	0xF4, 0x59, 0x71, 0x8E, 0xAF, 0xF1, 0x80, 0xFC, 0x18, 0x70, 0x33, 0x05, 0xA6, 0x56, 0x2E, 0x34, 
	0xCA, 0x4E, 0x33, 0xE2, 0x58, 0x49, 0x76, 0x55, 0x0C, 0x70, 0x8A, 0x5F, 0x92, 0xC8, 0x2D, 0x8E, 
	0x6C, 0x77, 0xB2, 0xA9, 0x1B, 0x05, 0xA9, 0x5C, 0x05, 0x46, 0xBC, 0xBE, 0x8E, 0xFA, 0x82, 0x6B, 
	0xDA, 0x7E, 0x19, 0x05, 0x66, 0x67, 0x03, 0x5B, 0x49, 0x21, 0xDA, 0x3A, 0x39, 0xD4, 0xD6, 0x19, 
	0x05, 0x90, 0x2C, 0xAD, 0xBA, 0xB1, 0x7D, 0xE2, 0x51, 0x04, 0x12, 0x57, 0x31, 0x05, 0xAB, 0x54, 
	0x27, 0xFD, 0xC1, 0x75, 0xAA, 0x35, 0x89, 0x93, 0xBB, 0x37, 0x78, 0x1C, 0x04, 0x1B, 0xAC, 0x8B, 
	0x0B, 0xC3, 0x43, 0xC1, 0x50
	};

	AesStream_S	*AesStreamOut;
	AesStream_S	*AesStreamIn;
	SResponse	Response;
	uchar		*Browser;
	uint		Size;
	
	Browser = data0;
	Size = sizeof(data0);

	AesStreamOut = (AesStream_S *)malloc(sizeof(AesStream_S));
	AesStreamIn = (AesStream_S *)malloc(sizeof(AesStream_S));

	unsigned char key[32] = {
	0x90, 0x69, 0x3E, 0xF6, 0xA2, 0xE9, 0xC0, 0x68, 0x71, 0x1D, 0x91, 0x5A, 0xBC, 0xF5, 0x50, 0x6C, 
	0x90, 0x69, 0x3E, 0xF6, 0xA2, 0xE9, 0xC0, 0x68, 0x71, 0x1D, 0x91, 0x5A, 0xBC, 0xF5, 0x50, 0x6C
	};

	Response.Objs = NULL;
	Response.NbObj = 0;

	/*uchar				SessionKey[SK_SZ] = {0};
	uchar				SHAResult[32] = {0};

	GetSessionKey(SessionKey);
	SpecialSHA(SessionKey, 0x80, SHAResult, 16);

	showmem(SessionKey, 0x80);
	printf("--\n");
	showmem(SHAResult, 16);*/

	UserPacketManager(&Browser, (uint *)&Size, &Response, AesStreamOut, 1);

	for (uint Idx = 0; Idx < Response.NbObj; Idx++)
	{
		//DumpObj(Response.Objs[Idx]);
	}

	Browser = data1;
	Size = sizeof(data1);

	Response.Objs = NULL;
	Response.NbObj = 0;

	UserPacketManager(&Browser, (uint *)&Size, &Response, AesStreamIn, 1);

	for (uint Idx = 0; Idx < Response.NbObj; Idx++)
	{
		//DumpObj(Response.Objs[Idx]);
	}

	Browser = data2;
	Size = sizeof(data2);

	Response.Objs = NULL;
	Response.NbObj = 0;

	UserPacketManager(&Browser, (uint *)&Size, &Response, AesStreamOut, 0);

	for (uint Idx = 0; Idx < Response.NbObj; Idx++)
	{
		DumpObj(Response.Objs[Idx]);
		//if (Response.Objs[Idx].Id == 0x11)
			//DumpDirBlobMetaDatas(Response.Objs[Idx].Value.Memory.Memory, Response.Objs[Idx].Value.Memory.MsZ);
	}

	Browser = data3;
	Size = sizeof(data3);

	Response.Objs = NULL;
	Response.NbObj = 0;

	UserPacketManager(&Browser, (uint *)&Size, &Response, AesStreamIn, 0);

	for (uint Idx = 0; Idx < Response.NbObj; Idx++)
	{
		DumpObj(Response.Objs[Idx]);
	}

	ExitProcess(0);
	
	unsigned char testd[] = {0xCC, 0xD0, 0x02};
	unsigned int  testv = 0;
	unsigned char *testp = testd;

	ReadValue(&testp, &testv);
	printf("-> 0x%x\n", testv);
	ExitProcess(0);
	
	unsigned char data[328] = {
	0x00, 0x00, 0x00, 0xC4, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x63, 0xE0, 0xE5, 0x02, 0xF4, 0x91, 0x16, 
	0x4F, 0xC6, 0xAF, 0x34, 0x92, 0xB6, 0x8E, 0x16, 0xE4, 0x25, 0x8F, 0x3D, 0xD8, 0xA3, 0x2B, 0xA2, 
	0x57, 0xE8, 0x8E, 0xB9, 0x0D, 0x20, 0x08, 0x9A, 0x8D, 0xC2, 0x86, 0xC0, 0x8C, 0x16, 0xF4, 0xF8, 
	0xA0, 0xA5, 0x72, 0x1A, 0x6D, 0x21, 0xC2, 0xE2, 0x9C, 0x1B, 0xEE, 0x93, 0x47, 0x19, 0xEE, 0x5F, 
	0x25, 0x20, 0xEF, 0x6D, 0x9C, 0xEC, 0xFA, 0x5B, 0x4D, 0x3E, 0xB3, 0xA0, 0x57, 0xDC, 0x85, 0xE0, 
	0x21, 0x38, 0xBF, 0x7D, 0xB3, 0x72, 0x25, 0xDB, 0x9D, 0xC6, 0x34, 0xFA, 0xEB, 0xD4, 0xC7, 0x1E, 
	0x87, 0x0B, 0xAB, 0xBB, 0xF6, 0x1B, 0x25, 0x25, 0x99, 0xCF, 0x39, 0x5F, 0xDF, 0xC6, 0xA4, 0xAF, 
	0x10, 0xF8, 0x6B, 0x50, 0xFA, 0x49, 0x82, 0x96, 0x5E, 0xC1, 0xB0, 0xCC, 0x3F, 0x70, 0x50, 0x2B, 
	0x6C, 0xEE, 0x9C, 0xB0, 0x53, 0x2C, 0xD3, 0x33, 0x76, 0xBA, 0x09, 0xD5, 0x6F, 0x2E, 0x25, 0x98, 
	0xCA, 0x08, 0x1D, 0xA1, 0xCD, 0x16, 0xDC, 0x84, 0xC1, 0xB4, 0x71, 0xAF, 0xF1, 0x7C, 0xDA, 0x47, 
	0x7B, 0x6A, 0xD1, 0x02, 0x3D, 0x56, 0x93, 0xDA, 0xF4, 0xD2, 0xE5, 0x1A, 0xE1, 0xBF, 0xAE, 0x2B, 
	0x5C, 0x6E, 0xAA, 0x2C, 0xA9, 0x65, 0x98, 0x7F, 0x3F, 0x6A, 0x0F, 0xFE, 0x10, 0x4B, 0x61, 0x9A, 
	0xC3, 0x62, 0x09, 0x13, 0xE2, 0x43, 0x27, 0xBD, 0x69, 0x83, 0x3A, 0xAA, 0xF6, 0x15, 0xA1, 0xCB, 
	0x2B, 0x0D, 0xA4, 0xAC, 0x01, 0x0A, 0xD2, 0x9A, 0xB1, 0x2F, 0xB5, 0xDA, 0x45, 0x60, 0x82, 0x71, 
	0x99, 0x7A, 0x2C, 0xAD, 0x3B, 0xC4, 0xAB, 0x6B, 0xDB, 0xFC, 0x7F, 0x89, 0x32, 0xA6, 0x56, 0x0A, 
	0x49, 0x13, 0xE7, 0xA7, 0xD0, 0x32, 0x4A, 0x24, 0xD9, 0xCF, 0x1B, 0x20, 0x2C, 0x4D, 0x6D, 0x37, 
	0x82, 0x96, 0x09, 0x89, 0x43, 0x73, 0x3A, 0xB3, 0xA0, 0xA6, 0x4F, 0xFC, 0xAA, 0x15, 0x5B, 0x84, 
	0x2B, 0x6C, 0xBA, 0xD3, 0x4D, 0x78, 0xA6, 0xBB, 0x9E, 0x9D, 0x70, 0xEA, 0xBE, 0x3E, 0xDD, 0xC5, 
	0x26, 0xF9, 0x82, 0x4C, 0x8A, 0x88, 0x18, 0x74, 0x4B, 0xA6, 0xF9, 0xF1, 0x1D, 0x49, 0x84, 0x5D, 
	0x62, 0xB1, 0xDA, 0x49, 0x60, 0xC4, 0xF4, 0x5F, 0xBF, 0x8E, 0xA8, 0xBA, 0xE2, 0xBF, 0x44, 0x1C, 
	0x5D, 0x9C, 0xE4, 0x14, 0x2C, 0xA6, 0xFD, 0x93
	};

	DumpDirBlobMetaDatas(data, sizeof(data));
	ExitProcess(0);
	
	/*unsigned char data[470] = {
	0x41, 0x06, 0x00, 0x01, 0x24, 0x03, 0x02, 0x23, 0x6F, 0x6A, 0x2E, 0x6F, 0x6E, 0x65, 0x2F, 0x24, 
	0x6F, 0x6A, 0x2E, 0x6D, 0x65, 0x64, 0x2E, 0x70, 0x65, 0x72, 0x6D, 0x3B, 0x62, 0x37, 0x37, 0x31, 
	0x62, 0x32, 0x34, 0x38, 0x65, 0x33, 0x66, 0x61, 0x37, 0x30, 0x33, 0x33, 0x00, 0x00, 0x1B, 0x9B, 
	0x01, 0x03, 0x12, 0x6F, 0x6A, 0x2E, 0x6D, 0x65, 0x64, 0x2E, 0x70, 0x65, 0x72, 0x6D, 0x20, 0x6F, 
	0x6A, 0x2E, 0x6F, 0x6E, 0x65, 0x00, 0x03, 0x1E, 0x00, 0x05, 0x19, 0x41, 0x04, 0x05, 0x00, 0x41, 
	0x05, 0x00, 0x00, 0x9C, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0xE6, 0xD6, 0xCC, 0x9F, 0x04, 0x04, 
	0x03, 0x9B, 0x01, 0x57, 0x95, 0x40, 0x5C, 0x04, 0xCA, 0x12, 0x20, 0x1F, 0xDB, 0x2E, 0x9B, 0x21, 
	0xC5, 0x04, 0x27, 0x28, 0xD2, 0xFF, 0xB2, 0x92, 0x7C, 0xF3, 0x3E, 0x06, 0x9B, 0x2E, 0xBB, 0x21, 
	0xF5, 0xB9, 0x45, 0x89, 0x76, 0xE8, 0x3C, 0x7C, 0xCA, 0x9B, 0x85, 0x9E, 0xA7, 0x79, 0x14, 0xA3, 
	0x93, 0x55, 0xC1, 0xF8, 0x1E, 0x72, 0x28, 0x8F, 0x8C, 0x6E, 0xD2, 0xA7, 0xE6, 0x2F, 0x81, 0xF3, 
	0x2F, 0x1C, 0xF1, 0xCB, 0x43, 0xE5, 0x7C, 0x6F, 0x22, 0x4C, 0xBE, 0x30, 0xC0, 0x43, 0x8C, 0xE3, 
	0xB1, 0xFD, 0x4E, 0xB7, 0x9C, 0xC8, 0x30, 0x03, 0x5C, 0x0D, 0x21, 0x37, 0xA5, 0x59, 0xB1, 0xBE, 
	0xE5, 0xF1, 0x76, 0xA0, 0x55, 0x7C, 0x02, 0x77, 0xA0, 0x16, 0x39, 0x09, 0x1B, 0x7C, 0x16, 0xD8, 
	0x7B, 0x07, 0xE7, 0xDA, 0x09, 0xC9, 0x95, 0x86, 0x2E, 0xE3, 0xF2, 0x86, 0x88, 0x86, 0x8D, 0x9A, 
	0x45, 0x78, 0xB1, 0x03, 0x01, 0x6F, 0x6A, 0x2E, 0x6D, 0x65, 0x64, 0x2E, 0x70, 0x65, 0x72, 0x6D, 
	0x00, 0x00, 0x0A, 0x9A, 0xD7, 0xF2, 0xEB, 0x07, 0x06, 0x1B, 0x00, 0x00, 0x0B, 0x01, 0x04, 0x04, 
	0xC4, 0x01, 0x00, 0x00, 0x00, 0x00, 0x18, 0x12, 0xF6, 0xD8, 0x62, 0xFF, 0x21, 0x1F, 0x80, 0x4A, 
	0xE8, 0x33, 0x94, 0xE8, 0xFB, 0xF2, 0x48, 0x12, 0x8A, 0x58, 0xDE, 0x8E, 0x07, 0xBC, 0xEC, 0x27, 
	0x8A, 0x8D, 0xF7, 0xE5, 0x6B, 0xA3, 0xDF, 0x7A, 0xBF, 0x50, 0x51, 0xA6, 0x8F, 0x9F, 0x83, 0x73, 
	0xF0, 0x7E, 0x90, 0x00, 0x0C, 0x93, 0x81, 0xCF, 0xB9, 0x8D, 0x3E, 0xD0, 0xF9, 0xA7, 0xDD, 0xA8, 
	0x46, 0xA2, 0x53, 0xD4, 0xA8, 0x29, 0xB5, 0xC3, 0x67, 0x30, 0x51, 0x03, 0xB5, 0xC3, 0x32, 0x6D, 
	0x11, 0x09, 0x3D, 0xF5, 0xAC, 0x11, 0x4D, 0x05, 0x96, 0xFA, 0xC3, 0x6D, 0x19, 0xF3, 0x27, 0xAB, 
	0x46, 0x20, 0x38, 0x1E, 0xCA, 0x7F, 0x23, 0xA5, 0xA2, 0x0A, 0xB4, 0x7B, 0xD3, 0x07, 0x2F, 0xC9, 
	0x02, 0x98, 0xDE, 0xA1, 0xC1, 0x66, 0x37, 0x0E, 0x55, 0x49, 0x26, 0x13, 0x0A, 0x59, 0xAC, 0xF1, 
	0x96, 0x76, 0xD5, 0x7F, 0xFD, 0x85, 0x17, 0x03, 0x00, 0x21, 0x8F, 0x5A, 0xD9, 0x84, 0x1A, 0x83, 
	0x92, 0xA5, 0xBA, 0xE5, 0xFC, 0xF1, 0x5E, 0x4D, 0xC8, 0xAB, 0x78, 0x72, 0x0B, 0x1C, 0x78, 0x99, 
	0x3D, 0xBF, 0x4A, 0x78, 0x0D, 0x0F, 0x3C, 0xAF, 0xCB, 0x3C, 0x79, 0xF2, 0x53, 0x3B, 0xA5, 0xCB, 
	0x24, 0xCC, 0x89, 0x86, 0x84, 0x23, 0xB3, 0xFB, 0x47, 0x12, 0x03, 0x3B, 0xEE, 0x6D, 0xB9, 0x0D, 
	0x48, 0xBB, 0xEA, 0xB7, 0x7B, 0x53, 0x00, 0x06, 0x01, 0x00, 0x07, 0x9A, 0xD7, 0xF2, 0xEB, 0x07, 
	0x00, 0x09, 0xC9, 0xF7, 0xBA, 0x09
	};
	
	unsigned char data[386] = {
	0x41, 0x02, 0x00, 0x01, 0x2A, 0x05, 0x18, 0x41, 0x04, 0x05, 0x02, 0x41, 0x05, 0x00, 0x00, 0x0E, 
	0x00, 0x01, 0x01, 0x00, 0x02, 0xBC, 0xC7, 0xFA, 0xAF, 0x09, 0x04, 0x03, 0x8C, 0x01, 0x45, 0xF0, 
	0x08, 0x94, 0x71, 0x58, 0xA2, 0x1E, 0xE6, 0x64, 0x5B, 0xF7, 0x48, 0x0A, 0x24, 0x3D, 0x14, 0xD4, 
	0xC6, 0xA6, 0x25, 0xB5, 0x42, 0xF4, 0x27, 0x25, 0x67, 0x79, 0x2C, 0x09, 0x1A, 0x06, 0xC1, 0x2A, 
	0x57, 0x2E, 0x06, 0x41, 0xFF, 0x39, 0x6B, 0xFA, 0x86, 0xA5, 0x4C, 0x5A, 0xAE, 0x24, 0x5F, 0x78, 
	0x42, 0xA9, 0x17, 0xD1, 0x8A, 0x4F, 0x34, 0x91, 0xE5, 0x01, 0x1D, 0x7B, 0x9A, 0x75, 0x03, 0x38, 
	0xB1, 0x56, 0xC4, 0x9C, 0x67, 0xA6, 0xEF, 0x9B, 0x76, 0xCC, 0x3C, 0x1B, 0xAE, 0xE0, 0xD9, 0xF8, 
	0xEA, 0x6F, 0x70, 0xF2, 0xCF, 0x7E, 0x80, 0x1A, 0x97, 0x7A, 0x3D, 0xE5, 0x2E, 0x6A, 0x69, 0x93, 
	0x54, 0xFB, 0x1E, 0x61, 0xA3, 0x0E, 0xCF, 0x9B, 0xA6, 0x85, 0x8E, 0xCC, 0xAB, 0x8C, 0x89, 0x11, 
	0x02, 0x8C, 0x10, 0x56, 0x13, 0x49, 0x0A, 0xD9, 0x81, 0x71, 0x8C, 0x17, 0x14, 0x6D, 0x0F, 0x00, 
	0x00, 0x0A, 0x97, 0x8D, 0xFF, 0xCA, 0x06, 0x06, 0x1B, 0x00, 0x04, 0x04, 0xC4, 0x01, 0x00, 0x00, 
	0x00, 0x00, 0xA8, 0xE9, 0xDD, 0xDB, 0x3D, 0x03, 0xF2, 0xA4, 0x84, 0x87, 0xA3, 0xAC, 0x36, 0x26, 
	0xE9, 0x9A, 0xD7, 0xAB, 0x0A, 0x2E, 0x9A, 0xF5, 0x3D, 0xA3, 0x29, 0x1A, 0xAC, 0xD0, 0xDB, 0x7D, 
	0x85, 0x42, 0x9C, 0x5C, 0xAA, 0x6C, 0x3A, 0x4A, 0xEA, 0x1D, 0x59, 0x36, 0x8F, 0x52, 0xA1, 0xE0, 
	0x16, 0x44, 0x78, 0x96, 0x7A, 0xAB, 0xF8, 0x87, 0xF1, 0x50, 0x23, 0xD7, 0x7F, 0xD6, 0xC2, 0xE3, 
	0x29, 0xEC, 0xC1, 0xFD, 0x88, 0xB3, 0xBE, 0x4E, 0xD9, 0xC8, 0x6F, 0x2F, 0xF6, 0x2E, 0x6D, 0xC7, 
	0x6F, 0x2B, 0x44, 0xD2, 0xFB, 0x35, 0xDA, 0x73, 0x3C, 0xFD, 0x37, 0x1F, 0xFE, 0x36, 0x07, 0x48, 
	0x52, 0x75, 0x9C, 0x69, 0xC9, 0xD7, 0xF3, 0x2E, 0x59, 0xD2, 0x84, 0x89, 0x0C, 0x61, 0x21, 0xD9, 
	0x39, 0xD7, 0xA3, 0x93, 0xA4, 0x18, 0xEF, 0x77, 0xDA, 0xFB, 0xA1, 0x85, 0xE8, 0xAB, 0x74, 0x18, 
	0xD0, 0x91, 0xCC, 0xE4, 0xC3, 0xA7, 0xB9, 0x2B, 0xD8, 0xC8, 0x55, 0xEC, 0x6B, 0x3B, 0xA0, 0x71, 
	0x0C, 0x6B, 0xA4, 0xF4, 0x89, 0x3C, 0x6E, 0x50, 0x65, 0x47, 0xE5, 0xF8, 0x6C, 0x64, 0x1F, 0x8A, 
	0x4B, 0x0E, 0x0C, 0xA1, 0x48, 0x34, 0xA7, 0x86, 0x60, 0xB1, 0x43, 0x11, 0x79, 0x29, 0x91, 0x29, 
	0xFC, 0xB9, 0xC8, 0x20, 0xE4, 0x8A, 0x7C, 0x8B, 0x3E, 0x06, 0x2E, 0x57, 0x6B, 0x23, 0x99, 0x45, 
	0xE0, 0x4A, 0x00, 0x06, 0x01, 0x00, 0x07, 0x97, 0x8D, 0xFF, 0xCA, 0x06, 0x00, 0x09, 0x91, 0xE7, 
	0xBB, 0x09
	};
	
	unsigned char data[90] = {
	0x41, 0x06, 0x00, 0x01, 0x13, 0x00, 0x0F, 0xB9, 0xC3, 0xC8, 0xBE, 0x02, 0x05, 0x14, 0x41, 0x03, 
	0x00, 0x09, 0xB9, 0xC3, 0xC8, 0xBE, 0x02, 0x00, 0x0A, 0xB9, 0xC3, 0xC8, 0xBE, 0x02, 0x00, 0x15, 
	0x86, 0xE8, 0xBE, 0xD4, 0x0C, 0x05, 0x14, 0x41, 0x03, 0x00, 0x09, 0xBA, 0xC3, 0xC8, 0xBE, 0x02, 
	0x00, 0x0A, 0xBA, 0xC3, 0xC8, 0xBE, 0x02, 0x00, 0x15, 0xE7, 0xE5, 0x8E, 0xD1, 0x05, 0x03, 0x12, 
	0x6F, 0x6A, 0x2E, 0x6D, 0x65, 0x64, 0x2E, 0x70, 0x65, 0x72, 0x6D, 0x20, 0x6F, 0x6A, 0x2E, 0x6F, 
	0x6E, 0x65, 0x00, 0x05, 0x2F, 0x41, 0x01, 0x00, 0x02, 0x02
	};
	
	
	unsigned char data[377] = {
	0x41, 0x03, 0x00, 0x01, 0x2B, 0x05, 0x20, 0x41, 0x05, 0x00, 0x0A, 0x88, 0xF0, 0xF8, 0xE0, 0x03, 
	0x00, 0x00, 0xEE, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0xF9, 0xAB, 0xE9, 0xC4, 0x04, 0x04, 0x03, 
	0x92, 0x01, 0x63, 0x5D, 0x35, 0x79, 0x1B, 0x49, 0x1A, 0x67, 0xEC, 0xA8, 0xEA, 0x3C, 0x86, 0xC3, 
	0x4A, 0x31, 0x85, 0x0C, 0x6F, 0xB9, 0x68, 0x9C, 0x42, 0x46, 0xA2, 0x90, 0xD4, 0x63, 0xB5, 0x85, 
	0x31, 0x86, 0xC7, 0xA5, 0x63, 0xC6, 0x85, 0xB5, 0x28, 0x80, 0x7E, 0xF0, 0xF8, 0x8D, 0x27, 0x15, 
	0x6F, 0xB4, 0x1A, 0x9F, 0xCA, 0xD2, 0xEE, 0x85, 0x5C, 0x39, 0xB1, 0x1D, 0x67, 0x66, 0xE3, 0x43, 
	0xC9, 0xE0, 0x11, 0x2F, 0x78, 0x17, 0x90, 0xEA, 0xD9, 0x1D, 0x92, 0x66, 0x97, 0x1E, 0x30, 0x55, 
	0x21, 0x80, 0x9F, 0x9B, 0x7E, 0xDF, 0x24, 0xA9, 0x7D, 0x6D, 0x44, 0x22, 0xA8, 0x38, 0xF5, 0xF9, 
	0xDC, 0x90, 0x5A, 0x7D, 0xD1, 0x08, 0xD4, 0xD8, 0x78, 0xF2, 0xCA, 0x75, 0xD2, 0x24, 0x7E, 0x8A, 
	0x27, 0x8E, 0x66, 0x31, 0x18, 0xAF, 0x2F, 0x9A, 0x3C, 0x64, 0x9B, 0x78, 0x74, 0x73, 0xE2, 0x34, 
	0x3C, 0xB4, 0x2E, 0x74, 0x77, 0x6F, 0x00, 0x00, 0x0A, 0xE8, 0xEA, 0xE6, 0xC0, 0x05, 0x06, 0x1B, 
	0x00, 0x00, 0x0B, 0x01, 0x05, 0x20, 0x41, 0x05, 0x00, 0x0A, 0x89, 0xF0, 0xF8, 0xE0, 0x03, 0x00, 
	0x00, 0xDD, 0x01, 0x00, 0x01, 0x01, 0x00, 0x02, 0xF9, 0xAB, 0xE9, 0xC4, 0x04, 0x04, 0x03, 0xA8, 
	0x01, 0x0C, 0x2A, 0xA8, 0xCD, 0x97, 0xE7, 0x7B, 0x96, 0x94, 0x1E, 0xA2, 0xE7, 0x74, 0x6B, 0xDD, 
	0x3A, 0x2C, 0xE6, 0x6B, 0xA7, 0x2F, 0x2A, 0xC5, 0x08, 0xAC, 0xF8, 0x52, 0xFC, 0x9F, 0x2E, 0xA8, 
	0x1E, 0x97, 0x66, 0xD8, 0x49, 0x10, 0x56, 0x1A, 0xFF, 0x48, 0x95, 0xB6, 0xFE, 0xD1, 0xF6, 0xF4, 
	0x59, 0xF7, 0xD2, 0x84, 0xBD, 0xFA, 0x6E, 0xB3, 0xC4, 0xFE, 0x64, 0x31, 0x73, 0x45, 0x99, 0x94, 
	0x46, 0xC1, 0x1D, 0xE7, 0x9B, 0xDA, 0x13, 0xCA, 0xB4, 0x86, 0x53, 0x97, 0x3B, 0x50, 0xFB, 0x6E, 
	0xFC, 0x9E, 0x32, 0x75, 0xBC, 0x87, 0x3C, 0x02, 0x37, 0x72, 0xBE, 0x63, 0x1A, 0x8D, 0x85, 0xAC, 
	0xDD, 0x5F, 0x8B, 0x84, 0x13, 0xF3, 0x26, 0x67, 0x93, 0xE6, 0x27, 0x0F, 0x02, 0x6C, 0x00, 0xE4, 
	0xB2, 0x5E, 0x1D, 0x43, 0x64, 0x1F, 0xA4, 0xC5, 0x9F, 0x8A, 0xCE, 0xF2, 0xCB, 0x69, 0xB4, 0x91, 
	0xA0, 0x4E, 0x4A, 0x4F, 0x55, 0x52, 0x20, 0x43, 0x48, 0x45, 0x52, 0x20, 0x41, 0x4D, 0x49, 0x20, 
	0x4A, 0x45, 0x20, 0x53, 0x55, 0x49, 0x53, 0x20, 0x56, 0x52, 0x41, 0x49, 0x4D, 0x45, 0x4E, 0x54, 
	0x20, 0x43, 0x4F, 0x4E, 0x54, 0x45, 0x4E, 0x54, 0x00
	};
	
	unsigned char data[419] = {
	0x41, 0x03, 0x00, 0x01, 0xE1, 0xDB, 0xCB, 0xCD, 0x09, 0x00, 0x03, 0x04, 0x04, 0x04, 0x93, 0x03, 
	0x41, 0x03, 0x00, 0x01, 0x2B, 0x05, 0x20, 0x41, 0x05, 0x00, 0x0A, 0xB3, 0x99, 0x86, 0x9A, 0x05, 
	0x00, 0x00, 0x0F, 0x00, 0x01, 0x01, 0x00, 0x02, 0xB7, 0xFA, 0xFA, 0xC3, 0x01, 0x04, 0x03, 0x97, 
	0x01, 0xB0, 0xA0, 0xCA, 0xE2, 0x69, 0x78, 0xE2, 0x4C, 0x46, 0x35, 0x5E, 0x01, 0x02, 0x46, 0x34, 
	0xDE, 0x4E, 0x06, 0x13, 0x5C, 0x26, 0xAE, 0x13, 0x35, 0x34, 0x3B, 0xEA, 0x8A, 0xA8, 0xD5, 0x36, 
	0x85, 0x15, 0xA7, 0x43, 0x61, 0x8D, 0xBC, 0x97, 0x65, 0x01, 0xE9, 0xAF, 0x03, 0x0F, 0x03, 0xDD, 
	0x78, 0xEB, 0x3C, 0xDF, 0xD2, 0x33, 0xCC, 0x55, 0xC0, 0x5C, 0x50, 0x96, 0x60, 0xE7, 0xC2, 0xC8, 
	0x28, 0x0A, 0x0C, 0x0B, 0x91, 0x61, 0xFA, 0x48, 0x04, 0x9D, 0x6A, 0x25, 0x89, 0xFC, 0x78, 0x74, 
	0x9F, 0xEB, 0xAC, 0xE7, 0x2A, 0x29, 0xD3, 0x4C, 0x55, 0x87, 0x1C, 0xDE, 0xD5, 0x89, 0xB9, 0x87, 
	0xBC, 0x25, 0x14, 0x0C, 0x80, 0x31, 0x98, 0x6C, 0x6B, 0xE9, 0xE8, 0xAB, 0x17, 0xE0, 0x18, 0xF9, 
	0xDC, 0xB8, 0xCE, 0xC1, 0x2C, 0x5B, 0x02, 0x55, 0xCE, 0x95, 0xD1, 0x00, 0x54, 0x6E, 0x26, 0x47, 
	0xE4, 0x9A, 0x05, 0x03, 0x01, 0x6F, 0x6A, 0x2E, 0x74, 0x77, 0x6F, 0x00, 0x00, 0x0A, 0xFC, 0x8E, 
	0xB3, 0x56, 0x06, 0x1B, 0x00, 0x00, 0x0B, 0x01, 0x05, 0x20, 0x41, 0x05, 0x00, 0x0A, 0xB4, 0x99, 
	0x86, 0x9A, 0x05, 0x00, 0x00, 0x0B, 0x00, 0x01, 0x01, 0x00, 0x02, 0xB7, 0xFA, 0xFA, 0xC3, 0x01, 
	0x04, 0x03, 0xBF, 0x01, 0x9F, 0xC6, 0x0F, 0x4B, 0x57, 0x5D, 0x4C, 0xDD, 0x3A, 0x64, 0x2C, 0xAE, 
	0xF4, 0x69, 0x5C, 0x83, 0xAE, 0xB8, 0x8E, 0x52, 0x71, 0x14, 0xD7, 0x79, 0x9F, 0xAA, 0x86, 0x36, 
	0xE8, 0xE6, 0x1B, 0x21, 0x19, 0xBA, 0xDD, 0x05, 0x69, 0x9D, 0xC6, 0x88, 0xD2, 0xE2, 0x64, 0xB7, 
	0x84, 0x8C, 0x51, 0xEC, 0x38, 0xBB, 0xC7, 0x96, 0x48, 0x39, 0xF2, 0x89, 0x86, 0x83, 0xB3, 0x1F, 
	0xAC, 0xC7, 0x70, 0x58, 0xE5, 0x2C, 0xE6, 0x95, 0x47, 0x7D, 0x9B, 0xE1, 0x4B, 0xAC, 0xF4, 0xDD, 
	0xA7, 0xA3, 0x4C, 0x85, 0xF7, 0x26, 0x04, 0xB6, 0x68, 0x0E, 0xBB, 0xC9, 0xFA, 0xDA, 0xDF, 0x55, 
	0x30, 0xD8, 0x8B, 0x3D, 0x14, 0xAC, 0x75, 0x41, 0x4B, 0xAB, 0x80, 0x5F, 0xBE, 0xFD, 0xE2, 0x2F, 
	0x5B, 0x4D, 0x62, 0x2F, 0x9E, 0x5A, 0x75, 0x37, 0x1A, 0x57, 0x5C, 0x27, 0xE2, 0x7A, 0x79, 0x08, 
	0x5A, 0x56, 0x1C, 0x32, 0x9A, 0x05, 0x03, 0x02, 0x53, 0x41, 0x4C, 0x55, 0x54, 0x20, 0x4D, 0x4F, 
	0x4E, 0x20, 0x41, 0x4D, 0x49, 0x20, 0x4A, 0x45, 0x20, 0x53, 0x55, 0x49, 0x53, 0x20, 0x54, 0x52, 
	0x45, 0x53, 0x20, 0x43, 0x4F, 0x4E, 0x54, 0x45, 0x4E, 0x54, 0x20, 0x44, 0x45, 0x20, 0x54, 0x45, 
	0x20, 0x56, 0x4F, 0x49, 0x52, 0x20, 0x45, 0x54, 0x20, 0x54, 0x45, 0x20, 0x50, 0x41, 0x52, 0x4C, 
	0x45, 0x52, 0x00
	};*/
	
	unsigned char data[361] = {
	0x41, 0x03, 0x00, 0x01, 0x2B, 0x05, 0x20, 0x41, 0x05, 0x00, 0x0A, 0xCE, 0xE5, 0x99, 0x79, 0x00, 
	0x00, 0x14, 0x00, 0x01, 0x01, 0x00, 0x02, 0xD8, 0x98, 0xCF, 0x8F, 0x0C, 0x04, 0x03, 0x9E, 0x01, 
	0x64, 0xF6, 0x65, 0xA0, 0x81, 0xEB, 0x6F, 0x09, 0xCD, 0x95, 0xF2, 0x4E, 0xFD, 0x68, 0x04, 0xAE, 
	0x52, 0xA8, 0x30, 0x71, 0xA2, 0x7A, 0x8C, 0x91, 0x2C, 0xC1, 0x43, 0x91, 0xA4, 0x66, 0xDD, 0xD4, 
	0x22, 0x40, 0x51, 0x00, 0x23, 0x65, 0x3A, 0xB4, 0xD4, 0xA2, 0xF8, 0x03, 0x76, 0x39, 0x9A, 0x30, 
	0x71, 0x68, 0xCC, 0x75, 0xD0, 0x8C, 0x32, 0x21, 0x94, 0x97, 0x84, 0x44, 0x20, 0xF4, 0x90, 0xE1, 
	0x1D, 0x44, 0xA3, 0x4E, 0xFA, 0x6F, 0x66, 0x9A, 0xA7, 0x97, 0x84, 0x57, 0x64, 0x48, 0x0A, 0x33, 
	0x74, 0xBE, 0xEB, 0xD2, 0xEB, 0x19, 0xCE, 0x8B, 0x17, 0xCA, 0xCD, 0x64, 0x65, 0x20, 0x52, 0x34, 
	0xBC, 0x16, 0x95, 0xBF, 0x24, 0xFC, 0xDF, 0xA3, 0xBE, 0x55, 0xD7, 0xC8, 0xCA, 0xA4, 0x4C, 0x1B, 
	0xC8, 0x50, 0xE1, 0x1D, 0x44, 0x42, 0x56, 0x08, 0x85, 0x51, 0xD3, 0x36, 0xD1, 0x30, 0xE7, 0x24, 
	0x79, 0x03, 0x01, 0x63, 0x68, 0x69, 0x65, 0x6E, 0x2E, 0x6C, 0x75, 0x6E, 0x61, 0x74, 0x69, 0x63, 
	0x00, 0x00, 0x0A, 0xA2, 0xE0, 0x9C, 0x8D, 0x02, 0x06, 0x1B, 0x00, 0x00, 0x0B, 0x01, 0x05, 0x20, 
	0x41, 0x05, 0x00, 0x0A, 0xCF, 0xE5, 0x99, 0x79, 0x00, 0x00, 0x0D, 0x00, 0x01, 0x01, 0x00, 0x02, 
	0xD8, 0x98, 0xCF, 0x8F, 0x0C, 0x04, 0x03, 0x90, 0x01, 0x62, 0x1B, 0x4F, 0x65, 0x4A, 0x41, 0x2F, 
	0x78, 0x2F, 0xEA, 0x1A, 0x05, 0x6D, 0x73, 0xC3, 0x3C, 0x5F, 0x93, 0x68, 0xCA, 0x16, 0x60, 0xC7, 
	0xC5, 0x47, 0xBF, 0xB1, 0x19, 0xDE, 0x40, 0xDF, 0xA8, 0x97, 0xFA, 0x8B, 0x47, 0xCD, 0xC3, 0x8F, 
	0x88, 0xAE, 0xEF, 0x48, 0xCD, 0xE3, 0xAB, 0x02, 0x3D, 0x5C, 0xA3, 0x5F, 0xBA, 0xE7, 0x5C, 0x33, 
	0x34, 0xB9, 0xE6, 0xA6, 0x78, 0xD3, 0x30, 0x7B, 0xB5, 0x9D, 0xCE, 0xC0, 0x1C, 0x86, 0x71, 0x66, 
	0x16, 0x2D, 0xB0, 0xF3, 0x55, 0xB9, 0x92, 0x4A, 0x63, 0xB6, 0x11, 0xD5, 0xDF, 0x9E, 0xD2, 0x04, 
	0x0B, 0xE5, 0x7C, 0xA9, 0xCE, 0xBE, 0x70, 0x61, 0xE8, 0x50, 0x1F, 0x51, 0x93, 0x01, 0x29, 0xCE, 
	0x20, 0xF6, 0x0B, 0xA9, 0xBA, 0x73, 0x41, 0x16, 0x08, 0x9B, 0x88, 0xEA, 0x23, 0x20, 0x14, 0x77, 
	0x70, 0x1A, 0x16, 0x1B, 0x16, 0xFD, 0x2A, 0x0B, 0xF3, 0x79, 0x03, 0x02, 0x42, 0x41, 0x41, 0x41, 
	0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x48, 0x00
	};

	SResponse	Response;
	uchar		*Buffer;
	uint		Size;

	Buffer = data;
	Size = sizeof(data);

	ZeroMemory(&Response, sizeof(Response));
	ManageObjects(&Buffer, Size, &Response);
	for (uint Idx = 0; Idx < Response.NbObj; Idx++)
	{
		DumpObj(Response.Objs[Idx]);
	}

	ExitProcess(0);