Untitled

#include amxmodx
#include amxmisc

#include orpheu
#include orpheu_memory
#include orpheu_advanced

#define PLUGIN_NAME "Check files by OSTROG"
#define PLUGIN_VERSION "1.0"
#define PLUGIN_AUTHOR "OSTROG"

//  Название команды на меню
#define SHOW_MENU_CMD_NAME  "ost_menu_create"

#define CONFIG_PATH                 "addons/amxmodx/configs/ost_path_list.ini"
#define ORPHEU_FUNCTIONS_PATH       "addons/amxmodx/configs/orpheu/functions/"
#define ORPHEU_MEMORY_PATH          "addons/amxmodx/configs/orpheu/memory/"

#define CONSOLE_PRINT_PREFIX        "[OST Check Files] "
#define CONSOLE_PRINT_ERROR_PREFIX  "[ERROR] "

static  NAME_CMD_PATH[]                     =   "add_path"
static  NAME_CMD_ACCESS[]                   =   "add_flags"
static  CHAR_PATH_W_B[]                     =   "["
static  CHAR_PATH_W_E[]                     =   "]"
static  CHAR_PATH_R_E[]                     =   "="

static  CONFIG_SAVE[]                       =   "add_path[ kick ^"%n^" ^"OpenGL Detected^" ] = ../opengl32.dll^r^nadd_path[ kick ^"%n^" ^"Anime Detected^" ] = ../anime.ini^r^nadd_path[ kick ^"%n^" ^"CSXGuard Detected^" ] = ../CSXGuard.dll^r^nadd_path[ kick ^"%n^" ^"Protector Detected^" ] = ../protector.dll^r^nadd_flags = abcd"


/*    ######################################    EngineBase Begin    ######################################    */
static  ORPHEU_NAME_ENGINE_BASE[]                       =   "__ost_engine_base"
static  ORPHEU_PATTERN_ENGINE_BASE[]                    =   "[^"*^"]"
/*     ######################################    EngineBase End    ######################################     */

/*    ######################################    WriteByteEng Begin    ######################################    */
static  ORPHEU_NAME_WRITE_BYTE_ENG[]                    =   "__ost_write_byte_eng"
static  ORPHEU_PATTERN_WRITE_BYTE_ENG[]                 =   "0"
/*     ######################################    WriteByteEng End    ######################################     */

/*    ######################################    WriteByte Begin    ######################################    */
static  ORPHEU_NAME_WRITE_BYTE[]                        =   "__ost_write_byte"
static  ORPHEU_ARGV_WRITE_BYTE[]                        =   "{^"type^":^"long^"},{^"type^":^"long^"}"
static  ORPHEU_RET_WRITE_BYTE[]                         =   "long"
static  ORPHEU_PATTERN_WRITE_BYTE[]                     =   "[0x43,0x6D,0x64,0x5F,0x41,0x64,0x64,0x43,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x3A,0x20,0x25,0x73,0x20,0x61,0x6C,0x72,0x65,0x61,0x64,0x79,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x64,0x20,0x61,0x73,0x20,0x61,0x20,0x76,0x61,0x72,0x0A,0x00]"
/*     ######################################    WriteByte End    ######################################     */

/*    ######################################    MoveResource Begin    ######################################    */
static  ORPHEU_NAME_MOVE_RESOURCE[]                     =   "__ost_move_resource"
static  ORPHEU_ARGV_MOVE_RESOURCE[]                     =   "{^"type^":^"long^"},{^"type^":^"long^"},{^"type^":^"long^"}"
static  ORPHEU_RET_MOVE_RESOURCE[]                      =   "long"
/*     ######################################    MoveResource End    ######################################     */

/*    ######################################    Malloc Begin    ######################################    */
static  ORPHEU_NAME_MALLOC_WIN[]                        =   "__ost_malloc_win"

static  ORPHEU_NAME_MALLOC_LIN[]                        =   "__ost_malloc_lin"
static  ORPHEU_PATTERN_MALLOC_W[]                       =   "[^"*^"]"
static  ORPHEU_PATTERN_MALLOC_L[]                       =   "^"Hunk_Alloc^""

static  ORPHEU_ARGV_MALLOC[]                            =   "{^"type^":^"long^"}"
static  ORPHEU_RET_MALLOC[]                             =   "long"
/*     ######################################    Malloc End    ######################################     */

/*    ######################################    Cbuf_AddText Begin    ######################################    */
static  ORPHEU_NAME_CBUF_ADDTEXT[]                      =   "__ost_cbuf_addtext_lin"
static  ORPHEU_PATTERN_CBUF_ADDTEXT_W[]                 =   "[^"*^"]"
static  ORPHEU_PATTERN_CBUF_ADDTEXT_L[]                 =   "^"Cbuf_AddText^""
/*     ######################################    Cbuf_AddText End    ######################################     */

/*    ######################################    SV_SendRes_f Begin    ######################################    */
static  ORPHEU_NAME_SV_SENDRES_F[]                      =   "__ost_sv_sendres_f"
static  ORPHEU_PATTERN_CALL_BASE_W[]                    =   "[0xE8,^"*^",^"*^",^"*^",^"*^",0x8B,0x0D,^"*^",^"*^",^"*^",^"*^",0x8D,0x45,0xEC,0x83,0xC1,0x20,0x50,0x51,0x6A,0x01,0xE8]"
static  ORPHEU_PATTERN_CALL_BASE_L[]                    =   "^"SV_SendRes_f^""
/*     ######################################    SV_SendRes_f End    ######################################     */

/*    ######################################    SV_ParseConsistencyResponse Begin    ######################################    */
static  ORPHEU_NAME_SV_PARSECONS[]                      =   "__ost_sv_parseconsistencyresponse"
static  ORPHEU_PATTERN_SV_PARSECONS_W[]                 =   "[0xE8,^"*^",^"*^",^"*^",^"*^",0x8B,0x4E,0x4D,0x83,0xC4,0x04,0x3B,0xC1,0x0F,0x84,^"*^",^"*^",^"*^",^"*^",0xE9,^"*^",^"*^",^"*^",^"*^",0x8D,0x55,0xEC,0x6A,0x0C,0x52,0xE8,^"*^",^"*^",^"*^",^"*^",0x8D,0x45,0xE0,0x6A,0x0C,0x50,0xE8,^"*^",^"*^",^"*^",^"*^"]"
static  ORPHEU_PATTERN_SV_PARSECONS_L[]                 =   "^"SV_ParseConsistencyResponse^""
/*     ######################################    SV_ParseConsistencyResponse End    ######################################     */

/*    ######################################    SV_SendResources Begin    ######################################    */
static  ORPHEU_NAME_SV_SENDRES[]                        =   "__ost_sv_sendresources_lin"
static  ORPHEU_PATTERN_SV_SENDRES_W[]                   =   "[^"*^"]"
static  ORPHEU_PATTERN_SV_SENDRES_L[]                   =   "^"SV_SendResources^""
/*     ######################################    SV_SendResources End    ######################################     */

/*    ######################################    MSG_ReadBits Begin    ######################################    */
static  ORPHEU_NAME_MSG_READBITS[]                      =   "__ost_msg_readbits_lin"
static  ORPHEU_PATTERN_MSG_READBITS_W[]                 =   "[^"*^"]"
static  ORPHEU_PATTERN_MSG_READBITS_L[]                 =   "^"MSG_ReadBits^""
/*     ######################################    MSG_ReadBits End    ######################################     */

/*    ######################################    MSG_WriteBits Begin    ######################################    */
static  ORPHEU_NAME_MSG_WRITEBITS[]                     =   "__ost_msg_writebits_lin"
static  ORPHEU_PATTERN_MSG_WRITEBITS_W[]                =   "[^"*^"]"
static  ORPHEU_PATTERN_MSG_WRITEBITS_L[]                =   "^"MSG_WriteBits^""
/*     ######################################    MSG_WriteBits End    ######################################     */


static  SAVE_ORIGINAL_DATA_W[] = {
    0x43,0x6D,0x64,0x5F,0x41,0x64,0x64,0x43,0x6F,0x6D,0x6D,0x61,0x6E,0x64,0x3A,0x20,0x25,0x73,0x20,
    0x61,0x6C,0x72,0x65,0x61,0x64,0x79,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x64,0x20,0x61,0x73,0x20,
    0x61,0x20,0x76,0x61,0x72,0x0A,0x00
}


