Results 1 to 2 of 2
  1. #1
    Junior Member
    Join Date
    Sep 2012
    Posts
    3

    Help with source code?

    I have a source code for a COD4 silent aim, and im trying to change the hook so that it works for mw2, but I have little to no experience with coding. Basically im trying to make the code work for mw2, then compile it so i can run and use it on fourdeltaone. Can anyone help me? The code is posted below.


    Code:
    __size32 global26 = 0;// 4 bytes
    __size32 global25 = 0;// 4 bytes
    __size32 global24 = 0;// 4 bytes
    __size32 global23 = 0;// 4 bytes
    __size32 global22 = 0;// 4 bytes
    __size32 global21 = 0;// 4 bytes
    unsigned int timeGetTime = 0x2610;
    __size32 CloseHandle = 0x25a8;// 4 bytes
    __size32 global2 = 0x44bf19b1;// 4 bytes
    int global0 = 0xbb40e64e;
    unsigned int global32;
    __size32 Process32Next = 0x253e;// 4 bytes
    __size32 _stricmp = 0x2628;// 4 bytes
    __size32 sprintf_s = 0x2634;// 4 bytes
    void global60;
    __size32 global91 = 0;// 4 bytes
    __size32 global77 = 0;// 4 bytes
    __size32 global70;// 4 bytes
    
    void proc2(int param1, __size32 param2, __size32 param3, __size32 param4);
    void proc5(unsigned int param1, unsigned int param2);
    void _start();
    void proc7(__size32 *param1);
    void proc8(short param1, unsigned char param2, __size32 param3, __size32 param4, __size32 param5);
    void proc10();
    void proc11(short param1, unsigned char param2, __size32 param3, unsigned int param4);
    void proc12(__size32 param1, __size32 param2, __size32 param3, __size32 param4, __size32 param5, __size32 param6);
    int proc13(__size16 *param1);
    __size32 proc14(__size32 param1, unsigned int param2, unsigned int param3);
    
    // address: 0x401ba9
    void proc1(int param1, int param2) {
        __size32 eax;         // r24
        unsigned int eax_1;         // r24{66}
        int eax_2;         // r24{55}
        int esi;         // r30
        int esi_1;         // r30{56}
    
        if (global0 == 0xbb40e64e || (global0 & 0xffff0000) == 0) {
            GetSystemTimeAsFileTime();
            GetCurrentProcessId();
            GetCurrentThreadId();
            GetTickCount();
            esi_1 = 0 ^ eax ^ eax ^ eax_2;
            QueryPerformanceCounter();
            eax_1 = param2 ^ param1;
            esi = esi_1 ^ eax_1;
            if ((esi_1 ^ eax_1) != 0xbb40e64e) {
                if (((esi_1 ^ eax_1) & 0xffff0000) == 0) {
                    eax = (esi_1 ^ eax_1 | 0x4711) * 0x10000;
                    esi = esi_1 ^ eax_1 | eax;
                }
            } else {
                esi = 0xbb40e64f;
            }
            global0 = esi;
            global2 =  !esi;
        } else {
            global2 =  !global0;
        }
        return;
    }
    
    // address: 0x401b00
    void proc2(int param1, __size32 param2, __size32 param3, __size32 param4) {
        __size32 *esp;         // r28
        __size32 local0;         // m[esp]
    
        *(__size32*)(esp - param1 - 12) = param2;
        *(__size32*)(esp - param1 - 16) = param3;
        *(__size32*)(esp - param1 - 20) = param4;
        *(int*)(esp - param1 - 24) = global0 ^ (esp + 8);
        *(__size32*)(esp - param1 - 28) = local0;
        *(union { __size32 * x2047; int x2048; }*)0 = (esp - 8);
        return;
    }
    
    // address: 0x401a30
    void proc5(unsigned int param1, unsigned int param2) {
        __size32 eax;         // r24
        __size32 eax_1;         // r24{57}
        __size32 eax_2;         // r24{39}
        int esp;         // r28
        unsigned int local1;         // m[esp - 48]
    
        eax = *0;
        *(int*)0 = (esp - 20);
        eax_2 = proc13(0x400000);
        if (eax_2 == 0) {
    L1:
            *(__size32*)0 = eax;
        } else {
            local1 = param1 - 0x400000;
            eax_1 = proc14(0x400000, local1, param2);
            if (eax_1 == 0) {
                goto L1;
            } else {
                *(__size32*)0 = eax;
            }
        }
        return;
    }
    
    // address: 0x401730
    void _start() {
        __size8 al;         // r8
        __size16 ax;         // r0
        int bl_2;         // r11{169}
        unsigned char cl;         // r9
        __size16 cx;         // r1
        unsigned char dl;         // r10
        short dx;         // r2
        __size32 eax;         // r24
        union { union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1983; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1984; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1985; __size8 ** x1988; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1990; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1992; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1994; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1996; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1998; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2000; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2002; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2004; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2006; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2008; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2010; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2012; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2014; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2016; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2018; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2020; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2022; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2024; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2026; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2028; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2030; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2032; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2034; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2036; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2038; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2156; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2158; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2160; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2162; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2164; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2166; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2168; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2170; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2172; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2174; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2176; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2178; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2180; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2182; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2184; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2186; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2188; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2190; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2192; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2194; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2196; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2198; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2200; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2202; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2204; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2206; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2208; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2210; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2212; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2214; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2216; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2218; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2220; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2222; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2224; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2226; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2228; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2230; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2232; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2234; } eax_1;         // r24
        union { union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1983; __size8 ** x1984; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1985; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1989; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1993; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1997; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2001; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2005; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2009; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2013; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2017; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2021; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2025; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2029; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2033; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2037; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2157; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2161; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2165; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2169; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2173; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2177; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2181; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2185; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2189; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2193; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2197; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2201; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2205; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2209; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2213; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2217; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2221; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2225; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2229; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2233; } eax_2;         // r24
        __size8 *eax_3;         // r24{154}
        int eax_4;         // r24{351}
        void *ebp_1;         // r29{8}
        __size32 ebx_1;         // r27{283}
        int ebx_2;         // r27{9}
        int ecx;         // r25
        __size32 edi_1;         // r31{283}
        __size32 edi_2;         // r31{41}
        int edx;         // r26
        __size32 esi;         // r30
        union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } esi_1;         // r30
        union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } esi_2;         // r30
        union { unsigned int * x1977; __size8 * x1978; } esi_3;         // r30
        union { unsigned int * x1973; __size8 * x1974; } esi_4;         // r30
        union { unsigned int * x1973; __size8 * x1974; } esi_5;         // r30
        union { unsigned int * x1977; __size8 * x1978; } esi_7;         // r30
        union { unsigned int * x1977; __size8 * x1978; } esi_8;         // r30
        int esp;         // r28
        void *esp_4;         // r28{35}
        void *esp_5;         // r28{20}
        void *esp_6;         // r28{8}
        int esp_7;         // r28{169}
        int local1;         // m[esp - 24]
        union { unsigned int * x1977; __size8 * x1978; } local10;         // m[ebp_1 - 32]{173}
        union { unsigned int * x1977; __size8 * x1978; } local12;         // m[ebp_1 - 32]{258}
        void *local13;         // esp_4{288}
        void *local14;         // esp_4{292}
        union { union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1983; __size8 ** x1984; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1985; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1989; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1993; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x1997; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2001; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2005; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2009; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2013; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2017; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2021; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2025; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2029; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2033; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2037; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2157; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2161; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2165; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2169; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2173; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2177; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2181; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2185; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2189; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2193; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2197; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2201; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2205; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2209; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2213; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2217; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2221; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2225; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2229; union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } * x2233; } local15;         // eax_2{340}
        union { unsigned int * x1977; __size8 ** x1978; __size8 * x1982; } local16;         // esi_2{344}
        union { unsigned int * x1973; __size8 * x1974; } local17;         // esi_4{352}
        union { unsigned int * x1977; __size8 * x1978; } local18;         // esi_8{376}
        int local2;         // m[esp - 20]
        __size32 local5;         // m[esp_6 - 4]{24}
        union { void * x2149; int x2150; } local6;         // m[esp_6 - 4]{15}
        union { unsigned int * x1973; __size8 * x1974; } local7;         // m[esp_7 - 8]{211}
        unsigned int local8;         // m[esp_7 - 8]{247}
        union { unsigned int * x1973; __size8 * x1974; } local9;         // m[ebp_1 - 32]{196}
    
        proc1(local1, local2);
        proc2(92, ebx_1, esi, edi_1);
        ebx_2 = 0;
        bl_2 = 0;
        *(__size32*)(ebp_1 - 28) = 0;
        local6 = ebp_1 - 108;
        GetStartupInfoW(*(esp_6 - 4));
        local13 = esp_5;
        if (*0x403480 == 0) {
            local5 = 0;
            *(__size32*)(esp_6 - 8) = 0;
            *(__size32*)(esp_6 - 12) = 1;
            *(__size32*)(esp_6 - 16) = 0;
            HeapSetInformation();
            local13 = esp_4;
        }
        esp_4 = local13;
        *(__size32*)(ebp_1 - 4) = 0;
        eax = *24;
        esi = *(eax + 4);
        *(__size32*)(ebp_1 - 36) = 0;
        edi_2 = 0x403474;
        local14 = esp_4;
        for(;;) {
            esp_4 = local14;
            *(__size32*)(esp_4 - 4) = 0;
            *(__size32*)(esp_4 - 8) = esi;
            *(__size32*)(esp_4 - 12) = 0x403474;
            InterlockedCompareExchange();
            if (eax == 0) {
                goto L32;
            }
            if (eax == esi) {
                break;
            }
            *(__size32*)(esp_4 - 16) = 1000;
            Sleep(*(esp_4 - 16));
            local14 = esp;
        }
        *(__size32*)(ebp_1 - 36) = 1;
    L32:
        if (global70 == 1) {
            *(__size32*)(esp_4 - 16) = 31;
            _amsg_exit();
    L22:
            eax = *0x403470;
            if (eax == 1) {
                *(__size32*)(esp_4 - 16) = 0x402118;
                *(__size32*)(esp_4 - 20) = 0x402110;
                _initterm();
                global70 = 2;
            }
            if (*(ebp_1 - 36) == 0) {
                *(__size32*)(esp_4 - 16) = 0;
                *(__size32*)(esp_4 - 20) = 0x403474;
                InterlockedExchange(*(esp_4 - 20), *(esp_4 - 16));
            }
            esp_7 = esp_4 - 12;
            if (*0x403484 != 0) {
                *(__size32*)(esp_4 - 16) = 0x403484;
                proc5(*(esp_4 - 16), 0);
                ecx = *(esp_4 - 16);
                esp_7 = esp_4 - 12;
                if (eax_3 != 0) {
                    *(__size32*)(esp_4 - 16) = 0;
                    *(__size32*)(esp_4 - 20) = 2;
                    *(__size32*)(esp_4 - 24) = 0;
                    (*global60)(local1, local2, pc, 0x4022a8, 92, ax, cx, dx, (unsigned char) eax, cl, dl, 0, eax_3, ecx, edx, 0, ebp_1, 1, 0x403474, LOGICALFLAGS32(eax_3), LOGICALFLAGS32(eax_3), LOGICALFLAGS32(eax_3));
                }
            }
            eax_1 = *0x4020d0;
            esi_1 = *eax_1;
            local15 = eax_1;
            local16 = esi_1;
            for(;;) {
                eax_2 = local15;
                esi_2 = local16;
                local10 = esi_2;
                al = *esi_2;
                eax = eax_2 >> 8 & 0xffffff | (al);
                local17 = esi_2;
                local17 = esi_2;
                local18 = esi_2;
                if ( !(al > 32 || al != bl_2 && *(ebp_1 - 28) != ebx_2)) {
                    eax_4 = eax;
                    esi_4 = local17;
                    al = *esi_4;
                    eax = eax_4 >> 8 & 0xffffff | (al);
                    while ( !(al == bl_2 || al > 32)) {
                        esi_5 = esi_4 + 1;
                        local9 = esi_4 + 1;
                        local17 = esi_5;
                        eax_4 = eax;
                        esi_4 = local17;
                        al = *esi_4;
                        eax = eax_4 >> 8 & 0xffffff | (al);
                    }
                    tmpb = *(ebp_1 - 64) & 0x1;
                    if (tmpb != 0) {
                        eax = *(unsigned short*)(ebp_1 - 60);
    L6:
                        *(unsigned int*)(esp_7 - 4) = eax;
                        local7 = esi_4;
                        *(int*)(esp_7 - 12) = ebx_2;
                        *(__size32*)(esp_7 - 16) = 0x400000;
                        proc8(dx, cl, ebx_2, esi_4, edi_2);
                    }
                    *(__size32*)(esp_7 - 4) = 10;
                    eax = *(esp_7 - 4);
                    goto L6;
                }
                if (al == 34) {
                    cl =  (*(ebp_1 - 28) == ebx_2) ? 1 : 0;
                    ecx = 0 >> 8 & 0xffffff | (cl);
                    *(int*)(ebp_1 - 28) = ecx;
                }
                *(unsigned int*)(esp_7 - 4) = (al);
                _ismbblead();
                local15 = eax;
                if (eax != 0) {
                    esi_7 = esi_2 + 1;
                    local12 = esi_2 + 1;
                    local18 = esi_7;
                }
                esi_8 = local18;
                esi_3 = esi_8 + 1;
                local16 = esi_3;
            }
        }
        if (global70 != 0) {
            global77 = 1;
            goto L22;
        }
        global70 = 1;
        *(__size32*)(esp_4 - 16) = 0x402128;
        *(__size32*)(esp_4 - 20) = 0x40211c;
        _initterm_e();
        if (eax == 0) {
            goto L22;
        }
        *(__size32*)(ebp_1 - 4) = -2;
        proc7(ebp);
        return;
    }
    
    // address: 0x401b45
    void proc7(__size32 *param1) {
        __size32 ecx;         // r25
        __size32 local0;         // m[esp]
    
        ecx = *(param1 - 16);
        *(__size32*)0 = ecx;
        *(__size32*)param1 = local0;
        return;
    }
    
    // address: 0x401280
    void proc8(short param1, unsigned char param2, __size32 param3, __size32 param4, __size32 param5) {
        char al;         // r8
        short ax;         // r0
        __size8 bl;         // r11
        unsigned char cl;         // r9
        __size8 cl_1;         // r9{334}
        short dx;         // r2
        __size16 dx_1;         // r2{333}
        __size32 eax;         // r24
        unsigned int eax_1;         // r24{289}
        unsigned int eax_2;         // r24{253}
        __size32 ebp;         // r29
        __size32 ebx;         // r27
        int ecx;         // r25
        __size32 edi;         // r31
        int edx;         // r26
        __size32 esi;         // r30
        int esp;         // r28
        unsigned int *esp_1;         // r28
        union { __size32 * x2283; int x2284; } esp_2;         // r28
        union { __size32 * x2285; int x2286; } esp_3;         // r28
        union { __size32 * x2283; int x2284; } esp_4;         // r28
        union { __size32 * x1137; int x1138; } esp_5;         // r28
        int esp_6;         // r28{165}
        int esp_7;         // r28{7}
        __size32 local0;         // m[esp - 4]
        int local1;         // m[esp - 4]{247}
        int local2;         // %flags{149}
        int local3;         // %flags{142}
        int local4;         // %ZF{149}
        int local5;         // %ZF{142}
        int local6;         // %CF{149}
        int local7;         // %CF{142}
        unsigned int local8;         // eax_1{301}
    
        esp_7 = (esp - 4 & 0xfffffff8) - 876;
        *(int*)(esp_7 + 872) = global0 ^ esp_7;
        *(__size32*)(esp_7 - 4) = param3;
        *(__size32*)(esp_7 - 8) = param4;
        *(__size32*)(esp_7 - 12) = param5;
        al = (unsigned char) esp_7 + 7;
        ax = (unsigned short) esp_7 + 7;
        *(__size32*)(esp_7 - 16) = esp_7 + 7;
        GetCurrentProcess();
        *(__size32*)(esp_7 - 20) = eax;
        IsWow64Process();
        *(__size32*)(esp_7 - 24) = esp_7 + 92;
        *(__size32*)(esp_7 - 28) = 256;
        GetCurrentDirectoryA();
        tmpb = *(esp_7 - 9);
        if (*(esp_7 - 9) == 0) {
            ecx = esp_7 + 84;
            *(__size32*)(esp_7 - 32) = esp_7 + 84;
            *(__size32*)(esp_7 - 36) = 0x402198;
            *(__size32*)(esp_7 - 40) = 256;
            edx = esp_7 + 340;
            *(__size32*)(esp_7 - 44) = esp_7 + 340;
        } else {
            edx = esp_7 + 84;
            *(__size32*)(esp_7 - 32) = esp_7 + 84;
            *(__size32*)(esp_7 - 36) = 0x402184;
            *(__size32*)(esp_7 - 40) = 256;
            eax = esp_7 + 340;
            al = (unsigned char) esp_7 + 340;
            ax = (unsigned short) esp_7 + 340;
            *(__size32*)(esp_7 - 44) = esp_7 + 340;
        }
        (*sprintf_s)(ebp, ax, param1, al, param2, eax, ecx, edx, param3, esp - 4, param4, sprintf_s, SUBFLAGS8(*(esp_7 - 9), 0, tmpb), tmpb == 0, *(esp_7 - 9) < 0);
        *(__size32*)(esp + 12) = 68;
        *(__size32*)(esp + 8) = 0;
        *(void **)(esp + 4) = esp + 56;
        memset(*(esp + 4), *(esp + 8), *(esp + 12));
        *(void **)(esp + 12) = esp + 40;
        *(void **)(esp + 8) = esp + 56;
        *(__size32*)(esp + 4) = 0;
        *(unsigned int*)esp = 0;
        local0 = 0x4000000;
        *(__size32*)(esp - 8) = 0;
        *(__size32*)(esp - 12) = 0;
        *(__size32*)(esp - 16) = 0;
        *(__size32*)(esp - 20) = 0;
        *(__size32*)(esp + 40) = 0;
        *(__size32*)(esp + 44) = 0;
        *(__size32*)(esp + 48) = 0;
        *(__size32*)(esp + 52) = 0;
        *(void **)(esp - 24) = esp + 384;
        *(__size32*)(esp + 56) = 68;
        CreateProcessA();
        ecx = *esp;
        *(unsigned int*)(esp - 28) = ecx;
        (*CloseHandle)(local0, (unsigned short) esp + 384, dx, (unsigned char) esp + 384, cl, bl, eax, ecx, edx, ebx, ebp, CloseHandle, edi, <all>, LOGICALFLAGS32(0), LOGICALFLAGS32(0), LOGICALFLAGS32(0));
        edx = *(esp + 28);
        local0 = edx;
        (*esi)(local0, ax, dx, al, cl, bl, eax, ecx, edx, ebx, ebp, esi, edi, <all>, local3, local5, local7);
        local0 = esp + 112;
        *(__size32*)(esp - 8) = 0x4021ac;
        *(__size32*)(esp - 12) = 256;
        *(void **)(esp - 16) = esp + 624;
        (*edi)(local0, (unsigned short) esp + 112, dx, (unsigned char) esp + 112, cl, bl, esp + 112, esp + 624, edx, ebx, ebp, esi, edi, <all>, local2, local4, local6);
        local8 = eax_1;
        edi = timeGetTime;
        esp = esp_6 + 16;
        *(__size8*)(esp_6 + 34) = 0;
        *(__size8*)(esp_6 + 33) = 0;
        *(__size32*)(esp_6 + 36) = 0;
        esi = 0;
        for(;;) {
    L19:
            eax_1 = local8;
            esp = esp - 4;
            proc10();
            if (eax_1 == 0) {
                *(__size8*)(esp + 14) = 0;
            } else {
                if (*(esp + 14) == 0) {
                    *(__size32*)(esp - 8) = 0x9c4;
                    Sleep(*(esp - 8));
                    *(void **)(esp - 8) = esp + 620;
                    proc11(param1, param2, eax_1, edi);
                    esp = esp - 8;
                }
                *(__size8*)(esp + 18) = 1;
            }
            local0 = 100;
            Sleep(*(esp - 4));
            bl = *(esp + 17);
            local0 = 57;
            GetKeyState();
            *(char*)(esp + 13) = (unsigned char) eax & 0x1;
            (*edi)(local0, ax / 0x8000 >> 8 & 0xff | ((unsigned char) eax & 0x1), dx_1, (unsigned char) eax & 0x1, cl_1, bl, (eax >> 16 & 0xffff | (ax / 0x8000)) >> 8 & 0xffffff | ((unsigned char) eax & 0x1), ecx, edx, eax_1 >> 8 & 0xffffff | (bl), ebp, esi, edi, <all>, LOGICALFLAGS8((unsigned char) eax & 0x1), LOGICALFLAGS8((unsigned char) eax & 0x1), LOGICALFLAGS8((unsigned char) eax & 0x1));
            local8 = eax_1;
            local8 = eax_1;
            if (eax_1 < esi + 500) {
                break;
            }
            *(__size32*)(esp + 20) = 0;
            (*edi)(local0, ax, dx, al, cl, bl, eax_1, esi + 500, edx, ebx, ebp, esi, edi, <all>, SUBFLAGS32(eax_1, esi + 500, eax_1 - esi - 500), eax_1 - esi - 500 == 0, eax_1 < esi + 500);
            local8 = eax_1;
            esi = eax_1;
        }
        if (bl == 0) {
            goto L19;
        }
        tmpb = *(esp + 17);
        if (*(esp + 17) != 0) {
            goto L19;
        }
        (*edi)(local0, ax, dx, al, cl, bl, eax_1, esi + 500, edx, ebx, ebp, esi, edi, <all>, SUBFLAGS8(*(esp + 17), 0, tmpb), tmpb == 0, *(esp + 17) < 0);
        esi = eax;
        eax = *(esp + 20);
        eax_2 = eax + 1;
        ax = (unsigned short) eax + 1;
        *(__size32*)(esp + 20) = eax + 1;
        local8 = eax_2;
        if (eax + 1 < 3) {
            goto L19;
        }
        ecx = *(esp + 884);
        edi = *esp;
        esi = *(esp + 4);
        ebx = *(esp + 8);
        proc12(local1, 0, dx, 0, cl, (unsigned char) ebx, 0, ecx ^ esp + 12, edx, ebx, ebp, esi, edi, <all>, LOGICALFLAGS32(0), LOGICALFLAGS32(0), LOGICALFLAGS32(0));
        return;
    }
    
    // address: 0x4011b0
    void proc10() {
        __size32 eax;         // r24
        union { void * x3473; int x3474; } eax_1;         // r24
        int ebp;         // r29
        void *ebp_1;         // r29
        union { void * x971; int x972; } ebp_2;         // r29
        union { void * x971; int x972; } ebp_3;         // r29
        __size32 ebx;         // r27
        int ecx;         // r25
        __size32 edi;         // r31
        int edx;         // r26
        __size32 esi;         // r30
        int esp;         // r28
        __size32 *esp_1;         // r28
        __size32 esp_2;         // r28{62}
        unsigned int local0;         // m[esp - 344]
        __size32 local1;         // m[esp - 340]
        int local10;         // m[esp - 8]
        __size32 local11;         // m[esp - 4]
        union { void * x3447; int x3448; } local12;         // m[esp_2 + 20]{71}
        union { void * x3447; int x3448; } local13;         // m[esp_2 + 20]{71}
        unsigned int local14;         // m[esp_2 + 20]{124}
        __size32 local15;         // m[esp_2 + 20]{104}
        __size32 local16;         // m[esp - 4]{167}
        int local17;         // m[esp - 4]{62}
        int local18;         // m[esp - 8]{168}
        int local19;         // m[esp - 8]{62}
        int local2;         // m[esp - 336]
        __size32 local20;         // m[esp - 308]{169}
        int local21;         // m[esp - 308]{62}
        __size32 local22;         // m[esp - 312]{170}
        int local23;         // m[esp - 312]{62}
        __size32 local24;         // m[esp - 316]{171}
        int local25;         // m[esp - 316]{62}
        __size32 local26;         // m[esp - 320]{172}
        int local27;         // m[esp - 320]{62}
        __size32 local28;         // m[esp - 324]{173}
        int local29;         // m[esp - 324]{62}
        __size32 local3;         // m[esp - 332]
        __size32 local30;         // m[esp - 328]{174}
        int local31;         // m[esp - 328]{62}
        __size32 local32;         // m[esp - 332]{175}
        int local33;         // m[esp - 332]{62}
        int local34;         // m[esp - 336]{176}
        int local35;         // m[esp - 336]{62}
        __size32 local36;         // m[esp - 340]{177}
        int local37;         // m[esp - 340]{62}
        unsigned int local38;         // m[esp - 344]{178}
        int local39;         // m[esp - 344]{62}
        __size32 local4;         // m[esp - 328]
        int local40;         // %flags{140}
        int local41;         // %flags{54}
        int local42;         // %flags{54}
        int local43;         // %flags{37}
        int local44;         // %flags{80}
        int local45;         // %ZF{141}
        int local46;         // %ZF{54}
        int local47;         // %ZF{54}
        int local48;         // %ZF{37}
        int local49;         // %ZF{80}
        __size32 local5;         // m[esp - 324]
        int local50;         // %CF{142}
        int local51;         // %CF{54}
        int local52;         // %CF{54}
        int local53;         // %CF{37}
        int local54;         // %CF{80}
        int local55;         // local40{140}
        int local56;         // local45{141}
        int local57;         // local50{142}
        __size32 local6;         // m[esp - 320]
        __size32 local7;         // m[esp - 316]
        __size32 local8;         // m[esp - 312]
        __size32 local9;         // m[esp - 308]
    
        ebp = esp - 4;
        CreateToolhelp32Snapshot();
        Process32First();
        local43 = LOGICALFLAGS32(eax);
        local55 = local43;
        local56 = local48;
        local57 = local53;
        if (eax != 0) {
            esi = sprintf_s;
            edi = _stricmp;
            ebx = Process32Next;
            do {
                local40 = local55;
                local45 = local56;
                local50 = local57;
                local11 = ebp - 268;
                local10 = 0x402180;
                *(__size32*)(esp - 12) = 256;
                *(__size32*)(esp - 16) = 0x403370;
                (*esi)(*(esp - 344), *(esp - 340), *(esp - 336), *(esp - 332), *(esp - 328), *(esp - 324), *(esp - 320), *(esp - 316), *(esp - 312), *(esp - 308), *(esp - 8), *(esp - 4), eax, ecx, ebp - 268, ebx, ebp, esi, edi, local40, local45, local50);
                local11 = 0x4021c8;
                local10 = 0x403370;
                (*edi)(*(esp - 344), *(esp - 340), *(esp - 336), *(esp - 332), *(esp - 328), *(esp - 324), *(esp - 320), *(esp - 316), *(esp - 312), *(esp - 308), *(esp - 8), *(esp - 4), eax, ecx, edx, ebx, ebp, esi, edi, <all>, local41, local46, local51);
                if (eax == 0) {
                    edx = *(ebp_1 - 296);
                    local15 = edx;
                    *(__size32*)(esp_2 + 16) = 1;
                    *(__size32*)(esp_2 + 12) = 0x1f0fff;
                    OpenProcess();
                    ecx = *(ebp_1 - 4);
                    edi = *(esp_2 + 12);
                    esi = *(esp_2 + 16);
                    ebx = *(esp_2 + 20);
                    proc12(local39, local37, local35, local33, local31, local29, local27, local25, local23, local21, local19, local17, eax, ecx ^ ebp_1, edx, ebx, ebp_1, esi, edi, <all>, LOGICALFLAGS32(ecx ^ ebp_1), LOGICALFLAGS32(ecx ^ ebp_1), LOGICALFLAGS32(ecx ^ ebp_1));
                }
                ecx = *(ebp_1 - 308);
                local12 = ebp_1 - 304;
                *(__size32*)(esp_2 + 16) = ecx;
                (*ebx)(*(esp - 344), *(esp - 340), *(esp - 336), *(esp - 332), *(esp - 328), *(esp - 324), *(esp - 320), *(esp - 316), *(esp - 312), *(esp - 308), *(esp - 8), *(esp - 4), ebp_1 - 304, ecx, edx, ebx, ebp_1, esi, edi, <all>, LOGICALFLAGS32(eax), LOGICALFLAGS32(eax), LOGICALFLAGS32(eax));
                local44 = LOGICALFLAGS32(eax);
                local55 = local44;
                local56 = local49;
                local57 = local54;
            } while (eax != 0);
        }
        ebp_2 = ebp;
        edi = *esp;
        esi = *(esp + 4);
        ebx = *(esp + 8);
        ecx = *(ebp_2 - 4);
        proc12(*(esp - 344), *(esp - 340), *(esp - 336), *(esp - 332), *(esp - 328), *(esp - 324), *(esp - 320), *(esp - 316), *(esp - 312), *(esp - 308), *(esp - 8), *(esp - 4), 0, ecx ^ ebp_2, edx, ebx, ebp_2, esi, edi, LOGICALFLAGS32(ecx ^ ebp_2), LOGICALFLAGS32(ecx ^ ebp_2), LOGICALFLAGS32(ecx ^ ebp_2));
    }
    
    // address: 0x401000
    void proc11(short param1, unsigned char param2, __size32 param3, unsigned int param4) {
        unsigned char cl;         // r9
        short dx;         // r2
        __size32 eax;         // r24
        __size32 eax_1;         // r24{217}
        __size32 eax_2;         // r24{163}
        int eax_3;         // r24{152}
        int eax_4;         // r24{135}
        __size32 eax_5;         // r24{95}
        __size32 eax_6;         // r24{86}
        HANDLE eax_7;         // r24{77}
        __size32 ebp;         // r29
        int ecx;         // r25
        unsigned int edi;         // r31
        int edx;         // r26
        HANDLE edx_1;         // r26{175}
        unsigned int esi;         // r30
        __size32 esi_1;         // r30{241}
        unsigned int esi_2;         // r30{39}
        int esp;         // r28
        unsigned int *esp_1;         // r28
        int esp_2;         // r28{137}
        int esp_3;         // r28{163}
        int esp_4;         // r28{152}
        int esp_5;         // r28{270}
        unsigned int local0;         // m[esp - 0x44c]
        unsigned int local1;         // m[esp - 0x448]
        int local10;         // m[esp - 0x424]
        __size32 local11;         // m[esp - 0x420]
        __size32 local12;         // m[esp - 0x41c]
        unsigned int local13;         // m[esp - 0x418]
        unsigned int local2;         // m[esp - 0x444]
        __size32 local21;         // m[esp + 4]
        __size8 local22;         // m[esp - 0x3f8]
        __size32 local23;         // m[esp - 0x3f7]
        __size16 local24;         // m[esp - 0x3f3]
        __size32 local25;         // m[esp - 0x3f1]
        __size8 local26;         // m[esp - 0x3ed]
        __size32 local27;         // m[esp - 0x3ec]
        __size16 local28;         // m[esp - 1000]
        __size32 local29;         // m[esp - 998]
        unsigned int local3;         // m[esp - 0x440]
        __size32 local30;         // m[esp - 994]
        __size32 local31;         // m[esp - 990]
        __size32 local32;         // m[esp - 724]
        __size32 local33;         // m[esp - 540]
        int local4;         // m[esp - 0x43c]
        short local40;         // param1{251}
        unsigned int local41;         // param4{259}
        unsigned char local42;         // param2{266}
        int local43;         // esp_5{270}
        __size32 local5;         // m[esp - 0x438]
        __size32 local6;         // m[esp - 0x434]
        int local7;         // m[esp - 0x430]
        __size32 local8;         // m[esp - 0x42c]
        __size32 local9;         // m[esp - 0x428]
    
        VirtualAllocEx();
        local40 = param1;
        local41 = param4;
        local42 = param2;
        local42 = param2;
        if (eax == 0) {
    L0:
            param1 = local40;
            param4 = local41;
            esi_2 = *esp_1;
            proc12(local0, local1, local2, local3, local4, local5, local6, local7, local8, local9, local10, local11, local12, local13, param3, 0, 291, 0x1000, 64, esi, local21, local22, local23, local24, local25, local26, local27, local28, local29, local30, local31, local32, local33, global0 ^ esp - 4, ebp, local21, param1, 0, param2, 0, global0 ^ esp - 4 ^ esp - 4, edx, param3, esp - 4, esi_2, param4, LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4), LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4), LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4));
        }
        GetModuleHandleA();
        GetProcAddress(eax_7, "LoadLibraryA");
        GetProcAddress(eax_7, "ExitThread");
        lstrcpyA();
        WriteProcessMemory();
        dx = (unsigned short) global32;
        GetThreadContext();
        edi = global32;
        esp_2 = esp - 1084;
        local41 = edi;
        local43 = esp_2;
        if (eax_4 != 0) {
            SetThreadContext();
            local43 = esp_4;
            if (eax_3 != 0) {
                dx = (unsigned short) global32;
                ResumeThread();
                local43 = esp_3;
                cl =  (eax_2 != -1) ? 1 : 0;
                ecx = 0 >> 8 & 0xffffff | (cl);
                local42 = cl;
                if (ecx != 0) {
                    edx_1 = *0x40336c;
                    WaitForSingleObject(edx_1, -1);
                    proc12(pc, edx_1, -1, pc, global32, esp - 724, esp - 724, param3, eax, esp - 1016, 291, 0, (esp - 986), local21, 0x402154, param4, param3, 0, 291, 0x1000, 64, esi, local21, 104, eax + 30, 0x15ff, eax + 22, 104, 0, 0x15ff, eax + 26, eax_6, eax_5, 0x10007, eax, global0 ^ esp - 4, ebp, local21, (unsigned short) edx_1, 1, cl, 1, global0 ^ esp - 4 ^ esp - 4, edx, param3, esp - 4, global32, global32, LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4), LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4), LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4));
                }
            }
        }
        param2 = local42;
        esp_5 = local43;
        *(__size32*)(esp_5 - 4) = 0;
        *(__size32*)(esp_5 - 8) = 0;
        *(__size32*)(esp_5 - 12) = 0;
        *(__size32*)(esp_5 - 16) = eax;
        *(__size32*)(esp_5 - 20) = 0;
        *(__size32*)(esp_5 - 24) = 0;
        *(__size32*)(esp_5 - 28) = param3;
        CreateRemoteThread();
        local40 = dx;
        if (eax_1 != 0) {
            *(__size32*)(esp_5 - 32) = -1;
            *(__size32*)(esp_5 - 36) = eax_1;
            WaitForSingleObject(*(esp_5 - 36), *(esp_5 - 32));
            *(__size32*)(esp_5 - 32) = eax_1;
            CloseHandle(*(esp_5 - 32));
            esi_1 = *(esp_5 - 28);
            proc12(local0, local1, local2, local3, esp - 724, param3, eax, esp - 1016, 291, 0, esp - 986, local21, 0x402154, param4, param3, 0, 291, 0x1000, 64, esi, local21, 104, eax + 30, 0x15ff, eax + 22, 104, 0, 0x15ff, eax + 26, eax_6, eax_5, 0x10007, local33, global0 ^ esp - 4, ebp, local21, dx, 1, param2, 1, global0 ^ esp - 4 ^ esp - 4, edx, param3, esp - 4, esi_1, global32, LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4), LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4), LOGICALFLAGS32(global0 ^ esp - 4 ^ esp - 4));
        }
        goto L0;
    }
    
    // address: 0x401443
    void proc12(__size32 param1, __size32 param2, __size32 param3, __size32 param4, __size32 param5, __size32 param6) {
        if (param2 != *0x403000) {
        }
        global21 = param1;
        global22 = param2;
        global23 = param3;
        global24 = param4;
        global25 = param5;
        global26 = param6;
    }
    
    // address: 0x4019a0
    int proc13(__size16 *param1) {
        unsigned char dl;         // r10
        int eax;         // r24
        int edx;         // r26
    
        if (*param1 == 0x5a4d) {
            eax = *(param1 + 60);
            if (*(eax + param1) != 0x4550) {
    L1:
                eax = 0;
            } else {
                dl =  (*(eax + param1 + 24) == 267) ? 1 : 0;
                edx = 0 >> 8 & 0xffffff | (dl);
                eax = edx;
            }
        } else {
            goto L1;
        }
        return eax;
    }
    
    // address: 0x4019e0
    __size32 proc14(__size32 param1, unsigned int param2, unsigned int param3) {
        unsigned int eax;         // r24
        unsigned int ebx;         // r27
        unsigned int ebx_1;         // r27{66}
        __size32 ecx;         // r25
        __size32 edx;         // r26
        __size32 edx_1;         // r26{60}
        unsigned int esi;         // r30
        unsigned int local0;         // param3{61}
        unsigned int local1;         // ebx_1{66}
    
        ecx = *(param1 + 60);
        eax = *(unsigned short*)(ecx + param1 + 20);
        esi = *(unsigned short*)(ecx + param1 + 6);
        edx = 0;
        eax = eax + ecx + param1 + 24;
        local0 = param3;
        if (esi == 0) {
    L1:
            eax = 0;
        } else {
            do {
                edx_1 = edx;
                param3 = local0;
                ecx = *(eax + 12);
                local1 = param3;
                if (param2 >= ecx) {
                    ebx = *(eax + 8);
                    ebx_1 = ebx + ecx;
                    local1 = ebx_1;
                    if (param2 < ebx + ecx) {
                        goto L0;
                    }
                    goto L2;
                }
    L2:
                ebx_1 = local1;
                edx = edx_1 + 1;
                eax += 40;
                local0 = ebx_1;
            } while (edx_1 + 1 < esi);
            goto L1;
        }
    L0:
        return eax;
    }

  2. #2

    Re: Help with source code?

    You're playing way outside the sandbox on this one. You need to know what you're doing first before you start trying to make a hack.

    Take a few C and C++ classes and then try again. You'll understand it all then.


Similar Threads

  1. Replies: 1
    Last Post: April 29th, 2011, 17:33
  2. oldskool source code?
    By marcus008 in forum Enemy Territory Cheats
    Replies: 6
    Last Post: June 23rd, 2009, 15:55
  3. eth 32 source code problem
    By King-OrgY in forum Basehooks / Sources
    Replies: 4
    Last Post: September 20th, 2007, 01:02

Bookmarks

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •