//antidebug.h

//antidebug lib v2.3

//Http://www.antidebuglib.com

#ifndef _ANTIDEBUG_H

#define _ANTIDEBUG_H

__declspec( selectany ) UINT32 GJ_Macro=0;

#define GJ_MACRO_INIT \

__asm __emit 0xEB \

__asm __emit 0x36 \

__asm mov ebx,offset GJ_Macro \

__asm __emit 'A' \

__asm __emit 'N' \

__asm __emit 'T' \

__asm __emit 'I' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit 'B' \

__asm __emit 'U' \

__asm __emit 'G' \

__asm __emit 'L' \

__asm __emit 'I' \

__asm __emit 'B' \

__asm __emit 'A' \

__asm __emit 'N' \

__asm __emit 'T' \

__asm __emit 'I' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit 'B' \

__asm __emit 'U' \

__asm __emit 'G' \

__asm __emit 'L' \

__asm __emit 'I' \

__asm __emit 'B' \

__asm __emit 'A' \

__asm __emit 'N' \

__asm __emit 'T' \

__asm __emit 'I' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit 'B' \

__asm __emit 'U' \

__asm __emit 'G' \

__asm __emit '_' \

__asm __emit '_' \

__asm __emit '_' \

__asm __emit 'G' \

__asm __emit 'J' \

__asm __emit '_' \

__asm __emit 'M' \

__asm __emit 'A' \

__asm __emit 'C' \

__asm __emit 'R' \

__asm __emit 'O' \

__asm __emit '_' \

__asm __emit 'I' \

__asm __emit 'N' \

__asm __emit 'I' \

__asm __emit 'T'

#define GJ_MACRO_END \

__asm __emit 0xEB \

__asm __emit 0x26 \

__asm mov ebx,offset GJ_Macro \

__asm __emit 'A' \

__asm __emit 'N' \

__asm __emit 'T' \

__asm __emit 'I' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit 'B' \

__asm __emit 'U' \

__asm __emit 'G' \

__asm __emit 'L' \

__asm __emit 'I' \

__asm __emit 'B' \

__asm __emit 'A' \

__asm __emit 'N' \

__asm __emit 'T' \

__asm __emit 'I' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit 'B' \

__asm __emit 'U' \

__asm __emit 'G' \

__asm __emit 'L' \

__asm __emit 'I' \

__asm __emit 'B' \

__asm __emit 'M' \

__asm __emit 'A' \

__asm __emit 'C' \

__asm __emit 'R' \

__asm __emit 'O' \

__asm __emit '_' \

__asm __emit 'E' \

__asm __emit 'N' \

__asm __emit 'D'

#define GJ_ONCE_CODE_START \

__asm __emit 0xEB \

__asm __emit 0x21 \

__asm mov ebx,offset GJ_Macro \

__asm __emit '0' \

__asm mov ebx,offset GJ_Macro \

__asm __emit 'A' \

__asm __emit 'N' \

__asm __emit 'T' \

__asm __emit 'I' \

__asm __emit 'G' \

__asm __emit 'J' \

__asm __emit '_' \

__asm __emit 'O' \

__asm __emit 'N' \

__asm __emit 'C' \

__asm __emit 'E' \

__asm __emit '_' \

__asm __emit 'C' \

__asm __emit 'O' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit '_' \

__asm __emit 'S' \

__asm __emit 'T' \

__asm __emit 'A' \

__asm __emit 'R' \

__asm __emit 'T'

#define GJ_ONCE_CODE_END \

__asm __emit 0xEB \

__asm __emit 0x14 \

__asm mov ebx,offset GJ_Macro \

__asm __emit 'G' \

__asm __emit 'J' \

__asm __emit 'O' \

__asm __emit 'N' \

__asm __emit 'C' \

__asm __emit 'E' \

__asm __emit '_' \

__asm __emit 'C' \

__asm __emit 'O' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit '_' \

__asm __emit 'E' \

__asm __emit 'N' \

__asm __emit 'D'

#define GJ_ENCRYPT_CODE_START \

__asm __emit 0xEB \

__asm __emit 0x21 \

__asm mov ebx,offset GJ_Macro \