static  BYTE_CODE_W_BYTE[] = { 0x8A, 0x44, 0x24, 0x08, 0x8B, 0x54, 0x24, 0x04, 0x88, 0x02, 0xC3 , 0x00 }
static  BYTE_CODE_MOVE_RESOURCE[] = { 0x57577342,0x0E251341,0x12250B6D,0x16254389,0xFD03A84F,0xC0305C19,0x0000E2AF,0xABF2949C,0x9D673679,0x00418359,0x51ED8A3B,0xFE44BDCE }
static  BYTE_CODE_RANDOM[] = {
    0x32C68851,0x00015884,0xF2FCFFD7,0xB8060BA6,0x00010030,0xFFB9C16D,0x290100E1,0x90C235D4,0x89522D72,0xFCE07FA1,0x29FE9551,0x02E8BF69,0xD688BD97,0x89A49128,0x5BA5912F,0x90C23305,
    0x89522C12,0xFCE082C1,0x29FE9431,0x02E8C209,0xD688BCF7,0x75A69048,0xF3D88933,0xB8060E7E,0x000102FF,0x00B8FDC1,0x5B010288,0x90C234D5,0x83ED87A3,0x4D88B070,0xF8547C8C,0x8BFD497B,
    0x4527FFE3,0x0C447E1C,0xFFE548EF,0x458AA747,0xF8547EAC,0x5F73B4F1,0xE0547B06,0x8BFD489B,0xC084A8C3,0x8940DBAA,0x45C6B18B,0x000104C0,0xF4447E90,0x0FED4A89,0x4588050A,0xE87C8654,
    0x00010579,0x458A00D0,0xEC4404B4,0x3B0158C5,0x08749D33,0xFFED4ACD,0xD574B273,0x3BED4AD9,0x0B740283,0x03FD49A1,0x4587FFCB,0xFF0C9BBC,0x4DFE9213,0x33A915D4,0xF04481D8,0x8BF145F9,
    0x08C32DC3,0x00417DC4,0x83ED821B,0x89679A48,0x83678CF3,0x75018F8F,0x89C0D879,0x4BEA915F,0x22F542C1,0x8B22EBFA,0x6967940B,0x4085052C,0xF2447EF2,0x66F547F1,0x66F337DD,0xB70DFB3B,
    0xB70E9623,0xEAF68AB7,0xC1ED472F,0x0F119CA7,0x89ED4721,0xB70E93D7,0x453A8DFB,0x660D1284,0xE8FF4745,0xFFFE8A04,0x8BF9440F,0xE58A93AF,0xC08AC6AB,0x51ED9707,0x62FDD05A,0x0002C21E,
    0xFFFE8F48,0x01E98F1D,0x15751366,0xEB22FE44,0x18B8F39A,0xFF6F75D4,0x61058861,0xEBFDD194,0x18B8F33A,0xFF5F7564,0x410588D1,0xEBFDCE24,0x08B8F29A,0xFF4F74F4,0x30058941,0x8AFDD2B4,
    0x5D5889A3,0x00419BB9,0x83ED94DB,0x45C68088,0x11101FE8,0x08B8F1FB,0xFF2B77B8,0x45028605,0x04C18A58,0xEBF4D0A3,0xFF877703,0x558A86B5,0xFF0397C8,0x458A8677,0xF4444B00,0x458A7BAF,
    0x00014FB8,0x8BFCCE41,0x90C1E68B,0x9C66DDEE,0xB1E8EDD2,0x66FE840D,0x669BEC67,0x33327524,0xFFFE434D,0xFFFE87BD,0xFFFE8751,0xFFFE8775,0xFFFE8709,0xFFFE872D,0xFFFE86C1,0xFFFE86E5,
    0xFFFE86F9,0xFFFE86DD,0xFFFE8631,0xFFFE8615,0xFFFE8669,0xFFFE864D,0xFFFE81A1,0xFFFE8185,0xFFFE81D9,0xFFFE81FD,0xFFFE8111,0xC08A4D35,0xFFFE8149,0xFFFE816D
}
static  BYTE_CODE_GET_INDEX_FILE[] = {
    0x22E90346,0x8322E1DA,0x0587FBAC,0x110FF0E3,0xFFFE964D,0xFFFE960D,0xFFFE95E1,0xFFFE95C5,0xFFFE9599,0xFFFE95BD,0xFFFE9551,0xFFFE9575,0xFFFE9509,0xFFFE952D,0xFFFE94C1,0xFFFE94E5,
    0xC3FE94F9,0xFFFE94DD,0xFFFE9431
}
static  BYTE_CODE_TRY_FILES[] = {
    0x32C68851,0x00015884,0xF2FCFFD7,0xB8060BA6,0x00010030,0xFFB9C16D,0x290100E1,0x90C235D4,0x89522D72,0xFCE07FA1,0x29FE9551,0x02E8BF69,0xD688BD97,0x89A49128,0x5BA5912F,0x90C23305,
    0x89522C12,0xFCE082C1,0x29FE9431,0x02E8C209,0xD688BCF7,0x75A69048,0xF3D88933,0xB8060E7E,0x000102FF,0x00B8FDC1,0x5B010288,0x90C234D5,0x83ED87A3,0x4D88B070,0xF8547C8C,0x8BFD497B,
    0x4527FFE3,0x0C447E1C,0xFFE548EF,0x458AA747,0xF8547EAC,0x5F73B4F1,0xE0547B06,0x8BFD489B,0xC084A8C3,0x8940DBAA,0x45C6B18B,0x000104C0,0xF4447E90,0x0FED4A89,0x4588050A,0xE87C8654,
    0x00010579,0x458A00D0,0xEC4404B4,0x3B0158C5,0x08749D33,0xFFED4ACD,0xD574B273,0x3BED4AD9,0x0B740283,0x03FD49A1,0x4587FFCB,0xFF0C9BBC,0x4DFE9213,0x33A915D4,0xF04481D8,0x8BF145F9,
    0x08C32DC3,0x00417DC4,0x83ED821B,0x55889248,0xFC448128,0xB9FD42D1,0x0001097E,0xF1F6BB91,0x8B31CA00,0xC0829027,0xB91181CF,0x0001082A,0x33FD4295,0x89F095DA,0x458A8C9B,0x000B53E0,
    0xD23208E0,0xC2819BD5,0xF84481F8,0x8809C831,0x000B5240,0x458A0B14,0xF7D2D6A4,0xFC448093,0xB9FD4745,0x00010BA2,0xF1F6B9C5,0x8B31C9EC,0xC0829393,0xB9119235,0x00010A1E,0x33FCD079,
    0x89F0834E,0x458A8987,0x000BC5F4,0xD2320D8C,0xC2817DA1,0xF84494C4,0x88074D45,0x000BC2EC,0x458A0D00,0xF7D33C38,0xFC4492C7,0xB9FCCE29,0x00010C96,0xF1F65AF9,0x8B314A58,0xC08284FF,
    0xB9119463,0x00010C02,0x33FCD3AD,0x89F081E2,0x458A8833,0x000BC7C8,0xD2320FB8,0xC2817C0D,0xF8449290,0x88054FD9,0x000BC438,0x458A0EEC,0xF7D33ACC,0xFC4498FB,0xB9FCCD1D,0x00010E7A,
    0xF1F6636D,0x8B315344,0xC0828A2B,0xB91195F1,0x00011236,0x33FCC9D1,0x89F07C16,0x458A865F,0x000BC59C,0xD23212E4,0xC2817D59,0xF844983C,0x880352AD,0x000BC804,0x458A1358,0xF7D342E0,
    0xFC4498EF,0xB9FCCC01,0x000113AE,0xF1F66241,0x8B314DF0,0x884188D7,0x000BCB08,0x458A10DC,0xF7D33DDC,0xFC449BEB,0xB9FCCF0D,0x0001116A,0xF1F6629D,0x8B3157B4,0x108979DB,0x8BF4DB79,
    0x90C1E243,0x83ED8C77,0x4D88692C,0xF8548ED8,0x8BFCDA37,0x408A8217,0xEC4489CC,0xC7ECDA99,0x2062E300,0xEC448F7A,0xB90556F5,0x0001178C,0xE8F8E515,0xFFFE801C,0x83ECD85D,0xC082377C,
    0x00015564,0xE8ECD881,0xFFFE807C,0x8BE8D84B,0x45027333,0x00C5FBFC,0x458234E6,0x558A1634,0xE854112C,0x35F4DBA1,0x00134FB6,0xFFFF2584,0xE84491C9,0xEC4490B2,0x66E8D6A5,0x000B153D,
    0x50ECD625,0xFFFCD741,0x8B580F18,0xE58A84CF,0xC08A59CB,0x83ED9267,0x4D885E3C,0xF8548CC8,0x8BFCD707,0x408A7E27,0xEC448CFC,0xE8F4D0A9,0xFFFE7F5C,0x8BE0D5F3,0x4502869B,0x02E99BDC,
    0x8BDCD467,0x45888547,0x8B0C73C0,0x8167728F,0x746F35A8,0xE8447811,0x3BE8D6BD,0xEB745D1F,0x3BE8D545,0x26745C67,0x8BE0CE0D,0x458A85DF,0xFCAB713C,0x458A786D,0xE0441C74,0x0A01611E,
    0xEC44A520,0xFC44A574,0x590CC8F1,0x4589F0E9,0xF44445D8,0x8BE4DC53,0x558A8333,0xEC44A648,0xFFFCF668,0xEC44A63D,0xB9E4DC75,0x00011E8C,0xE8F8CC15,0xFFFE7A1C,0x03ECE15D,0xC08282FF,
    0x00015C40,0xE8ECE181,0xFFFE7A7C,0x8BE4E14B,0x452A5A33,0x4587DCFC,0xE854A7D8,0x8B035F21,0x45028983,0xE04CA040,0xFFFD2860,0xEC44A0B5,0x03E4E1ED,0xC7677C77,0x8B012A98,0x8B5180BF,
    0x50FE7763,0x4589DCC8,0x5DE4AE78,0x0041A031,0x83EDAEC3,0x45888110,0xFC44ADE4,0xC7F8D81B,0x11106843,0x33B90B8B,0x8B323585,0xF044AC2C,0x8BF0DF95,0x023A6947,0xC0320755,0x8BF8DB3B,
    0x408A6923,0x0501AC8C,0x0000E2A0,0x83ECDACB,0x750175EB,0xFC44A363,0x89F4C9BD,0x4D8A1A62,0xEC54A3DC,0xE8F4D921,0xFFFE70B0,0x458A3C09,0x0441A344,0x74FCEC21,0xF4449A31,0x8B10E079,
    0x3C8277D3,0x207527B4,0x8BFCECED,0x4288733F,0xF4449BB4,0x8B10E051,0x0C8A700B,0xEC54996C,0xE8F4EC85,0xFFFE7788,0x8BF8E3CD,0x90C1CBCF,0x9C66D272,0x5756D2DA,0xE820FF35,0x22234722,
    0xFF4B7996,0x5F5A745D,0x665ACBD2,0xC35B03B7,0xFFFE74E9,0xFFFE74CD,0xFFFE6B21,0xFFFE6B05,0xFFFE6B59,0xFFFE6B7D,0xFFFE6B91,0xFFFE6BB5,0xFFFE6BC9,0xFFFE6BED,0xFFFE6A01,0xFFFE6A25,
    0x90C26BB9,0xFFFE6B9D,0xFFFE6B71
}


#define OS_BAD      0
#define OS_WINDOWS  1
#define OS_LINUX    2

static OS = OS_BAD
static PE_Base = 0
static MODULE_SIZE = 0

static IF_RESTART = false
static CURR_PATH_FILE[1024]
static ENGINE_BASE = 0
static ENGINE_END = 10*1024*1024
static Malloc_Base = 0
static WriteByteAddr = 0
static OrpheuFunction:o_Malloc
static OrpheuFunction:o_wByte
static OrpheuFunction:o_MoveResource
static SV_SendResourcesCall_Base = 0
static SV_SendResources = 0
static Resources_Base = 0
static CountResources_Base = 0
static SomeTotalValue_Base = 0
static Cbuf_AddText = 0
static MSG_ReadBits = 0
static MSG_WriteBits = 0
static SV_SendRes_f_Lin = 0
static SV_ParseCons = 0
static SV_ParseConsCall_Base = 0
static FileIndexCall_Base = 0
static FileIndex_Base = 0
static WriteByteProcess = false

static InfoTable_Size = 0x500
static InfoTable_Base = 0

static TASK_ID = 1

static global_host_client = 0
static RandomPathID = 0
static RandomPathCode_Base = 0
static RandomPathEntryPoint_Base = 0
static TryFilesCode_Base = 0
static GetFileIndex_EntryPoint = 0
static TryFiles_EntryPoint = 0
static OwnResourcesCount = 0
static MoveResourseProcess = false

static AdminFlags[ 1024 ] = ""

#define REOURCE_COUNT_MAX       0x500
#define REOURCE_ITEM_SIZE       0x88
#define CONS_DATA_COUNT_MAX     0x200

/*
5758 {
    amd     =   0x00080DBF
    i486    =   0x0009242E
    i686    =   0x0008DC4F
}
6132 {
    i486fb  =   0x0008B569
}
__ost_real_write_byte
*/

public plugin_init() {

    register_plugin (   PLUGIN_NAME     ,   PLUGIN_VERSION          ,   PLUGIN_AUTHOR   )

    MSG_Print( "Loaded..." )


    TryConfig()

    read_function_init()

}
public plugin_end() {

    DeatchAllEngineHook()

}


stock MSG_Print( msg[] ) {

    server_print( "%s%s" , CONSOLE_PRINT_PREFIX , msg )

}
stock MSG_Error( msg[] ) {

    server_print( "%s%s%s" , CONSOLE_PRINT_PREFIX , CONSOLE_PRINT_ERROR_PREFIX , msg )

}
stock GetDWordHex( W ) {

    static HexTable[256][2] = {
        { 0x30 , 0x30 } , { 0x30 , 0x31 } , { 0x30 , 0x32 } , { 0x30 , 0x33 } , { 0x30 , 0x34 } , { 0x30 , 0x35 } , { 0x30 , 0x36 } , { 0x30 , 0x37 } , { 0x30 , 0x38 } , { 0x30 , 0x39 } , { 0x30 , 0x41 } , { 0x30 , 0x42 } , { 0x30 , 0x43 } , { 0x30 , 0x44 } , { 0x30 , 0x45 } , { 0x30 , 0x46 } ,
        { 0x31 , 0x30 } , { 0x31 , 0x31 } , { 0x31 , 0x32 } , { 0x31 , 0x33 } , { 0x31 , 0x34 } , { 0x31 , 0x35 } , { 0x31 , 0x36 } , { 0x31 , 0x37 } , { 0x31 , 0x38 } , { 0x31 , 0x39 } , { 0x31 , 0x41 } , { 0x31 , 0x42 } , { 0x31 , 0x43 } , { 0x31 , 0x44 } , { 0x31 , 0x45 } , { 0x31 , 0x46 } ,
        { 0x32 , 0x30 } , { 0x32 , 0x31 } , { 0x32 , 0x32 } , { 0x32 , 0x33 } , { 0x32 , 0x34 } , { 0x32 , 0x35 } , { 0x32 , 0x36 } , { 0x32 , 0x37 } , { 0x32 , 0x38 } , { 0x32 , 0x39 } , { 0x32 , 0x41 } , { 0x32 , 0x42 } , { 0x32 , 0x43 } , { 0x32 , 0x44 } , { 0x32 , 0x45 } , { 0x32 , 0x46 } ,
        { 0x33 , 0x30 } , { 0x33 , 0x31 } , { 0x33 , 0x32 } , { 0x33 , 0x33 } , { 0x33 , 0x34 } , { 0x33 , 0x35 } , { 0x33 , 0x36 } , { 0x33 , 0x37 } , { 0x33 , 0x38 } , { 0x33 , 0x39 } , { 0x33 , 0x41 } , { 0x33 , 0x42 } , { 0x33 , 0x43 } , { 0x33 , 0x44 } , { 0x33 , 0x45 } , { 0x33 , 0x46 } ,

        { 0x34 , 0x30 } , { 0x34 , 0x31 } , { 0x34 , 0x32 } , { 0x34 , 0x33 } , { 0x34 , 0x34 } , { 0x34 , 0x35 } , { 0x34 , 0x36 } , { 0x34 , 0x37 } , { 0x34 , 0x38 } , { 0x34 , 0x39 } , { 0x34 , 0x41 } , { 0x34 , 0x42 } , { 0x34 , 0x43 } , { 0x34 , 0x44 } , { 0x34 , 0x45 } , { 0x34 , 0x46 } ,
        { 0x35 , 0x30 } , { 0x35 , 0x31 } , { 0x35 , 0x32 } , { 0x35 , 0x33 } , { 0x35 , 0x34 } , { 0x35 , 0x35 } , { 0x35 , 0x36 } , { 0x35 , 0x37 } , { 0x35 , 0x38 } , { 0x35 , 0x39 } , { 0x35 , 0x41 } , { 0x35 , 0x42 } , { 0x35 , 0x43 } , { 0x35 , 0x44 } , { 0x35 , 0x45 } , { 0x35 , 0x46 } ,
        { 0x36 , 0x30 } , { 0x36 , 0x31 } , { 0x36 , 0x32 } , { 0x36 , 0x33 } , { 0x36 , 0x34 } , { 0x36 , 0x35 } , { 0x36 , 0x36 } , { 0x36 , 0x37 } , { 0x36 , 0x38 } , { 0x36 , 0x39 } , { 0x36 , 0x41 } , { 0x36 , 0x42 } , { 0x36 , 0x43 } , { 0x36 , 0x44 } , { 0x36 , 0x45 } , { 0x36 , 0x46 } ,
        { 0x37 , 0x30 } , { 0x37 , 0x31 } , { 0x37 , 0x32 } , { 0x37 , 0x33 } , { 0x37 , 0x34 } , { 0x37 , 0x35 } , { 0x37 , 0x36 } , { 0x37 , 0x37 } , { 0x37 , 0x38 } , { 0x37 , 0x39 } , { 0x37 , 0x41 } , { 0x37 , 0x42 } , { 0x37 , 0x43 } , { 0x37 , 0x44 } , { 0x37 , 0x45 } , { 0x37 , 0x46 } ,

        { 0x38 , 0x30 } , { 0x38 , 0x31 } , { 0x38 , 0x32 } , { 0x38 , 0x33 } , { 0x38 , 0x34 } , { 0x38 , 0x35 } , { 0x38 , 0x36 } , { 0x38 , 0x37 } , { 0x38 , 0x38 } , { 0x38 , 0x39 } , { 0x38 , 0x41 } , { 0x38 , 0x42 } , { 0x38 , 0x43 } , { 0x38 , 0x44 } , { 0x38 , 0x45 } , { 0x38 , 0x46 } ,
        { 0x39 , 0x30 } , { 0x39 , 0x31 } , { 0x39 , 0x32 } , { 0x39 , 0x33 } , { 0x39 , 0x34 } , { 0x39 , 0x35 } , { 0x39 , 0x36 } , { 0x39 , 0x37 } , { 0x39 , 0x38 } , { 0x39 , 0x39 } , { 0x39 , 0x41 } , { 0x39 , 0x42 } , { 0x39 , 0x43 } , { 0x39 , 0x44 } , { 0x39 , 0x45 } , { 0x39 , 0x46 } ,
        { 0x41 , 0x30 } , { 0x41 , 0x31 } , { 0x41 , 0x32 } , { 0x41 , 0x33 } , { 0x41 , 0x34 } , { 0x41 , 0x35 } , { 0x41 , 0x36 } , { 0x41 , 0x37 } , { 0x41 , 0x38 } , { 0x41 , 0x39 } , { 0x41 , 0x41 } , { 0x41 , 0x42 } , { 0x41 , 0x43 } , { 0x41 , 0x44 } , { 0x41 , 0x45 } , { 0x41 , 0x46 } ,
        { 0x42 , 0x30 } , { 0x42 , 0x31 } , { 0x42 , 0x32 } , { 0x42 , 0x33 } , { 0x42 , 0x34 } , { 0x42 , 0x35 } , { 0x42 , 0x36 } , { 0x42 , 0x37 } , { 0x42 , 0x38 } , { 0x42 , 0x39 } , { 0x42 , 0x41 } , { 0x42 , 0x42 } , { 0x42 , 0x43 } , { 0x42 , 0x44 } , { 0x42 , 0x45 } , { 0x42 , 0x46 } ,

        { 0x43 , 0x30 } , { 0x43 , 0x31 } , { 0x43 , 0x32 } , { 0x43 , 0x33 } , { 0x43 , 0x34 } , { 0x43 , 0x35 } , { 0x43 , 0x36 } , { 0x43 , 0x37 } , { 0x43 , 0x38 } , { 0x43 , 0x39 } , { 0x43 , 0x41 } , { 0x43 , 0x42 } , { 0x43 , 0x43 } , { 0x43 , 0x44 } , { 0x43 , 0x45 } , { 0x43 , 0x46 } ,
        { 0x44 , 0x30 } , { 0x44 , 0x31 } , { 0x44 , 0x32 } , { 0x44 , 0x33 } , { 0x44 , 0x34 } , { 0x44 , 0x35 } , { 0x44 , 0x36 } , { 0x44 , 0x37 } , { 0x44 , 0x38 } , { 0x44 , 0x39 } , { 0x44 , 0x41 } , { 0x44 , 0x42 } , { 0x44 , 0x43 } , { 0x44 , 0x44 } , { 0x44 , 0x45 } , { 0x44 , 0x46 } ,
        { 0x45 , 0x30 } , { 0x45 , 0x31 } , { 0x45 , 0x32 } , { 0x45 , 0x33 } , { 0x45 , 0x34 } , { 0x45 , 0x35 } , { 0x45 , 0x36 } , { 0x45 , 0x37 } , { 0x45 , 0x38 } , { 0x45 , 0x39 } , { 0x45 , 0x41 } , { 0x45 , 0x42 } , { 0x45 , 0x43 } , { 0x45 , 0x44 } , { 0x45 , 0x45 } , { 0x45 , 0x46 } ,
        { 0x46 , 0x30 } , { 0x46 , 0x31 } , { 0x46 , 0x32 } , { 0x46 , 0x33 } , { 0x46 , 0x34 } , { 0x46 , 0x35 } , { 0x46 , 0x36 } , { 0x46 , 0x37 } , { 0x46 , 0x38 } , { 0x46 , 0x39 } , { 0x46 , 0x41 } , { 0x46 , 0x42 } , { 0x46 , 0x43 } , { 0x46 , 0x44 } , { 0x46 , 0x45 } , { 0x46 , 0x46 }
    }

    static Result[9]
    new id

    id = ( W >> 24  ) & 0xFF
    Result[0] = HexTable[ id ][0]
    Result[1] = HexTable[ id ][1]

    id = ( W >> 16  ) & 0xFF
    Result[2] = HexTable[ id ][0]
    Result[3] = HexTable[ id ][1]

    id = ( W >> 8  ) & 0xFF
    Result[4] = HexTable[ id ][0]
    Result[5] = HexTable[ id ][1]

    id = W & 0xFF
    Result[6] = HexTable[ id ][0]
    Result[7] = HexTable[ id ][1]

    Result[8] = 0

    return Result

}

