xp3filter.cpp

#include "tjsCommHead.h"
#include "tjsObject.h"
#include "tjsNative.h"
#include "xp3filter.h"
#include <list>

//#define CHECK_CXDEC

#if defined(WIN32) && defined(CHECK_CXDEC)
static int xcode_building_stage0(struct cxdec_xcode_status *xcode, int stage);
static int xcode_building_stage1(struct cxdec_xcode_status *xcode, int stage);
struct cxdec_xcode_status {
	BYTE *start;
	BYTE *curr;
	DWORD space_size;
	DWORD seed;
	int(*xcode_building)(struct cxdec_xcode_status *, int);
};

struct cxdec_callback {
	const char *name;
	DWORD key[2];
	int(*xcode_building)(struct cxdec_xcode_status *, int);
};

static DWORD xcode_rand(struct cxdec_xcode_status *xcode)
{
	DWORD seed = xcode->seed;
	xcode->seed = 1103515245 * seed + 12345;
	return xcode->seed ^ (seed << 16) ^ (seed >> 16);
}

static int push_bytexcode(struct cxdec_xcode_status *xcode, BYTE code)
{
	if ((DWORD)xcode->curr - (DWORD)xcode->start + 1 > xcode->space_size)
		return 0;

	*xcode->curr++ = code;

	return 1;
}

static int push_2bytesxcode(struct cxdec_xcode_status *xcode,
	BYTE code0, BYTE code1)
{
	if ((DWORD)xcode->curr - (DWORD)xcode->start + 2 > xcode->space_size)
		return 0;

	*xcode->curr++ = code0;
	*xcode->curr++ = code1;

	return 1;
}

static int push_3bytesxcode(struct cxdec_xcode_status *xcode,
	BYTE code0, BYTE code1, BYTE code2)
{
	if ((DWORD)xcode->curr - (DWORD)xcode->start + 3 > xcode->space_size)
		return 0;

	*xcode->curr++ = code0;
	*xcode->curr++ = code1;
	*xcode->curr++ = code2;

	return 1;
}

static int push_4bytesxcode(struct cxdec_xcode_status *xcode,
	BYTE code0, BYTE code1, BYTE code2, BYTE code3)
{
	if ((DWORD)xcode->curr - (DWORD)xcode->start + 4 > xcode->space_size)
		return 0;

	*xcode->curr++ = code0;
	*xcode->curr++ = code1;
	*xcode->curr++ = code2;
	*xcode->curr++ = code3;

	return 1;
}

static int push_5bytesxcode(struct cxdec_xcode_status *xcode,
	BYTE code0, BYTE code1, BYTE code2, BYTE code3, BYTE code4)
{
	if ((DWORD)xcode->curr - (DWORD)xcode->start + 5 > xcode->space_size)
		return 0;

	*xcode->curr++ = code0;
	*xcode->curr++ = code1;
	*xcode->curr++ = code2;
	*xcode->curr++ = code3;
	*xcode->curr++ = code4;

	return 1;
}

static int push_6bytesxcode(struct cxdec_xcode_status *xcode,
	BYTE code0, BYTE code1, BYTE code2, BYTE code3, BYTE code4, BYTE code5)
{
	if ((DWORD)xcode->curr - (DWORD)xcode->start + 6 > xcode->space_size)
		return 0;

	*xcode->curr++ = code0;
	*xcode->curr++ = code1;
	*xcode->curr++ = code2;
	*xcode->curr++ = code3;
	*xcode->curr++ = code4;
	*xcode->curr++ = code5;

	return 1;
}
static int push_dwordxcode(struct cxdec_xcode_status *xcode, DWORD code)
{
	if ((DWORD)xcode->curr - (DWORD)xcode->start + 4 > xcode->space_size)
		return 0;

	*xcode->curr++ = (BYTE)code;
	*xcode->curr++ = (BYTE)(code >> 8);
	*xcode->curr++ = (BYTE)(code >> 16);
	*xcode->curr++ = (BYTE)(code >> 24);

	return 1;
}

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

static int xcode_building_first_stage(struct cxdec_xcode_status *xcode)
{
	switch (xcode_rand(xcode) % 3) {
	case 0:
		// MOV ESI, EncryptionControlBlock
		// MOV EAX, DWORD PTR DS:[ESI+((xcode_rand(xcode) & 0x3ff) << 2)]
		if (!push_bytexcode(xcode, 0xbe)
			|| !push_dwordxcode(xcode, (DWORD)EncryptionControlBlock)
			|| !push_2bytesxcode(xcode, 0x8b, 0x86)
			|| !push_dwordxcode(xcode, (xcode_rand(xcode) & 0x3ff) << 2))
			return 0;
		break;
	case 1:
		// MOV EAX, xcode_rand(xcode)
		if (!push_bytexcode(xcode, 0xb8)
			|| !push_dwordxcode(xcode, xcode_rand(xcode)))
			return 0;
		break;
	case 2:
		// MOV EAX, EDI
		if (!push_2bytesxcode(xcode, 0x8b, 0xc7))
			return 0;
		break;
	}
	return 1;
}

static int xcode_building_stage0(struct cxdec_xcode_status *xcode, int stage)
{
	if (stage-- == 1)
		return xcode_building_first_stage(xcode);

	if (xcode_rand(xcode) & 1) {
		if (!xcode_building_stage1(xcode, stage))
			return 0;
	}
	else {
		if (!xcode_building_stage0(xcode, stage))
			return 0;
	}

	switch (xcode_rand(xcode) & 7) {
	case 3:
		// NOT EAX
		if (!push_2bytesxcode(xcode, 0xf7, 0xd0))
			return 0;
		break;
	case 4:
		// DEC EAX
		if (!push_bytexcode(xcode, 0x48))
			return 0;
		break;
	case 6:
		// XOR EAX, xcode_rand(xcode)
		if (!push_bytexcode(xcode, 0x35)
			|| !push_dwordxcode(xcode, xcode_rand(xcode)))
			return 0;
		break;
	case 7:
		if (xcode_rand(xcode) & 1) {
			// ADD EAX, xcode_rand(xcode)
			if (!push_bytexcode(xcode, 0x05))
				return 0;
		}
		else {
			// SUB EAX, xcode_rand(xcode)
			if (!push_bytexcode(xcode, 0x2d))
				return 0;
		}
		if (!push_dwordxcode(xcode, xcode_rand(xcode)))
			return 0;
		break;
	case 2:
		// INC EAX
		if (!push_bytexcode(xcode, 0x40))
			return 0;
		break;
	case 0:
		// NEG EAX
		if (!push_2bytesxcode(xcode, 0xf7, 0xd8))
			return 0;
		break;
	case 5:
		// PUSH EBX
		// MOV EBX, EAX
		// AND EBX, AAAAAAAA
		// AND EAX, 55555555
		// SHR EBX, 1
		// SHL EAX, 1
		// OR EAX, EBX
		// POP EBX
		if (!push_bytexcode(xcode, 0x53)
			|| !push_2bytesxcode(xcode, 0x89, 0xc3)
			|| !push_6bytesxcode(xcode, 0x81, 0xe3, 0xaa, 0xaa, 0xaa, 0xaa)
			|| !push_5bytesxcode(xcode, 0x25, 0x55, 0x55, 0x55, 0x55)
			|| !push_2bytesxcode(xcode, 0xd1, 0xeb)
			|| !push_2bytesxcode(xcode, 0xd1, 0xe0)
			|| !push_2bytesxcode(xcode, 0x09, 0xd8)
			|| !push_bytexcode(xcode, 0x5b))
			return 0;
		break;
	case 1:
		// MOV ESI, EncryptionControlBlock
		// AND EAX, 3FFh
		// MOV EAX, DWORD PTR DS:[ESI+EAX*4]
		if (!push_bytexcode(xcode, 0xbe)
			|| !push_dwordxcode(xcode, (DWORD)EncryptionControlBlock)
			|| !push_bytexcode(xcode, 0x25)
			|| !push_dwordxcode(xcode, 0x3ff)
			|| !push_3bytesxcode(xcode, 0x8b, 0x04, 0x86))
			return 0;
		break;
	}
	return 1;
}

static int xcode_building_stage1(struct cxdec_xcode_status *xcode, int stage)
{
	if (stage-- == 1)
		return xcode_building_first_stage(xcode);

	// PUSH EBX
	if (!push_bytexcode(xcode, 0x53))
		return 0;

	if (xcode_rand(xcode) & 1) {
		if (!xcode_building_stage1(xcode, stage))
			return 0;
	}
	else {
		if (!xcode_building_stage0(xcode, stage))
			return 0;
	}

	// MOV EBX, EAX
	if (!push_2bytesxcode(xcode, 0x89, 0xc3))
		return 0;

	if (xcode_rand(xcode) & 1) {
		if (!xcode_building_stage1(xcode, stage))
			return 0;
	}
	else {
		if (!xcode_building_stage0(xcode, stage))
			return 0;
	}

	switch (xcode_rand(xcode) % 6) {
	case 0:
		// SUB EAX, EBX
		if (!push_2bytesxcode(xcode, 0x29, 0xd8))
			return 0;
		break;
	case 5:
		// ADD EAX, EBX
		if (!push_2bytesxcode(xcode, 0x01, 0xd8))
			return 0;
		break;
	case 2:
		// PUSH ECX
		// MOV ECX, EBX
		// AND ECX, 0F
		// SHL EAX, CL
		// POP ECX
		if (!push_bytexcode(xcode, 0x51)
			|| !push_2bytesxcode(xcode, 0x89, 0xd9)
			|| !push_3bytesxcode(xcode, 0x83, 0xe1, 0x0f)
			|| !push_2bytesxcode(xcode, 0xd3, 0xe0)
			|| !push_bytexcode(xcode, 0x59))
			return 0;
		break;
	case 3:
		// IMUL EAX, EBX
		if (!push_3bytesxcode(xcode, 0x0f, 0xaf, 0xc3))
			return 0;
		break;
	case 4:
		// NEG EAX, ADD EAX, EBX
		if (!push_2bytesxcode(xcode, 0xf7, 0xd8)
			|| !push_2bytesxcode(xcode, 0x01, 0xd8))
			return 0;
		break;
	case 1:
		// PUSH ECX
		// MOV ECX, EBX
		// AND ECX, 0F
		// SHR EAX, CL
		// POP ECX
		if (!push_bytexcode(xcode, 0x51)
			|| !push_2bytesxcode(xcode, 0x89, 0xd9)
			|| !push_3bytesxcode(xcode, 0x83, 0xe1, 0x0f)
			|| !push_2bytesxcode(xcode, 0xd3, 0xe8)
			|| !push_bytexcode(xcode, 0x59))
			return 0;
		break;
	}
	// POP EBX
	return push_bytexcode(xcode, 0x5b);
}