__asm __emit '0' \

__asm mov ebx,offset GJ_Macro \

__asm __emit 'A' \

__asm __emit 'G' \

__asm __emit 'J' \

__asm __emit '_' \

__asm __emit 'E' \

__asm __emit 'N' \

__asm __emit 'C' \

__asm __emit 'R' \

__asm __emit 'Y' \

__asm __emit 'P' \

__asm __emit 'T' \

__asm __emit '_' \

__asm __emit 'C' \

__asm __emit 'O' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit '_' \

__asm __emit 'S' \

__asm __emit 'T' \

__asm __emit 'A' \

__asm __emit 'R' \

__asm __emit 'T'

#define GJ_ENCRYPT_CODE_END \

__asm __emit 0xEB \

__asm __emit 0x14 \

__asm mov ebx,offset GJ_Macro \

__asm __emit 'E' \

__asm __emit 'N' \

__asm __emit 'C' \

__asm __emit 'R' \

__asm __emit 'Y' \

__asm __emit 'P' \

__asm __emit 'T' \

__asm __emit 'C' \

__asm __emit 'O' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit '_' \

__asm __emit 'E' \

__asm __emit 'N' \

__asm __emit 'D'

#define GJ_ENCRYPT_CODE_WITH_LIC_START \

__asm __emit 0xEB \

__asm __emit 0x21 \

__asm mov ebx,offset GJ_Macro \

__asm __emit '0' \

__asm mov ebx,offset GJ_Macro \

__asm __emit 'P' \

__asm __emit 'T' \

__asm __emit '_' \

__asm __emit 'C' \

__asm __emit 'O' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit '_' \

__asm __emit 'W' \

__asm __emit 'I' \

__asm __emit 'T' \

__asm __emit 'H' \

__asm __emit '_' \

__asm __emit 'L' \

__asm __emit 'I' \

__asm __emit 'C' \

__asm __emit '_' \

__asm __emit 'S' \

__asm __emit 'T' \

__asm __emit 'A' \

__asm __emit 'R' \

__asm __emit 'T'

#define GJ_ENCRYPT_CODE_WITH_LIC_END \

__asm __emit 0xEB \

__asm __emit 0x14 \

__asm mov ebx,offset GJ_Macro \

__asm __emit 'R' \

__asm __emit 'Y' \

__asm __emit 'P' \

__asm __emit 'T' \

__asm __emit 'C' \

__asm __emit 'O' \

__asm __emit 'D' \

__asm __emit 'E' \

__asm __emit '_' \

__asm __emit 'L' \

__asm __emit 'I' \

__asm __emit 'C' \

__asm __emit 'E' \

__asm __emit 'N' \

__asm __emit 'D'

extern "C++"