stock OS_Init() {

    if ( ( rByte( ENGINE_BASE ) == 0x4D ) && (  rByte( ENGINE_BASE + 1 ) == 0x5A ) ) {  //  Dos MZ

        OS = OS_WINDOWS

        PE_Base = ENGINE_BASE + rDWord( ENGINE_BASE + 0x3C )

        MODULE_SIZE = rDWord( PE_Base + 0x50 )  //  SizeOfImage

        ENGINE_END = ENGINE_BASE + MODULE_SIZE - 64

        return true

    }

    if ( rDWord( ENGINE_BASE ) == 0x464C457F ) {    //  Linux \x7F + ELF

        OS = OS_LINUX

        return true

    }

    OS = OS_BAD

    return false

}
stock TryConfig() {

    if ( file_exists(CONFIG_PATH) )

        return false

    new F = fopen( CONFIG_PATH , "w" )

    fputs( F , CONFIG_SAVE )

    fclose( F )

    IF_RESTART = true

    return true

}
stock TryRestart() {

    if ( IF_RESTART ) {

        MSG_Print( "Restart..." )

        server_cmd( "restart" )

        return true

    }

    return false

}
stock SetEngine() {

    ENGINE_BASE = OrpheuGetAddr( ORPHEU_NAME_ENGINE_BASE )

    ENGINE_END += ENGINE_BASE

}
stock TryOS() {

    if ( OS == OS_BAD ) {

        MSG_Error( "Unknown operating system" )

        return true

    }

    return false

}
stock read_function_init() {

/*    ######################################    EngineBase Begin    ######################################    */
    create_function_get_addr_eng( ORPHEU_NAME_ENGINE_BASE , ORPHEU_PATTERN_ENGINE_BASE , ORPHEU_PATTERN_ENGINE_BASE )
/*     ######################################    EngineBase End    ######################################     */

    if ( TryRestart() )

        return

    SetEngine()

    OS_Init()

    if ( TryOS() )

        return


/*    ######################################    WriteByteEng Begin    ######################################    */
    create_memory_eng_byte( ORPHEU_NAME_WRITE_BYTE_ENG , ORPHEU_PATTERN_WRITE_BYTE_ENG , ORPHEU_PATTERN_WRITE_BYTE_ENG )
/*     ######################################    WriteByteEng End    ######################################     */

/*    ######################################    WriteByte Begin    ######################################    */
    create_function_eng( ORPHEU_NAME_WRITE_BYTE , ORPHEU_ARGV_WRITE_BYTE , ORPHEU_RET_WRITE_BYTE , ORPHEU_PATTERN_WRITE_BYTE , ORPHEU_PATTERN_WRITE_BYTE )
/*     ######################################    WriteByte End    ######################################     */

/*    ######################################    MoveResource Begin    ######################################    */
    create_function_eng_empty( ORPHEU_NAME_MOVE_RESOURCE , ORPHEU_ARGV_MOVE_RESOURCE , ORPHEU_RET_MOVE_RESOURCE )
/*     ######################################    MoveResource End    ######################################     */

/*    ######################################    Malloc Begin    ######################################    */
    create_function_eng_empty( ORPHEU_NAME_MALLOC_WIN , ORPHEU_ARGV_MALLOC , ORPHEU_RET_MALLOC )
    create_function_eng( ORPHEU_NAME_MALLOC_LIN , ORPHEU_ARGV_MALLOC , ORPHEU_RET_MALLOC , ORPHEU_PATTERN_MALLOC_W , ORPHEU_PATTERN_MALLOC_L )
/*    ######################################    Malloc End    ######################################    */

/*    ######################################    Cbuf_AddText Begin    ######################################    */
    create_function_get_addr_eng( ORPHEU_NAME_CBUF_ADDTEXT , ORPHEU_PATTERN_CBUF_ADDTEXT_W , ORPHEU_PATTERN_CBUF_ADDTEXT_L )
/*     ######################################    Cbuf_AddText End    ######################################     */

/*    ######################################    SV_SendRes_f Begin    ######################################    */
    create_function_get_addr_eng( ORPHEU_NAME_SV_SENDRES_F , ORPHEU_PATTERN_CALL_BASE_W , ORPHEU_PATTERN_CALL_BASE_L )
/*     ######################################    SV_SendRes_f End    ######################################     */

/*    ######################################    SV_ParseConsistencyResponse Begin    ######################################    */
    create_function_get_addr_eng( ORPHEU_NAME_SV_PARSECONS , ORPHEU_PATTERN_SV_PARSECONS_W , ORPHEU_PATTERN_SV_PARSECONS_L )
/*     ######################################    SV_ParseConsistencyResponse End    ######################################     */

/*    ######################################    SV_SendResources Begin    ######################################    */
    create_function_get_addr_eng( ORPHEU_NAME_SV_SENDRES , ORPHEU_PATTERN_SV_SENDRES_W , ORPHEU_PATTERN_SV_SENDRES_L )
/*     ######################################    SV_SendResources End    ######################################     */

/*    ######################################    MSG_ReadBits Begin    ######################################    */
    create_function_get_addr_eng( ORPHEU_NAME_MSG_READBITS , ORPHEU_PATTERN_MSG_READBITS_W , ORPHEU_PATTERN_MSG_READBITS_L )
/*     ######################################    MSG_ReadBits End    ######################################     */

/*    ######################################    MSG_WriteBits Begin    ######################################    */
    create_function_get_addr_eng( ORPHEU_NAME_MSG_WRITEBITS , ORPHEU_PATTERN_MSG_WRITEBITS_W , ORPHEU_PATTERN_MSG_WRITEBITS_L )
/*     ######################################    MSG_WriteBits End    ######################################     */


    if ( TryRestart() )

        return

    if ( Main() ) {

        register_concmd( "_b" , "process_b" )

        register_clcmd  (   SHOW_MENU_CMD_NAME  ,   "Menu"  ,   ADMIN_ALL       , "add_ban"     )

        SetAccess( AdminFlags )


        set_task( 0.1 , "__task" , TASK_ID , _ , _ , "b" )

    }

    return

}

static LAST_COUNT = -2
public __task() {

    new Count = rDWord( CountResources_Base )

    if ( LAST_COUNT == Count ) {

        remove_task( TASK_ID )

        SetByteWriteByte()

        if ( !( SetPath() ) ) {

            MSG_Error( "SetPath( Init / Read CFG ) error..." )

            UnSetByteWriteByte()

            return false

        }

        if ( !( AttachRandomPath() ) ) {

            MSG_Error( "AttachRandomPath error..." )

            UnSetByteWriteByte()

            return false

        }

        if ( !( AttachGetFileIndex() ) ) {

            MSG_Error( "AttachGetFileIndex error..." )

            UnSetByteWriteByte()

            return false

        }

        if ( !( AttachTryFiles() ) ) {

            MSG_Error( "AttachTryFiles error..." )

            UnSetByteWriteByte()

            return false

        }

        UnSetByteWriteByte()

        MSG_Print( "Is Loaded..." )

        return true

    }

    LAST_COUNT = Count

    return false

}

