API tools faq
paste
Guest User

darkfate

a guest
May 11th, 2008
595
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 16.64 KB | None | 0 0
raw download clone embed print report
  1. #include <windows.h>
  2. #include <defs.h>
  3.  
  4.  
  5. //-------------------------------------------------------------------------
  6. // Data declarations
  7.  
  8. extern int dword_10007100[]; // idb
  9. extern int dword_10007148[]; // idb
  10. extern int dword_10008148[64]; // weak
  11. extern int dword_10008ECC[2]; // weak
  12. extern int dword_10008ED4; // weak
  13. extern char LibFileName[]; // idb
  14. extern char Str2[]; // idb
  15. extern int dword_1000A050; // weak
  16. extern int len; // idb
  17. extern int dword_1000A2EC; // weak
  18. extern int dword_1000A2F0; // weak
  19. extern char byte_1000A504; // weak
  20. extern char byte_1000A520[]; // idb
  21. extern int dword_1000A620[632]; // weak
  22. extern char byte_1004A720[]; // idb
  23. extern char byte_1008A720; // weak
  24. extern char buf[]; // idb
  25. extern int dword_1009A741; // weak
  26. extern char byte_1009A745; // weak
  27. extern __int16 word_1009A746; // weak
  28. extern int dword_1009A748[16901]; // weak
  29. extern int (__stdcall *dword_100AB2D8)(_DWORD, _DWORD, _DWORD); // idb
  30.  
  31. //-------------------------------------------------------------------------
  32. // Function declarations
  33.  
  34. signed int __stdcall sub_10001000(int a1, int a2, unsigned int a3, int a4, signed int a5);
  35. int __stdcall sub_100012F0(int a1, int *a2, int *a3);
  36. int __stdcall sub_100013A0(int a1, unsigned int a2);
  37. int __stdcall sub_10001440(int a1, int *a2, int *a3);
  38. int __stdcall sub_100014F0(int a1, int a2, signed int a3);
  39. void __cdecl dummyfunc();
  40. BOOL __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved); // idb
  41. void *__cdecl sub_10001710();
  42. int __stdcall sub_10001760(unsigned __int16 a1);
  43. bool __stdcall sub_100018B0(char a1);
  44. bool __cdecl sub_10001930();
  45. void *__stdcall sub_10001950(HMODULE hModule, LPCSTR Str1); // idb
  46. int __stdcall sub_100019A0(SOCKET s, struct sockaddr *name, int namelen); // idb
  47. int __stdcall sub_100019D0(SOCKET s, int a2, int a3, int a4); // idb
  48. signed int __stdcall sub_10001E50(LPVOID lpAddress, int a2, DWORD dwSize); // idb
  49. // int __stdcall connect(SOCKET s, const struct sockaddr *name, int namelen); idb
  50. // int __stdcall send(SOCKET s, const char *buf, int len, int flags); idb
  51. // void *__cdecl memcpy(void *Dst, const void *Src, size_t Size); idb
  52. int __cdecl sub_1000225D(int a1);
  53. // int __cdecl rand(); idb
  54. // _DWORD __stdcall _CRT_INIT(_DWORD, _DWORD, _DWORD); weak
  55. // BOOL __stdcall DllEntryPoint(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved); idb
  56. void __cdecl sub_10002D32();
  57. void __cdecl sub_10002D76(); // idb
  58. signed int __cdecl sub_10004ED1();
  59. // int __cdecl _stricmp(const char *Str1, const char *Str2); idb
  60. // FARPROC __stdcall GetProcAddress(HMODULE hModule, LPCSTR lpProcName); idb
  61. // HMODULE __stdcall LoadLibraryA(LPCSTR lpLibFileName); idb
  62. // void __stdcall Sleep(DWORD dwMilliseconds); idb
  63. // DWORD __stdcall GetTickCount(); idb
  64. // BOOL __stdcall VirtualProtect(LPVOID lpAddress, DWORD dwSize, DWORD flNewProtect, PDWORD lpflOldProtect); idb
  65.  
  66.  
  67. //----- (10001000) --------------------------------------------------------
  68. signed int __stdcall sub_10001000(int a1, int a2, unsigned int a3, int a4, signed int a5)
  69. {
  70.   signed int result; // eax@2
  71.   char v6; // [sp+14h] [bp-1048h]@7
  72.   int v7; // [sp+8h] [bp-1054h]@7
  73.   unsigned int v8; // [sp+Ch] [bp-1050h]@7
  74.   int Dst; // [sp+0h] [bp-105Ch]@9
  75.   int Src; // [sp+4h] [bp-1058h]@9
  76.   size_t Size; // [sp+10h] [bp-104Ch]@9
  77.  
  78.   if ( a1 )
  79.   {
  80.     if ( a2 )
  81.     {
  82.       if ( a4 )
  83.       {
  84.         sub_100014F0((int)&v6, a4, a5);
  85.         v7 = 0;
  86.         v8 = 0;
  87.         while ( v8 < a3 )
  88.         {
  89.           Dst = 0;
  90.           Src = 0;
  91.           Size = 4;
  92.           if ( a3 - v8 < 4 )
  93.             Size = a3 - v8;
  94.           memcpy(&Dst, (const void *)(v8 + a1), Size);
  95.           v8 += 4;
  96.           Size = 4;
  97.           if ( a3 - v8 < 4 )
  98.             Size = a3 - v8;
  99.           memcpy(&Src, (const void *)(v8 + a1), Size);
  100.           v8 += 4;
  101.           sub_100012F0((int)&v6, &Dst, &Src);
  102.           memcpy((void *)(v7 + a2), &Dst, 4u);
  103.           v7 += 4;
  104.           memcpy((void *)(v7 + a2), &Src, 4u);
  105.           v7 += 4;
  106.         }
  107.         result = 0;
  108.       }
  109.       else
  110.       {
  111.         result = -1;
  112.       }
  113.     }
  114.     else
  115.     {
  116.       result = -1;
  117.     }
  118.   }
  119.   else
  120.   {
  121.     result = -1;
  122.   }
  123.   return result;
  124. }
  125.  
  126. //----- (100012F0) --------------------------------------------------------
  127. int __stdcall sub_100012F0(int a1, int *a2, int *a3)
  128. {
  129.   int result; // eax@4
  130.   int v4; // [sp+0h] [bp-10h]@1
  131.   int v5; // [sp+4h] [bp-Ch]@1
  132.   __int16 v6; // [sp+Ch] [bp-4h]@1
  133.   int v7; // [sp+8h] [bp-8h]@3
  134.  
  135.   v4 = *a2;
  136.   v5 = *a3;
  137.   v6 = 0;
  138.   while ( v6 < 16 )
  139.   {
  140.     v4 ^= *(_DWORD *)(a1 + 4 * v6);
  141.     v7 = v4;
  142.     v4 = v5 ^ sub_100013A0(a1, v4);
  143.     v5 = v7;
  144.     ++v6;
  145.   }
  146.   v7 = v4;
  147.   v4 = v5;
  148.   v5 = v7;
  149.   v5 = *(_DWORD *)(a1 + 64) ^ v7;
  150.   v4 ^= *(_DWORD *)(a1 + 68);
  151.   *a2 = v4;
  152.   result = v5;
  153.   *a3 = v5;
  154.   return result;
  155. }
  156.  
  157. //----- (100013A0) --------------------------------------------------------
  158. int __stdcall sub_100013A0(int a1, unsigned int a2)
  159. {
  160.   unsigned __int16 v3; // [sp+4h] [bp-10h]@1
  161.   unsigned __int16 v4; // [sp+0h] [bp-14h]@1
  162.   unsigned __int16 v5; // [sp+8h] [bp-Ch]@1
  163.   __int16 v6; // [sp+Ch] [bp-8h]@1
  164.   int v7; // [sp+10h] [bp-4h]@1
  165.  
  166.   v3 = (unsigned __int8)a2;
  167.   a2 >>= 8;
  168.   v4 = (unsigned __int8)a2;
  169.   a2 >>= 8;
  170.   v5 = (unsigned __int8)a2;
  171.   a2 >>= 8;
  172.   v6 = (unsigned __int8)a2;
  173.   v7 = *(_DWORD *)(a1 + 4 * v5 + 1096) + *(_DWORD *)(a1 + 4 * (unsigned __int8)a2 + 72);
  174.   v7 ^= *(_DWORD *)(a1 + 4 * v4 + 2120);
  175.   v7 += *(_DWORD *)(a1 + 4 * v3 + 3144);
  176.   return v7;
  177. }
  178.  
  179. //----- (10001440) --------------------------------------------------------
  180. int __stdcall sub_10001440(int a1, int *a2, int *a3)
  181. {
  182.   int result; // eax@4
  183.   int v4; // [sp+0h] [bp-10h]@1
  184.   int v5; // [sp+4h] [bp-Ch]@1
  185.   __int16 v6; // [sp+Ch] [bp-4h]@1
  186.   int v7; // [sp+8h] [bp-8h]@3
  187.  
  188.   v4 = *a2;
  189.   v5 = *a3;
  190.   v6 = 17;
  191.   while ( v6 > 1 )
  192.   {
  193.     v4 ^= *(_DWORD *)(a1 + 4 * v6);
  194.     v7 = v4;
  195.     v4 = v5 ^ sub_100013A0(a1, v4);
  196.     v5 = v7;
  197.     --v6;
  198.   }
  199.   v7 = v4;
  200.   v4 = v5;
  201.   v5 = v7;
  202.   v5 = *(_DWORD *)(a1 + 4) ^ v7;
  203.   v4 ^= *(_DWORD *)a1;
  204.   *a2 = v4;
  205.   result = v5;
  206.   *a3 = v5;
  207.   return result;
  208. }
  209.  
  210. //----- (100014F0) --------------------------------------------------------
  211. int __stdcall sub_100014F0(int a1, int a2, signed int a3)
  212. {
  213.   int result; // eax@6
  214.   signed int v4; // [sp+18h] [bp-4h]@1
  215.   signed int v5; // [sp+4h] [bp-18h]@3
  216.   int v6; // [sp+8h] [bp-14h]@9
  217.   signed int v7; // [sp+Ch] [bp-10h]@9
  218.   int v8; // [sp+10h] [bp-Ch]@15
  219.   int v9; // [sp+14h] [bp-8h]@15
  220.  
  221.   v4 = 0;
  222.   while ( v4 < 4 )
  223.   {
  224.     v5 = 0;
  225.     while ( v5 < 256 )
  226.     {
  227.       *(_DWORD *)(a1 + (v4 << 10) + 72 + 4 * v5) = *(int *)((char *)&dword_10007148[256 * v4] + 4 * v5);
  228.       ++v5;
  229.     }
  230.     result = v4++ + 1;
  231.   }
  232.   v5 = 0;
  233.   v4 = 0;
  234.   while ( v4 < 18 )
  235.   {
  236.     v6 = 0;
  237.     v7 = 0;
  238.     while ( v7 < 4 )
  239.     {
  240.       v6 = *(_BYTE *)(v5++ + a2) | (v6 << 8);
  241.       if ( v5 >= a3 )
  242.         v5 = 0;
  243.       ++v7;
  244.     }
  245.     *(_DWORD *)(a1 + 4 * v4) = v6 ^ dword_10007100[v4];
  246.     result = v4++ + 1;
  247.   }
  248.   v8 = 0;
  249.   v9 = 0;
  250.   v4 = 0;
  251.   while ( v4 < 18 )
  252.   {
  253.     sub_100012F0(a1, &v8, &v9);
  254.     *(_DWORD *)(a1 + 4 * v4) = v8;
  255.     result = v4;
  256.     *(_DWORD *)(a1 + 4 * v4 + 4) = v9;
  257.     v4 += 2;
  258.   }
  259.   v4 = 0;
  260.   while ( v4 < 4 )
  261.   {
  262.     v5 = 0;
  263.     while ( v5 < 256 )
  264.     {
  265.       sub_100012F0(a1, &v8, &v9);
  266.       *(_DWORD *)(a1 + (v4 << 10) + 72 + 4 * v5) = v8;
  267.       *(_DWORD *)(a1 + (v4 << 10) + 72 + 4 * v5 + 4) = v9;
  268.       v5 += 2;
  269.     }
  270.     result = v4++ + 1;
  271.   }
  272.   return result;
  273. }
  274.  
  275. //----- (100016B0) --------------------------------------------------------
  276. void __cdecl dummyfunc()
  277. {
  278.   ;
  279. }
  280.  
  281. //----- (100016C0) --------------------------------------------------------
  282. BOOL __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  283. {
  284.   DWORD v4; // [sp+0h] [bp-Ch]@1
  285.  
  286.   v4 = fdwReason;
  287.   if ( fdwReason == 1 )
  288.   {
  289.     sub_10001E50((LPVOID)0x6B9274, (int)sub_10001950, 4u);
  290.     sub_10001E50((LPVOID)0x6B9444, (int)sub_100019A0, 4u);
  291.   }
  292.   return 1;
  293. }
  294.  
  295. //----- (10001710) --------------------------------------------------------
  296. void *__cdecl sub_10001710()
  297. {
  298.   dword_1000A2EC = 0;
  299.   byte_1008A720 = 0;
  300.   byte_1000A504 = 0;
  301.   memcpy(byte_1000A520, dword_10008148, 0x100u);
  302.   return memcpy(dword_1000A620, dword_10008148, 0x100u);
  303. }
  304.  
  305. //----- (10001760) --------------------------------------------------------
  306. int __stdcall sub_10001760(unsigned __int16 a1)
  307. {
  308.   int result; // eax@1
  309.   int v2; // [sp+4h] [bp-Ch]@1
  310.   bool v3; // [sp+8h] [bp-8h]@1
  311.   signed int v4; // [sp+Ch] [bp-4h]@1
  312.   int v5; // [sp+0h] [bp-10h]@3
  313.  
  314.   result = a1 % 4;
  315.   v2 = a1 % 4;
  316.   v3 = (unsigned __int8)byte_1000A504 == 0;
  317.   v4 = 0;
  318.   while ( v4 < 256 )
  319.   {
  320.     result = v2;
  321.     v5 = v2;
  322.     if ( (unsigned int)v2 <= 3 )
  323.     {
  324.       switch ( v5 )
  325.       {
  326.         case 0:
  327.           *(&byte_1000A520[256 * v3] + v4) += a1;
  328.           result = v2++ + 1;
  329.           break;
  330.         case 1:
  331.           result = *(&byte_1000A520[256 * v3] + v4) - a1;
  332.           *(&byte_1000A520[256 * v3] + v4) -= a1;
  333.           ++v2;
  334.           break;
  335.         case 2:
  336.           result = v4;
  337.           *(&byte_1000A520[256 * v3] + v4) += a1;
  338.           ++v2;
  339.           break;
  340.         case 3:
  341.           result = v3 << 8;
  342.           *(&byte_1000A520[256 * v3] + v4) -= a1;
  343.           v2 = 0;
  344.           break;
  345.       }
  346.     }
  347.     ++v4;
  348.   }
  349.   return result;
  350. }
  351.  
  352. //----- (100018B0) --------------------------------------------------------
  353. bool __stdcall sub_100018B0(char a1)
  354. {
  355.   bool result; // eax@1
  356.   bool v2; // [sp+0h] [bp-4h]@1
  357.  
  358.   v2 = (unsigned __int8)byte_1000A504 == 0;
  359.   *(&byte_1000A520[256 * ((unsigned __int8)byte_1000A504 == 0)] + (unsigned __int8)byte_1008A720) = a1 ^ (unsigned __int8)*(&byte_1000A520[256 * ((unsigned __int8)byte_1000A504 == 0)] + (unsigned __int8)byte_1008A720);
  360.   ++byte_1008A720;
  361.   result = (unsigned __int8)byte_1008A720;
  362.   if ( (unsigned __int8)byte_1008A720 == 255 )
  363.   {
  364.     byte_1008A720 = 0;
  365.     result = sub_10001930();
  366.   }
  367.   return result;
  368. }
  369.  
  370. //----- (10001930) --------------------------------------------------------
  371. bool __cdecl sub_10001930()
  372. {
  373.   bool result; // eax@1
  374.  
  375.   result = (unsigned __int8)byte_1000A504 == 0;
  376.   byte_1000A504 = (unsigned __int8)byte_1000A504 == 0;
  377.   return result;
  378. }
  379.  
  380. //----- (10001950) --------------------------------------------------------
  381. void *__stdcall sub_10001950(HMODULE hModule, LPCSTR Str1)
  382. {
  383.   void *result; // eax@3
  384.   HMODULE v3; // eax@1
  385.   HMODULE v4; // [sp+0h] [bp-4h]@1
  386.  
  387.   v3 = LoadLibraryA("WS2_32.DLL");
  388.   v4 = v3;
  389.   if ( hModule != v3 || _stricmp(Str1, "send") )
  390.     result = GetProcAddress(hModule, Str1);
  391.   else
  392.     result = sub_100019D0;
  393.   return result;
  394. }
  395.  
  396. //----- (100019A0) --------------------------------------------------------
  397. int __stdcall sub_100019A0(SOCKET s, struct sockaddr *name, int namelen)
  398. {
  399.   sub_10001710();
  400.   return connect(s, name, namelen);
  401. }
  402.  
  403. //----- (100019D0) --------------------------------------------------------
  404. int __stdcall sub_100019D0(SOCKET s, int a2, int a3, int a4)
  405. {
  406.   int v5; // eax@7
  407.   int v6; // eax@12
  408.   int v7; // eax@2
  409.   DWORD v8; // esi@2
  410.   int v9; // eax@2
  411.   signed int v10; // eax@2
  412.   int v11; // eax@2
  413.   char v12; // bl@4
  414.   int v13; // eax@7
  415.   int v14; // eax@12
  416.   unsigned __int8 v15; // al@14
  417.   int v16; // eax@23
  418.   int v17; // eax@28
  419.   int v18; // [sp+24h] [bp-10h]@2
  420.   __int16 v19; // [sp+28h] [bp-Ch]@2
  421.   int v20; // [sp+2Ah] [bp-Ah]@2
  422.   __int16 v21; // [sp+2Eh] [bp-6h]@2
  423.   int Size; // [sp+20h] [bp-14h]@2
  424.   int v23; // [sp+14h] [bp-20h]@4
  425.   int v24; // [sp+30h] [bp-4h]@4
  426.   char *v25; // [sp+18h] [bp-1Ch]@7
  427.   int v26; // [sp+10h] [bp-24h]@7
  428.   int v27; // [sp+Ch] [bp-28h]@10
  429.   int v28; // [sp+8h] [bp-2Ch]@14
  430.   int v29; // [sp+1Ch] [bp-18h]@23
  431.  
  432.   if ( !dword_1000A2EC )
  433.   {
  434.     v7 = GetTickCount();
  435.     sub_1000225D(v7);
  436.     v18 = rand() + 78319;
  437.     sub_10001930();
  438.     sub_10001760(v18);
  439.     sub_10001930();
  440.     buf[0] = -119;
  441.     dword_1009A741 = v18;
  442.     Sleep(0xAu);
  443.     v8 = GetTickCount();
  444.     v9 = rand();
  445.     sub_1000225D(v9 ^ v8);
  446.     v10 = rand() + 42564;
  447.     v18 = v10;
  448.     v19 = (unsigned __int16)((signed int)(unsigned __int8)rand() >> 5) | (unsigned __int16)(8
  449.                                                                                           * (unsigned __int16)(v10 >> 3));
  450.     sub_1000225D(v18);
  451.     v11 = rand();
  452.     v18 = v11;
  453.     v20 = v11;
  454.     sub_1000225D(8 * *(__int16 *)((char *)&v19 + 1));
  455.     v21 = rand();
  456.     sub_10001000((int)&v19, (int)&byte_1009A745, 8u, (int)byte_1000A520, 256);
  457.     sub_10001930();
  458.     Size = 0;
  459.     while ( Size < 56 )
  460.     {
  461.       v23 = Size % 8;
  462.       v12 = (unsigned __int8)((signed int)*((_BYTE *)&v19 + Size / 8 + 1) >> (8 - Size % 8)) | (unsigned __int8)(*((_BYTE *)&v19 + Size / 8) << Size % 8);
  463.       v24 = (unsigned __int8)v12;
  464.       sub_100018B0(v12);
  465.       ++Size;
  466.     }
  467.     sub_10001930();
  468.     if ( send(s, buf, 13, 0) != 13 )
  469.       return -1;
  470.   }
  471.   v25 = buf;
  472.   buf[0] = (unsigned __int8)(8 * (dword_1000A2EC % 8u & 7)) | (unsigned __int8)(buf[0] & 0xC7);
  473.   v13 = rand();
  474.   v26 = v13;
  475.   v5 = v13 & 0x80000003;
  476.   if ( v5 < 0 )
  477.     v5 = ((v5 - 1) | 0xFFFFFFFC) + 1;
  478.   *v25 = v5 & 3 | (unsigned __int8)(*v25 & 0xFC);
  479.   if ( a3 % 4 )
  480.     v27 = 4 - a3 % 4;
  481.   else
  482.     v27 = 0;
  483.   *v25 = (unsigned __int8)((v27 & 3) << 6) | *v25 & 0x3F;
  484.   v14 = GetTickCount();
  485.   sub_1000225D(v14);
  486.   v6 = rand() & 0x800000FF;
  487.   if ( v6 < 0 )
  488.     v6 = ((v6 - 1) | 0xFFFFFF00) + 1;
  489.   LOBYTE(dword_1009A741) = (unsigned __int8)(*(_BYTE *)a2 ^ 0x36) ^ (_BYTE)v6;
  490.   v15 = *v25 & 3;
  491.   v28 = v15;
  492.   if ( v15 <= 3u )
  493.   {
  494.     switch ( v28 )
  495.     {
  496.       case 0:
  497.         sub_100018B0(dword_1009A741);
  498.         break;
  499.       case 1:
  500.         sub_100018B0(dword_1009A741);
  501.         break;
  502.       case 2:
  503.         sub_100018B0((_BYTE)dword_1009A741 ^ 0x2D);
  504.         break;
  505.       case 3:
  506.         sub_100018B0((unsigned __int8)((signed int)(unsigned __int8)buf[0] >> 4) | (unsigned __int8)(16 * (_BYTE)dword_1009A741));
  507.         break;
  508.     }
  509.   }
  510.   *v25 = (unsigned __int8)(4 * (byte_1000A504 & 1)) | (unsigned __int8)(*v25 & 0xFB);
  511.   *(int *)((char *)&dword_1009A741 + 1) = dword_1000A2EC;
  512.   word_1009A746 = (_WORD)a3 + (((unsigned __int8)*v25 >> 6) & 3) + 12;
  513.   sub_10001000(
  514.     a2,
  515.     (int)dword_1009A748,
  516.     a3 + (((unsigned __int8)*v25 >> 6) & 3) + 4,
  517.     (int)&byte_1000A520[256 * (unsigned __int8)byte_1000A504],
  518.     256);
  519.   if ( 262144 - len < (unsigned int)(unsigned __int16)word_1009A746 )
  520.     return -1;
  521.   Size = (unsigned __int16)word_1009A746;
  522.   sub_10001000((int)buf, (int)buf, 8u, (int)dword_10008148, 256);
  523.   if ( len )
  524.   {
  525.     memcpy(&byte_1004A720[len], buf, Size);
  526.     len += Size;
  527.     v17 = send(s, byte_1004A720, len, 0);
  528.     v29 = v17;
  529.     if ( v17 < 0 )
  530.       return v29;
  531.     len -= Size;
  532.   }
  533.   else
  534.   {
  535.     v16 = send(s, buf, Size, 0);
  536.     v29 = v16;
  537.     if ( v16 != Size )
  538.     {
  539.       if ( v29 < 0 )
  540.         return v29;
  541.       memcpy(&byte_1004A720[len], &buf[v29], Size - v29);
  542.       len += Size - v29;
  543.     }
  544.   }
  545.   ++dword_1000A2EC;
  546.   return a3;
  547. }
  548.  
  549. //----- (10001E50) --------------------------------------------------------
  550. signed int __stdcall sub_10001E50(LPVOID lpAddress, int a2, DWORD dwSize)
  551. {
  552.   signed int result; // eax@4
  553.   DWORD flOldProtect; // [sp+0h] [bp-8h]@5
  554.   signed int v5; // [sp+4h] [bp-4h]@5
  555.  
  556.   if ( lpAddress && a2 && (signed int)dwSize >= 4 )
  557.   {
  558.     VirtualProtect(lpAddress, dwSize, 0x40u, &flOldProtect);
  559.     *(_DWORD *)lpAddress = a2;
  560.     v5 = 4;
  561.     while ( v5 < (signed int)dwSize )
  562.       *((_BYTE *)lpAddress + v5++) = -112;
  563.     result = 0;
  564.   }
  565.   else
  566.   {
  567.     result = -1;
  568.   }
  569.   return result;
  570. }
  571.  
  572. //----- (1000225D) --------------------------------------------------------
  573. int __cdecl sub_1000225D(int a1)
  574. {
  575.   int result; // eax@1
  576.  
  577.   result = a1;
  578.   dword_1000A050 = a1;
  579.   return result;
  580. }
  581.  
  582. //----- (10002D32) --------------------------------------------------------
  583. void __cdecl sub_10002D32()
  584. {
  585.   int *v0; // [sp+Ch] [bp-1Ch]@1
  586.   CPPEH_RECORD ms_exc; // [sp+10h] [bp-18h]@3
  587.  
  588.   v0 = dword_10008ECC;
  589.   while ( v0 < dword_10008ECC )
  590.   {
  591.     ms_exc.disabled = 0;
  592.     if ( *v0 )
  593.       ((int (*)(void))*v0)();
  594.     ++v0;
  595.   }
  596. }
  597.  
  598. //----- (10002D76) --------------------------------------------------------
  599. void __cdecl sub_10002D76()
  600. {
  601.   int *v0; // [sp+Ch] [bp-1Ch]@1
  602.   CPPEH_RECORD ms_exc; // [sp+10h] [bp-18h]@3
  603.  
  604.   v0 = &dword_10008ED4;
  605.   while ( v0 < &dword_10008ED4 )
  606.   {
  607.     ms_exc.disabled = 0;
  608.     if ( *v0 )
  609.       ((int (*)(void))*v0)();
  610.     ++v0;
  611.   }
  612. }
  613.  
  614. //----- (10004ED1) --------------------------------------------------------
  615. signed int __cdecl sub_10004ED1()
  616. {
  617.   return 1;
  618. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!