//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