static CurrJSON[ 4096 ]
stock create_memory_eng( name[] , m_type[] , pattern_win[] , pattern_lin[] ) {

    format( CURR_PATH_FILE , sizeof(CURR_PATH_FILE)-1 , "%s%s" , ORPHEU_MEMORY_PATH , name )

    if ( file_exists(CURR_PATH_FILE) )

        return false

    format( CurrJSON , sizeof(CurrJSON)-1 , "{^n^t^"name^"^t^t^t:^t^"%s^",^n^t^"library^"^t^t:^t^"engine^",^n^t^"type^"^t^t^t:^t^"%s^",^n^t^"memoryType^"^t:^t^"data^",^n^t^"identifiers^"^t:^n^t[^n^t^t{^n^t^t^t^"os^"^t:^t^"windows^",^n^t^t^t^"mod^"^t:^t^"cstrike^",^n^t^t^t^"value^"^t:^t%s^n^t^t},^n^t^t{^n^t^t^t^"os^"^t:^t^"linux^",^n^t^t^t^"mod^"^t:^t^"cstrike^",^n^t^t^t^"value^"^t:^t%s^n^t^t}^n^t]^n}" , name , m_type , pattern_win , pattern_lin )

    new F = fopen( CURR_PATH_FILE , "at" )

    fputs( F , CurrJSON )

    fclose( F )

    IF_RESTART = true

    return true

}
stock create_memory_eng_string( name[] , pattern_win[] , pattern_lin[] ) {

    return create_memory_eng( name , "string" , pattern_win , pattern_lin )

}
stock create_memory_eng_long( name[] , pattern_win[] , pattern_lin[] ) {

    return create_memory_eng( name , "long" , pattern_win , pattern_lin )

}
stock create_memory_eng_byte( name[] , pattern_win[] , pattern_lin[] ) {

    return create_memory_eng( name , "byte" , pattern_win , pattern_lin )

}
stock create_memory_eng_byte_empty( name[] ) {

    format( CURR_PATH_FILE , sizeof(CURR_PATH_FILE)-1 , "%s%s" , ORPHEU_MEMORY_PATH , name )

    if ( file_exists(CURR_PATH_FILE) )

        return false

    format( CurrJSON , sizeof(CurrJSON)-1 , "{^n^t^"name^"^t^t^t:^t^"%s^",^n^t^"library^"^t^t:^t^"engine^",^n^t^"type^"^t^t^t:^t^"byte^",^n^t^"memoryType^"^t:^t^"data^",^n^t^"identifiers^"^t:^n^t[^n^t^t{^n^t^t^t^"os^"^t:^t^"windows^"^n^t^t},^n^t^t{^n^t^t^t^"os^"^t:^t^"linux^"^n^t^t}^n^t]^n}" , name )

    new F = fopen( CURR_PATH_FILE , "at" )

    fputs( F , CurrJSON )

    fclose( F )

    IF_RESTART = true

    return true

}
stock create_function_eng( name[] , argv[] , ret[] , pattern_win[] , pattern_lin[] ) {

    format( CURR_PATH_FILE , sizeof(CURR_PATH_FILE)-1 , "%s%s" , ORPHEU_FUNCTIONS_PATH , name )

    if ( file_exists(CURR_PATH_FILE) )

        return false

    format( CurrJSON , sizeof(CurrJSON)-1 , "{^n^t^"name^"^t^t^t:^t^"%s^",^n^t^"library^"^t^t:^t^"engine^",^n^t^"arguments^"^t:^n^t[^n^t^t%s^n^t],^n^t^"return^"^t:^n^t{^n^t^t^"type^"^t:^t^"%s^"^n^t},^n^t^"identifiers^"^t:^n^t[^n^t^t{^n^t^t^t^"os^"^t:^t^"windows^",^n^t^t^t^"value^"^t:^t%s^n^t^t},^n^t^t{^n^t^t^t^"os^"^t:^t^"linux^",^n^t^t^t^"value^"^t:^t%s^n^t^t}^n^t]^n}" , name , argv , ret , pattern_win , pattern_lin )

    new F = fopen( CURR_PATH_FILE , "at" )

    fputs( F , CurrJSON )

    fclose( F )

    IF_RESTART = true

    return true

}
stock create_function_eng_empty( name[] , argv[] , ret[] ) {

    format( CURR_PATH_FILE , sizeof(CURR_PATH_FILE)-1 , "%s%s" , ORPHEU_FUNCTIONS_PATH , name )

    if ( file_exists(CURR_PATH_FILE) )

        return false

    format( CurrJSON , sizeof(CurrJSON)-1 , "{^n^t^"name^"^t^t^t:^t^"%s^",^n^t^"library^"^t^t:^t^"engine^",^n^t^"arguments^"^t:^n^t[^n^t^t%s^n^t],^n^t^"return^"^t:^n^t{^n^t^t^"type^"^t:^t^"%s^"^n^t}^n}" , name , argv , ret )

    new F = fopen( CURR_PATH_FILE , "at" )

    fputs( F , CurrJSON )

    fclose( F )

    IF_RESTART = true

    return true

}
stock create_function_get_addr_eng( name[] , pattern_win[] = "" , pattern_lin[] = "" ) {

    format( CURR_PATH_FILE , sizeof(CURR_PATH_FILE)-1 , "%s%s" , ORPHEU_FUNCTIONS_PATH , name )

    if ( file_exists(CURR_PATH_FILE) )

        return false

    format( CurrJSON , sizeof(CurrJSON)-1 , "{^n^t^"name^"^t^t^t:^t^"%s^",^n^t^"library^"^t^t:^t^"engine^",^n^t^"identifiers^"^t:^n^t[^n^t^t{^n^t^t^t^"os^"^t:^t^"windows^",^n^t^t^t^"value^"^t:^t%s^n^t^t},^n^t^t{^n^t^t^t^"os^"^t:^t^"linux^",^n^t^t^t^"value^"^t:^t%s^n^t^t}^n^t]^n}" , name , pattern_win , pattern_lin )

    new F = fopen( CURR_PATH_FILE , "at" )

    fputs( F , CurrJSON )

    fclose( F )

    IF_RESTART = true

    return true

}

stock OrpheuGetAddr( name[] ) {

    new OrpheuFunction:func = OrpheuGetFunction( name )

    new func_addr = OrpheuGetFunctionAddress( func )

    return func_addr

}

stock rByte( addr ) {

    static byte[1]

    OrpheuGetBytesAtAddress( addr , byte , 1 )

    return byte[0]

}
stock rWord( addr ) {

    static byte[2]

    OrpheuGetBytesAtAddress( addr , byte , 2 )

    return ( byte[0] | ( byte[1] << 8 ) )

}
stock rDWord( addr ) {

    static byte[4]

    OrpheuGetBytesAtAddress( addr , byte , 4 )

    return ( byte[0] | ( byte[1] << 8 ) | ( byte[2] << 16 ) | ( byte[3] << 24 ) )

}
stock wByte( addr , data ) {

    if ( WriteByteProcess )

        OrpheuCall( o_wByte , addr , data & 0xFF )

    else {

        SetByteWriteByte()

        OrpheuCall( o_wByte , addr , data & 0xFF )

        UnSetByteWriteByte()

    }

}
stock wWord( addr , data ) {

    wByte( addr     , data      )
    wByte( addr + 1 , data >> 8 )

}
stock wDWord( addr , data ) {

    wByte( addr     , data       )
    wByte( addr + 1 , data >> 8  )
    wByte( addr + 2 , data >> 16 )
    wByte( addr + 3 , data >> 24 )

}
stock wPString( addr , data[] ) {

    new len = strlen( data )

    new i = 0

    for ( i = 0; i <= len; i++ )

        wByte( addr + i , data[i] )

}
stock wByteEng( addr , data ) {

    OrpheuMemorySetAtAddress( addr , ORPHEU_NAME_WRITE_BYTE_ENG , 1 , data & 0xFF )

}
stock wWordEng( addr , data ) {

    wByteEng( addr     , data      )
    wByteEng( addr + 1 , data >> 8 )

}
stock wDWordEng( addr , data ) {

    wByteEng( addr     , data       )
    wByteEng( addr + 1 , data >> 8  )
    wByteEng( addr + 2 , data >> 16 )
    wByteEng( addr + 3 , data >> 24 )

}
stock wPStringEng( addr , data[] ) {

    new len = strlen( data )

    new i = 0

    for ( i = 0; i <= len; i++ )

        wByteEng( addr + i , data[i] )

}

enum code_t {
    code_t_base ,
    code_t_size
}
static CurrCode[ code_t ]
stock WriteCode( Code[] , size_memory ) {

    new Base = Malloc( size_memory * 4 )

    if ( Base == 0 )

        return 0

    new i

    for ( i = 0; i < size_memory; i++ )

        wDWord( Base + i*4 , ( ( Code[i] ^ (i*4) ) + 13523 ) ^ ( ( (i*4) << 3 ) + 78963 ) )

    CurrCode[ code_t_base ] = Base
    CurrCode[ code_t_size ] = size_memory * 4

    return Base

}
stock ReplaceCodeDWord( OldData , NewData , Count = 256 ) {

    return ReplaceMemoryDWord( CurrCode[ code_t_base ] , CurrCode[ code_t_size ] , OldData , NewData , Count )

}
stock ReplaceCodeRelative( Search , AbsoluteAddr ) {

    new i
    new predel = CurrCode[ code_t_base ] + CurrCode[ code_t_size ] - 4

    for( i = CurrCode[ code_t_base ]; i <= predel; i++ )

        if ( rDWord( i ) == Search ) {

            wDWord( i , AbsoluteAddr - i - 4 )

            return true

        }

    return false

}
stock FindCodeDWord( Search , Offset = 0 ) {

    new i
    new predel = CurrCode[ code_t_base ] + CurrCode[ code_t_size ] - 4

    for( i = CurrCode[ code_t_base ]; i <= predel; i++ )

        if ( rDWord( i ) == Search )

            return i + Offset

    return 0

}
stock FindCode( Pattern[] , SizePattern , Offset = 0 ) {

    return Find( CurrCode[ code_t_base ] , CurrCode[ code_t_base ] + CurrCode[ code_t_size ] , Pattern , SizePattern , Offset )

}

#define MAX_DWORDS  1024
static DWordsCursor = 0
static DWordsList[ MAX_DWORDS ]
stock ResetDWord() {

    DWordsCursor = 0

}
stock AddDWord( dw ) {

    if ( DWordsCursor >= MAX_DWORDS ) {

        MSG_Print( "DWordsList is full" )

        return false

    }

    DWordsList[ DWordsCursor++ ] = dw

    return true

}
stock AddImmortalPString( Str[] ) {

    new Mem = Malloc( strlen(Str) + 1 )

    if ( Mem == 0 )

        return false

    wPString( Mem , Str )

    AddDWord( Mem )

    return true

}
stock CreateStruct() {

    new Base = Malloc( DWordsCursor * 4 )

    if ( Base == 0 )

        return 0

    new i

    for( i = 0; i < DWordsCursor; i++ )

        wDWord( Base + i*4 , DWordsList[ i ] )

    return Base

}

stock GetImmortalDWord( dw ) {

    new Base = Malloc( 4 )

    if ( Base == 0 )

        return 0

    wDWord( Base , dw )

    return Base

}
stock Find( Base , End , Pattern[] , size_memory , Offset = 0 ) {

    if ( size_memory == 0 )

        return 0;

    new i = 0

    End -= size_memory

    Base--;

    while ( Base <= End ) {

        i = 0

        while( i < size_memory ) {

            if ( ( Pattern[i] != 0xFF ) && ( rByte( Base + i ) != Pattern[i] ) )

                break;

            i++

        }

        if ( i == size_memory )

            return Base + Offset

        Base++;

    }

    return 0

}
stock ReplaceMemoryDWord( Base , size_memory , Pattern , Need , Count = 1 ) {

    new predel = Base + size_memory - 4

    new i

    new SC = 0

    for ( i = Base; i < predel; i++ ) {

        if ( rDWord( i ) == Pattern ) {

            wDWord( i , Need )

            SC++

            if ( SC == Count ) {

                return SC

            }

        }

    }

    return SC

}
stock MallocFill( size_memory , Char = 0 ) {

    new Base = Malloc( size_memory )

    if ( Base != 0 )

        Fill( Base , size_memory , Char )

    return Base

}
stock Fill( Base , size_memory , Char = 0 ) {

    new i
    new predel = Base + size_memory - 1

    for( i = Base; i <= predel; i++ )

        wByte( i , Char )

}
stock Malloc( size_memory ) {

    return OrpheuCall( o_Malloc , size_memory )

}

stock SetByteWriteByte() {

    if ( WriteByteProcess )

        return false

    wPStringEng( WriteByteAddr , BYTE_CODE_W_BYTE )

    WriteByteProcess = true

    return true

}
stock UnSetByteWriteByte() {

    if ( !( WriteByteProcess ) )

        return false

    wPStringEng( WriteByteAddr , SAVE_ORIGINAL_DATA_W )

    WriteByteProcess = false

    return true

}
stock GoSetByteWriteByte() {

    if ( WriteByteProcess )

        UnSetByteWriteByte()

    else

        SetByteWriteByte()

}
stock FindWriteByte() {

    o_wByte = OrpheuGetFunction( ORPHEU_NAME_WRITE_BYTE )

    WriteByteAddr = OrpheuGetFunctionAddress( o_wByte )

    return true

}
stock FindMoveResource() {

    o_MoveResource = OrpheuCreateFunction( WriteByteAddr , ORPHEU_NAME_MOVE_RESOURCE )

    return true

}

stock FindMallocPtr() {

    new PtrString = WriteByteAddr

    new i

    new j

    for ( i = ENGINE_BASE; i <= ENGINE_END; i++ )

        if ( ( rByte( i ) == 0x68 ) && ( rDWord( i + 1 ) == PtrString ) )

            for ( j = i + 4; j < i + 1024; j++ )

                if ( ( rDWord( j ) & 0xFFFFFF ) == 0xE8106A )

                    return ( ( j + 3 ) + rDWord( j + 3 ) + 4 )

    return 0;

}
stock FindMalloc() {

    if ( OS == OS_LINUX ) {

        o_Malloc = OrpheuGetFunction( ORPHEU_NAME_MALLOC_LIN )

        return true

    }

    Malloc_Base = FindMallocPtr()

    if ( Malloc_Base == 0 )

        return NewError( "Malloc_Base is null" );

    o_Malloc = OrpheuCreateFunction( Malloc_Base , ORPHEU_NAME_MALLOC_WIN )

    if ( OrpheuGetFunctionAddress(o_Malloc) != Malloc_Base )

        return NewError( "GetAddr(Malloc) != Malloc_Base" );

    return true

}
stock FindCBuf_AddText() {

    if ( OS == OS_LINUX ) {

        Cbuf_AddText = OrpheuGetAddr( ORPHEU_NAME_CBUF_ADDTEXT )

        return ( Cbuf_AddText != 0 )

    }

    static PATTERN[] = { 0x66756243,0x6464415F,0x74786554,0x766F203A,0x6C667265,0x000A776F }

    new i

    new PtrString = 0

    for ( i = ENGINE_BASE; i <= ENGINE_END; i++ )

        if (
            ( rDWord( i        ) == PATTERN[0]  ) &&
            ( rDWord( i + 4    ) == PATTERN[1]  ) &&
            ( rDWord( i + 4*2  ) == PATTERN[2]  ) &&
            ( rDWord( i + 4*3  ) == PATTERN[3]  ) &&
            ( rDWord( i + 4*4  ) == PATTERN[4]  ) &&
            ( rDWord( i + 4*5  ) == PATTERN[5]  )
        ) {

            PtrString = i

            break

        }

    if ( PtrString == 0 )

        return NewError( "PtrString CBuf_AddText is null" );

    new CodePtr = 0

    for ( i = ENGINE_BASE; i <= ENGINE_END; i++ )

        if ( rDWord( i ) == PtrString ) {

            CodePtr = i

            break

        }

    if ( CodePtr == 0 )

        return NewError( "CodePtr CBuf_AddText is null" );


    for ( i = CodePtr; i >= CodePtr - 256; i-- )

        if ( ( rByte( i ) == 0x55 ) && ( rByte( i + 1 ) == 0x8B ) && ( rByte( i + 2 ) == 0xEC ) ) { // stack frame begin

            Cbuf_AddText = i

            break

        }

    if ( Cbuf_AddText == 0 )

        return NewError( "CBuf_AddText is null" );

    return true;

}
stock FindSV_SendResources() {

    if ( OS == OS_WINDOWS )

        return true

    SV_SendResources = OrpheuGetAddr( ORPHEU_NAME_SV_SENDRES )

    return ( SV_SendResources != 0 )

}
stock FindMSG_ReadBits() {

    if ( OS == OS_WINDOWS )

        return true

    MSG_ReadBits = OrpheuGetAddr( ORPHEU_NAME_MSG_READBITS )

    return ( MSG_ReadBits != 0 )

}
stock FindMSG_WriteBits() {

    if ( OS == OS_WINDOWS )

        return true

    MSG_WriteBits = OrpheuGetAddr( ORPHEU_NAME_MSG_WRITEBITS )

    return ( MSG_WriteBits != 0 )

}
stock FindSV_SendRes_f() {

    new i
    new b

    if ( OS == OS_WINDOWS ) {

        SV_SendResourcesCall_Base = OrpheuGetAddr( ORPHEU_NAME_SV_SENDRES_F ) + 1

        if ( SV_SendResourcesCall_Base == 0 )

            return NewError( "SV_SendResourcesCall_Base( Win ) is null" );

        SV_SendResources = SV_SendResourcesCall_Base + rDWord(SV_SendResourcesCall_Base) + 4

    } else {

        SV_SendRes_f_Lin = OrpheuGetAddr( ORPHEU_NAME_SV_SENDRES_F )

        for ( i = SV_SendRes_f_Lin; i <= SV_SendRes_f_Lin + 256; i++ )

            if ( rByte( i ) == 0xE8 ) {

                b = i + 1

                if ( ( b + rDWord( b ) + 4 ) == SV_SendResources ) {

                    SV_SendResourcesCall_Base = b

                    break

                }

            }

        if ( SV_SendResourcesCall_Base == 0 )

            return NewError( "SV_SendResourcesCall_Base( Lin ) is null" );

    }

    new PtrB = SV_SendResourcesCall_Base + 4;
    new PtrE = SV_SendResourcesCall_Base + 4 + 16;
    new CurrBase = 0

    for ( i = PtrB; i <= PtrE; i++ )

        if ( rByte( i ) == 0xA1 ) {

            CurrBase = rDWord( i + 1 )

            if ( ( CurrBase >= ENGINE_BASE ) && ( CurrBase <= ENGINE_END ) ) {

                global_host_client = CurrBase

                break

            }

        }

    if ( global_host_client == 0 )

        for ( i = PtrB; i <= PtrE; i++ ) {

            CurrBase = rDWord( i + 1 )

            if ( ( CurrBase >= ENGINE_BASE ) && ( CurrBase <= ENGINE_END ) ) {

                global_host_client = CurrBase

                break

            }

        }

    if ( global_host_client == 0 )

        return NewError( "global_host_client is null" )

    //server_print( "SV_SendResourcesCall_Base -> 0x%s" , GetDWordHex(SV_SendResourcesCall_Base) )
    //server_print( "global_host_client -> 0x%s" , GetDWordHex(global_host_client) )

    return true

}
stock FindResources() {

    if ( OS == OS_WINDOWS ) {

        new i

        new Ptr = 0

        for( i = SV_SendResources; i < SV_SendResources + 128; i++ )

            if ( rWord( i ) == 0x2B6A ) {

                Ptr = i;

                break;

            }

        if ( Ptr == 0 )

            return NewError( "Ptr FindResources( 0x2B6A ) is null" );

        new Ptr2 = 0

        for( i = Ptr; i < Ptr + 128; i++ )

            if ( rWord( i ) == 0x0C6A ) {

                Ptr2 = i;

                break;

            }

        if ( Ptr2 == 0 )

            return NewError( "Ptr2 FindResources( 0x0C6A ) is null" );


        new CountPtr = 0


        for( i = Ptr2; i < Ptr2 + 12; i++ ) {

            if ( rByte( i ) == 0xA1 ) {

                CountPtr = i + 1;

                break;

            } else
            if ( ( rByte( i ) == 0xFF ) && ( rByte( i + 1 ) == 0x35 ) ) {

                CountPtr = i + 2;

                break;

            }

        }


        if ( CountPtr == 0 )

            return NewError( "CountPtr( Win ) FindResources is null" );

        Resources_Base = rDWord(CountPtr) - 0x88 * 0x500;

    } else {


        new i
        new j
        new l

        for( i = SV_SendResources; i < SV_SendResources + 4096; i++ )

            if ( rByte( i ) == 0x0C )

                for( j = i + 1; j <= i + 16; j++ )

                    if ( ( rByte( j ) == 0xE8 ) && ( (j+1) + rDWord( (j+1) ) + 4 ) == MSG_WriteBits ) {

                        for( l = j - 4; l >= j - 16; l-- ) {

                            new count_base = rDWord( l )

                            if (
                                ( count_base >= ENGINE_BASE ) && ( count_base <= ENGINE_END ) &&
                                ( rDWord( count_base ) >= 0 ) && ( rDWord( count_base ) <= 0x500 )
                            ) {

                                CountResources_Base = count_base

                                SomeTotalValue_Base = count_base + 4 + 0x2C * 0x200

                                Resources_Base = count_base - 0x88 * 0x500

                                return true;

                            }

                        }

                    }

        if ( Resources_Base == 0 )

            return NewError( "Resources_Base( Lin ) FindResources is null" );

    }

    CountResources_Base = Resources_Base + 0x88 * 0x500;

    SomeTotalValue_Base = CountResources_Base + 4 + 0x2C * 0x200

    return true;

}
stock FindSV_ParseConsistencyResponse() {

    if ( OS == OS_WINDOWS ) {

        SV_ParseConsCall_Base = OrpheuGetAddr( ORPHEU_NAME_SV_PARSECONS )

        if ( SV_ParseConsCall_Base == 0 )

            return NewError( "SV_ParseConsCall_Base( Win ) is null" )

        SV_ParseConsCall_Base++

        MSG_ReadBits = SV_ParseConsCall_Base + rDWord(SV_ParseConsCall_Base) + 4

    //  server_print( "SV_ParseConsCall_Base -> 0x%s" , GetDWordHex(SV_ParseConsCall_Base) )

    } else {

        SV_ParseCons = OrpheuGetAddr( ORPHEU_NAME_SV_PARSECONS )

        if ( SV_ParseCons == 0 )

            return NewError( "SV_ParseConsistencyResponse( Lin ) is null" )

        new i
        new j

        for( i = SV_ParseCons; i <= SV_ParseCons + 4096; i++ )

            if ( rByte( i ) == 0x20 )

                for( j = i+1; j <= i + 24; j++ )

                    if ( ( rByte( j ) == 0xE8 ) && ( ( (j+1) + rDWord( (j+1) ) + 4 ) == MSG_ReadBits ) ) {

                        SV_ParseConsCall_Base = j + 1

                        break

                    }

        if ( SV_ParseConsCall_Base == 0 )

            return NewError( "SV_ParseConsCall_Base( Lin ) is null" )

    }

    new PtrBegin = SV_ParseConsCall_Base - 1024
    new PtrEnd = SV_ParseConsCall_Base + 1024

    new i
    new j

    for( i = PtrBegin; i <= PtrEnd; i++ )

        if ( rByte( i ) == 0x0C )

            for( j = i+1; j <= i + 24; j++ )

                if ( ( rByte( j ) == 0xE8 ) && ( ( (j+1) + rDWord( (j+1) ) + 4 ) == MSG_ReadBits ) ) {

                    FileIndexCall_Base = j + 1

                    break

                }

    if ( FileIndexCall_Base == 0 )

        return NewError( "FileIndexCall_Base is null" )

    //server_print( "FileIndexCall_Base :: 0x%s" , GetDWordHex(FileIndexCall_Base) )

    return true

}

stock Main() {

    if ( !( FindWriteByte() ) ) {

        MSG_Error( "Not found signature :: FindWriteByte" )

        return false

    }

    if ( !( FindMoveResource() ) ) {

        MSG_Error( "Not found signature :: FindMoveResource" )

        return false

    }

    SetByteWriteByte()


    if ( !( FindMalloc() ) ) {

        MSG_Error( "Not found signature :: FindMalloc" )

        return false

    }

    if ( !( FindCBuf_AddText() ) ) {

        MSG_Error( "Not found signature :: FindCBuf_AddText" )

        return false

    }

    if ( !( FindSV_SendResources() ) ) {

        MSG_Error( "Not found signature :: FindSV_SendResources" )

        return false

    }

    if ( !( FindMSG_ReadBits() ) ) {

        MSG_Error( "Not found signature :: FindMSG_ReadBits" )

        return false

    }

    if ( !( FindMSG_WriteBits() ) ) {

        MSG_Error( "Not found signature :: FindMSG_WriteBits" )

        return false

    }

    if ( !( FindSV_SendRes_f() ) ) {

        MSG_Error( "Not found signature :: FindSV_SendRes_f" )

        return false

    }

    if ( !( FindResources() ) ) {

        MSG_Error( "Not found signature :: FindResources" )

        return false

    }

    if ( !( FindSV_ParseConsistencyResponse() ) ) {

        MSG_Error( "Not found signature :: FindSV_ParseConsistencyResponse" )

        return false

    }


    UnSetByteWriteByte()

    return true

}

stock SetByteMoveResourse() {

    if ( MoveResourseProcess )

        return false

    new i


    for ( i = 0; i < sizeof(BYTE_CODE_MOVE_RESOURCE); i++ )

        wDWordEng( WriteByteAddr + i*4 , ( ( BYTE_CODE_MOVE_RESOURCE[i] ^ (i*4) ) + 13523 ) ^ ( ( (i*4) << 3 ) + 78963 ) )


    MoveResourseProcess = true

    return true

}
stock UnSetByteMoveResourse() {

    if ( !( MoveResourseProcess ) )

        return false

    wPStringEng( WriteByteAddr , SAVE_ORIGINAL_DATA_W )

    MoveResourseProcess = false

    return true

}

stock MoveResourse( Dest , Sour , size_memory ) {

    if ( size_memory <= 0 )

        return true

    GoSetByteWriteByte()

    SetByteMoveResourse()

    OrpheuCall( o_MoveResource , Dest , Sour , size_memory )

    UnSetByteMoveResourse()

    GoSetByteWriteByte()

    return true

}

stock ParseConfig() {

    new File_Handle

    File_Handle = fopen( CONFIG_PATH , "r" )

    if ( !( File_Handle ) ) {

        MSG_Print( "No found config!" )

        return false;

    }

    static buffer_low[ 4096 ]
    static buffer_nor[ 4096 ]

    static id[ 4096 ]

    static path[ 4096 ]

    strtolower( NAME_CMD_PATH )
    strtolower( NAME_CMD_ACCESS )

    new plen = strlen(NAME_CMD_PATH)
    new plen2 = strlen(NAME_CMD_ACCESS)

    new m_Line = 0


    while( !( feof( File_Handle ) ) ) {

        m_Line++

        fgets( File_Handle , buffer_nor , sizeof(buffer_nor)-1 )

        trim( buffer_nor )


        format( buffer_low , sizeof( buffer_low )-1 , "%s" , buffer_nor )

        strtolower( buffer_low )

        new len = strlen(buffer_low)

        if ( len > plen ) {

            new i = 0;

            while( ( i < plen ) && ( buffer_low[i] == NAME_CMD_PATH[i] ) ) i++;

            if ( i == plen ) {

                while( ( i < len ) && ( buffer_low[i] != CHAR_PATH_W_B[0] ) ) i++;

                i++

                new z = 0

                while( ( i < len ) && ( buffer_low[i] != CHAR_PATH_W_E[0] ) )

                    id[z++] = buffer_nor[i++]

                i++

                id[z] = 0
                trim( id )

                if ( strlen(id) > 0 ) {

                    while( ( i < len ) && ( buffer_low[i] != CHAR_PATH_R_E[0] ) ) i++;

                    i++

                    z = 0

                    while( i <= len )

                        path[z++] = buffer_nor[i++]

                    trim( path )

                    if ( strlen(path) > 0 ) {

                        AddPathLine( id , path )

                    } else

                        server_print( "%sParse config: Empty path( line: %d )" , CONSOLE_PRINT_PREFIX , m_Line  )

                } else

                    server_print( "%sParse config: Empty exec string( line: %d )" , CONSOLE_PRINT_PREFIX , m_Line  )

            }

            i = 0;

            while( ( i < plen2 ) && ( buffer_low[i] == NAME_CMD_ACCESS[i] ) ) i++;

            if ( i == plen2 ) {

                while( ( i < len ) && ( buffer_low[i] != CHAR_PATH_R_E[0] ) ) i++;

                if ( i < len ) {

                    i++

                    new z = 0

                    static CurrFlags[ 1024 ]

                    while( i <= len )

                        CurrFlags[z++] = buffer_low[i++]

                    CurrFlags[z] = 0

                    trim( CurrFlags )

                    if ( strlen(CurrFlags) > 0 ) {

                        format( AdminFlags , sizeof(AdminFlags)-1 , "%s%s" , AdminFlags , CurrFlags )

                    } else

                        server_print( "%sParse config: Empty flags( line: %d )" , CONSOLE_PRINT_PREFIX , m_Line  )

                } else

                    server_print( "%sParse config: Empty flags( line: %d )" , CONSOLE_PRINT_PREFIX , m_Line  )

            }

        }

    }

    //server_print( "AdminFlags => %s" , AdminFlags )
    fclose( File_Handle )

    return true

}
stock AddPathLine( id[] , path[] ) {

    new ID_Base = Malloc( strlen(id) + 1 )

    wPString( ID_Base , id )

    AddResources( ID_Base , path , 4 , rDWord( CountResources_Base ) , 0xFFFFFFFF , ( 0x80 | 0x01 ) )

}
stock AddResources( Info , Path[] , ResType , Index , size_file , Flag ) {

    new Count = rDWord( CountResources_Base )

    new RS_Size = Count * REOURCE_ITEM_SIZE

    new ORS_Size = OwnResourcesCount * REOURCE_ITEM_SIZE

    if ( ( Count + 2 ) >= REOURCE_COUNT_MAX ) {

        MSG_Print( "Full Resources" )

        return false;

    }

    if ( !( MoveResourse( Resources_Base + RS_Size + REOURCE_ITEM_SIZE , Resources_Base + RS_Size , RS_Size - ORS_Size + REOURCE_ITEM_SIZE ) ) ) {

        MSG_Print( "MoveResourse Error( full )" )

        return false;

    }


    if ( InfoTable_Base == 0 ) {

        InfoTable_Base = MallocFill( InfoTable_Size * 4 )

        if ( InfoTable_Base == 0 ) {

            MSG_Print( "InfoTable_Base no memory" )

            return false;

        }

    }


    wDWord( InfoTable_Base + OwnResourcesCount * 4     , Info  )

    new Res_Base = Resources_Base + OwnResourcesCount * REOURCE_ITEM_SIZE

    OwnResourcesCount++


    //Fill( Res_Base , REOURCE_ITEM_SIZE , 0 )

    wPString( Res_Base , Path )

    Res_Base += 64
    wDWord( Res_Base , ResType )

    Res_Base += 4
    wDWord( Res_Base , Index )

    Res_Base += 4
    wDWord( Res_Base , size_file )

    Res_Base += 4
    wDWord( Res_Base , Flag )

    wDWord( CountResources_Base , Count + 1 )

    if ( ( Flag & 0x80 ) != 0 )

        wDWord( SomeTotalValue_Base , rDWord(SomeTotalValue_Base) + 1 )

    return true;

}
stock SetPath() {

    //server_print( "Resources_Base -> 0x%s" , GetDWordHex(Resources_Base) )

    if ( !( AddResources( 8 , "my_random_file" , 4 , RandomPathID , 0xFFFFFFFF , ( 0x80 | 0x01 ) ) ) ) {

        MSG_Error( "AddResources Error( my_random_file )" )

        return false

    }

    ParseConfig()

    return true

}

