API tools faq
paste
eirexe

Untitled

eirexe
Jun 30th, 2013
120
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 28.08 KB | None | 0 0
raw download clone embed print report
  1. #include <windows.h>
  2. #include <defs.h>
  3.  
  4.  
  5.  
  6.  
  7.  
  8. extern int dword_10003114;
  9. extern char aFindleaderboar[];
  10. extern char aOnfindleaderbo[];
  11. extern char aLeaderboardCuo[];
  12. extern char aUploadscore[];
  13. extern char aOnuploadscore[];
  14. extern char aScoreCouldNotB[];
  15. extern char aDownloadscore[];
  16. extern char aOndownloadscor[];
  17. extern _UNKNOWN unk_100031D1;
  18. extern int (__stdcall *off_100031D8)(int, int, int, int);
  19. extern int (__stdcall *off_100031E8)(int, int, int, int);
  20. extern int (__stdcall *off_100031F8)(int, int, int, int);
  21. extern char aFail[];
  22. extern char aClosingSteam[];
  23. extern char aDone_[];
  24. extern int (__stdcall *off_100034E8)(int, int, int, int);
  25. extern int (__stdcall *off_100034F8)(int, int, int, int);
  26. extern int (__stdcall *off_10003508)(int, int, int, int);
  27. extern char aName[5];
  28. extern char aS[];
  29. extern char aDesc[5];
  30. extern char aRequeststatsFa[];
  31. extern char aStorestatsFail[];
  32. extern _UNKNOWN unk_100038AC;
  33. extern int __security_cookie;
  34. extern _UNKNOWN unk_10005238;
  35. extern _UNKNOWN unk_100088E8;
  36. extern _UNKNOWN unk_10008CBC;
  37. extern int dword_10008CC4;
  38. extern int dword_10008CC8;
  39. extern char byte_10008CCC;
  40. extern int dword_10008CD0;
  41.  
  42.  
  43.  
  44.  
  45. #define __thiscall __cdecl
  46.  
  47.  
  48. int __stdcall sub_10001170(int a1);
  49. int __thiscall sub_10001210(void *this, int a2, char a3);
  50. char __stdcall sub_10001260(int a1);
  51. int __stdcall sub_10001310(int a1, char a2);
  52. char __cdecl sub_10001350();
  53. int __thiscall sub_10001400(void *this, int a2, char a3);
  54. int __thiscall sub_100014A0(int this, int a2);
  55. signed int __cdecl sub_100014C0();
  56. int __thiscall sub_100014D0(int this, int a2, int a3, int a4, int a5);
  57. signed int __cdecl sub_10001510();
  58. int __stdcall sub_10001520(int a1);
  59. double __cdecl SteamInit();
  60. double __cdecl SteamRunCallbacks();
  61. double __cdecl SteamShutdown();
  62.  
  63.  
  64. double __cdecl SteamStoreStats();
  65. double __cdecl SteamSetStatInt(const char *a1, double a2);
  66. double __cdecl SteamSetStat(const char *a1, double a2, double a3);
  67. double __cdecl SteamFindLeaderboard(int a1);
  68. double __cdecl SteamUploadScore(double a1);
  69. double __cdecl SteamDownloadScores();
  70. double __cdecl SteamGetScoreForPosition(double a1);
  71. int __cdecl SteamGetNameForPosition(double);
  72. double __cdecl SteamGetGlobalRankForPosition(double a1);
  73. double __cdecl SteamResetAllStats(double a1);
  74. double __cdecl SteamIncreaseStat(const char *a1, double a2);
  75. signed int __cdecl sub_10001A20();
  76. int __thiscall sub_10001A50(int this);
  77. int __thiscall sub_10001A60(int this, int a2, int a3, int a4, int a5);
  78. signed int __cdecl sub_10001AA0();
  79. int __stdcall sub_10001AB0(int a1);
  80.  
  81. char __stdcall sub_10001CC0(const char *a1, double a2, double a3);
  82. char __stdcall sub_10001D60(const char *a1, int a2);
  83. char __stdcall sub_10001DE0(const char *a1, int a2);
  84. char __stdcall sub_10001E60(const char *a1, double a2);
  85.  
  86.  
  87. int __stdcall nullsub_1(int);
  88.  
  89. int __cdecl sub_100026EC();
  90. int (*__cdecl sub_100027B0())(void);
  91. BOOL __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved);
  92.  
  93. int __cdecl sub_10002B92();
  94.  
  95.  
  96.  
  97. int __cdecl sub_10002BD1(int a1, int a2);
  98.  
  99.  
  100.  
  101.  
  102.  
  103.  
  104.  
  105.  
  106.  
  107.  
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119. int __usercall sub_10001000<eax>(int result<eax>)
  120. {
  121.   *(_DWORD *)result = 0;
  122.   *(_DWORD *)(result + 4) = 0;
  123.   *(_DWORD *)(result + 8) = 0;
  124.   *(_DWORD *)(result + 16) = 0;
  125.   *(_DWORD *)(result + 48) = 0;
  126.   *(_DWORD *)(result + 80) = 0;
  127.   *(_DWORD *)(result + 112) = 0;
  128.   *(_DWORD *)(result + 144) = 0;
  129.   *(_DWORD *)(result + 176) = 0;
  130.   *(_DWORD *)(result + 208) = 0;
  131.   *(_DWORD *)(result + 240) = 0;
  132.   *(_DWORD *)(result + 272) = 0;
  133.   *(_DWORD *)(result + 304) = 0;
  134.   *(_DWORD *)(result + 20) &= 0xFF0FFFFFu;
  135.   *(_DWORD *)(result + 52) &= 0xFF0FFFFFu;
  136.   *(_DWORD *)(result + 84) &= 0xFF0FFFFFu;
  137.   *(_DWORD *)(result + 116) &= 0xFF0FFFFFu;
  138.   *(_DWORD *)(result + 148) &= 0xFF0FFFFFu;
  139.   *(_DWORD *)(result + 180) &= 0xFF0FFFFFu;
  140.   *(_DWORD *)(result + 212) &= 0xFF0FFFFFu;
  141.   *(_DWORD *)(result + 244) &= 0xFF0FFFFFu;
  142.   *(_DWORD *)(result + 276) &= 0xFF0FFFFFu;
  143.   *(_DWORD *)(result + 308) &= 0xFF0FFFFFu;
  144.   *(_BYTE *)(result + 23) = 0;
  145.   *(_DWORD *)(result + 20) &= 0xFFF00000u;
  146.   *(_BYTE *)(result + 55) = 0;
  147.   *(_DWORD *)(result + 52) &= 0xFFF00000u;
  148.   *(_BYTE *)(result + 87) = 0;
  149.   *(_DWORD *)(result + 84) &= 0xFFF00000u;
  150.   *(_BYTE *)(result + 119) = 0;
  151.   *(_DWORD *)(result + 116) &= 0xFFF00000u;
  152.   *(_BYTE *)(result + 151) = 0;
  153.   *(_DWORD *)(result + 148) &= 0xFFF00000u;
  154.   *(_BYTE *)(result + 183) = 0;
  155.   *(_DWORD *)(result + 180) &= 0xFFF00000u;
  156.   *(_BYTE *)(result + 215) = 0;
  157.   *(_DWORD *)(result + 212) &= 0xFFF00000u;
  158.   *(_BYTE *)(result + 247) = 0;
  159.   *(_DWORD *)(result + 244) &= 0xFFF00000u;
  160.   *(_BYTE *)(result + 279) = 0;
  161.   *(_DWORD *)(result + 276) &= 0xFFF00000u;
  162.   *(_BYTE *)(result + 311) = 0;
  163.   *(_DWORD *)(result + 308) &= 0xFFF00000u;
  164.   *(_BYTE *)(result + 340) = 0;
  165.   *(_DWORD *)(result + 336) = &off_100031D8;
  166.   *(_DWORD *)(result + 352) = 0;
  167.   *(_DWORD *)(result + 356) = 0;
  168.   *(_DWORD *)(result + 360) = 0;
  169.   *(_DWORD *)(result + 364) = 0;
  170.   *(_DWORD *)(result + 344) = 1104;
  171.   *(_BYTE *)(result + 372) = 0;
  172.   *(_DWORD *)(result + 368) = &off_100031E8;
  173.   *(_DWORD *)(result + 384) = 0;
  174.   *(_DWORD *)(result + 388) = 0;
  175.   *(_DWORD *)(result + 392) = 0;
  176.   *(_DWORD *)(result + 396) = 0;
  177.   *(_DWORD *)(result + 376) = 1106;
  178.   *(_BYTE *)(result + 404) = 0;
  179.   *(_DWORD *)(result + 400) = &off_100031F8;
  180.   *(_DWORD *)(result + 416) = 0;
  181.   *(_DWORD *)(result + 420) = 0;
  182.   *(_DWORD *)(result + 424) = 0;
  183.   *(_DWORD *)(result + 428) = 0;
  184.   *(_DWORD *)(result + 408) = 1105;
  185.   return result;
  186. }
  187.  
  188.  
  189.  
  190.  
  191.  
  192. int __stdcall sub_10001170(int a1)
  193. {
  194.   int v1;
  195.   int v2;
  196.   int v3;
  197.   int v4;
  198.   int result;
  199.   int v6;
  200.  
  201.   v2 = dword_10008CC8;
  202.   printf("FindLeaderboard\n");
  203.   *(_DWORD *)v2 = 0;
  204.   *(_DWORD *)(v2 + 4) = 0;
  205.   v3 = SteamUserStats();
  206.   v1 = (*(int (__thiscall **)(int, int))(*(_DWORD *)v3 + 84))(v3, a1);
  207.   v6 = v4;
  208.   if ( *(_QWORD *)(v2 + 352) )
  209.     SteamAPI_UnregisterCallResult(v2 + 336, *(_DWORD *)(v2 + 352), *(_DWORD *)(v2 + 356));
  210.   result = v6;
  211.   *(_DWORD *)(v2 + 352) = v1;
  212.   *(_DWORD *)(v2 + 356) = v6;
  213.   *(_DWORD *)(v2 + 360) = v2;
  214.   *(_DWORD *)(v2 + 364) = sub_10001210;
  215.   if ( v6 | v1 )
  216.     result = SteamAPI_RegisterCallResult(v2 + 336, v1, v6);
  217.   return result;
  218. }
  219.  
  220.  
  221.  
  222.  
  223.  
  224. int __thiscall sub_10001210(void *this, int a2, char a3)
  225. {
  226.   int result;
  227.   void *v4;
  228.  
  229.   v4 = this;
  230.   ((void (__cdecl *)(_DWORD))printf)("OnFindLeaderboard\n");
  231.   result = a2;
  232.   if ( !*(_BYTE *)(a2 + 8) || a3 )
  233.   {
  234.     result = printf("Leaderboard cuold not be found\n");
  235.   }
  236.   else
  237.   {
  238.     *(_DWORD *)v4 = *(_DWORD *)a2;
  239.     *((_DWORD *)v4 + 1) = *(_DWORD *)(a2 + 4);
  240.   }
  241.   return result;
  242. }
  243.  
  244.  
  245. char __stdcall sub_10001260(int a1)
  246. {
  247.   int v1;
  248.   char result;
  249.   int v3;
  250.   int v4;
  251.   int v5;
  252.   int v6;
  253.  
  254.   v1 = dword_10008CC8;
  255.   printf("UploadScore\n");
  256.   if ( *(_QWORD *)v1 )
  257.   {
  258.     v3 = SteamUserStats();
  259.     v4 = (*(int (__thiscall **)(int, _DWORD, _DWORD, signed int, int, _DWORD, _DWORD))(*(_DWORD *)v3 + 116))(
  260.            v3,
  261.            *(_DWORD *)v1,
  262.            *(_DWORD *)(v1 + 4),
  263.            1,
  264.            a1,
  265.            0,
  266.            0);
  267.     v6 = v5;
  268.     if ( *(_QWORD *)(v1 + 384) )
  269.       SteamAPI_UnregisterCallResult(v1 + 368, *(_DWORD *)(v1 + 384), *(_DWORD *)(v1 + 388));
  270.     *(_DWORD *)(v1 + 384) = v4;
  271.     *(_DWORD *)(v1 + 388) = v6;
  272.     *(_DWORD *)(v1 + 392) = v1;
  273.     *(_DWORD *)(v1 + 396) = sub_10001310;
  274.     if ( v6 | v4 )
  275.       SteamAPI_RegisterCallResult(v1 + 368, v4, v6);
  276.     result = 1;
  277.   }
  278.   else
  279.   {
  280.     result = 0;
  281.   }
  282.   return result;
  283. }
  284.  
  285.  
  286.  
  287.  
  288.  
  289. int __stdcall sub_10001310(int a1, char a2)
  290. {
  291.   int result;
  292.  
  293.   ((void (__cdecl *)(_DWORD))printf)("OnUploadScore\n");
  294.   result = a1;
  295.   if ( !*(_BYTE *)a1 || a2 )
  296.     result = printf("Score could not be uploaded to Steam\n");
  297.   return result;
  298. }
  299.  
  300.  
  301. char __cdecl sub_10001350()
  302. {
  303.   int v0;
  304.   char result;
  305.   int v2;
  306.   int v3;
  307.   int v4;
  308.   int v5;
  309.  
  310.   v0 = dword_10008CC8;
  311.   printf("DownloadScore\n");
  312.   if ( *(_QWORD *)v0 )
  313.   {
  314.     v2 = SteamUserStats();
  315.     v3 = (*(int (__thiscall **)(int, _DWORD, _DWORD, signed int, signed int, signed int))(*(_DWORD *)v2 + 104))(
  316.            v2,
  317.            *(_DWORD *)v0,
  318.            *(_DWORD *)(v0 + 4),
  319.            1,
  320.            -4,
  321.            5);
  322.     v5 = v4;
  323.     if ( *(_QWORD *)(v0 + 416) )
  324.       SteamAPI_UnregisterCallResult(v0 + 400, *(_DWORD *)(v0 + 416), *(_DWORD *)(v0 + 420));
  325.     *(_DWORD *)(v0 + 416) = v3;
  326.     *(_DWORD *)(v0 + 420) = v5;
  327.     *(_DWORD *)(v0 + 424) = v0;
  328.     *(_DWORD *)(v0 + 428) = sub_10001400;
  329.     if ( v5 | v3 )
  330.       SteamAPI_RegisterCallResult(v0 + 400, v3, v5);
  331.     result = 1;
  332.   }
  333.   else
  334.   {
  335.     result = 0;
  336.   }
  337.   return result;
  338. }
  339.  
  340.  
  341.  
  342.  
  343.  
  344. int __thiscall sub_10001400(void *this, int a2, char a3)
  345. {
  346.   int result;
  347.   void *v4;
  348.   int v5;
  349.   int v6;
  350.   int v7;
  351.   void *v8;
  352.   char v9;
  353.   unsigned int v10;
  354.  
  355.   v10 = (unsigned int)&v8 ^ __security_cookie;
  356.   v4 = this;
  357.   v8 = this;
  358.   result = printf("OnDownloadScore\n");
  359.   if ( !a3 )
  360.   {
  361.     result = *(_DWORD *)(a2 + 16);
  362.     if ( result >= 10 )
  363.       result = 10;
  364.     v5 = 0;
  365.     *((_DWORD *)v4 + 2) = result;
  366.     if ( result > 0 )
  367.     {
  368.       v6 = (int)((char *)v4 + 16);
  369.       do
  370.       {
  371.         v7 = SteamUserStats();
  372.         (*(void (__thiscall **)(int, _DWORD, _DWORD, int, int, char *, signed int))(*(_DWORD *)v7 + 112))(
  373.           v7,
  374.           *(_DWORD *)(a2 + 8),
  375.           *(_DWORD *)(a2 + 12),
  376.           v5,
  377.           v6,
  378.           &v9,
  379.           3);
  380.         result = (int)v8;
  381.         ++v5;
  382.         v6 += 32;
  383.       }
  384.       while ( v5 < *((_DWORD *)v8 + 2) );
  385.     }
  386.   }
  387.   return result;
  388. }
  389.  
  390.  
  391.  
  392. int __thiscall sub_100014A0(int this, int a2)
  393. {
  394.   int (__thiscall *v3)(_DWORD, _DWORD, _DWORD);
  395.  
  396.   v3 = *(int (__thiscall **)(_DWORD, _DWORD, _DWORD))(this + 28);
  397.   *(_DWORD *)(this + 16) = 0;
  398.   *(_DWORD *)(this + 20) = 0;
  399.   return v3(*(_DWORD *)(this + 24), a2, 0);
  400. }
  401.  
  402.  
  403. signed int __cdecl sub_100014C0()
  404. {
  405.   return 16;
  406. }
  407.  
  408.  
  409. int __thiscall sub_100014D0(int this, int a2, int a3, int a4, int a5)
  410. {
  411.   int result;
  412.  
  413.   result = this;
  414.   if ( a4 == *(_DWORD *)(this + 16) )
  415.   {
  416.     if ( a5 == *(_DWORD *)(this + 20) )
  417.     {
  418.       *(_DWORD *)(this + 16) = 0;
  419.       *(_DWORD *)(this + 20) = 0;
  420.       result = (*(int (__thiscall **)(_DWORD, int, int))(this + 28))(*(_DWORD *)(this + 24), a2, a3);
  421.     }
  422.   }
  423.   return result;
  424. }
  425.  
  426.  
  427. signed int __cdecl sub_10001510()
  428. {
  429.   return 32;
  430. }
  431.  
  432.  
  433. int __stdcall sub_10001520(int a1)
  434. {
  435.   int v1;
  436.   int v2;
  437.   char v3;
  438.   int v4;
  439.   int v5;
  440.   char v6;
  441.   int result;
  442.   int v8;
  443.   char v9;
  444.  
  445.   v1 = *(_DWORD *)(a1 + 416);
  446.   v2 = *(_DWORD *)(a1 + 420);
  447.   v3 = *(_QWORD *)(a1 + 416) == 0i64;
  448.   *(_DWORD *)(a1 + 400) = &off_100031F8;
  449.   if ( !v3 )
  450.   {
  451.     SteamAPI_UnregisterCallResult(a1 + 400, v1, v2);
  452.     *(_DWORD *)(a1 + 416) = 0;
  453.     *(_DWORD *)(a1 + 420) = 0;
  454.   }
  455.   v4 = *(_DWORD *)(a1 + 384);
  456.   v5 = *(_DWORD *)(a1 + 388);
  457.   v6 = *(_QWORD *)(a1 + 384) == 0i64;
  458.   *(_DWORD *)(a1 + 368) = &off_100031E8;
  459.   if ( !v6 )
  460.   {
  461.     SteamAPI_UnregisterCallResult(a1 + 368, v4, v5);
  462.     *(_DWORD *)(a1 + 384) = 0;
  463.     *(_DWORD *)(a1 + 388) = 0;
  464.   }
  465.   result = *(_DWORD *)(a1 + 352);
  466.   v8 = *(_DWORD *)(a1 + 356);
  467.   v9 = *(_QWORD *)(a1 + 352) == 0i64;
  468.   *(_DWORD *)(a1 + 336) = &off_100031D8;
  469.   if ( !v9 )
  470.   {
  471.     result = SteamAPI_UnregisterCallResult(a1 + 336, result, v8);
  472.     *(_DWORD *)(a1 + 352) = 0;
  473.     *(_DWORD *)(a1 + 356) = 0;
  474.   }
  475.   return result;
  476. }
  477.  
  478.  
  479.  
  480.  
  481.  
  482.  
  483. double __cdecl SteamInit()
  484. {
  485.   int v0;
  486.   int v1;
  487.   int v2;
  488.   double result;
  489.  
  490.   byte_10008CCC = SteamAPI_Init();
  491.   if ( byte_10008CCC )
  492.   {
  493.     v0 = operator new(88);
  494.     if ( v0 )
  495.       v1 = sub_10001AB0(v0);
  496.     else
  497.       v1 = 0;
  498.     dword_10008CC4 = v1;
  499.     v2 = operator new(432);
  500.     if ( v2 )
  501.     {
  502.       result = 1.0;
  503.       dword_10008CC8 = sub_10001000(v2);
  504.     }
  505.     else
  506.     {
  507.       result = 1.0;
  508.       dword_10008CC8 = 0;
  509.     }
  510.   }
  511.   else
  512.   {
  513.     printf("Fail\n");
  514.     result = -1.0;
  515.   }
  516.   return result;
  517. }
  518.  
  519.  
  520.  
  521.  
  522.  
  523.  
  524.  
  525. double __cdecl SteamRunCallbacks()
  526. {
  527.   SteamAPI_RunCallbacks();
  528.   return 0.0;
  529. }
  530.  
  531.  
  532.  
  533. double __cdecl SteamShutdown()
  534. {
  535.   int v0;
  536.  
  537.   ((void (__cdecl *)(_DWORD))printf)("Closing Steam - ");
  538.   SteamAPI_Shutdown();
  539.   if ( dword_10008CC4 )
  540.     sub_100016B0(dword_10008CC4);
  541.   if ( dword_10008CC8 )
  542.   {
  543.     v0 = dword_10008CC8;
  544.     sub_10001520(dword_10008CC8);
  545.     operator delete(v0);
  546.   }
  547.   printf("Done.\n");
  548.   return 1.0;
  549. }
  550.  
  551.  
  552.  
  553.  
  554.  
  555.  
  556. int __usercall sub_100016B0<eax>(int a1<esi>)
  557. {
  558.   char v1;
  559.   char v2;
  560.   char v3;
  561.  
  562.   v1 = (*(_BYTE *)(a1 + 72) & 1) == 0;
  563.   *(_DWORD *)(a1 + 68) = &off_10003508;
  564.   if ( !v1 )
  565.     SteamAPI_UnregisterCallback(a1 + 68);
  566.   v2 = (*(_BYTE *)(a1 + 52) & 1) == 0;
  567.   *(_DWORD *)(a1 + 48) = &off_100034F8;
  568.   if ( !v2 )
  569.     SteamAPI_UnregisterCallback(a1 + 48);
  570.   v3 = (*(_BYTE *)(a1 + 32) & 1) == 0;
  571.   *(_DWORD *)(a1 + 28) = &off_100034E8;
  572.   if ( !v3 )
  573.     SteamAPI_UnregisterCallback(a1 + 28);
  574.   operator delete(a1);
  575.   return a1;
  576. }
  577.  
  578.  
  579.  
  580.  
  581.  
  582.  
  583.  
  584. double __usercall SteamSetAchievement<st0>(int a1<ecx>, int a2<esi>, int a3)
  585. {
  586.   double result;
  587.   int v4;
  588.   int v5;
  589.  
  590.   if ( dword_10008CC4 )
  591.   {
  592.     if ( *(_BYTE *)(dword_10008CC4 + 24) )
  593.     {
  594.       v4 = ((int (__stdcall *)(_DWORD))SteamUserStats)(a2);
  595.       (*(void (__thiscall **)(_DWORD, _DWORD))(*(_DWORD *)v4 + 28))(v4, a3);
  596.       v5 = SteamUserStats();
  597.       result = (double)(unsigned __int8)(*(int (__thiscall **)(_DWORD))(*(_DWORD *)v5 + 40))(v5);
  598.     }
  599.     else
  600.     {
  601.       result = (double)0;
  602.     }
  603.   }
  604.   else
  605.   {
  606.     result = -1.0;
  607.   }
  608.   return result;
  609. }
  610.  
  611.  
  612.  
  613. double __cdecl SteamStoreStats()
  614. {
  615.   char v0;
  616.   double result;
  617.  
  618.   if ( dword_10008CC4 && (sub_10001C00(dword_10008CC4), v0) )
  619.     result = 1.0;
  620.   else
  621.     result = -1.0;
  622.   return result;
  623. }
  624.  
  625.  
  626.  
  627. double __cdecl SteamSetStatInt(const char *a1, double a2)
  628. {
  629.   double result;
  630.  
  631.   if ( dword_10008CC4 && sub_10001D60(a1, (signed int)a2) )
  632.     result = 1.0;
  633.   else
  634.     result = -1.0;
  635.   return result;
  636. }
  637.  
  638.  
  639.  
  640. double __cdecl SteamSetStat(const char *a1, double a2, double a3)
  641. {
  642.   if ( dword_10008CC4 )
  643.   {
  644.     if ( a3 >= 0.001 || a3 <= -0.001 )
  645.     {
  646.       if ( sub_10001CC0(a1, a2, a3) )
  647.         return 1.0;
  648.     }
  649.     else
  650.     {
  651.       if ( sub_10001E60(a1, a2) )
  652.         return 1.0;
  653.     }
  654.   }
  655.   return -1.0;
  656. }
  657.  
  658.  
  659.  
  660. double __cdecl SteamFindLeaderboard(int a1)
  661. {
  662.   double result;
  663.  
  664.   if ( dword_10008CC8 )
  665.   {
  666.     sub_10001170(a1);
  667.     result = (double)(2 * (*(_DWORD *)(dword_10008CC8 + 8) == 0) - 1);
  668.   }
  669.   else
  670.   {
  671.     result = -1.0;
  672.   }
  673.   return result;
  674. }
  675.  
  676.  
  677.  
  678. double __cdecl SteamUploadScore(double a1)
  679. {
  680.   double result;
  681.  
  682.   if ( dword_10008CC8 )
  683.   {
  684.     sub_10001260((signed int)a1);
  685.     result = 1.0;
  686.   }
  687.   else
  688.   {
  689.     result = -1.0;
  690.   }
  691.   return result;
  692. }
  693.  
  694.  
  695.  
  696. double __cdecl SteamDownloadScores()
  697. {
  698.   double result;
  699.  
  700.   if ( dword_10008CC8 )
  701.   {
  702.     sub_10001350();
  703.     result = 1.0;
  704.   }
  705.   else
  706.   {
  707.     result = -1.0;
  708.   }
  709.   return result;
  710. }
  711.  
  712.  
  713.  
  714. double __cdecl SteamGetScoreForPosition(double a1)
  715. {
  716.   double result;
  717.  
  718.   if ( dword_10008CC8 && (signed int)a1 < *(_DWORD *)(dword_10008CC8 + 8) )
  719.     result = (double)*(signed int *)(32 * (signed int)a1 + dword_10008CC8 + 28);
  720.   else
  721.     result = -1.0;
  722.   return result;
  723. }
  724.  
  725.  
  726.  
  727. int __cdecl SteamGetNameForPosition(double a1)
  728. {
  729.   int v1;
  730.   int v2;
  731.   int result;
  732.  
  733.   v1 = dword_10008CC8;
  734.   if ( dword_10008CC8 )
  735.   {
  736.     if ( (signed int)a1 >= *(_DWORD *)(dword_10008CC8 + 8) )
  737.     {
  738.       result = (int)&unk_100031D1;
  739.     }
  740.     else
  741.     {
  742.       v2 = SteamFriends();
  743.       result = (*(int (__thiscall **)(int, _DWORD, _DWORD))(*(_DWORD *)v2 + 28))(
  744.                  v2,
  745.                  *(_DWORD *)(32 * (signed int)a1 + v1 + 16),
  746.                  *(_DWORD *)(32 * (signed int)a1 + v1 + 20));
  747.     }
  748.   }
  749.   else
  750.   {
  751.     result = (int)&unk_100031D1;
  752.   }
  753.   return result;
  754. }
  755.  
  756.  
  757.  
  758.  
  759. double __cdecl SteamGetGlobalRankForPosition(double a1)
  760. {
  761.   double result;
  762.  
  763.   if ( dword_10008CC8 && (signed int)a1 < *(_DWORD *)(dword_10008CC8 + 8) )
  764.     result = (double)*(signed int *)(32 * (signed int)a1 + dword_10008CC8 + 24);
  765.   else
  766.     result = -1.0;
  767.   return result;
  768. }
  769.  
  770.  
  771.  
  772. double __cdecl SteamResetAllStats(double a1)
  773. {
  774.   int v1;
  775.   double result;
  776.   char v3;
  777.   char v4;
  778.   int v5;
  779.  
  780.   result = 0.0;
  781.   v1 = dword_10008CC4;
  782.   if ( dword_10008CC4 )
  783.   {
  784.     v3 = 1;
  785.     if ( a1 <= 0.0 )
  786.       v4 = 0;
  787.     v5 = SteamUserStats();
  788.     (*(void (__thiscall **)(int))(*(_DWORD *)v5 + 76))(v5);
  789.     sub_10001C00(v1);
  790.     result = 1.0;
  791.   }
  792.   return result;
  793. }
  794.  
  795.  
  796.  
  797. double __cdecl SteamIncreaseStat(const char *a1, double a2)
  798. {
  799.   double result;
  800.  
  801.   if ( dword_10008CC4 )
  802.   {
  803.     sub_10001DE0(a1, (signed int)a2);
  804.     result = 1.0;
  805.   }
  806.   else
  807.   {
  808.     result = 0.0;
  809.   }
  810.   return result;
  811. }
  812.  
  813.  
  814.  
  815. signed int __cdecl sub_10001A20()
  816. {
  817.   return 24;
  818. }
  819.  
  820.  
  821. int __thiscall sub_10001A50(int this)
  822. {
  823.   return (*(int (__thiscall **)(_DWORD))(this + 16))(*(_DWORD *)(this + 12));
  824. }
  825.  
  826.  
  827. int __thiscall sub_10001A60(int this, int a2, int a3, int a4, int a5)
  828. {
  829.   return (*(int (__thiscall **)(_DWORD, int))(this + 16))(*(_DWORD *)(this + 12), a2);
  830. }
  831.  
  832.  
  833. signed int __cdecl sub_10001AA0()
  834. {
  835.   return 152;
  836. }
  837.  
  838.  
  839. int __stdcall sub_10001AB0(int a1)
  840. {
  841.   int (__stdcall *v1)(int);
  842.   int (__stdcall *v2)(int);
  843.   int v3;
  844.   int v4;
  845.   int v5;
  846.  
  847.   *(_DWORD *)a1 = 0;
  848.   *(_DWORD *)(a1 + 4) = 0;
  849.   *(_BYTE *)(a1 + 24) = 0;
  850.   *(_BYTE *)(a1 + 32) = 0;
  851.   *(_DWORD *)(a1 + 36) = 0;
  852.   *(_DWORD *)(a1 + 28) = &off_100034E8;
  853.   *(_DWORD *)(a1 + 40) = a1;
  854.   *(_DWORD *)(a1 + 44) = sub_10001EE0;
  855.   if ( sub_10001EE0 )
  856.   {
  857.     *(_DWORD *)(a1 + 40) = a1;
  858.     *(_DWORD *)(a1 + 44) = sub_10001EE0;
  859.     SteamAPI_RegisterCallback(a1 + 28, 1101);
  860.   }
  861.   *(_BYTE *)(a1 + 52) = 0;
  862.   *(_DWORD *)(a1 + 56) = 0;
  863.   *(_DWORD *)(a1 + 48) = &off_100034F8;
  864.   *(_DWORD *)(a1 + 60) = a1;
  865.   *(_DWORD *)(a1 + 64) = sub_10002080;
  866.   if ( sub_10002080 )
  867.   {
  868.     *(_DWORD *)(a1 + 60) = a1;
  869.     *(_DWORD *)(a1 + 64) = sub_10002080;
  870.     SteamAPI_RegisterCallback(a1 + 48, 1102);
  871.   }
  872.   v2 = nullsub_1;
  873.   v1 = nullsub_1;
  874.   *(_BYTE *)(a1 + 72) = 0;
  875.   *(_DWORD *)(a1 + 76) = 0;
  876.   *(_DWORD *)(a1 + 68) = &off_10003508;
  877.   *(_DWORD *)(a1 + 80) = a1;
  878.   *(_DWORD *)(a1 + 84) = nullsub_1;
  879.   if ( nullsub_1 )
  880.   {
  881.     *(_DWORD *)(a1 + 80) = a1;
  882.     *(_DWORD *)(a1 + 84) = nullsub_1;
  883.     SteamAPI_RegisterCallback(a1 + 68, 1103);
  884.   }
  885.   v3 = SteamUtils(v2, v1);
  886.   *(_DWORD *)a1 = (*(int (__thiscall **)(int))(*(_DWORD *)v3 + 36))(v3);
  887.   *(_DWORD *)(a1 + 4) = 0;
  888.   *(_DWORD *)(a1 + 8) = &unk_100088E8;
  889.   *(_DWORD *)(a1 + 12) = 4;
  890.   *(_DWORD *)(a1 + 16) = &unk_10005238;
  891.   *(_DWORD *)(a1 + 20) = 35;
  892.   if ( SteamUserStats() )
  893.   {
  894.     if ( SteamUser() )
  895.     {
  896.       v4 = SteamUser();
  897.       if ( (unsigned __int8)(*(int (__thiscall **)(int))(*(_DWORD *)v4 + 4))(v4) )
  898.       {
  899.         v5 = SteamUserStats();
  900.         (**(void (***)(void))v5)();
  901.       }
  902.     }
  903.   }
  904.   return a1;
  905. }
  906.  
  907.  
  908.  
  909.  
  910.  
  911.  
  912.  
  913.  
  914.  
  915. void __usercall sub_10001C00(int a1<ebx>)
  916. {
  917.   int v1;
  918.   int v2;
  919.   int v3;
  920.   int v4;
  921.   int v5;
  922.   void (__thiscall *v6)(_DWORD, _DWORD, _DWORD);
  923.   int v7;
  924.   int v8;
  925.   float v9;
  926.   int v10;
  927.   int v11;
  928.  
  929.   if ( *(_BYTE *)(a1 + 24) )
  930.   {
  931.     v11 = 0;
  932.     if ( *(_DWORD *)(a1 + 12) > 0 )
  933.     {
  934.       v10 = 0;
  935.       while ( 1 )
  936.       {
  937.         v2 = v10 + *(_DWORD *)(a1 + 8);
  938.         v1 = *(_DWORD *)(v2 + 8);
  939.         if ( !v1 )
  940.           break;
  941.         v3 = v1 - 1;
  942.         if ( !v3 )
  943.         {
  944.           v4 = SteamUserStats();
  945.           v6 = *(void (__thiscall **)(_DWORD, _DWORD, _DWORD))(*(_DWORD *)v4 + 12);
  946.           v9 = *(float *)(v2 + 20);
  947.           goto LABEL_11;
  948.         }
  949.         if ( v3 == 1 )
  950.         {
  951.           v5 = SteamUserStats();
  952.           (*(void (__thiscall **)(int, _DWORD, _DWORD, _DWORD, _DWORD))(*(_DWORD *)v5 + 20))(
  953.             v5,
  954.             *(_DWORD *)(v2 + 12),
  955.             *(float *)(v2 + 24),
  956.             COERCE_UNSIGNED_INT64(*(float *)(v2 + 28)),
  957.             COERCE_UNSIGNED_INT64(*(float *)(v2 + 28)) >> 32);
  958.           v4 = SteamUserStats();
  959.           v6 = *(void (__thiscall **)(_DWORD, _DWORD, _DWORD))(*(_DWORD *)v4 + 4);
  960.           v7 = v2 + 20;
  961.           goto LABEL_10;
  962.         }
  963. LABEL_12:
  964.         v10 += 32;
  965.         ++v11;
  966.         if ( v11 >= *(_DWORD *)(a1 + 12) )
  967.           goto LABEL_13;
  968.       }
  969.       v4 = SteamUserStats();
  970.       v7 = *(_DWORD *)(v2 + 16);
  971.       v6 = *(void (__thiscall **)(_DWORD, _DWORD, _DWORD))(*(_DWORD *)v4 + 16);
  972. LABEL_10:
  973.       LODWORD(v9) = v7;
  974. LABEL_11:
  975.       v6(v4, *(_DWORD *)(v2 + 12), LODWORD(v9));
  976.       goto LABEL_12;
  977.     }
  978. LABEL_13:
  979.     v8 = SteamUserStats();
  980.     (*(void (__thiscall **)(int))(*(_DWORD *)v8 + 40))(v8);
  981.   }
  982. }
  983.  
  984.  
  985. char __stdcall sub_10001CC0(const char *a1, double a2, double a3)
  986. {
  987.   int v3;
  988.   int v4;
  989.   const char **v5;
  990.   char result;
  991.   int v7;
  992.   float v8;
  993.   float v9;
  994.  
  995.   v3 = *(_DWORD *)(dword_10008CC4 + 12);
  996.   v4 = 0;
  997.   if ( v3 <= 0 )
  998.   {
  999. LABEL_5:
  1000.     result = 0;
  1001.   }
  1002.   else
  1003.   {
  1004.     v5 = (const char **)(*(_DWORD *)(dword_10008CC4 + 8) + 12);
  1005.     while ( strcmp(a1, *v5) )
  1006.     {
  1007.       ++v4;
  1008.       v5 += 8;
  1009.       if ( v4 >= v3 )
  1010.         goto LABEL_5;
  1011.     }
  1012.     v7 = dword_10008CC4;
  1013.     v8 = a2;
  1014.     *(float *)(*(_DWORD *)(dword_10008CC4 + 8) + 32 * v4 + 24) = v8;
  1015.     v9 = a3;
  1016.     *(float *)(*(_DWORD *)(v7 + 8) + 32 * v4 + 28) = v9;
  1017.     result = 1;
  1018.   }
  1019.   return result;
  1020. }
  1021.  
  1022.  
  1023.  
  1024. char __stdcall sub_10001D60(const char *a1, int a2)
  1025. {
  1026.   int v2;
  1027.   int v3;
  1028.   const char **v4;
  1029.   char result;
  1030.   int v6;
  1031.  
  1032.   v2 = *(_DWORD *)(dword_10008CC4 + 12);
  1033.   v3 = 0;
  1034.   if ( v2 <= 0 )
  1035.   {
  1036. LABEL_5:
  1037.     result = 0;
  1038.   }
  1039.   else
  1040.   {
  1041.     v6 = *(_DWORD *)(dword_10008CC4 + 8);
  1042.     v4 = (const char **)(v6 + 12);
  1043.     while ( strcmp(a1, *v4) )
  1044.     {
  1045.       ++v3;
  1046.       v4 += 8;
  1047.       if ( v3 >= v2 )
  1048.         goto LABEL_5;
  1049.     }
  1050.     *(_DWORD *)(32 * v3 + v6 + 16) = a2;
  1051.     result = 1;
  1052.   }
  1053.   return result;
  1054. }
  1055.  
  1056.  
  1057.  
  1058. char __stdcall sub_10001DE0(const char *a1, int a2)
  1059. {
  1060.   int v2;
  1061.   int v3;
  1062.   const char **v4;
  1063.   char result;
  1064.  
  1065.   v2 = *(_DWORD *)(dword_10008CC4 + 12);
  1066.   v3 = 0;
  1067.   if ( v2 <= 0 )
  1068.   {
  1069. LABEL_5:
  1070.     result = 0;
  1071.   }
  1072.   else
  1073.   {
  1074.     v4 = (const char **)(*(_DWORD *)(dword_10008CC4 + 8) + 12);
  1075.     while ( strcmp(a1, *v4) )
  1076.     {
  1077.       ++v3;
  1078.       v4 += 8;
  1079.       if ( v3 >= v2 )
  1080.         goto LABEL_5;
  1081.     }
  1082.     *(_DWORD *)(32 * v3 + *(_DWORD *)(dword_10008CC4 + 8) + 16) += a2;
  1083.     result = 1;
  1084.   }
  1085.   return result;
  1086. }
  1087.  
  1088.  
  1089.  
  1090. char __stdcall sub_10001E60(const char *a1, double a2)
  1091. {
  1092.   int v2;
  1093.   int v3;
  1094.   const char **v4;
  1095.   char result;
  1096.   int v6;
  1097.   float v7;
  1098.  
  1099.   v2 = *(_DWORD *)(dword_10008CC4 + 12);
  1100.   v3 = 0;
  1101.   if ( v2 <= 0 )
  1102.   {
  1103. LABEL_5:
  1104.     result = 0;
  1105.   }
  1106.   else
  1107.   {
  1108.     v6 = *(_DWORD *)(dword_10008CC4 + 8);
  1109.     v4 = (const char **)(v6 + 12);
  1110.     while ( strcmp(a1, *v4) )
  1111.     {
  1112.       ++v3;
  1113.       v4 += 8;
  1114.       if ( v3 >= v2 )
  1115.         goto LABEL_5;
  1116.     }
  1117.     v7 = a2;
  1118.     *(float *)(32 * v3 + v6 + 20) = v7;
  1119.     result = 1;
  1120.   }
  1121.   return result;
  1122. }
  1123.  
  1124.  
  1125.  
  1126. int __userpurge sub_10001EE0<eax>(int a1<ecx>, int a2<edi>, int a3)
  1127. {
  1128.   int result;
  1129.   int v4;
  1130.   int v5;
  1131.   int v6;
  1132.   void (__thiscall *v7)(_DWORD);
  1133.   int v8;
  1134.   int v9;
  1135.   int v10;
  1136.   int v11;
  1137.   int v12;
  1138.   int v13;
  1139.   int v14;
  1140.   int v15;
  1141.   int v16;
  1142.   int v17;
  1143.   char v18;
  1144.   unsigned int v19;
  1145.   int v20;
  1146.  
  1147.   v19 = (unsigned int)&v20 ^ __security_cookie;
  1148.   result = a3;
  1149.   v4 = a1;
  1150.   if ( *(_DWORD *)a1 != *(_DWORD *)a3 || *(_DWORD *)(a1 + 4) != *(_DWORD *)(a3 + 4) )
  1151.   {
  1152.     result = snprintf(&v18, 0x80u, "RequestStats - failed, %d", *(_DWORD *)(a3 + 8));
  1153.   }
  1154.   else
  1155.   {
  1156.     if ( *(_DWORD *)(a3 + 8) == 1 )
  1157.     {
  1158.       v14 = 0;
  1159.       if ( *(_DWORD *)(a1 + 12) > 0 )
  1160.       {
  1161.         v16 = 0;
  1162.         while ( 1 )
  1163.         {
  1164.           v5 = *(_DWORD *)(v16 + *(_DWORD *)(v4 + 8) + 8);
  1165.           if ( !v5 )
  1166.             break;
  1167.           if ( (unsigned int)(v5 - 1) <= 1 )
  1168.           {
  1169.             v6 = SteamUserStats();
  1170.             v7 = *(void (__thiscall **)(_DWORD))(*(_DWORD *)v6 + 4);
  1171. LABEL_10:
  1172.             v7(v6);
  1173.           }
  1174.           v16 += 32;
  1175.           ++v14;
  1176.           if ( v14 >= *(_DWORD *)(v4 + 12) )
  1177.             goto LABEL_12;
  1178.         }
  1179.         v6 = SteamUserStats();
  1180.         v7 = *(void (__thiscall **)(_DWORD))(*(_DWORD *)v6 + 8);
  1181.         goto LABEL_10;
  1182.       }
  1183. LABEL_12:
  1184.       result = 0;
  1185.       v15 = 0;
  1186.       if ( *(_DWORD *)(v4 + 20) > 0 )
  1187.       {
  1188.         v17 = 0;
  1189.         do
  1190.         {
  1191.           v8 = v17 + *(_DWORD *)(v4 + 16);
  1192.           v9 = SteamUserStats();
  1193.           (*(void (__thiscall **)(int, _DWORD, int))(*(_DWORD *)v9 + 24))(v9, *(_DWORD *)(v8 + 4), v8 + 392);
  1194.           v10 = SteamUserStats();
  1195.           v11 = (*(int (__thiscall **)(int, _DWORD, _DWORD))(*(_DWORD *)v10 + 48))(v10, *(_DWORD *)(v8 + 4), "name");
  1196.           snprintf((char *)(v8 + 8), 0x80u, "%s", v11);
  1197.           v12 = SteamUserStats();
  1198.           v13 = (*(int (__thiscall **)(int, _DWORD, _DWORD))(*(_DWORD *)v12 + 48))(v12, *(_DWORD *)(v8 + 4), "desc");
  1199.           snprintf((char *)(v8 + 136), 0x100u, "%s", v13);
  1200.           v17 += 400;
  1201.           result = v15 + 1;
  1202.           v15 = result;
  1203.         }
  1204.         while ( result < *(_DWORD *)(v4 + 20) );
  1205.       }
  1206.     }
  1207.     *(_BYTE *)(v4 + 24) = 1;
  1208.   }
  1209.   return result;
  1210. }
  1211.  
  1212.  
  1213.  
  1214.  
  1215.  
  1216. int __userpurge sub_10002080<eax>(int a1<ecx>, int a2<edi>, int a3)
  1217. {
  1218.   int result;
  1219.   int v4;
  1220.   int v5;
  1221.   char v6;
  1222.   int v7;
  1223.   int v8;
  1224.   int v9;
  1225.   int v10;
  1226.   int v11;
  1227.   char v12;
  1228.   unsigned int v13;
  1229.  
  1230.   v13 = (unsigned int)&v6 ^ __security_cookie;
  1231.   result = a3;
  1232.   v4 = *(_DWORD *)a1;
  1233.   v5 = *(_DWORD *)(a1 + 4);
  1234.   if ( *(_DWORD *)a1 == *(_DWORD *)a3 )
  1235.   {
  1236.     if ( v5 == *(_DWORD *)(a3 + 4) )
  1237.     {
  1238.       result = *(_DWORD *)(a3 + 8);
  1239.       if ( result != 1 )
  1240.       {
  1241.         if ( result == 8 )
  1242.         {
  1243.           v11 &= 0xFF0FFFFFu;
  1244.           BYTE3(v11) = 0;
  1245.           v11 &= 0xFFF00000u;
  1246.           v10 = 0;
  1247.           v9 = 1;
  1248.           v7 = v4;
  1249.           v8 = v5;
  1250.           result = sub_10001EE0(a1, a2, (int)&v7);
  1251.         }
  1252.         else
  1253.         {
  1254.           result = snprintf(&v12, 0x80u, "StoreStats - failed, %d\n", result);
  1255.         }
  1256.       }
  1257.     }
  1258.   }
  1259.   return result;
  1260. }
  1261.  
  1262.  
  1263.  
  1264. int __cdecl sub_100026EC()
  1265. {
  1266.   return _clean_type_info_names_internal(&unk_10008CBC);
  1267. }
  1268.  
  1269.  
  1270.  
  1271. int (*__cdecl sub_100027B0())(void)
  1272. {
  1273.   int (*result)(void);
  1274.   unsigned int v1;
  1275.  
  1276.   result = (int (*)(void))&unk_100038AC;
  1277.   v1 = (unsigned int)&unk_100038AC;
  1278.   if ( &unk_100038AC < &unk_100038AC )
  1279.   {
  1280.     do
  1281.     {
  1282.       result = *(int (**)(void))v1;
  1283.       if ( *(_DWORD *)v1 )
  1284.         result = (int (*)(void))result();
  1285.       v1 += 4;
  1286.     }
  1287.     while ( v1 < (unsigned int)&unk_100038AC );
  1288.   }
  1289.   return result;
  1290. }
  1291.  
  1292.  
  1293. BOOL __stdcall DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  1294. {
  1295.   if ( fdwReason == 1 )
  1296.   {
  1297.     if ( !dword_10003114 )
  1298.       DisableThreadLibraryCalls(hinstDLL);
  1299.   }
  1300.   return 1;
  1301. }
  1302.  
  1303.  
  1304.  
  1305. int __cdecl sub_10002B92()
  1306. {
  1307.   dword_10008CD0 = IsProcessorFeaturePresent(0xAu);
  1308.   return 0;
  1309. }
  1310.  
  1311.  
  1312.  
  1313. int __usercall sub_10002BB0<eax>(int a1<ebp>)
  1314. {
  1315.   char v1;
  1316.   int result;
  1317.  
  1318.   result = *(_DWORD *)(a1 + 8) + 28;
  1319.   v1 = (*(_BYTE *)(*(_DWORD *)(a1 + 8) + 32) & 1) == 0;
  1320.   *(_DWORD *)result = &off_100034E8;
  1321.   if ( !v1 )
  1322.     result = SteamAPI_UnregisterCallback(result);
  1323.   return result;
  1324. }
  1325.  
  1326.  
  1327.  
  1328.  
  1329. int __usercall sub_10002BBB<eax>(int a1<ebp>)
  1330. {
  1331.   char v1;
  1332.   int result;
  1333.  
  1334.   result = *(_DWORD *)(a1 + 8) + 48;
  1335.   v1 = (*(_BYTE *)(*(_DWORD *)(a1 + 8) + 52) & 1) == 0;
  1336.   *(_DWORD *)result = &off_100034F8;
  1337.   if ( !v1 )
  1338.     result = SteamAPI_UnregisterCallback(result);
  1339.   return result;
  1340. }
  1341.  
  1342.  
  1343.  
  1344.  
  1345. int __usercall sub_10002BC6<eax>(int a1<ebp>)
  1346. {
  1347.   char v1;
  1348.   int result;
  1349.  
  1350.   result = *(_DWORD *)(a1 + 8) + 68;
  1351.   v1 = (*(_BYTE *)(*(_DWORD *)(a1 + 8) + 72) & 1) == 0;
  1352.   *(_DWORD *)result = &off_10003508;
  1353.   if ( !v1 )
  1354.     result = SteamAPI_UnregisterCallback(result);
  1355.   return result;
  1356. }
  1357.  
  1358.  
  1359.  
  1360.  
  1361. int __cdecl sub_10002BD1(int a1, int a2)
  1362. {
  1363.   __security_check_cookie((a2 + 12) ^ *(_DWORD *)(a2 - 16));
  1364.   return _CxxFrameHandler3(a1, a2);
  1365. }
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!