struct cxdec_callback dec_callback = {
	"",
	{ 0x2B2, 0x2E6 },
	xcode_building_stage1
};

static struct cxdec {
	BYTE *xcode;			// 容纳128个解密函数，每个函数100字节
	void *address_list[128];// 128个解密函数的地址(用index索引)
	DWORD current_count;		// 当前有效的解密函数的个数
	DWORD index_list[100];	// 记录有效的index编号
	int init_flag;
} cxdec;

#ifdef WIN32
//#define CHECK_MEM_OVERRUN
#define MEM_COMMIT           0x1000     
#define MEM_DECOMMIT         0x4000     
#define PAGE_NOACCESS          0x01     
#define PAGE_READWRITE         0x04     
#define PAGE_EXECUTE_READWRITE 0x40     
extern "C" __declspec(dllimport) void* __stdcall VirtualAlloc(
	void* lpAddress,
	DWORD dwSize,
	DWORD flAllocationType,
	DWORD flProtect
	);
extern "C" __declspec(dllimport) int __stdcall FlushInstructionCache(
	int hProcess,
	void* lpBaseAddress,
	int dwSize
	);
extern "C" __declspec(dllimport) int __stdcall GetCurrentProcess();
#endif

static int cxdec_init(void)
{
	cxdec.xcode = (BYTE *)VirtualAlloc(NULL, 128 * 100, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
	if (!cxdec.xcode)
		return S_FALSE;

	memset(cxdec.address_list, 0, sizeof(cxdec.address_list));
	cxdec.current_count = 0;
	memset(cxdec.index_list, -1, sizeof(cxdec.index_list));
	cxdec.init_flag = 1;

	return 0;
}

//---------------------------------------------------------------------------
static int xcode_building_start(struct cxdec_xcode_status *xcode, int stage)
{
	// PUSH EDI, PUSH ESI, PUSH EBX, PUSH ECX, PUSH EDX
	if (!push_5bytesxcode(xcode, 0x57, 0x56, 0x53, 0x51, 0x52))
		return 0;

	// MOV EDI, DWORD PTR SS:[ESP+18] (load parameter0)
	if (!push_4bytesxcode(xcode, 0x8b, 0x7c, 0x24, 0x18))
		return 0;

	if (!xcode->xcode_building(xcode, stage))
		return 0;

	// POP EDX, POP ECX, POP EBX, POP ESI, POP EDI
	if (!push_5bytesxcode(xcode, 0x5a, 0x59, 0x5b, 0x5e, 0x5f))
		return 0;

	// RETN
	return push_bytexcode(xcode, 0xc3);
}
//---------------------------------------------------------------------------
static int xcode_building(struct cxdec_callback *callback, DWORD seed, void *start, DWORD size)
{
	struct cxdec_xcode_status xcode;
	int stage;

	xcode.start = (BYTE *)start;
	xcode.curr = (BYTE *)start;
	xcode.space_size = size;
	xcode.seed = seed;
	xcode.xcode_building = callback->xcode_building;

	// @1E017A90
	for (stage = 5; stage > 0; --stage) {
		if (xcode_building_start(&xcode, stage))
			break;
		xcode.curr = (BYTE *)start;
	}
	if (!stage) {
		TVPThrowExceptionMessage(TJS_W("Insufficient code space"));
		return S_FALSE;
	}

	FlushInstructionCache(GetCurrentProcess(), start, size);
	return 1;
}
//---------------------------------------------------------------------------
static void cxdec_execute_xcode(struct cxdec_callback *callback, DWORD hash, DWORD *ret1, DWORD *ret2)
{
	DWORD index = hash & 0x7f;
	hash >>= 7;

	if (!cxdec.init_flag)
		cxdec_init();

	if (!cxdec.address_list[index]) {
		if (cxdec.index_list[cxdec.current_count] != index) {
			if (cxdec.index_list[cxdec.current_count] != -1)
				cxdec.address_list[cxdec.index_list[cxdec.current_count]] = 0;
			xcode_building(callback, index, cxdec.xcode + cxdec.current_count * 128, 128);
			cxdec.address_list[index] = cxdec.xcode + cxdec.current_count * 128;
			cxdec.index_list[cxdec.current_count++] = index;
			if (cxdec.current_count >= 100)
				cxdec.current_count = 0;
		}
	}

	*ret1 = (*(DWORD(*)(DWORD))cxdec.address_list[index])(hash);
	*ret2 = (*(DWORD(*)(DWORD))cxdec.address_list[index])(~hash);
}
//---------------------------------------------------------------------------
static void __cxdec_decode(struct cxdec_callback *callback, DWORD hash, DWORD offset, BYTE *buf, DWORD len)
{
	BYTE key[12];
	DWORD ret[2], i, k, *dbuf;

	cxdec_execute_xcode(callback, hash, &ret[0], &ret[1]);

	key[8] = ret[0] >> 8;
	key[9] = ret[0] >> 16;
	key[10] = ret[0];
	DWORD key1 = ret[1] >> 16;
	DWORD key2 = ret[1] & 0xffff;
	*(DWORD *)&key[0] = key1;

	if (key1 == key2)
		++key2;

	*(DWORD *)&key[4] = key2;

	if (!key[10])
		key[10] = 1;

	if ((key2 >= offset) && (key2 < offset + len))
		buf[key2 - offset] ^= key[9];

	if ((key1 >= offset) && (key1 < offset + len))
		buf[key1 - offset] ^= key[8];

	if (len>16)
	{
		k = 0x1010101 * key[10];
		for (i = 0; i < ((DWORD)buf & 3); i++) buf[i] ^= key[10];
		len -= i;
		dbuf = (DWORD*)(buf + i);
		for (i = 0; i < len >> 2; i++) *(dbuf++) ^= k;
		buf = (BYTE*)dbuf;
		for (i = 0; i < (len & 3); i++) *buf++ ^= key[10];
	}
	else
		for (i = 0; i < len; ++i)
			buf[i] ^= key[10];
}
//---------------------------------------------------------------------------
static void cxdec_decode(struct cxdec_callback *callback, DWORD hash, DWORD offset, BYTE *buf, DWORD len)
{
	DWORD bondary = (hash & callback->key[0]) + callback->key[1];
	DWORD dec_len = 0;

	if (offset < bondary) {
		if (offset + len > bondary)
			dec_len = bondary - offset;
		else
			dec_len = len;
		__cxdec_decode(callback, hash, offset, buf, dec_len);
		offset += dec_len;
		buf += dec_len;
		dec_len = len - dec_len;
	}
	else
		dec_len = len;

	if (dec_len)
		__cxdec_decode(callback, (hash >> 16) ^ hash, offset, buf, dec_len);
}
#endif


class CBinaryAccessor : public tTJSDispatch
{
	unsigned int m_length;
	unsigned int m_curPos;
	unsigned char *m_buff;

	tjs_error FuncXor(tjs_int numparams, tTJSVariant **param);

	tjs_error FuncAdd(tjs_int numparams, tTJSVariant **param);

public:
	CBinaryAccessor(unsigned char* buff, unsigned int len);
public:
	virtual tjs_error TJS_INTF_METHOD
		FuncCall( // function invocation
		tjs_uint32 flag,			// calling flag
		const tjs_char * membername,// member name ( NULL for a default member )
		tjs_uint32 *hint,			// hint for the member name (in/out)
		tTJSVariant *result,		// result
		tjs_int numparams,			// number of parameters
		tTJSVariant **param,		// parameters
		iTJSDispatch2 *objthis		// object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		PropGet( // property get
		tjs_uint32 flag,			// calling flag
		const tjs_char * membername,// member name ( NULL for a default member )
		tjs_uint32 *hint,			// hint for the member name (in/out)
		tTJSVariant *result,		// result
		iTJSDispatch2 *objthis		// object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		PropGetByNum( // property get by index number
		tjs_uint32 flag,			// calling flag
		tjs_int num,				// index number
		tTJSVariant *result,		// result
		iTJSDispatch2 *objthis		// object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		PropSet( // property set
		tjs_uint32 flag,			// calling flag
		const tjs_char *membername,	// member name ( NULL for a default member )
		tjs_uint32 *hint,			// hint for the member name (in/out)
		const tTJSVariant *param,	// parameters
		iTJSDispatch2 *objthis		// object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		PropSetByNum( // property set by index number
		tjs_uint32 flag,			// calling flag
		tjs_int num,				// index number
		const tTJSVariant *param,	// parameters
		iTJSDispatch2 *objthis		// object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		GetCount( // get member count
		tjs_int *result,         	// variable that receives the result
		const tjs_char *membername,	// member name ( NULL for a default member )
		tjs_uint32 *hint,			// hint for the member name (in/out)
		iTJSDispatch2 *objthis      // object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		Invalidate( // invalidation
		tjs_uint32 flag,			// calling flag
		const tjs_char *membername,	// member name ( NULL for a default member )
		tjs_uint32 *hint,			// hint for the member name (in/out)
		iTJSDispatch2 *objthis		// object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		IsValid( // get validation, returns TJS_S_TRUE (valid) or TJS_S_FALSE (invalid)
		tjs_uint32 flag,			// calling flag
		const tjs_char *membername,	// member name ( NULL for a default member )
		tjs_uint32 *hint,			// hint for the member name (in/out)
		iTJSDispatch2 *objthis		// object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		Operation( // operation with member
		tjs_uint32 flag,			// calling flag
		const tjs_char *membername,	// member name ( NULL for a default member )
		tjs_uint32 *hint,			// hint for the member name (in/out)
		tTJSVariant *result,		// result ( can be NULL )
		const tTJSVariant *param,	// parameters
		iTJSDispatch2 *objthis		// object as "this"
		);

	virtual tjs_error TJS_INTF_METHOD
		OperationByNum( // operation with member by index number
		tjs_uint32 flag,			// calling flag
		tjs_int num,				// index number
		tTJSVariant *result,		// result ( can be NULL )
		const tTJSVariant *param,	// parameters
		iTJSDispatch2 *objthis		// object as "this"
		);
};

tjs_error TJS_INTF_METHOD CBinaryAccessor::OperationByNum( /* operation with member by index number */ tjs_uint32 flag, /* calling flag */ tjs_int num, /* index number */ tTJSVariant *result, /* result ( can be NULL ) */ const tTJSVariant *param, /* parameters */ iTJSDispatch2 *objthis /* object as "this" */)
{
	num += m_curPos;
	if (num < 0 || num >= m_length) return TJS_E_MEMBERNOTFOUND;
	unsigned char opnum = param->AsInteger();
	switch (flag & TJS_OP_MASK) {
	case TJS_OP_BAND: m_buff[num] &= opnum; break;
	case TJS_OP_BOR:  m_buff[num] |= opnum; break;
	case TJS_OP_BXOR: m_buff[num] ^= opnum; break;
	case TJS_OP_SUB:  m_buff[num] -= opnum; break;
	case TJS_OP_ADD:  m_buff[num] += opnum; break;
	case TJS_OP_MOD:  m_buff[num] %= opnum; break;
	case TJS_OP_DIV:  m_buff[num] /= (signed char)opnum; break;
	case TJS_OP_IDIV: m_buff[num] /= opnum; break;
	case TJS_OP_MUL:  m_buff[num] *= opnum; break;
	case TJS_OP_LOR:  m_buff[num] = m_buff[num] || opnum; break;
	case TJS_OP_LAND: m_buff[num] = m_buff[num] && opnum; break;
	case TJS_OP_SAR:  m_buff[num] >>= opnum; break;
	case TJS_OP_SAL:  m_buff[num] <<= opnum; break;
	case TJS_OP_SR:   m_buff[num] >>= opnum; break;
	case TJS_OP_INC:  m_buff[num] ++; break;
	case TJS_OP_DEC:  m_buff[num] --; break;
	default:
		return TJS_E_NOTIMPL;
	}

	return TJS_S_OK;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::Operation( /* operation with member */ tjs_uint32 flag, /* calling flag */ const tjs_char *membername, /* member name ( NULL for a default member ) */ tjs_uint32 *hint, /* hint for the member name (in/out) */ tTJSVariant *result, /* result ( can be NULL ) */ const tTJSVariant *param, /* parameters */ iTJSDispatch2 *objthis /* object as "this" */)
{
	if (membername) {
		if (hint) {
			if (!*hint)
				*hint = !TJS_strcmp(membername, TJS_W("ptr"));
			if (!*hint)
				return TJS_E_NOTIMPL;
		} else if (TJS_strcmp(membername, TJS_W("ptr"))) {
			return TJS_E_NOTIMPL;
		}
	}
	tjs_uint32 op = flag & TJS_OP_MASK;
	switch (op) {
	case TJS_OP_ADD:
		m_curPos += param->AsInteger();
		break;
	case TJS_OP_SUB:
		m_curPos -= param->AsInteger();
		break;
	case TJS_OP_INC:
		++m_curPos;
		break;
	case TJS_OP_DEC:
		--m_curPos;
		break;
	default:
		return TJS_E_NOTIMPL;
	}
	return TJS_S_OK;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::IsValid( /* get validation, returns TJS_S_TRUE (valid) or TJS_S_FALSE (invalid) */ tjs_uint32 flag, /* calling flag */ const tjs_char *membername, /* member name ( NULL for a default member ) */ tjs_uint32 *hint, /* hint for the member name (in/out) */ iTJSDispatch2 *objthis /* object as "this" */)
{
	return m_buff ? TJS_S_TRUE : TJS_S_FALSE;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::Invalidate( /* invalidation */ tjs_uint32 flag, /* calling flag */ const tjs_char *membername, /* member name ( NULL for a default member ) */ tjs_uint32 *hint, /* hint for the member name (in/out) */ iTJSDispatch2 *objthis /* object as "this" */)
{
	m_buff = NULL;
	return TJS_S_OK;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::GetCount( /* get member count */ tjs_int *result, /* variable that receives the result */ const tjs_char *membername, /* member name ( NULL for a default member ) */ tjs_uint32 *hint, /* hint for the member name (in/out) */ iTJSDispatch2 *objthis /* object as "this" */)
{
	if (membername) return TJS_E_MEMBERNOTFOUND;
	*result = m_length;
	return TJS_S_OK;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::PropSetByNum( /* property set by index number */ tjs_uint32 flag, /* calling flag */ tjs_int num, /* index number */ const tTJSVariant *param, /* parameters */ iTJSDispatch2 *objthis /* object as "this" */)
{
	num += m_curPos;
	if (num < 0 || num >= m_length) return TJS_E_MEMBERNOTFOUND;
	m_buff[num] = param->AsInteger();
	return TJS_S_OK;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::PropSet( /* property set */ tjs_uint32 flag, /* calling flag */ const tjs_char *membername, /* member name ( NULL for a default member ) */ tjs_uint32 *hint, /* hint for the member name (in/out) */ const tTJSVariant *param, /* parameters */ iTJSDispatch2 *objthis /* object as "this" */)
{
	if (!membername) return TJS_E_NOTIMPL;
	if (!TJS_strcmp(membername, TJS_W("ptr"))) {
		m_curPos = param->AsInteger();
		return TJS_S_OK;
	}
	return TJS_E_NOTIMPL;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::PropGetByNum( /* property get by index number */ tjs_uint32 flag, /* calling flag */ tjs_int num, /* index number */ tTJSVariant *result, /* result */ iTJSDispatch2 *objthis /* object as "this" */)
{
	num += m_curPos;
	if (num < 0 || num >= m_length) return TJS_E_MEMBERNOTFOUND;
	result->operator =((tjs_int32)m_buff[num]);
	return TJS_S_OK;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::PropGet( /* property get */ tjs_uint32 flag, /* calling flag */ const tjs_char * membername,/* member name ( NULL for a default member ) */ tjs_uint32 *hint, /* hint for the member name (in/out) */ tTJSVariant *result, /* result */ iTJSDispatch2 *objthis /* object as "this" */)
{
	if (!membername) return TJS_E_NOTIMPL;
	if (!TJS_strcmp(membername, TJS_W("count"))) {
		result->operator =((tjs_int64)m_length);
	} else if (!TJS_strcmp(membername, TJS_W("ptr"))) {
		result->operator =((tjs_int64)m_curPos);
	} else {
		result->Clear();
	}
	return TJS_S_OK;
}

tjs_error TJS_INTF_METHOD CBinaryAccessor::FuncCall( /* function invocation */ tjs_uint32 flag, /* calling flag */ const tjs_char * membername,/* member name ( NULL for a default member ) */ tjs_uint32 *hint, /* hint for the member name (in/out) */ tTJSVariant *result, /* result */ tjs_int numparams, /* number of parameters */ tTJSVariant **param, /* parameters */ iTJSDispatch2 *objthis /* object as "this" */)
{
	if (hint) {
		if (!*hint) {
			*hint = !TJS_strcmp(membername, TJS_W("xor"));
			if (*hint) {
				return FuncXor(numparams, param);
			}
		} else {
			return FuncXor(numparams, param);
		}
	} else if (!TJS_strcmp(membername, TJS_W("xor"))) {
		return FuncXor(numparams, param);
	}
	return TJS_E_NOTIMPL;
}

CBinaryAccessor::CBinaryAccessor(unsigned char* buff, unsigned int len)
{
	m_buff = buff;
	m_length = len;
	m_curPos = 0;
}

tjs_error CBinaryAccessor::FuncAdd(tjs_int numparams, tTJSVariant **param)
{
	if (numparams < 3) {
		return TJS_E_BADPARAMCOUNT;
	}

	int bufoff = param[0]->AsInteger();
	int len = param[1]->AsInteger();
	unsigned char xorval = param[2]->AsInteger();

	unsigned char *buf = m_buff + m_curPos + bufoff;
	unsigned int i;
	for (i = 0; i < len; ++i)
		buf[i] += xorval;
	return TJS_S_OK;
}

tjs_error CBinaryAccessor::FuncXor(tjs_int numparams, tTJSVariant **param)
{
	if (numparams < 3) {
		return TJS_E_BADPARAMCOUNT;
	}

	int bufoff = param[0]->AsInteger();
	int len = param[1]->AsInteger();
	unsigned char xorval = param[2]->AsInteger();

	unsigned char *buf = m_buff + m_curPos + bufoff;
	unsigned int i;
	if (len>16)
	{
		unsigned long k = 0x1010101 * xorval;
		for (i = 0; i < ((unsigned int)buf & 3); i++) buf[i] ^= xorval;
		len -= i;
		unsigned long *dbuf = (unsigned long*)(buf + i);
		for (i = 0; i < len >> 2; i++) *(dbuf++) ^= k;
		buf = (unsigned char*)dbuf;
		for (i = 0; i < (len & 3); i++) *buf++ ^= xorval;
	} else
		for (i = 0; i < len; ++i)
			buf[i] ^= xorval;
	return TJS_S_OK;
}

struct XP3FilterDecoder {
    tTJS * ScriptEngine;
    tTJSVariantClosure ManagedDecoder;
    XP3FilterDecoder() : ManagedDecoder(nullptr), ScriptEngine(nullptr) {}
};

static std::list<XP3FilterDecoder> sTVPScriptEngineStack;
static tTJSCriticalSection sTVPScriptEngineStackLock;
static ttstr sXP3FilterScript;

class XP3FilterRegister : public tTJSDispatch
{
    typedef tTJSDispatch inherited;

    XP3FilterDecoder *Decoder;
public:

    XP3FilterRegister(XP3FilterDecoder *decoder) {
        Decoder = decoder;
        //if(TJSObjectHashMapEnabled()) TJSAddObjectHashRecord(this);
    }
    ~XP3FilterRegister() {
        //if(TJSObjectHashMapEnabled()) TJSRemoveObjectHashRecord(this);
    }

    tjs_error TJS_INTF_METHOD
        IsInstanceOf(tjs_uint32 flag, const tjs_char *membername, tjs_uint32 *hint,
        const tjs_char *classname,
        iTJSDispatch2 *objthis)
    {
        if(membername == NULL)
        {
            if(!TJS_strcmp(classname, TJS_W("Function"))) return TJS_S_TRUE;
        }

        return inherited::IsInstanceOf(flag, membername, hint, classname, objthis);
    }
    tjs_error  TJS_INTF_METHOD
        FuncCall(tjs_uint32 flag, const tjs_char * membername, tjs_uint32 *hint,
        tTJSVariant *result,
        tjs_int numparams, tTJSVariant **param,	iTJSDispatch2 *objthis)
    {
        if(membername) return inherited::FuncCall(flag, membername, hint,
            result, numparams, param, objthis);
        if(!objthis) return TJS_E_NATIVECLASSCRASH;

        if(result) result->Clear();

        if (numparams < 1) return TJS_E_BADPARAMCOUNT;
        if (Decoder->ManagedDecoder.Object) Decoder->ManagedDecoder.Release();
        Decoder->ManagedDecoder = param[0]->AsObjectClosure();
        return TJS_S_OK;
    }
};

extern void * TVPGetImportFuncPtr(const char *name);
extern void * TVPImportFuncPtr0936d0f6fc53339d255893e58bcc6699;
iTJSDispatch2 * TVPGetScriptDispatch() {
	if (!TVPImportFuncPtr0936d0f6fc53339d255893e58bcc6699)
	{
		static char funcname[] = "iTJSDispatch2 * ::TVPGetScriptDispatch()";
		TVPImportFuncPtr0936d0f6fc53339d255893e58bcc6699 = TVPGetImportFuncPtr(funcname);
	}
	typedef iTJSDispatch2 * (__stdcall * __functype)();
	return ((__functype)(TVPImportFuncPtr0936d0f6fc53339d255893e58bcc6699))();
}
static void AddXP3Decoder() {
    XP3FilterDecoder decoder;
    decoder.ScriptEngine = new tTJS();
    tTJSVariant val;
    iTJSDispatch2 *dsp;
    iTJSDispatch2 *global = decoder.ScriptEngine->GetGlobalNoAddRef();
	iTJSDispatch2 *host_global = TVPGetScriptDispatch();
#define REGISTER_OBJECT(classname) \
	host_global->PropGet(0, TJS_W(#classname), nullptr, &val, host_global); \
	dsp = val.AsObjectNoAddRef(); \
    val = tTJSVariant(dsp/*, dsp*/); \
    dsp->Release(); \
    global->PropSet(TJS_MEMBERENSURE|TJS_IGNOREPROP, TJS_W(#classname), NULL, \
    &val, global);
	REGISTER_OBJECT(Debug);
	REGISTER_OBJECT(System);
	REGISTER_OBJECT(Storages);
	TJSNativeClassRegisterNCM((tTJSNativeClass*)dsp, TJS_W("setXP3ArchiveExtractionFilter"),
        new XP3FilterRegister(&decoder),
        TJS_W("Storages"), nitMethod, TJS_STATICMEMBER);

    decoder.ScriptEngine->ExecScript(sXP3FilterScript);
	sTVPScriptEngineStack.push_back(decoder);
}

void TVPXP3ArchiveExtractionFilterCleanup() {
	for (auto it = sTVPScriptEngineStack.begin(); it != sTVPScriptEngineStack.end(); ++it) {
		it->ScriptEngine->Release();
	}
	sTVPScriptEngineStack.clear();
}

struct tTVPXP3ExtractionFilterInfo
{
	const tjs_uint SizeOfSelf; //00h structure size of tTVPXP3ExtractionFilterInfo itself
	const tjs_uint64 Offset; //04h offset of the buffer data in uncompressed stream position
	void * Buffer; //0ch target data buffer
	const tjs_uint BufferSize; //10h buffer size in bytes pointed by "Buffer"
	const tjs_uint32 FileHash; //14h hash value of the file (since inteface v2)
};
#ifndef TVP_tTVPXP3ArchiveExtractionFilter_CONVENTION
#ifdef _WIN32
#define	TVP_tTVPXP3ArchiveExtractionFilter_CONVENTION _stdcall
#else
#define TVP_tTVPXP3ArchiveExtractionFilter_CONVENTION
#endif
#endif
void TVPThrowExceptionMessage(const tjs_char * msg);
void TVP_tTVPXP3ArchiveExtractionFilter_CONVENTION
    TVPXP3ArchiveExtractionFilterWrapper(tTVPXP3ExtractionFilterInfo *info)
{
    if (info->SizeOfSelf != sizeof(tTVPXP3ExtractionFilterInfo))
        TVPThrowExceptionMessage(TJS_W("Incompatible tTVPXP3ExtractionFilterInfo size"));
    XP3FilterDecoder decoder;
    {
        tTJSCSH lock(sTVPScriptEngineStackLock);
        if(sTVPScriptEngineStack.empty()) {
			//TVPAddAtExitHandler(TVP_ATEXIT_PRI_CLEANUP, TVPXP3ArchiveExtractionFilterCleanup);
            AddXP3Decoder();
        }
        decoder = sTVPScriptEngineStack.back();
        sTVPScriptEngineStack.pop_back();
    }
    if (decoder.ManagedDecoder.Object) {
        tTJSVariant FileHash = (tjs_int64)info->FileHash;
        tTJSVariant Offset = (tjs_int64)info->Offset;
        tTJSVariant Buffer(new CBinaryAccessor((unsigned char*)info->Buffer, info->BufferSize));
		tTJSVariant BufferSize((tjs_int64)info->BufferSize);
		//tTJSVariant FileName(info->FileName);
        tTJSVariant *vars[5] = {
            &FileHash, &Offset, &Buffer, &BufferSize//, &FileName
        };
#if defined(WIN32) && defined(CHECK_CXDEC)
        unsigned char *pBackup = new unsigned char[info->BufferSize], *pBuffer = (unsigned char*)info->Buffer;
        memcpy(pBackup, info->Buffer, info->BufferSize);
#endif
		decoder.ManagedDecoder.FuncCall(0, NULL, NULL, NULL, 5, vars, NULL);
#if defined(WIN32) && defined(CHECK_CXDEC)
		cxdec_decode(&dec_callback, info->FileHash, info->Offset, pBackup, info->BufferSize);
        for (int i = 0; i < info->BufferSize; ++i)
        {
            if (pBackup[i] != pBuffer[i]) {
                assert(false);
				break;
            }
        }
        delete []pBackup;
#endif
    }
    {
        tTJSCSH lock(sTVPScriptEngineStackLock);
        sTVPScriptEngineStack.push_back(decoder);
    }
}

extern void * TVPImportFuncPtr4b9c9ac2aafad07af4b16f34e9d4bba2;
ttstr TVPGetAppPath()
{
	if (!TVPImportFuncPtr4b9c9ac2aafad07af4b16f34e9d4bba2)
	{
		static char funcname[] = "ttstr ::TVPGetAppPath()";
		TVPImportFuncPtr4b9c9ac2aafad07af4b16f34e9d4bba2 = TVPGetImportFuncPtr(funcname);
	}
	typedef ttstr(__stdcall * __functype)();
	return ((__functype)(TVPImportFuncPtr4b9c9ac2aafad07af4b16f34e9d4bba2))();
}
extern void * TVPImportFuncPtr4a197be1985d45ee86d5672d24134560;
bool TVPIsExistentStorageNoSearch(const ttstr & name)
{
	if (!TVPImportFuncPtr4a197be1985d45ee86d5672d24134560)
	{
		static char funcname[] = "bool ::TVPIsExistentStorageNoSearch(const ttstr &)";
		TVPImportFuncPtr4a197be1985d45ee86d5672d24134560 = TVPGetImportFuncPtr(funcname);
	}
	typedef bool(__stdcall * __functype)(const ttstr &);
	return ((__functype)(TVPImportFuncPtr4a197be1985d45ee86d5672d24134560))(name);
}
extern void * TVPImportFuncPtr95aab2a1ac9491e8026f4977e0918760;
iTJSTextReadStream * TVPCreateTextStreamForRead(const ttstr & name, const ttstr & modestr)
{
	if (!TVPImportFuncPtr95aab2a1ac9491e8026f4977e0918760)
	{
		static char funcname[] = "iTJSTextReadStream * ::TVPCreateTextStreamForRead(const ttstr &,const ttstr &)";
		TVPImportFuncPtr95aab2a1ac9491e8026f4977e0918760 = TVPGetImportFuncPtr(funcname);
	}
	typedef iTJSTextReadStream * (__stdcall * __functype)(const ttstr &, const ttstr &);
	return ((__functype)(TVPImportFuncPtr95aab2a1ac9491e8026f4977e0918760))(name, modestr);
}
typedef void (TVP_tTVPXP3ArchiveExtractionFilter_CONVENTION *
			  tTVPXP3ArchiveExtractionFilter)(tTVPXP3ExtractionFilterInfo *info);
void TVPSetXP3ArchiveExtractionFilter(tTVPXP3ArchiveExtractionFilter filter);
void RegistXP3Filter()
{
    ttstr path = TVPGetAppPath() + TJS_W("xp3filter.tjs");
    if (TVPIsExistentStorageNoSearch(path)) {
        iTJSTextReadStream * stream = TVPCreateTextStreamForRead(path, "");
        try
        {
            stream->Read(sXP3FilterScript, 0);
        }
        catch(...)
        {
            stream->Destruct();
            throw;
        }
        stream->Destruct();
        AddXP3Decoder();
        TVPSetXP3ArchiveExtractionFilter(TVPXP3ArchiveExtractionFilterWrapper);
    }
    //TVPSetXP3ArchiveExtractionFilter(TVPXP3ArchiveExtractionFilter);
}