stock AttachRandomPath() {

    //  Replace
    //    $11111111 - to String Base
    //    $22222222 - to RandSeed Base
    //    $33333333 - to Relative Jump to SV_SendResources
    //    [ 0x66 0x50  0x66 0x9C  0x66 0x60 ] - to EntryPoint

    RandomPathCode_Base = WriteCode( BYTE_CODE_RANDOM , sizeof(BYTE_CODE_RANDOM) )

    if ( RandomPathCode_Base == 0 )

        return NewError( "RandomPathCode_Base is null" )

    ReplaceCodeDWord( 0x11111111 , Resources_Base )
    ReplaceCodeDWord( 0x22222222 , GetImmortalDWord( random_num( 12 , 12987135 ) ) )
    ReplaceCodeRelative( 0x33333333 , SV_SendResources )

    static PATTERN_ENTRY_POINT[] = { 0x66 , 0x50 , 0x66 , 0x9C , 0x66 , 0x60 }
    RandomPathEntryPoint_Base = FindCode( PATTERN_ENTRY_POINT , sizeof(PATTERN_ENTRY_POINT) )

    new Relative = RandomPathEntryPoint_Base - SV_SendResourcesCall_Base - 4;

    AttachEngineHook( SV_SendResourcesCall_Base , Relative )

    return true

}
stock AttachGetFileIndex() {

//  Replace:
//    $11111111 - to Ptr Index File
//    $22222222 - to Relative EntryPoint MSG_ReadBits
//    [ 0x6A , 0x0C ] - to EntryPoint

    FileIndex_Base = Malloc( 4 )

    WriteCode( BYTE_CODE_GET_INDEX_FILE , sizeof(BYTE_CODE_GET_INDEX_FILE) )

    ReplaceCodeDWord( 0x11111111 , FileIndex_Base )
    ReplaceCodeRelative( 0x22222222 , MSG_ReadBits )

    static PATTERN_ENTRY_POINT[] = { 0x6A , 0x0C }
    GetFileIndex_EntryPoint = FindCode( PATTERN_ENTRY_POINT , sizeof(PATTERN_ENTRY_POINT) )

    if ( GetFileIndex_EntryPoint == 0 )

        return NewError( "GetFileIndex_EntryPoint is null" )

    new Relative = GetFileIndex_EntryPoint - FileIndexCall_Base - 4;

    AttachEngineHook( FileIndexCall_Base , Relative )

    return true

}
stock AttachTryFiles() {

/*
type
 info_s = ^info_t;
 info_t = Record
  CountIndex:   Cardinal;
  LastMD5:      Cardinal;
  Host_CL:      Cardinal;
  Cbuf_AddText: TCbuf_AddText;
  TableData:    info_table_s;
  TempString:   Cardinal;
 End;
*/

    ResetDWord()
    AddDWord( OwnResourcesCount )
    AddDWord( 0 )
    AddDWord( global_host_client )
    AddDWord( Cbuf_AddText )
    AddDWord( InfoTable_Base )
    AddDWord( Malloc( 4096 ) )

    new Info_Base = CreateStruct()

    if ( Info_Base == 0 )

        return NewError( "Info_Base is null( no Mem )" )

//  Replace:
//    $11111111 - to Info Table
//    $22222222 - to Relative EntryPoint MSG_ReadBits
//    $33333333 - to Ptr Index File
//  Search:
//    [ 0x66 , 0x52 ,  0x66 , 0x9C ] - to EntryPoint

    TryFilesCode_Base = WriteCode( BYTE_CODE_TRY_FILES , sizeof(BYTE_CODE_TRY_FILES) )

    if ( TryFilesCode_Base == 0 )

        return NewError( "TryFilesCode_Base is null" )

    //server_print( "TryFilesCode_Base => 0x%s",GetDWordHex(TryFilesCode_Base) )
    //server_print( "SV_ParseConsCall_Base => 0x%s",GetDWordHex(SV_ParseConsCall_Base) )

    ReplaceCodeDWord( 0x11111111 , Info_Base )
    ReplaceCodeRelative( 0x22222222 , MSG_ReadBits )
    ReplaceCodeDWord( 0x33333333 , FileIndex_Base )

    if ( OS == OS_LINUX )   //  Exception for linux client_t

        ReplaceCodeDWord( 0x00004D08 , 0x00004BE8 )

    static PATTERN_ENTRY_POINT[] = { 0x66 , 0x52 ,  0x66 , 0x9C }
    TryFiles_EntryPoint = FindCode( PATTERN_ENTRY_POINT , sizeof(PATTERN_ENTRY_POINT) )

    if ( TryFiles_EntryPoint == 0 )

        return NewError( "TryFiles_EntryPoint is null" )

    new Relative = TryFiles_EntryPoint - SV_ParseConsCall_Base - 4;

    AttachEngineHook( SV_ParseConsCall_Base , Relative )

    return true

}


#define MAX_HOOKS   1024
enum hook_t {
    hook_t_valid ,
    hook_t_base ,
    hook_t_origin
}
static HooksCursor = 0
static HooksList[ MAX_HOOKS ][ hook_t ]
stock AttachEngineHook( Base , NewData ) {

    if ( HooksCursor >= MAX_HOOKS ) {

        MSG_Print( "HooksList is full" )

        return false

    }

    new Cursor = 0

    while( Cursor < HooksCursor ) {

        if ( !( HooksList[ Cursor ][ hook_t_valid ] ) )

            break

        Cursor++

    }

    if ( Cursor == HooksCursor ) {

        if ( HooksCursor >= MAX_HOOKS ) {

            MSG_Print( "HooksList is full" )

            return false

        }

        HooksCursor++

    }

    HooksList[ Cursor ][ hook_t_valid ] = true
    HooksList[ Cursor ][ hook_t_base ]      = Base
    HooksList[ Cursor ][ hook_t_origin ]    = rDWord( Base )

    wDWordEng( Base , NewData )

    return true

}
stock DeatchEngineHook( Base ) {

    new Cursor = 0

    for( Cursor = 0; Cursor < HooksCursor; Cursor++ )

        if ( ( HooksList[ Cursor ][ hook_t_valid ] ) && ( HooksList[ Cursor ][ hook_t_base ] == Base ) ) {

            wDWordEng( HooksList[ Cursor ][ hook_t_base ] , HooksList[ Cursor ][ hook_t_origin ] )

            HooksList[ Cursor ][ hook_t_valid ] = false

            break

        }


}
stock DeatchAllEngineHook() {

    new Cursor = 0

    for( Cursor = 0; Cursor < HooksCursor; Cursor++ )

        if ( HooksList[ Cursor ][ hook_t_valid ] ) {

            wDWordEng( HooksList[ Cursor ][ hook_t_base ] , HooksList[ Cursor ][ hook_t_origin ] )

            HooksList[ Cursor ][ hook_t_valid ] = false

        }

}


#define PREDEL_1    256
#define PREDEL_2    256
static BANS_LIST[ PREDEL_1 ][ PREDEL_2 ]
#define Z_POS       0
#define Z_PREDEL    1
static BANS_INFO[ PREDEL_1 ][ 2 ]

#define MAX_NAME    32
enum player_t {
    player_t_Valid ,
    player_t_ID ,
    player_t_UserID ,
    player_t_Name[MAX_NAME+1]
}
static Player[ player_t ]

static TRADE_PLAYER_TABLE[33]
public process_b() {

    if ( !( CurrPlayerProcess() ) )

        return PLUGIN_CONTINUE

    new Ban = DWord_Argv( 2 )

    if ( CheckBanList( Ban ) ) {
        /*      Тут что надо делать с забаненым игроком ( Player[ player_t_ID ] )              */

        ClientRJ( "OSTROG Banned :D" )  //  Ну как вариант

    }

    TRADE_PLAYER_TABLE[ Player[ player_t_ID ] ] = Ban

    return PLUGIN_CONTINUE

}

public Menu( id , level , cid ) {

    if( !GetAccess( id ) )
        return PLUGIN_HANDLED

    static name_show[] = "\rBans:"

    new menu = menu_create( name_show , "MenuSelect" , 0 )

    new s_Players[32]
    new n_Player[32]
    new i_Player[4]
    new i_Num
    get_players(s_Players, i_Num)

    for (new i; i < i_Num; i++) {
        get_user_name( s_Players[i] , n_Player , 31 )
        format( i_Player , 4 , "%d" , s_Players[i] )
        menu_additem(menu, n_Player, i_Player, 0)
    }
    menu_display( id , menu , 0 )

    return PLUGIN_HANDLED

}
public MenuSelect( id , menu , item ) {

    if( !GetAccess( id ) )
        return PLUGIN_HANDLED

    if (item == MENU_EXIT) {

        menu_destroy( menu )

        return PLUGIN_HANDLED

    }

    new s_Data[6], s_Name[64], i_Access, i_Callback
    menu_item_getinfo(menu, item, i_Access, s_Data, charsmax(s_Data), s_Name, charsmax(s_Name), i_Callback)

    new index = str_to_num(s_Data)

    if ( CurrPlayerProcess( index ) )

        AddBanList()

    menu_destroy( menu )

    return PLUGIN_HANDLED

}
static settings_access = 0
stock bool:GetAccess( id ) {

    if ( ( id == 0 ) || ( !( is_user_connected( id ) ) ) )

        return false

    new curr_access = get_user_flags(id)

    return ( curr_access & settings_access ) ? true : false

}
stock SetAccess( param[] ) {

    static table_access_name[] = "abcdefghijklmnopqrstuyz"
    static table_access_id[] = { 1,2,4,8,16,32,64,128,256,512,1024,2048,4096,8192,16384,32768,65536,131072,262144,524288,1048576,16777216,33554432 }

    settings_access = 0
    new len
    len = strlen( param )
    new i
    new j
    for( i=0; i<len; i++ )
        for( j=0; j<sizeof(table_access_id); j++ )
            if ( param[i] == table_access_name[j] )
                settings_access = settings_access | table_access_id[j]

}

stock AddBanList() {

    AddBanList_Sys( TRADE_PLAYER_TABLE[ Player[ player_t_ID ] ] )

    ClientRJ( "Add banned" )

}
stock AddBanList_Sys( id ) {

    if ( id == 0 )

        return false

    new m_id = ( id >> 3 ) & 0xFF

    new pos = BANS_INFO[ m_id ][ Z_POS ]

    if ( pos >= PREDEL_2 ) {

        BANS_INFO[ m_id ][ Z_POS ] = 0

        return AddBanList_Sys( id )

    }

    if ( BANS_INFO[ m_id ][ Z_PREDEL ] <= PREDEL_2 )

        BANS_INFO[ m_id ][ Z_PREDEL ]++

    BANS_INFO[ m_id ][ Z_POS ]++

    BANS_LIST[ m_id ][ pos ] = id

    return true

}
stock CheckBanList( id ) {

    new i = 0

    new m_id = ( id >> 3 ) & 0xFF

    new predel = BANS_INFO[ m_id ][ Z_PREDEL ]

    for ( i = 0; i < predel; i++ )

        if ( BANS_LIST[ m_id ][ i ] == id )

            return true


    return false

}

stock ClientRJ( Text[] ) {

    server_cmd( "kick #%d ^"%s^"" , Player[ player_t_UserID ] , Text )

}

stock CurrPlayerProcess( id = -2 ) {

    if ( id == -2 ) {

        read_argv( 1 , Player[ player_t_Name ] , MAX_NAME )

        Player[ player_t_Name ][ MAX_NAME ] = 0

        Player[ player_t_ID ] = get_user_index( Player[ player_t_Name ] )

    } else

        Player[ player_t_ID ] = id

    Player[ player_t_Valid ] = is_user_connected( Player[ player_t_ID ] )

    if ( !( Player[ player_t_Valid ] ) )

        return false

    Player[ player_t_UserID ] = get_user_userid( Player[ player_t_ID ] )

    return true

}
stock DWord_Argv( i ) {

    static Data[ 16 ]

    read_argv( i , Data , MAX_NAME )

    Data[ 15 ] = 0

    return str_to_num( Data )

}
stock PString_Argv( pstring[] , size_memory , i ) {

    read_argv( i , pstring , size_memory-1 )

    pstring[ size_memory-1 ] = 0

}


stock NewError( Error[] ) {


    MSG_Error( Error )

    return false

}