{

//no license

//common function

BOOL GJ_IsAntidebugWorking();

BOOL GJ_Install_AntiDebugLIB();

void GJ_Remove_AntiDebugLIB();

BOOL GJ_Create_ADL_Serial_Number(char* version,char* username,char* userinfofilename,char* pSN);

BOOL GJ_GET_ADL_VERSION(char* adl_version);

BOOL GJ_Is_WindowNT();

//common function

//no license

//################################################################################

//demo function

//no license

BOOL GJ_OpenAntidebug_demo(char* antidebug_userid, char* antidebug_licence_filename, UINT antidebug_append_data_len, BYTE* antidebug_append_data);

BOOL GJ_OpenAntidebug_demo(char* antidebug_userid, char* antidebug_licence_filename, UINT antidebug_append_data_len, BYTE* antidebug_append_data,UINT32 uGJ_Macro);

BOOL GJ_OpenAntidebugB_demo(char* antidebug_userid, UINT Antidebug_licence_file_len,BYTE* Antidebug_licence_file, UINT antidebug_append_data_len, BYTE* antidebug_append_data);

BOOL GJ_OpenAntidebugB_demo(char* antidebug_userid, UINT Antidebug_licence_file_len,BYTE* Antidebug_licence_file, UINT antidebug_append_data_len, BYTE* antidebug_append_data,UINT32 uGJ_Macro);

BOOL GJ_CloseAntidebug_demo();

//no license

void* GJ_memcpy_demo( void *dest, const void *src, size_t count );

void* GJ_memset_demo( void *dest, int c, size_t count );

char* GJ_strcat_demo( char *strDestination, const char *strSource );

char* GJ_strcpy_demo( char *strDestination, const char *strSource );

//demo arithmetic: +,-,*,/

//demo dest=dest+src

char& GJ_add_demo(char& dest,char& src);

unsigned char& GJ_add_demo(unsigned char& dest,unsigned char& src);

signed char& GJ_add_demo(signed char& dest,signed char& src);

int& GJ_add_demo(int& dest,int& src);

unsigned int& GJ_add_demo(unsigned int& dest,unsigned int& src);

short int& GJ_add_demo(short int& dest,short int& src);

unsigned short int& GJ_add_demo(unsigned short int& dest,unsigned short int& src);

long int& GJ_add_demo(long int& dest,long int& src);

unsigned long int& GJ_add_demo(unsigned long int& dest,unsigned long int& src);

//dest=dest-src

char& GJ_sub_demo(char& dest,char& src);

unsigned char& GJ_sub_demo(unsigned char& dest,unsigned char& src);

signed char& GJ_sub_demo(signed char& dest,signed char& src);

int& GJ_sub_demo(int& dest,int& src);

unsigned int& GJ_sub_demo(unsigned int& dest,unsigned int& src);

short int& GJ_sub_demo(short int& dest,short int& src);

unsigned short int& GJ_sub_demo(unsigned short int& dest,unsigned short int& src);

long int& GJ_sub_demo(long int& dest,long int& src);

unsigned long int& GJ_sub_demo(unsigned long int& dest,unsigned long int& src);

//dest=dest%src

char& GJ_mod_demo(char& dest,char& src);

unsigned char& GJ_mod_demo(unsigned char& dest,unsigned char& src);

signed char& GJ_mod_demo(signed char& dest,signed char& src);

int& GJ_mod_demo(int& dest,int& src);

unsigned int& GJ_mod_demo(unsigned int& dest,unsigned int& src);

short int& GJ_mod_demo(short int& dest,short int& src);

unsigned short int& GJ_mod_demo(unsigned short int& dest,unsigned short int& src);

long int& GJ_mod_demo(long int& dest,long int& src);

unsigned long int& GJ_mod_demo(unsigned long int& dest,unsigned long int& src);

//dest=dest++

char& GJ_inc_demo(char& dest);

unsigned char& GJ_inc_demo(unsigned char& dest);

signed char& GJ_inc_demo(signed char& dest);

int& GJ_inc_demo(int& dest);

unsigned int& GJ_inc_demo(unsigned int& dest);

short int& GJ_inc_demo(short int& dest);

unsigned short int& GJ_inc_demo(unsigned short int& dest);

long int& GJ_inc_demo(long int& dest);

unsigned long int& GJ_inc_demo(unsigned long int& dest);

//dest<src

bool GJ_less_demo(char& dest,char& src);

bool GJ_less_demo(unsigned char& dest,unsigned char& src);

bool GJ_less_demo(signed char& dest,signed char& src);

bool GJ_less_demo(int& dest,int& src);

bool GJ_less_demo(unsigned int& dest,unsigned int& src);

bool GJ_less_demo(short int& dest,short int& src);

bool GJ_less_demo(unsigned short int& dest,unsigned short int& src);

bool GJ_less_demo(long int& dest,long int& src);

bool GJ_less_demo(unsigned long int& dest,unsigned long int& src);

//demo custom function

//<GJ_encrypt_custom_function_demo> Only used in another project.

BOOL GJ_encrypt_custom_function_demo(BYTE* _custom_function,unsigned int n_custom_function_size,char* function_name);

BYTE* GJ_load_custom_function_demo(BYTE* custom_function_code,int custom_function_length);

BOOL GJ_free_custom_function_demo(BYTE* _custom_function,int custom_function_length);

//demo fountion

//################################################################################

//no license

BOOL GJ_OpenAntidebug(char* antidebug_userid, char* antidebug_licence_filename, UINT antidebug_append_data_len, BYTE* antidebug_append_data);

BOOL GJ_OpenAntidebug(char* antidebug_userid, char* antidebug_licence_filename, UINT antidebug_append_data_len, BYTE* antidebug_append_data,UINT32 uGJ_Macro);

BOOL GJ_OpenAntidebugB(char* antidebug_userid, UINT Antidebug_licence_file_len,BYTE* Antidebug_licence_file, UINT antidebug_append_data_len, BYTE* antidebug_append_data);

BOOL GJ_OpenAntidebugB(char* antidebug_userid, UINT Antidebug_licence_file_len,BYTE* Antidebug_licence_file, UINT antidebug_append_data_len, BYTE* antidebug_append_data,UINT32 uGJ_Macro);

BOOL GJ_CloseAntidebug();

//no license

BOOL GJ_OpenFile(char* filename,UINT filepointer);

//filename --must include absolute path, and the path must already existed. for example:"c:\\antidebug_file"

//filepointer --setfilepointer in bytesize

//If the file already exists, open it. If it does not, create the given file.

BOOL GJ_ReadFile(LPVOID lpBuffer,DWORD nNumberOfBytesToRead,LPDWORD lpNumberOfBytesRead);

//lpBuffer --receive data buffer

//nNumberOfBytesToRead --want to read data number

//lpNumberOfBytesRead --actually read data number

//the filepointer auto increase nNumberOfBytesToRead

BOOL GJ_WriteFile(LPVOID lpBuffer,DWORD nNumberOfBytesToWrite,LPDWORD lpNumberOfBytesWrite);

//lpBuffer --source data buffer

//nNumberOfBytesToWrite --want to write data number

//lpNumberOfBytesWrite --actually write data number

//the filepointer auto nNumberOfBytesToWrite

BOOL GJ_SetFilePointer(UINT filepointer);

BOOL GJ_CloseFile();

//NOTE:When don't operate the file,you must invoke the funtion GJ_CloseFile() to close the file.!!!

int GJ_sprintf( char *buffer, const char *format, ... );

//only for format: %d,%i,%u,%x,%X

//datatype only for INT(int),UINT(unsigned int),LONG(long int),ULONG(unsigned long int)

//for example:

/*

char buffer[100];

INT X1=1;

int X2=2;

UINT X3=3;

unsigned int X4=4;

LONG X5=5;

long X6=6;

ULONG X7=7;

unsigned long X8=8;

memset(buffer,'g',sizeof(buffer));//The buffer must be initialized !

GJ_sprintf(buffer,"X1=%05d X2=%i X3=%u X4=%x X5=%X X6=%d X7=%d X8=%08d",X1,X2,X3,X4,X5*X8,X6,X7,X8);

//result: buffer "X1=00001 X2=2 X3=3 X4=4 X5=28 X6=6 X7=7 X8=00000008"

*/

void* GJ_memcpy(void *dest, const void *src, size_t count);

void* GJ_memset( void *dest, int c, size_t count );

char* GJ_strcpy( char *strDestination, const char *strSource );

wchar_t* GJ_wcscpy( wchar_t *strDestination, const wchar_t *strSource );

char* GJ_strncpy( char *strDest, const char *strSource, size_t count );

wchar_t* GJ_wcsncpy( wchar_t *strDest, const wchar_t *strSource, size_t count );

int GJ_strcmp( const char *string1, const char *string2 );

int GJ_wcscmp( const wchar_t *string1, const wchar_t *string2 );

int GJ_strncmp( const char *string1, const char *string2, size_t count );

int GJ_wcsncmp( const wchar_t *string1, const wchar_t *string2, size_t count );

char* GJ_strchr( const char *string, int c );

wchar_t* GJ_wcschr( const wchar_t *string, wint_t c );

char* GJ_strrchr( const char *string, int c );

wchar_t* GJ_wcsrchr( const wchar_t *string, wint_t c );

size_t GJ_strspn( const char *string, const char *strCharSet );

size_t GJ_wcsspn( const wchar_t *string, const wchar_t *strCharSet );

char* GJ_strstr( const char *string, const char *strCharSet );

wchar_t* GJ_wcsstr( const wchar_t *string, const wchar_t *strCharSet );

size_t GJ_strlen( const char *string );

size_t GJ_wcslen( const wchar_t *string );

char* GJ_strcat( char *strDestination, const char *strSource );

wchar_t* GJ_wcscat( wchar_t *strDestination, const wchar_t *strSource );

char* GJ_strncat( char *strDest, const char *strSource, size_t count );

wchar_t* GJ_wcsncat( wchar_t *strDest, const wchar_t *strSource, size_t count );

int GJ_atoi( const char *string );

long GJ_atol( const char *string );

int GJ_isdigit(int ch);

int GJ_islower(int ch);

int GJ_isupper(int ch);

int GJ_isprint(int ch);

int GJ_isspace(int ch);

//arithmetic: +,-,*,/

//dest=dest+src

char& GJ_add(char& dest,char& src);

unsigned char& GJ_add(unsigned char& dest,unsigned char& src);

signed char& GJ_add(signed char& dest,signed char& src);

int& GJ_add(int& dest,int& src);

unsigned int& GJ_add(unsigned int& dest,unsigned int& src);

short int& GJ_add(short int& dest,short int& src);

unsigned short int& GJ_add(unsigned short int& dest,unsigned short int& src);

long int& GJ_add(long int& dest,long int& src);

unsigned long int& GJ_add(unsigned long int& dest,unsigned long int& src);

//dest=dest-src

char& GJ_sub(char& dest,char& src);

unsigned char& GJ_sub(unsigned char& dest,unsigned char& src);

signed char& GJ_sub(signed char& dest,signed char& src);

int& GJ_sub(int& dest,int& src);

unsigned int& GJ_sub(unsigned int& dest,unsigned int& src);

short int& GJ_sub(short int& dest,short int& src);

unsigned short int& GJ_sub(unsigned short int& dest,unsigned short int& src);

long int& GJ_sub(long int& dest,long int& src);

unsigned long int& GJ_sub(unsigned long int& dest,unsigned long int& src);

//dest=dest*src

char& GJ_mul(char& dest,char& src);

unsigned char& GJ_mul(unsigned char& dest,unsigned char& src);

signed char& GJ_mul(signed char& dest,signed char& src);

int& GJ_mul(int& dest,int& src);

unsigned int& GJ_mul(unsigned int& dest,unsigned int& src);

short int& GJ_mul(short int& dest,short int& src);

unsigned short int& GJ_mul(unsigned short int& dest,unsigned short int& src);

long int& GJ_mul(long int& dest,long int& src);

unsigned long int& GJ_mul(unsigned long int& dest,unsigned long int& src);

//dest=dest/src

char& GJ_div(char& dest,char& src);

unsigned char& GJ_div(unsigned char& dest,unsigned char& src);

signed char& GJ_div(signed char& dest,signed char& src);

int& GJ_div(int& dest,int& src);

unsigned int& GJ_div(unsigned int& dest,unsigned int& src);

short int& GJ_div(short int& dest,short int& src);

unsigned short int& GJ_div(unsigned short int& dest,unsigned short int& src);

long int& GJ_div(long int& dest,long int& src);

unsigned long int& GJ_div(unsigned long int& dest,unsigned long int& src);

//dest=dest%src

char& GJ_mod(char& dest,char& src);

unsigned char& GJ_mod(unsigned char& dest,unsigned char& src);

signed char& GJ_mod(signed char& dest,signed char& src);

int& GJ_mod(int& dest,int& src);

unsigned int& GJ_mod(unsigned int& dest,unsigned int& src);

short int& GJ_mod(short int& dest,short int& src);

unsigned short int& GJ_mod(unsigned short int& dest,unsigned short int& src);

long int& GJ_mod(long int& dest,long int& src);

unsigned long int& GJ_mod(unsigned long int& dest,unsigned long int& src);

//dest=dest++

char& GJ_inc(char& dest);

unsigned char& GJ_inc(unsigned char& dest);

signed char& GJ_inc(signed char& dest);

int& GJ_inc(int& dest);

unsigned int& GJ_inc(unsigned int& dest);

short int& GJ_inc(short int& dest);

unsigned short int& GJ_inc(unsigned short int& dest);

long int& GJ_inc(long int& dest);

unsigned long int& GJ_inc(unsigned long int& dest);

//dest=dest--

char& GJ_dec(char& dest);

unsigned char& GJ_dec(unsigned char& dest);

signed char& GJ_dec(signed char& dest);

int& GJ_dec(int& dest);

unsigned int& GJ_dec(unsigned int& dest);

short int& GJ_dec(short int& dest);

unsigned short int& GJ_dec(unsigned short int& dest);

long int& GJ_dec(long int& dest);

unsigned long int& GJ_dec(unsigned long int& dest);

//relation: >,>=,<,<=,==,!=

//dest>src

bool GJ_greater(char& dest,char& src);

bool GJ_greater(unsigned char& dest,unsigned char& src);

bool GJ_greater(signed char& dest,signed char& src);

bool GJ_greater(int& dest,int& src);

bool GJ_greater(unsigned int& dest,unsigned int& src);

bool GJ_greater(short int& dest,short int& src);

bool GJ_greater(unsigned short int& dest,unsigned short int& src);

bool GJ_greater(long int& dest,long int& src);

bool GJ_greater(unsigned long int& dest,unsigned long int& src);

//dest>=src

bool GJ_greater_equal(char& dest,char& src);

bool GJ_greater_equal(unsigned char& dest,unsigned char& src);

bool GJ_greater_equal(signed char& dest,signed char& src);

bool GJ_greater_equal(int& dest,int& src);

bool GJ_greater_equal(unsigned int& dest,unsigned int& src);

bool GJ_greater_equal(short int& dest,short int& src);

bool GJ_greater_equal(unsigned short int& dest,unsigned short int& src);

bool GJ_greater_equal(long int& dest,long int& src);

bool GJ_greater_equal(unsigned long int& dest,unsigned long int& src);

//dest<src

bool GJ_less(char& dest,char& src);

bool GJ_less(unsigned char& dest,unsigned char& src);

bool GJ_less(signed char& dest,signed char& src);

bool GJ_less(int& dest,int& src);

bool GJ_less(unsigned int& dest,unsigned int& src);

bool GJ_less(short int& dest,short int& src);

bool GJ_less(unsigned short int& dest,unsigned short int& src);

bool GJ_less(long int& dest,long int& src);

bool GJ_less(unsigned long int& dest,unsigned long int& src);

//dest<=src

bool GJ_less_equal(char& dest,char& src);

bool GJ_less_equal(unsigned char& dest,unsigned char& src);

bool GJ_less_equal(signed char& dest,signed char& src);

bool GJ_less_equal(int& dest,int& src);

bool GJ_less_equal(unsigned int& dest,unsigned int& src);

bool GJ_less_equal(short int& dest,short int& src);

bool GJ_less_equal(unsigned short int& dest,unsigned short int& src);

bool GJ_less_equal(long int& dest,long int& src);

bool GJ_less_equal(unsigned long int& dest,unsigned long int& src);

//dest==src

bool GJ_equal_to(char& dest,char& src);

bool GJ_equal_to(unsigned char& dest,unsigned char& src);

bool GJ_equal_to(signed char& dest,signed char& src);

bool GJ_equal_to(int& dest,int& src);

bool GJ_equal_to(unsigned int& dest,unsigned int& src);

bool GJ_equal_to(short int& dest,short int& src);

bool GJ_equal_to(unsigned short int& dest,unsigned short int& src);

bool GJ_equal_to(long int& dest,long int& src);

bool GJ_equal_to(unsigned long int& dest,unsigned long int& src);

//dest!=src

bool GJ_not_equal_to(char& dest,char& src);

bool GJ_not_equal_to(unsigned char& dest,unsigned char& src);

bool GJ_not_equal_to(signed char& dest,signed char& src);

bool GJ_not_equal_to(int& dest,int& src);

bool GJ_not_equal_to(unsigned int& dest,unsigned int& src);

bool GJ_not_equal_to(short int& dest,short int& src);

bool GJ_not_equal_to(unsigned short int& dest,unsigned short int& src);

bool GJ_not_equal_to(long int& dest,long int& src);

bool GJ_not_equal_to(unsigned long int& dest,unsigned long int& src);

//bit operation:&,|,^,~,>>,<<

//dest=dest&src

char& GJ_and(char& dest,char& src);

unsigned char& GJ_and(unsigned char& dest,unsigned char& src);

signed char& GJ_and(signed char& dest,signed char& src);

int& GJ_and(int& dest,int& src);

unsigned int& GJ_and(unsigned int& dest,unsigned int& src);

short int& GJ_and(short int& dest,short int& src);

unsigned short int& GJ_and(unsigned short int& dest,unsigned short int& src);

long int& GJ_and(long int& dest,long int& src);

unsigned long int& GJ_and(unsigned long int& dest,unsigned long int& src);

//dest=dest|src

char& GJ_or(char& dest,char& src);

unsigned char& GJ_or(unsigned char& dest,unsigned char& src);

signed char& GJ_or(signed char& dest,signed char& src);

int& GJ_or(int& dest,int& src);

unsigned int& GJ_or(unsigned int& dest,unsigned int& src);

short int& GJ_or(short int& dest,short int& src);

unsigned short int& GJ_or(unsigned short int& dest,unsigned short int& src);

long int& GJ_or(long int& dest,long int& src);

unsigned long int& GJ_or(unsigned long int& dest,unsigned long int& src);

//dest=dest^src

char& GJ_xor(char& dest,char& src);

unsigned char& GJ_xor(unsigned char& dest,unsigned char& src);

signed char& GJ_xor(signed char& dest,signed char& src);

int& GJ_xor(int& dest,int& src);

unsigned int& GJ_xor(unsigned int& dest,unsigned int& src);

short int& GJ_xor(short int& dest,short int& src);

unsigned short int& GJ_xor(unsigned short int& dest,unsigned short int& src);

long int& GJ_xor(long int& dest,long int& src);

unsigned long int& GJ_xor(unsigned long int& dest,unsigned long int& src);

//dest=~dest

char& GJ_not(char& dest);

unsigned char& GJ_not(unsigned char& dest);

signed char& GJ_not(signed char& dest);

int& GJ_not(int& dest);

unsigned int& GJ_not(unsigned int& dest);

short int& GJ_not(short int& dest);

unsigned short int& GJ_not(unsigned short int& dest);

long int& GJ_not(long int& dest);

unsigned long int& GJ_not(unsigned long int& dest);

//dest=dest>>src

char& GJ_shr(char& dest,char& src);

unsigned char& GJ_shr(unsigned char& dest,unsigned char& src);

signed char& GJ_shr(signed char& dest,signed char& src);

int& GJ_shr(int& dest,int& src);

unsigned int& GJ_shr(unsigned int& dest,unsigned int& src);

short int& GJ_shr(short int& dest,short int& src);

unsigned short int& GJ_shr(unsigned short int& dest,unsigned short int& src);

long int& GJ_shr(long int& dest,long int& src);

unsigned long int& GJ_shr(unsigned long int& dest,unsigned long int& src);

//dest=dest<<src

char& GJ_shl(char& dest,char& src);

unsigned char& GJ_shl(unsigned char& dest,unsigned char& src);

signed char& GJ_shl(signed char& dest,signed char& src);

int& GJ_shl(int& dest,int& src);

unsigned int& GJ_shl(unsigned int& dest,unsigned int& src);

short int& GJ_shl(short int& dest,short int& src);

unsigned short int& GJ_shl(unsigned short int& dest,unsigned short int& src);

long int& GJ_shl(long int& dest,long int& src);

unsigned long int& GJ_shl(unsigned long int& dest,unsigned long int& src);

//custom function

//<GJ_encrypt_custom_function> Only used in another project.

BOOL GJ_encrypt_custom_function(BYTE* _custom_function,unsigned int n_custom_function_size,char* function_name);

BYTE* GJ_load_custom_function(BYTE* custom_function_code,int custom_function_length);

BOOL GJ_free_custom_function(BYTE* _custom_function,int custom_function_length);

}

#endif