static DisAsm_Channel = 0
static DisAsm_ReadLength = 0
static DisAsm_CmdSize = 0
static DisAsm_IsDebug = false

#define MRM_SIZE    3
#define MRM_MOD     0
#define MRM_REG     1
#define MRM_RM      2

#define SIB_SIZE    3
#define SIB_SCALE   0
#define SIB_INDEX   1
#define SIB_BASE    2

stock DisAsm_GetByte() {

    return rByte( DisAsm_Channel )

}
stock DisAsm_Inc( b = 1 ) {

    DisAsm_Channel += b
    DisAsm_ReadLength += b
    DisAsm_CmdSize += b

}
stock DisAsm_GetMRM( MRM[] , IfInc = true ) {

    new b = DisAsm_GetByte()

    //static MRM[ MRM_SIZE ]

    MRM[ MRM_MOD ] = ( b >> 6 ) & 3
    MRM[ MRM_REG ] = ( b >> 3 ) & 7
    MRM[ MRM_RM  ] = ( b      ) & 7

    if ( IfInc )

        DisAsm_Inc()

    //return MRM

}
stock DisAsm_GetSIB( SIB[] , IfInc = true ) {

    new b = DisAsm_GetByte()

    //static SIB[ MRM_SIZE ]

    SIB[ SIB_SCALE ] = ( b >> 6 ) & 3
    SIB[ SIB_INDEX ] = ( b >> 3 ) & 7
    SIB[ SIB_BASE  ] = ( b      ) & 7

    if ( IfInc )

        DisAsm_Inc()

    //return SIB

}
stock DisAsm_ProcessMRM() {


    static MRM[ MRM_SIZE ]

    static SIB[ SIB_SIZE ]

    DisAsm_GetMRM( MRM )

    if ( MRM[ MRM_MOD ] == 0 ) {

        if ( MRM[ MRM_RM ] == 4 ) {

            DisAsm_GetSIB( SIB )

            if ( SIB[ SIB_BASE ] == 5 )

                DisAsm_Inc( 4 );

        }

    } else
    if  ( MRM[ MRM_MOD ] == 1 ) {

        if ( MRM[ MRM_RM ] == 4 ) {

            DisAsm_GetSIB( SIB )

            DisAsm_Inc()

        } else

            DisAsm_Inc();

    } else
    if  ( MRM[ MRM_MOD ] == 2 ) {

        if ( MRM[ MRM_RM ] == 4 ) {

            DisAsm_GetSIB( SIB )

            DisAsm_Inc( 4 )

        } else

            DisAsm_Inc( 4 )

    } else
    if  ( MRM[ MRM_MOD ] == 3 ) {


    }

}


stock DisAsm_Read_Prefix() {

    new B = DisAsm_GetByte()

    if (
        ( B == 0x26 ) ||
        ( B == 0x26 ) ||
        ( B == 0x2E ) ||
        ( B == 0x36 ) ||
        ( B == 0x3E ) ||
        ( B == 0x64 ) ||
        ( B == 0x65 ) ||
        ( B == 0xF0 ) ||
        ( B == 0xF2 ) ||
        ( B == 0xF3 ) ||
        ( B == 0x66 ) ||
        ( B == 0x67 ) ||
        ( B == 0x0F )
    ) {

        DisAsm_Inc()

        return true

    }

    return false

}
stock DisAsm_Read_CmdOne( B ) {

    if (
        ( ( B >= 0x40 ) && ( B <= 0x61 ) ) ||
        ( ( B >= 0x9B ) && ( B <= 0x9F ) ) ||
        ( ( B >= 0x90 ) && ( B <= 0x99 ) ) ||
        ( ( B >= 0x6C ) && ( B <= 0x6F ) ) ||
        ( ( B >= 0xA4 ) && ( B <= 0xA7 ) ) ||
        ( ( B >= 0xAA ) && ( B <= 0xAF ) ) ||
        ( ( B >= 0xEC ) && ( B <= 0xF5 ) ) ||
        ( ( B >= 0xF8 ) && ( B <= 0xFD ) ) ||
        ( B == 0x06 ) ||
        ( B == 0x07 ) ||
        ( B == 0x0E ) ||
        ( B == 0x16 ) ||
        ( B == 0x17 ) ||
        ( B == 0x1E ) ||
        ( B == 0x1F ) ||
        ( B == 0x27 ) ||
        ( B == 0x2F ) ||
        ( B == 0x37 ) ||
        ( B == 0x3F ) ||
        ( B == 0xC3 ) ||
        ( B == 0xC9 ) ||
        ( B == 0xCB ) ||
        ( B == 0xCC ) ||
        ( B == 0xCE ) ||
        ( B == 0xCF ) ||
        ( B == 0xD6 ) ||
        ( B == 0xD7 )
    ) {

        DisAsm_Inc()

        return true

    }

    return false

}
stock DisAsm_Read_CmdMrmOrigin( B ) {

    if (
        ( ( B >= 0x00 ) && ( B <= 0x03 ) ) ||
        ( ( B >= 0x08 ) && ( B <= 0x0B ) ) ||
        ( ( B >= 0x10 ) && ( B <= 0x13 ) ) ||
        ( ( B >= 0x18 ) && ( B <= 0x1B ) ) ||
        ( ( B >= 0x20 ) && ( B <= 0x23 ) ) ||
        ( ( B >= 0x28 ) && ( B <= 0x2B ) ) ||
        ( ( B >= 0x30 ) && ( B <= 0x33 ) ) ||
        ( ( B >= 0x38 ) && ( B <= 0x3B ) ) ||
        ( ( B >= 0x62 ) && ( B <= 0x63 ) ) ||
        ( ( B >= 0x84 ) && ( B <= 0x8E ) ) ||
        ( ( B >= 0xC4 ) && ( B <= 0xC5 ) )
    ) {

        DisAsm_Inc()

        DisAsm_ProcessMRM()

        return true

    }

    return false

}
stock DisAsm_Read_CmdData1( B ) {

    if (
        ( ( B >= 0xB0) && ( B <= 0xB7 ) ) ||
        ( ( B >= 0xE0) && ( B <= 0xE7 ) ) ||
        ( ( B >= 0x70) && ( B <= 0x7F ) ) ||
        ( B == 0x04 ) ||
        ( B == 0x0C ) ||
        ( B == 0x14 ) ||
        ( B == 0x1C ) ||
        ( B == 0x24 ) ||
        ( B == 0x2C ) ||
        ( B == 0x34 ) ||
        ( B == 0x3C ) ||
        ( B == 0x6A ) ||
        ( B == 0xA8 ) ||
        ( B == 0xCD )
    ) {

        DisAsm_Inc()

        DisAsm_Inc()

        return true

    }

    return false

}
stock DisAsm_Read_CmdData2i4( B ) {

    if (
        ( ( B >= 0xA0 ) && ( B <= 0xA3 ) ) ||
        ( ( B >= 0xB8 ) && ( B <= 0xBF ) ) ||
        ( B == 0x05 ) ||
        ( B == 0x0D ) ||
        ( B == 0x15 ) ||
        ( B == 0x1D ) ||
        ( B == 0x25 ) ||
        ( B == 0x2D ) ||
        ( B == 0x35 ) ||
        ( B == 0x3D ) ||
        ( B == 0x68 ) ||
        ( B == 0xA9 ) ||
        ( B == 0xE8 ) ||
        ( B == 0xE9 )
    ) {

        DisAsm_Inc()

        DisAsm_Inc( 4 )

        return true

    }

    return false

}
stock DisAsm_Read_CmdMrmData1( B ) {

    if ( B == 0x69 ) {

        DisAsm_Inc()

        DisAsm_ProcessMRM()

        DisAsm_Inc( 4 )

        return true

    }

    return false

}
stock DisAsm_Read_CmdNnnData1( B ) {

    if (
        ( B == 0x80 ) ||
        ( B == 0x82 ) ||
        ( B == 0x83 ) ||
        ( B == 0xC0 ) ||
        ( B == 0xC1 ) ||
        ( B == 0xC6 )
    ) {

        DisAsm_Inc()

        DisAsm_ProcessMRM()

        DisAsm_Inc()

        return true

    }

    return false

}
stock DisAsm_Read_CmdNnnData2i4( B ) {

    if (
            ( B == 0x81 ) ||
            ( B == 0xC7 )
        ) {

        DisAsm_Inc()

        static MRM[ MRM_SIZE ]

        static SIB[ SIB_SIZE ]

        DisAsm_GetMRM( MRM )

        if ( MRM[ MRM_MOD ] == 0 ) {

            if ( MRM[ MRM_RM ] == 4 ) {

                DisAsm_GetSIB( SIB )

                if ( SIB[ SIB_BASE ] == 5 )

                    DisAsm_Inc( 4 )

            } else

                DisAsm_Inc( 4 )

        } else
        if  ( MRM[ MRM_MOD ] == 1 ) {

            if ( MRM[ MRM_RM ] == 4 ) {

                DisAsm_GetSIB( SIB )

                DisAsm_Inc()

            } else

                DisAsm_Inc()

        } else
        if  ( MRM[ MRM_MOD ] == 2 ) {

            if ( MRM[ MRM_RM ] == 4 ) {

                DisAsm_GetSIB( SIB )

                DisAsm_Inc( 4 )

            } else

                DisAsm_Inc( 4 )

        } else
        if  ( MRM[ MRM_MOD ] == 3 ) {


        }

        DisAsm_Inc( 4 )

        return true

    }

    return false

}

stock DisAsm_Reset() {

    DisAsm_CmdSize = 0

}
stock DisAsm_Init( Addr ) {

    DisAsm_Channel = Addr
    DisAsm_ReadLength = 0
    DisAsm_Reset()

}
stock DisAsm_DebugShow( t ) {

    if ( DisAsm_IsDebug ) {

        if ( t == 0 ) {

            server_print( "[OST] ---------------------------------------------" )
            server_print( "[OST] Addr   = 0x%s" , GetDWordHex( DisAsm_Channel ) )
            server_print( "[OST] Opcode = 0x%s" , GetDWordHex( rByte(DisAsm_Channel) ) )

        } else

        if ( t == 1 ) {

            server_print( "[OST] Size cmd = 0x%s" , GetDWordHex( DisAsm_CmdSize ) )
            server_print( "[OST] Milc cmd = 0x%s" , GetDWordHex( DisAsm_ReadLength ) )

        }

        if ( t == 2 ) {

            server_print( "[OST] Size cmd = 0x%s" , GetDWordHex( DisAsm_CmdSize ) )
            server_print( "[OST] Milc cmd = 0x%s" , GetDWordHex( DisAsm_ReadLength ) )

            server_print( "[OST] ---------------------------------------------" )
            server_print( "[OST] Addr   = 0x%s" , GetDWordHex( DisAsm_Channel ) )
            server_print( "[OST] Opcode = 0x%s" , GetDWordHex( rByte(DisAsm_Channel) ) )

        }

    }

}
stock DisAsm_Read_Cmd() {

    DisAsm_Reset()

    while( true )
        if ( !( DisAsm_Read_Prefix() ) )
            break;

    new Cmd = DisAsm_GetByte()

    if (
        ( DisAsm_Read_CmdOne( Cmd )        ) ||
        ( DisAsm_Read_CmdMrmOrigin( Cmd )  ) ||
        ( DisAsm_Read_CmdData1( Cmd )      ) ||
        ( DisAsm_Read_CmdData2i4( Cmd )    ) ||
        ( DisAsm_Read_CmdMrmData1( Cmd )   ) ||
        ( DisAsm_Read_CmdNnnData1( Cmd )   ) ||
        ( DisAsm_Read_CmdNnnData2i4( Cmd ) )
    )

            return true;

    return false;

}
stock DisAsm_GetMinLen( Addr , Len = 5 ) {

    DisAsm_Init( Addr )

    DisAsm_DebugShow( 0 )

    while( DisAsm_Read_Cmd() ) {

        if ( DisAsm_ReadLength >= Len ) {

            DisAsm_DebugShow( 1 )

            return DisAsm_ReadLength

        }

        DisAsm_DebugShow( 2 )

    }

    return -1;

}

stock Detours_GetGate( Addr , NewAddr ) {

    new MinLength = DisAsm_GetMinLen( Addr )

    if ( MinLength == -1 )

        return 0;

    new Gate = Malloc( MinLength + 5 )

    new i

    for ( i = 0; i < MinLength; i++ )

        wByte( Gate + i , rByte( Addr + i ) )

    wByte( Gate + MinLength , 0xE9 )

    wDWord( Gate + MinLength + 1 , Addr - Gate - 4 - 1 )

    wByte( Addr , 0xE9 )

    wDWord( Addr + 1 , NewAddr - Addr - 4 )

    return Gate

}


/*    ############################################################ Move  Resource ###########################################################  */
/*

//  [ESP] - Old EIP     [ESP + 4] - Dest      [ESP + 8] - Sour      [ESP + 12] - Size
function MoveResourse: Cardinal;
asm
  pushf
  push ESI
  push EDI

  mov EDI , [ ESP + 10 + 4 ]
  mov ESI , [ ESP + 10 + 8 ]
  mov ECX , [ ESP + 10 + 12 ]
  shr ECX , 2
  std
  rep movsd

  xor EAX , EAX
  mov ECX , 34
  cld
  rep stosd

  pop EDI
  pop ESI
  popf
end;

*/


/*    ############################################################# Random Path #############################################################   */
/*

function __strlen(s: Cardinal): Cardinal;
asm
  push EDI

  mov EDI , EAX
  xor AL , AL
  mov ECX , 65536
  cld
  repne scasb
  je @_return
  mov EAX , 0
  pop EDI
  ret

@_return:
  mov EAX , 65535
  sub EAX , ECX
  pop EDI
end;
function __copy(d, s, size: Cardinal): Cardinal;
asm
  push ESI
  push EDI
  push EBX

  mov EBX , ECX
  and ECX , $FFFFFFFC
  sub EBX , ECX
  shr ECX , 2

  mov EDI , EAX
  mov ESI , EDX
  cld
  rep movsd

  mov ECX , EBX
  rep movsb

  pop EBX
  pop EDI
  pop ESI
end;
function __equal(m1, m2, size: Cardinal): Cardinal;
asm
  push ESI
  push EDI
  push EBX

  mov EBX , ECX
  and ECX , $FFFFFFFC
  sub EBX , ECX
  shr ECX , 2

  mov EDI , EAX
  mov ESI , EDX
  cld
  repe cmpsd
  jnz @_not_equal

  mov ECX , EBX
  repe cmpsb
  jnz @_not_equal

  mov EAX , 1
  jmp @_exit

@_not_equal:
  mov EAX , 0

@_exit:
  pop EBX
  pop EDI
  pop ESI
end;
function __find(m_base, m_end, p_base, p_size, offset: Cardinal): Cardinal;
var
  i, _c, _p: Cardinal;
begin

  Dec(m_end, p_size);

  _p := p_size;
  Dec(_p);

  for m_base := m_base to m_end do
  begin

    for i := 0 to _p do
    begin

      _c := PByte(p_base + i)^;

      if (_c = $FF) then
        continue;

      if (not(_c = PByte(m_base + i)^)) then
        break;

    end;

    if (i = p_size) then
    begin
      Result := m_base + offset;
      Exit;
    end;

  end;

  Result := 0;
  Exit;

end;

function __random( max: Word ): Cardinal;
var
 pRandSeed: PWord;
 Temp: Word;
 TempInt: Int32;
begin

 if ( max = 0 ) then
  begin
    Result := 0;
    Exit;
  end;

 pRandSeed := Pointer($22222222);

 Temp := Word( pRandSeed^ * $08088405 + 1 );

 pRandSeed^ := Temp;

 TempInt := Cardinal(Temp) * Cardinal(Max);

 TempInt := TempInt shr 16;

 Result := Word(TempInt);

 if ( max <= Result ) then
  Result := __random( max );

end;
function __random_char: Byte;
begin
  Result := 98;
  case (__random(3) ) of
    0: Result := __random(24) + 97;
    1: Result := __random(24) + 65;
    2: Result := __random(8) + 48;
  end;
end;
function __process: Cardinal;
var
  base , predel: Cardinal;
begin

  base := Cardinal( $11111111 );

  predel := base + __random(8) + 4;

  while( not( base = predel ) ) do
   begin

    PByte( Base )^ := __random_char;

    Inc( Base );

   end;

  PByte( Base )^ := 0;

end;
function __jmp: Cardinal;
asm
  push AX

  pushf
  pusha

  call __process

  popa
  popf

  pop AX

  db $E9 db $33 db $33 db $33 db $33

  db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
  db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
  db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF

end;

//  Replace
//    $11111111 - to String Base
//    $22222222 - to RandSeed Base
//    $33333333 - to Relative Jump to SV_SendResources
//    [ 0x66 0x50  0x66 0x9C  0x66 0x60 ] - to EntryPoint

function __CopyEnd: Cardinal;
asm
 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
end;

procedure TForm34.Button1Click(Sender: TObject);
var
  f: Cardinal;
  i, v, c: Cardinal;
  s: AnsiString;
  Temp: Cardinal;
  m, cc: Cardinal;
begin

 s := '';

 m := Cardinal(@__strlen);
 i := m;

 cc := 0;
 while( i <= (Cardinal(@__CopyEnd)+4) ) do
  begin
   c := PCardinal(i)^;

   v := i - m;

   c := v XOR ( c XOR ( ( v shl 3 ) + 78963 ) - 13523 );

   s := s + '0x'+IntToHex( c , 8 ) + ',';

   Inc(cc);
   if ( cc = 16 ) then
    begin
     cc := 0;
     memo1.lines.add( s );
     s := '';
    end;


   Inc( i , 4 );

  end;

 memo1.lines.add( s );


 memo1.Lines.Add(inttohex(cardinal(@__strlen),8));
 memo1.Lines.Add(inttohex(cardinal(@__CopyEnd),8));
 memo1.Lines.Add(inttohex(cardinal(@__jmp),8));

 exit;
 __random(0);
 __random_char;
 __process;
 __jmp;
 __CopyEnd;

 __strlen(0);
 __copy(0,0,0);
 __equal(0,0,0);
 __find(0,0,0,0,0);
end;

*/


/*    ############################################################# Get File Index #############################################################   */
/*

function __jmp: Cardinal;
asm

 push $0C
 db $E8
  db $22 db $22 db $22 db $22
 add ESP , 4

 mov [$11111111] , EAX

 ret

 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
end;

//  Replace:
//    $11111111 - to Ptr Index File
//    $22222222 - to Relative EntryPoint MSG_ReadBits
//    [ 0x6A 0x0C ] - to EntryPoint


function __CopyEnd: Cardinal;
asm
 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
end;

procedure TForm34.Button1Click(Sender: TObject);
var
  f: Cardinal;
  i, v, c: Cardinal;
  s: AnsiString;
  Temp: Cardinal;
  m, cc: Cardinal;
begin

 s := '';

 m := Cardinal(@__jmp);
 i := m;

 cc := 0;
 while( i <= (Cardinal(@__CopyEnd)+4) ) do
  begin
   c := PCardinal(i)^;

   v := i - m;

   c := v XOR ( c XOR ( ( v shl 3 ) + 78963 ) - 13523 );

   s := s + '0x'+IntToHex( c , 8 ) + ',';

   Inc(cc);
   if ( cc = 16 ) then
    begin
     cc := 0;
     memo1.lines.add( s );
     s := '';
    end;


   Inc( i , 4 );

  end;

 memo1.lines.add( s );


 memo1.Lines.Add(inttohex(cardinal(@__strlen),8));
 memo1.Lines.Add(inttohex(cardinal(@__CopyEnd),8));

 exit;
 __process(0);
 __jmp;
 __CopyEnd;

 __strlen(0);
 __copy(0,0,0);
 __equal(0,0,0);
 __find(0,0,0,0,0);
end;


*/


/*    ############################################################## Try Files ##############################################################   */
/*
function __strlen(s: Cardinal): Cardinal;
asm
  push EDI

  mov EDI , EAX
  xor AL , AL
  mov ECX , 65536
  cld
  repne scasb
  je @_return
  mov EAX , 0
  pop EDI
  ret

@_return:
  mov EAX , 65535
  sub EAX , ECX
  pop EDI
end;
function __copy(d, s, size: Cardinal): Cardinal;
asm
  push ESI
  push EDI
  push EBX

  mov EBX , ECX
  and ECX , $FFFFFFFC
  sub EBX , ECX
  shr ECX , 2

  mov EDI , EAX
  mov ESI , EDX
  cld
  rep movsd

  mov ECX , EBX
  rep movsb

  pop EBX
  pop EDI
  pop ESI
end;
function __equal(m1, m2, size: Cardinal): Cardinal;
asm
  push ESI
  push EDI
  push EBX

  mov EBX , ECX
  and ECX , $FFFFFFFC
  sub EBX , ECX
  shr ECX , 2

  mov EDI , EAX
  mov ESI , EDX
  cld
  repe cmpsd
  jnz @_not_equal

  mov ECX , EBX
  repe cmpsb
  jnz @_not_equal

  mov EAX , 1
  jmp @_exit

@_not_equal:
  mov EAX , 0

@_exit:
  pop EBX
  pop EDI
  pop ESI
end;
function __find(m_base, m_end, p_base, p_size, offset: Cardinal): Cardinal;
var
  i, _c, _p: Cardinal;
begin

  Dec(m_end, p_size);

  _p := p_size;
  Dec(_p);

  for m_base := m_base to m_end do
  begin

    for i := 0 to _p do
    begin

      _c := PByte(p_base + i)^;

      if (_c = $FF) then
        continue;

      if (not(_c = PByte(m_base + i)^)) then
        break;

    end;

    if (i = p_size) then
    begin
      Result := m_base + offset;
      Exit;
    end;

  end;

  Result := 0;
  Exit;

end;

function t__write_num( num , mem: Cardinal ): Cardinal;
asm
 and EAX , $FF

 mov cl , 10
 div cl

 add ah , 48
 mov [EDX + 1] , ah

 xor ah , ah

 div cl
 add ah , 48
 mov [EDX] , ah
end;
function __write_num_2( num , mem: Cardinal ): Cardinal;
begin

 PByte( mem + 1 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem     )^ := 48 + ( num mod 10 );

end;
function __write_num_4( num , mem: Cardinal ): Cardinal;
begin

 PByte( mem + 3 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 2 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 1 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem     )^ := 48 + ( num mod 10 );

end;           // 4 294 967 296
function __write_num_10( num , mem: Cardinal ): Cardinal;
begin

 PByte( mem + 9 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 8 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 7 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 6 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 5 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 4 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 3 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 2 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem + 1 )^ := 48 + ( num mod 10 );

 num := num div 10;

 PByte( mem     )^ := 48 + ( num mod 10 );

end;

type
 info_table_s = ^info_table_t;
 info_table_t = Array[ 0..$500] of Cardinal;

type
 TCbuf_AddText = function( Str: Cardinal ): Cardinal; cdecl;

type
 info_s = ^info_t;
 info_t = Record
  CountIndex:   Cardinal;
  LastMD5:      Cardinal;
  Host_CL:      Cardinal;
  Cbuf_AddText: TCbuf_AddText;
  TableData:    info_table_s;
  TempString:   Cardinal;
 End;

function __write_try_num( Info: info_s; Name, Num: Cardinal ): Cardinal;
var
 Base: Cardinal;
 len: Cardinal;
begin

   Base := Info^.TempString;

   PCardinal( Base )^ := $2220625F;

   __copy( Base + 4 , Name , $20 );
   PByte( Base + $20 + 4 )^ := 0;

   len := __strlen( Base );

   PWord( Base + len )^ := $2022;
   Inc( len , 2 );

   __write_num_10( Num XOR 1231234 , Base + len );
   Inc( len , 10 );

   PWord( Base + len )^ := $000A;

   Info^.Cbuf_AddText( Base );

end;
function __write_is_file( Info: info_s; Name, Mem: Cardinal ): Cardinal;
var
 Base: Cardinal;
 i, len, mem_len, mem_predel: Cardinal;
begin
   //   %n

   Base := Info^.TempString;

   mem_len := __strlen( Mem );

   mem_predel := Mem + mem_len - 2;

   i := Mem;

   while( not( i = mem_predel ) ) do
    begin

     if ( PWord( i )^ = $6E25 ) then
      break;

     Inc( i );

    end;

   if ( i = mem_predel ) then
    begin

     __copy( Base , Mem , mem_len );

     PWord( Base + mem_len )^ := $000A;

     Info^.Cbuf_AddText( Base );

     Exit;

    end;

   len := i - Mem;

   __copy( Base , Mem , len );

   __copy( Base + len , Name , $20 );
   PByte( Base + len + $20 )^ := 0;

   len := __strlen( Base );
   mem_len := mem_predel - i + 1;
   __copy( Base + len , i + 2 , mem_len );

   PWord( Base + len + mem_len )^ := $000A;

   Info^.Cbuf_AddText( Base );

end;
function __process( MD5: Cardinal ): Cardinal;
var
 Info: info_s;
 Index: Cardinal;
 Name: Cardinal;
begin

 Result := MD5;

 Info :=  Pointer($11111111);

 Index := PCardinal($33333333)^;

 if ( Index >= Info^.CountIndex ) then
  Exit;

 Result := 0;

 Name := PCardinal(Info^.Host_CL)^ + $4D08;     //  If Linux => $4BE8

 if ( Index = 0 ) then
  begin

   Info^.LastMD5  := MD5;

   __write_try_num( Info , Name , MD5 );

   Exit;

  end;

 if ( ( Info^.LastMD5 <> MD5 ) AND ( Info^.TableData^[ Index ] <> 0 ) ) then
  begin

   Info^.LastMD5 := MD5;

   __write_is_file( Info , Name , Info^.TableData^[ Index ] );

  end;

end;

function __jmp: Cardinal;
asm
 push DX
 pushf

 push EDX
 push ECX
 push ESI
 push EDI
 push EBX

 push $20
 db $E8
  db $22 db $22 db $22 db $22
 pop EDX

 call __process

 pop EBX
 pop EDI
 pop ESI
 pop ECX
 pop EDX

 popf
 pop DX

 ret

 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
end;

//  Replace:
//    $11111111 - to Info Table
//    $22222222 - to Relative EntryPoint MSG_ReadBits
//    $33333333 - to Ptr Index File
//  Search:
//    [ 0x66 , 0x52 ,  0x66 , 0x9C ] - to EntryPoint


function __CopyEnd: Cardinal;
asm
 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
 db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF db $FF
end;

procedure TForm34.Button1Click(Sender: TObject);
var
  f: Cardinal;
  i, v, c: Cardinal;
  s: AnsiString;
  Temp: Cardinal;
  m, cc: Cardinal;
begin

 s := '';

 m := Cardinal(@__strlen);
 i := m;

 cc := 0;
 while( i <= (Cardinal(@__CopyEnd)+4) ) do
  begin
   c := PCardinal(i)^;

   v := i - m;

   c := v XOR ( c XOR ( ( v shl 3 ) + 78963 ) - 13523 );

   s := s + '0x'+IntToHex( c , 8 ) + ',';

   Inc(cc);
   if ( cc = 16 ) then
    begin
     cc := 0;
     memo1.lines.add( s );
     s := '';
    end;


   Inc( i , 4 );

  end;

 memo1.lines.add( s );


 memo1.Lines.Add(inttohex(cardinal(@__strlen),8));
 memo1.Lines.Add(inttohex(cardinal(@__CopyEnd),8));

 exit;
 __process(0);
 __jmp;
 __CopyEnd;

 __strlen(0);
 __copy(0,0,0);
 __equal(0,0,0);
 __find(0,0,0,0,0);
end;


*/