API tools faq
paste
Advertisement
p_gibson

X10 STM Firmware

p_gibson
Mar 31st, 2018
595
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 52.87 KB | None | 0 0
raw download clone embed print report
  1. #include <defs.h>
  2.  
  3.  
  4. //-------------------------------------------------------------------------
  5. // Function declarations
  6.  
  7. int sub_298();
  8. int sub_340();
  9. void sub_3A8();
  10. _DWORD *__fastcall sub_3C8(unsigned int a1, int a2);
  11. _DWORD *sub_400();
  12. int sub_4AC();
  13. int sub_510();
  14. unsigned int __fastcall sub_6F0(unsigned int result);
  15. unsigned int __fastcall sub_70E(unsigned int result);
  16. int sub_72C();
  17. signed int sub_D68();
  18. signed int __fastcall sub_E24(int a1);
  19. signed int sub_E54();
  20. unsigned int sub_FFC();
  21. int __fastcall sub_13A8(int a1);
  22. int __fastcall sub_13D0(int a1);
  23. int __fastcall sub_13E4(int a1);
  24. unsigned int __fastcall sub_140C(int a1);
  25. int __fastcall sub_1438(int a1);
  26. unsigned int __fastcall sub_144C(int a1);
  27. unsigned int __fastcall sub_1482(int a1);
  28. int __fastcall sub_14A0(int a1, int a2);
  29. int __fastcall sub_151C(int a1, int a2);
  30. int sub_1580();
  31. unsigned int __fastcall sub_15B0(int a1, int a2, int a3, _BYTE *a4, int a5);
  32. int __fastcall sub_1610(int a1);
  33. unsigned int sub_1688();
  34. int sub_16B4();
  35. int __fastcall sub_1DA8(int a1);
  36. int __fastcall sub_1E04(int a1);
  37. int __fastcall sub_1E14(int result);
  38. int __fastcall sub_1E6C(int result);
  39. unsigned int __fastcall sub_1EC4(int a1);
  40. unsigned int __fastcall sub_1ED8(int a1);
  41. unsigned int __fastcall sub_1EEC(int a1);
  42. unsigned int __fastcall sub_1F00(int a1);
  43. signed int __fastcall sub_1F14(char a1, int a2, unsigned int a3, int a4, unsigned int a5);
  44. int __fastcall sub_1F58(int a1);
  45. int __fastcall sub_2004(int result, int a2);
  46. int __fastcall sub_2008(int result, int a2);
  47. int __fastcall sub_200E(int a1, int a2);
  48. int __fastcall sub_2014(int result, int a2);
  49. int __fastcall sub_2026(int result, int a2, int a3, signed int a4);
  50. int __fastcall sub_206A(int result, int a2, int a3, signed int a4);
  51. int __fastcall sub_20A0(int result, int a2, signed int a3);
  52. unsigned int __fastcall sub_20F8(unsigned int result);
  53. _DWORD *__fastcall sub_2158(_DWORD *result);
  54. int __fastcall sub_2162(int result);
  55. _DWORD *__fastcall sub_2174(_DWORD *result);
  56. int __fastcall sub_217E(int a1, int a2, int a3, int a4, int a5, int a6);
  57. unsigned int __fastcall sub_21A8(unsigned int result);
  58. unsigned int *__fastcall sub_2228(unsigned int *result, int a2, int a3, int a4);
  59. _DWORD *__fastcall sub_223A(_DWORD *result);
  60. _DWORD *__fastcall sub_2244(_DWORD *result);
  61. _DWORD *__fastcall sub_224E(_DWORD *result);
  62. int __fastcall sub_2258(int result, int a2);
  63. int __fastcall sub_225C(int result, int a2);
  64. int __fastcall sub_2270(int result, int a2);
  65. int __fastcall sub_2274(int result, int a2);
  66. int __fastcall sub_22A8(int result, int a2);
  67. int __fastcall sub_22DC(int result, int a2, int a3);
  68. int __fastcall sub_2468(int result, int a2);
  69. int __fastcall sub_249C(int result, int a2);
  70. int __fastcall sub_2510(int result, int a2);
  71. int __fastcall sub_2584(int result, int a2);
  72. int __fastcall sub_25F8(int result, int a2);
  73. int __fastcall sub_2650(int result, int a2, int a3);
  74. int __fastcall sub_2670(int result);
  75. int __fastcall sub_2688(int result, int a2);
  76. int __fastcall sub_26B8(int result, int a2);
  77. int __fastcall sub_26CA(int result, int a2);
  78. int __fastcall sub_26D6(int result, int a2);
  79. int __fastcall sub_26E2(int result, int a2);
  80. int __fastcall sub_26EE(int result, int a2);
  81. int __fastcall sub_26FA(int result);
  82. unsigned int __fastcall sub_2704(int a1);
  83. int __fastcall sub_2718(unsigned int a1);
  84. int __fastcall sub_2754(int (**a1)(void), int a2, int a3, int a4, int a5, int a6, __int16 a7);
  85. signed int __fastcall sub_2C70(int a1, int a2);
  86. int __fastcall sub_31A8(int a1);
  87. int __fastcall sub_31B8(char a1);
  88. void sub_31D0();
  89. void sub_31E0();
  90. signed int __fastcall sub_31F0(unsigned int a1);
  91. int __fastcall sub_320C(int result);
  92. int *__fastcall sub_3898(int *result, unsigned __int8 a2, unsigned int a3);
  93.  
  94. //-------------------------------------------------------------------------
  95. // Data declarations
  96.  
  97. _UNKNOWN loc_2732; // weak
  98.  
  99.  
  100. //----- (00000298) --------------------------------------------------------
  101. int sub_298()
  102. {
  103.   sub_31F0(0x43u);
  104.   sub_31F0(0x2Au);
  105.   sub_2026(1073872896, 2, 0, 6144);
  106.   sub_20A0(1073872896, 10, 6144);
  107.   sub_2026(1073875968, 1, 0, 4);
  108.   sub_2008(1073875968, 4);
  109.   sub_6F0(1u);
  110.   sub_2004(1073875968, 4);
  111.   v200001C8 = sub_2754((int (**)(void))0x8003F00, 0x8003A93, 0x8003A53, 0x20000000, 3, 536871237, 128);
  112.   return sub_2C70(v200001C8, 134218237);
  113. }
  114.  
  115. //----- (00000340) --------------------------------------------------------
  116. int sub_340()
  117. {
  118.   sub_1F58(134233740);
  119.   sub_2718(0x600u);
  120.   sub_2718(0x601u);
  121.   sub_2718(0x602u);
  122.   sub_2718(0x603u);
  123.   sub_2718(0x604u);
  124.   sub_2718(0x884u);
  125.   sub_2718(0x88Cu);
  126.   sub_2718(0x80Eu);
  127.   sub_2718(0x80Fu);
  128.   sub_2718(0x800u);
  129.   return sub_2718(0x687u);
  130. }
  131.  
  132. //----- (000003A8) --------------------------------------------------------
  133. void sub_3A8()
  134. {
  135.   sub_31A8(168000);
  136.   sub_31B8(4);
  137.   sub_31E0();
  138.   sub_31D0();
  139. }
  140.  
  141. //----- (000003C8) --------------------------------------------------------
  142. _DWORD *__fastcall sub_3C8(unsigned int a1, int a2)
  143. {
  144.   _DWORD *v2; // r4@1
  145.   int v3; // r5@1
  146.  
  147.   v2 = (_DWORD *)a1;
  148.   v3 = a2;
  149.   sub_20F8(a1);
  150.   sub_217E((int)v2, v3, 0, 0, 2048, 0);
  151.   sub_2162((int)v2);
  152.   sub_2174(v2);
  153.   return sub_2158(v2);
  154. }
  155.  
  156. //----- (00000400) --------------------------------------------------------
  157. _DWORD *sub_400()
  158. {
  159.   sub_2026(1073872896, 2, 0, 224);
  160.   sub_20A0(1073872896, 5, 224);
  161.   sub_206A(1073872896, 0, 2, 160);
  162.   sub_3C8(0x40013000u, 32);
  163.   sub_2026(1073873920, 2, 0, 57344);
  164.   sub_20A0(1073873920, 5, 57344);
  165.   sub_206A(1073873920, 0, 2, 40960);
  166.   sub_3C8(0x40003800u, 24);
  167.   sub_2026(1073874944, 2, 0, 7168);
  168.   sub_20A0(1073874944, 6, 7168);
  169.   sub_206A(1073874944, 0, 2, 5120);
  170.   return sub_3C8(0x40003C00u, 24);
  171. }
  172.  
  173. //----- (000004AC) --------------------------------------------------------
  174. int sub_4AC()
  175. {
  176.   sub_2026(1073872896, 2, 1, 1536);
  177.   sub_20A0(1073872896, 7, 1536);
  178.   sub_2688(1073811456, 115200);
  179.   sub_26B8(1073811456, 8);
  180.   sub_26CA(1073811456, 0);
  181.   sub_26E2(1073811456, 12);
  182.   sub_26D6(1073811456, 0);
  183.   sub_26EE(1073811456, 0);
  184.   return sub_26FA(1073811456);
  185. }
  186.  
  187. //----- (00000510) --------------------------------------------------------
  188. int sub_510()
  189. {
  190.   sub_2026(1073872896, 2, 0, 2);
  191.   sub_206A(1073872896, 0, 0, 2);
  192.   sub_20A0(1073872896, 1, 2);
  193.   sub_21A8(0x40000000u);
  194.   sub_2228((unsigned int *)0x40000000, 0, 0, 0);
  195.   sub_2270(0x40000000, 1680);
  196.   sub_2258(0x40000000, 0);
  197.   sub_225C(0x40000000, 0);
  198.   sub_223A((_DWORD *)0x40000000);
  199.   sub_2244((_DWORD *)0x40000000);
  200.   sub_2584(0x40000000, 2);
  201.   sub_2274(0x40000000, 2);
  202.   sub_2468(0x40000000, 2);
  203.   sub_22A8(0x40000000, 2);
  204.   sub_22DC(0x40000000, 2, 6);
  205.   sub_249C(0x40000000, 2);
  206.   sub_25F8(0x40000000, 2);
  207.   sub_2650(0x40000000, 2, 840);
  208.   sub_223A((_DWORD *)0x40000000);
  209.   sub_2670(0x40000000);
  210.   sub_224E((_DWORD *)0x40000000);
  211.   return sub_2510(0x40000000, 2);
  212. }
  213.  
  214. //----- (Generate Big Delay) --------------------------------------------------------
  215. unsigned int __fastcall sub_6F0(unsigned int result)
  216. {
  217.   unsigned int i; // r3@1
  218.   signed int v2; // r2@3
  219.  
  220.   for ( i = 0; i < result; ++i )
  221.   {
  222.     v2 = 42000;
  223.     do
  224.       --v2;
  225.     while ( v2 );
  226.   }
  227.   return result;
  228. }
  229.  
  230. //----- (Generate Small Delay) --------------------------------------------------------
  231. unsigned int __fastcall sub_70E(unsigned int result)
  232. {
  233.   unsigned int i; // r3@1
  234.   signed int v2; // r2@3
  235.  
  236.   for ( i = 0; i < result; ++i )
  237.   {
  238.     v2 = 39;
  239.     do
  240.       --v2;
  241.     while ( v2 );
  242.   }
  243.   return result;
  244. }
  245.  
  246. //----- (0000072C) --------------------------------------------------------
  247. int sub_72C()
  248. {
  249.   return v2000291C;
  250. }
  251.  
  252. //----- (00000D68) --------------------------------------------------------
  253. signed int sub_D68()
  254. {
  255.   signed int v0; // r4@1
  256.   int v1; // r5@1
  257.  
  258.   sub_6F0(0x64u);
  259.   v0 = 134232932;
  260.   sub_2026(1073873920, 1, 0, 4096);
  261.   sub_2004(1073873920, 4096);
  262.   sub_2026(1073876992, 1, 0, 2);
  263.   sub_2004(1073876992, 2);
  264.   v1 = 0;
  265.  
  266.   do
  267.   {
  268.     sub_2026(*(_DWORD *)(v1 + 134233004), 0, 0, *(_WORD *)(v1 + 134233008));
  269.     sub_2026(*(_DWORD *)v0, 1, 0, *(_WORD *)(v0 + 4));
  270.     sub_2026(*(_DWORD *)(v0 + 8), 1, 0, *(_WORD *)(v0 + 12));
  271.     v1 += 8;
  272.     sub_2026(*(_DWORD *)(v0 + 16), 1, 0, *(_WORD *)(v0 + 20));
  273.     v0 += 24;
  274.   }
  275.   while ( v1 != 24 );
  276.  
  277.   sub_2026(1073873920, 0, 0, 256);
  278.   sub_2026(1073875968, 0, 0, 8);
  279.   sub_2026(1073873920, 1, 0, 16);
  280.   sub_2004(1073873920, 16);
  281.   return 1;
  282. }
  283.  
  284. //----- (00000E24) --------------------------------------------------------
  285. signed int __fastcall sub_E24(int a1)
  286. {
  287.   int v1; // r5@1
  288.   int v2; // r7@1
  289.   signed int v3; // r4@1
  290.  
  291.   v1 = a1;
  292.   v2 = *(_WORD *)(8 * a1 + 0x8003BB0);
  293.   v3 = 10;
  294.   while ( !sub_200E(*(_DWORD *)(8 * v1 + 0x8003BAC), v2) )
  295.   {
  296.     sub_6F0(1u);
  297.     if ( !--v3 )
  298.       return 0;
  299.   }
  300.   return 1;
  301. }
  302.  
  303. //----- (00000E54) --------------------------------------------------------
  304. signed int sub_E54()
  305. {
  306.   signed int v0; // r5@1
  307.   signed int v1; // r4@1
  308.   int v2; // r6@1
  309.   int v3; // r11@4
  310.   int v4; // r2@5
  311.   int v5; // r8@5
  312.   int v6; // ST0C_4@6
  313.   char v7; // r0@6
  314.   int v8; // r3@6
  315.   int v9; // r10@8
  316.   int v10; // r8@9
  317.   int v11; // r11@9
  318.   int v12; // r2@9
  319.   int v13; // ST08_4@11
  320.   int v14; // r0@11
  321.   char v15; // r3@16
  322.   int v16; // r0@18
  323.   int v17; // r3@19
  324.   int v19; // [sp+0h] [bp-38h]@4
  325.   char v20; // [sp+4h] [bp-34h]@4
  326.  
  327.   v0 = 536874176;
  328.   sub_3898((int *)0x20000CC0, 0, 0xA5Cu);
  329.   sub_D68();
  330.   sub_1688();
  331.   v1 = 536874176;
  332.   v2 = 0;
  333.   do
  334.   {
  335.     sub_16B4();
  336.     if ( !sub_E24(v2) )
  337.       *(_BYTE *)(v1 + 800) = 1;
  338.     v20 = 4 * v2;
  339.     v19 = 884 * v2;
  340.     v3 = 0;
  341.     do
  342.     {
  343.       v4 = (unsigned __int8)(v20 + v3);
  344.       v5 = 0;
  345.       do
  346.       {
  347.         v6 = v4;
  348.         v7 = v20000098(v4, v5);
  349.         v8 = v19 + 192 * v3 + 12 * v5++ + 536874176;
  350.         *(_BYTE *)(v8 + 8) = v7;
  351.         sub_6F0(1u);
  352.         v4 = v6;
  353.       }
  354.       while ( v5 != 16 );
  355.       ++v3;
  356.     }
  357.     while ( v3 != 4 );
  358.     v9 = 0;
  359.     do
  360.     {
  361.       v10 = v19 + 192 * v9 + 536874176;
  362.       v11 = 0;
  363.       v12 = (unsigned __int8)(v20 + v9);
  364.       do
  365.       {
  366.         if ( *(_BYTE *)(v10 + 8) == 3 )
  367.         {
  368.           v13 = v12;
  369.           v14 = v2000009C(v12, v11);
  370.           v12 = v13;
  371.           if ( v14 )
  372.             ++*(_BYTE *)(v1 + 768);
  373.           else
  374.             *(_BYTE *)(v10 + 8) = 2;
  375.         }
  376.         ++v11;
  377.         v10 += 12;
  378.       }
  379.       while ( v11 != 16 );
  380.       ++v9;
  381.     }
  382.     while ( v9 != 4 );
  383.     if ( *(_BYTE *)(v1 + 768) == 64 )
  384.       v15 = 3;
  385.     else
  386.       v15 = 2;
  387.     *(_BYTE *)(v1 + 800) = v15;
  388.     *(_BYTE *)(v1 + 770) = 26;
  389.     *(_BYTE *)(v1 + 773) = 55;
  390.     *(_BYTE *)(v1 + 774) = 50;
  391.     *(_BYTE *)(v1 + 771) = 0;
  392.     *(_BYTE *)(v1 + 772) = sub_1610(v2);
  393.     *(_DWORD *)(v1 + 788) = sub_72C() + 5000;
  394.     v16 = sub_72C();
  395.     ++v2;
  396.     *(_DWORD *)(v1 + 792) = v16;
  397.     *(_DWORD *)(v1 + 784) = 0;
  398.     *(_DWORD *)(v1 + 776) = 0;
  399.     *(_DWORD *)(v1 + 796) = 0;
  400.     v1 += 884;
  401.   }
  402.   while ( v2 != 3 );
  403.   v17 = v200016A8 + v20001334 + v20000FC0;
  404.   do
  405.   {
  406.     if ( v17 > 181 )
  407.     {
  408.       *(_BYTE *)(v0 + 769) = 64;
  409.       *(_BYTE *)(v0 + 800) = 3;
  410.     }
  411.     else
  412.     {
  413.       LOBYTE(v16) = *(_BYTE *)(v0 + 768);
  414.     }
  415.     if ( v17 <= 181 )
  416.       *(_BYTE *)(v0 + 769) = v16;
  417.     v0 += 884;
  418.   }
  419.   while ( v0 != 536876828 );
  420.   return 1;
  421. }
  422. // 20000098: using guessed type int (__fastcall *)(_DWORD, _DWORD);
  423. // 2000009C: using guessed type int (__fastcall *)(_DWORD, _DWORD);
  424.  
  425. //----- (00000FFC) --------------------------------------------------------
  426. unsigned int sub_FFC()
  427. {
  428.   signed int v0; // r11@1
  429.   signed int v1; // r9@1
  430.   signed int v2; // r7@1
  431.   int v3; // r6@1
  432.   int v4; // r8@4
  433.   int v5; // r10@5
  434.   int v6; // r4@5
  435.   int v7; // r3@7
  436.   int v8; // r5@9
  437.   int v9; // r2@15
  438.   int v10; // r3@16
  439.   int v11; // r0@18
  440.   int v12; // r2@18
  441.   void (__cdecl *v13)(int); // r3@19
  442.   signed int v14; // r4@21
  443.   signed int v15; // r5@21
  444.   signed int v16; // r6@21
  445.   int v17; // r8@21
  446.   int v18; // r0@23
  447.   int v19; // r3@23
  448.   int v20; // r10@26
  449.   int v21; // r9@27
  450.   int v22; // r7@27
  451.   unsigned int result; // r0@33
  452.   int v24; // r1@36
  453.   int v25; // r0@36
  454.   unsigned int v26; // r0@53
  455.   int v27; // r1@53
  456.   char v28; // cf@53
  457.   int v29; // r0@53
  458.   unsigned int v30; // r0@55
  459.   int v31; // [sp+0h] [bp-38h]@27
  460.  
  461.   v0 = 536874176;
  462.   v1 = 536876828;
  463.   v2 = 536874176;
  464.   v3 = 0;
  465.   do
  466.   {
  467.     if ( *(_BYTE *)(v2 + 800) == 5 && *(_DWORD *)(v2 + 780) )
  468.     {
  469.       v4 = 0;
  470.       do
  471.       {
  472.         v5 = 0;
  473.         v6 = 884 * v3 + 192 * v4 + 536874176;
  474.         do
  475.         {
  476.           if ( (unsigned int)*(_BYTE *)(v6 + 8) - 2 <= 1 )
  477.           {
  478.             v7 = 0;
  479.             do
  480.             {
  481.               if ( !*(_BYTE *)(v1 + 12 * v7 + 11) )
  482.               {
  483.                 v8 = 12 * v7 + 1536 * v3 + 536876828;
  484.                 goto LABEL_10;
  485.               }
  486.               ++v7;
  487.             }
  488.             while ( v7 != 128 );
  489.             v8 = v1;
  490. LABEL_10:
  491.             if ( v200000B4((unsigned __int8)(4 * v3 + v4), v5, v8) <= 0 )
  492.             {
  493.               ++*(_DWORD *)(v6 + 4);
  494.             }
  495.             else
  496.             {
  497.               *(_BYTE *)(v8 + 11) = 1;
  498.               *(_DWORD *)(v2 + 784) = sub_72C() + 5000;
  499.               ++*(_DWORD *)v6;
  500.             }
  501.           }
  502.           ++v5;
  503.           v6 += 12;
  504.         }
  505.         while ( v5 != 16 );
  506.         ++v4;
  507.       }
  508.       while ( v4 != 4 );
  509.     }
  510.     ++v3;
  511.     v2 += 884;
  512.     v1 += 1536;
  513.   }
  514.   while ( v3 != 3 );
  515.   v9 = v20000CB8;
  516.   if ( v20000CB8 != v20000CBC )
  517.   {
  518.     v10 = (v20000CB8 + 1) & 7;
  519.     if ( v20000CB8 + 1 <= 0 )
  520.       v10 = -(-(v20000CB8 + 1) & 7);
  521.     v20000CB8 = v10;
  522.     v11 = 220 * v9 + 536872408;
  523.     v12 = *(_BYTE *)(220 * v9 + 0x200005D9);
  524.     if ( (unsigned int)(v12 - 1) <= 6 )
  525.     {
  526.       v13 = *(void (__cdecl **)(int))(8 * v12 + 0x8003B28);
  527.       if ( v13 )
  528.         v13(v11);
  529.     }
  530.   }
  531.   v14 = 134232932;
  532.   v15 = 536874176;
  533.   v16 = 134232932;
  534.   v17 = 0;
  535.   do
  536.   {
  537.     if ( (unsigned int)sub_72C() >= *(_DWORD *)(v15 + 788) )
  538.     {
  539.       *(_BYTE *)(v15 + 772) = sub_1610(v17);
  540.       v18 = sub_72C();
  541.       v19 = *(_BYTE *)(v15 + 800);
  542.       *(_DWORD *)(v15 + 788) = v18 + 10000;
  543.       if ( v19 == 4 )
  544.       {
  545.         if ( *(_BYTE *)(v15 + 772) < (signed int)*(_BYTE *)(v15 + 773) )
  546.           *(_BYTE *)(v15 + 800) = 5;
  547.       }
  548.       else if ( v19 == 5 && *(_BYTE *)(v15 + 772) > (signed int)*(_BYTE *)(v15 + 773) )
  549.       {
  550.         *(_BYTE *)(v15 + 800) = 4;
  551.         sub_2004(*(_DWORD *)v16, *(_WORD *)(v16 + 4));
  552.         sub_2004(*(_DWORD *)(v16 + 8), *(_WORD *)(v16 + 12));
  553.         v20 = 0;
  554.         do
  555.         {
  556.           v31 = (unsigned __int8)(4 * v17 + v20);
  557.           v21 = 0;
  558.           v22 = 884 * v17 + 192 * v20 + 536874176;
  559.           do
  560.           {
  561.             if ( (unsigned int)*(_BYTE *)(v22 + 8) - 2 <= 1 )
  562.             {
  563.               v200000B0(v31, v21);
  564.               v20000094(v31, v21);
  565.               *(_BYTE *)(v22 + 9) = 0;
  566.             }
  567.             ++v21;
  568.             v22 += 12;
  569.           }
  570.           while ( v21 != 16 );
  571.           ++v20;
  572.         }
  573.         while ( v20 != 4 );
  574.       }
  575.     }
  576.     ++v17;
  577.     v15 += 884;
  578.     v16 += 24;
  579.   }
  580.   while ( v17 != 3 );
  581.   do
  582.   {
  583.     result = sub_72C();
  584.     if ( result >= *(_DWORD *)(v0 + 792) )
  585.     {
  586.       *(_DWORD *)(v0 + 792) = sub_72C() + 1000;
  587.       result = sub_72C();
  588.       if ( result >= *(_DWORD *)(v0 + 796) )
  589.       {
  590.         switch ( *(_BYTE *)(v0 + 800) )
  591.         {
  592.           case 0:
  593.             sub_2008(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
  594.             goto LABEL_48;
  595.           case 1:
  596.             sub_2014(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
  597.             goto LABEL_48;
  598.           case 2:
  599.             sub_2004(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
  600. LABEL_48:
  601.             sub_2008(*(_DWORD *)(v14 + 8), *(_WORD *)(v14 + 12));
  602.             v24 = *(_WORD *)(v14 + 20);
  603.             v25 = *(_DWORD *)(v14 + 16);
  604.             goto LABEL_49;
  605.           case 3:
  606.             sub_2004(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
  607.             goto LABEL_36;
  608.           case 5:
  609.             sub_2004(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
  610.             v26 = sub_72C();
  611.             v27 = *(_WORD *)(v14 + 20);
  612.             v28 = v26 >= *(_DWORD *)(v0 + 776) + 5000;
  613.             v29 = *(_DWORD *)(v14 + 16);
  614.             if ( v28 )
  615.             {
  616.               sub_2014(v29, v27);
  617.               *(_DWORD *)(v0 + 784) = 0;
  618.             }
  619.             else
  620.             {
  621.               sub_2004(v29, v27);
  622.             }
  623.             v30 = sub_72C();
  624.             v24 = *(_WORD *)(v14 + 12);
  625.             v28 = v30 >= *(_DWORD *)(v0 + 784);
  626.             v25 = *(_DWORD *)(v14 + 8);
  627.             if ( !v28 )
  628.               goto LABEL_37;
  629. LABEL_49:
  630.             result = sub_2008(v25, v24);
  631.             break;
  632.           case 4:
  633.             sub_2014(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
  634.             sub_2014(*(_DWORD *)(v14 + 8), *(_WORD *)(v14 + 12));
  635.             result = sub_2004(*(_DWORD *)(v14 + 16), *(_WORD *)(v14 + 20));
  636.             break;
  637.           default:
  638.             break;
  639.         }
  640.       }
  641.       else
  642.       {
  643.         sub_2014(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
  644. LABEL_36:
  645.         sub_2014(*(_DWORD *)(v14 + 8), *(_WORD *)(v14 + 12));
  646.         v24 = *(_WORD *)(v14 + 20);
  647.         v25 = *(_DWORD *)(v14 + 16);
  648. LABEL_37:
  649.         result = sub_2014(v25, v24);
  650.       }
  651.     }
  652.     v14 += 24;
  653.     v0 += 884;
  654.   }
  655.   while ( v14 != 134233004 );
  656.   return result;
  657. }
  658. // 20000094: using guessed type int (__fastcall *)(_DWORD, _DWORD);
  659. // 200000B0: using guessed type int (__fastcall *)(_DWORD, _DWORD);
  660. // 200000B4: using guessed type int (__fastcall *)(_DWORD, _DWORD, _DWORD);
  661.  
  662. //----- (000013A8) --------------------------------------------------------
  663. int __fastcall sub_13A8(int a1)
  664. {
  665.   int v1; // r0@1
  666.   signed int v2; // r5@1
  667.   int v3; // r4@1
  668.  
  669.   v1 = 16 * a1 + 134233148;
  670.   v2 = *(_WORD *)(v1 + 12);
  671.   v3 = *(_DWORD *)(v1 + 8);
  672.   sub_2026(*(_DWORD *)(v1 + 8), 1, 0, v2);
  673.   return sub_2004(v3, v2);
  674. }
  675.  
  676. //----- (000013D0) --------------------------------------------------------
  677. int __fastcall sub_13D0(int a1)
  678. {
  679.   return sub_2004(*(_DWORD *)(16 * a1 + 0x8003C3C), *(_WORD *)(16 * a1 + 0x8003C40));
  680. }
  681.  
  682. //----- (000013E4) --------------------------------------------------------
  683. int __fastcall sub_13E4(int a1)
  684. {
  685.   int v1; // r0@1
  686.   signed int v2; // r5@1
  687.   int v3; // r4@1
  688.  
  689.   v1 = 16 * a1 + 134233148;
  690.   v2 = *(_WORD *)(v1 + 12);
  691.   v3 = *(_DWORD *)(v1 + 8);
  692.   sub_2026(*(_DWORD *)(v1 + 8), 1, 0, v2);
  693.   return sub_2008(v3, v2);
  694. }
  695.  
  696. //----- (0000140C) --------------------------------------------------------
  697. unsigned int __fastcall sub_140C(int a1)
  698. {
  699.   int v1; // r4@1
  700.  
  701.   v1 = a1;
  702.   sub_13E4(a1);
  703.   sub_70E(1u);
  704.   sub_13D0(v1);
  705.   sub_70E(1u);
  706.   sub_13A8(v1);
  707.   return sub_70E(1u);
  708. }
  709.  
  710. //----- (00001438) --------------------------------------------------------
  711. int __fastcall sub_1438(int a1)
  712. {
  713.   return sub_2008(*(_DWORD *)(16 * a1 + 0x8003C3C), *(_WORD *)(16 * a1 + 0x8003C40));
  714. }
  715.  
  716. //----- (0000144C) --------------------------------------------------------
  717. unsigned int __fastcall sub_144C(int a1)
  718. {
  719.   int v1; // r4@1
  720.  
  721.   v1 = a1;
  722.   sub_13A8(a1);
  723.   sub_70E(1u);
  724.   sub_13D0(v1);
  725.   sub_70E(1u);
  726.   sub_13E4(v1);
  727.   sub_70E(1u);
  728.   sub_1438(v1);
  729.   return sub_70E(1u);
  730. }
  731.  
  732. //----- (00001482) --------------------------------------------------------
  733. unsigned int __fastcall sub_1482(int a1)
  734. {
  735.   int v1; // r4@1
  736.  
  737.   v1 = a1;
  738.   sub_13D0(a1);
  739.   sub_70E(1u);
  740.   sub_1438(v1);
  741.   return sub_70E(1u);
  742. }
  743.  
  744. //----- (000014A0) --------------------------------------------------------
  745. int __fastcall sub_14A0(int a1, int a2)
  746. {
  747.   int v2; // r7@1
  748.   signed int v3; // r9@1
  749.   int v4; // r4@1
  750.   int v5; // r8@1
  751.   int v6; // r6@1
  752.   int v7; // r5@1
  753.  
  754.   v2 = *(_DWORD *)(16 * a1 + 0x8003C44);
  755.   v3 = *(_WORD *)(16 * a1 + 0x8003C48);
  756.   v4 = a1;
  757.   v5 = a2;
  758.   sub_2026(*(_DWORD *)(16 * a1 + 0x8003C44), 0, 0, v3);
  759.   v6 = 0;
  760.   v7 = 0;
  761.   do
  762.   {
  763.     sub_70E(1u);
  764.     sub_13D0(v4);
  765.     sub_70E(1u);
  766.     if ( sub_200E(v2, v3) )
  767.       v7 = (unsigned __int8)(v7 | (128 >> v6));
  768.     ++v6;
  769.     sub_1438(v4);
  770.   }
  771.   while ( v6 != 8 );
  772.   if ( v5 )
  773.     sub_13A8(v4);
  774.   else
  775.     sub_13E4(v4);
  776.   sub_1482(v4);
  777.   return v7;
  778. }
  779.  
  780. //----- (0000151C) --------------------------------------------------------
  781. int __fastcall sub_151C(int a1, int a2)
  782. {
  783.   int v2; // r4@1
  784.   int v3; // r6@1
  785.   int v4; // r5@1
  786.   int v5; // r5@5
  787.   signed int v6; // r6@5
  788.  
  789.   v2 = a1;
  790.   v3 = a2;
  791.   v4 = 0;
  792.   do
  793.   {
  794.     if ( (128 >> v4) & v3 )
  795.       sub_13A8(v2);
  796.     else
  797.       sub_13E4(v2);
  798.     ++v4;
  799.     sub_1482(v2);
  800.   }
  801.   while ( v4 != 8 );
  802.   v5 = *(_DWORD *)(16 * v2 + 0x8003C44);
  803.   v6 = *(_WORD *)(16 * v2 + 0x8003C48);
  804.   sub_2026(*(_DWORD *)(16 * v2 + 0x8003C44), 0, 0, v6);
  805.   sub_13D0(v2);
  806.   sub_70E(1u);
  807.   sub_200E(v5, v6);
  808.   return sub_1438(v2);
  809. }
  810.  
  811. //----- (00001580) --------------------------------------------------------
  812. int sub_1580()
  813. {
  814.   signed int v0; // r4@1
  815.   int result; // r0@2
  816.  
  817.   v0 = 134233148;
  818.   do
  819.   {
  820.     sub_2026(*(_DWORD *)v0, 1, 0, *(_WORD *)(v0 + 4));
  821.     v0 += 16;
  822.     result = sub_2026(*(_DWORD *)(v0 - 8), 1, 0, *(_WORD *)(v0 - 4));
  823.   }
  824.   while ( v0 != 134233196 );
  825.   return result;
  826. }
  827.  
  828. //----- (000015B0) --------------------------------------------------------
  829. unsigned int __fastcall sub_15B0(int a1, int a2, int a3, _BYTE *a4, int a5)
  830. {
  831.   int v5; // r4@1
  832.   int v6; // r7@1
  833.   int v7; // r8@1
  834.   _BYTE *v8; // r6@1
  835.   _BYTE *v9; // r7@1
  836.   unsigned int v10; // r5@1
  837.  
  838.   v5 = a1;
  839.   v6 = a2;
  840.   v7 = a3;
  841.   v8 = a4;
  842.   sub_144C(a1);
  843.   sub_151C(v5, v6 & 0xFE);
  844.   sub_151C(v5, v7);
  845.   sub_144C(v5);
  846.   sub_151C(v5, v6 | 1);
  847.   v9 = v8;
  848.   v10 = a5 - 1;
  849.   while ( v10 > v9 - v8 )
  850.     *v9++ = sub_14A0(v5, 0);
  851.   v8[v10] = sub_14A0(v5, 1);
  852.   return sub_140C(v5);
  853. }
  854.  
  855. //----- (00001610) --------------------------------------------------------
  856. int __fastcall sub_1610(int a1)
  857. {
  858.   int v1; // r4@1
  859.   int v2; // r3@2
  860.   signed int v3; // r0@3
  861.   int v4; // r4@3
  862.   int v5; // r2@3
  863.   signed int v6; // r3@3
  864.   char v8; // [sp+Fh] [bp-11h]@1
  865.  
  866.   v1 = a1;
  867.   sub_15B0(a1, 144, 0, &v8, 1);
  868.   if ( (unsigned __int8)(v8 - 1) <= 0x7Du )
  869.   {
  870.     v2 = *(_DWORD *)(4 * v1 + 0x20002930);
  871.     *(_BYTE *)(5 * v1 + 536881440 + v2) = v8;
  872.     *(_DWORD *)(4 * v1 + 0x20002930) = (v2 + 1) % 5;
  873.   }
  874.   v3 = 0;
  875.   v4 = 5 * v1 + 536881440;
  876.   v5 = 0;
  877.   v6 = 0;
  878.   do
  879.   {
  880.     if ( *(_BYTE *)(v4 + v5) )
  881.     {
  882.       v6 += *(_BYTE *)(v4 + v5);
  883.       ++v3;
  884.     }
  885.     ++v5;
  886.   }
  887.   while ( v5 != 5 );
  888.   if ( !v3 )
  889.     v3 = 1;
  890.   return (char)(v6 / v3);
  891. }
  892.  
  893. //----- (00001688) --------------------------------------------------------
  894. unsigned int sub_1688()
  895. {
  896.   sub_2004(1073876992, 2);
  897.   sub_6F0(1u);
  898.   sub_2008(1073876992, 2);
  899.   return sub_6F0(2u);
  900. }
  901.  
  902. //----- (000016B4) --------------------------------------------------------
  903. int sub_16B4()
  904. {
  905.   int v0; // r5@1
  906.   int v1; // r4@2
  907.   int v2; // r7@3
  908.   signed int v3; // r8@3
  909.   int v4; // r7@3
  910.   signed int v5; // r8@3
  911.  
  912.   v0 = 0;
  913.   do
  914.   {
  915.     v1 = v0 + 134233196;
  916.     do
  917.     {
  918.       v2 = *(_DWORD *)(v1 + 4);
  919.       v3 = *(_WORD *)(v1 + 8);
  920.       sub_2026(*(_DWORD *)(v1 + 4), 1, 0, v3);
  921.       sub_206A(v2, 0, 2, v3);
  922.       sub_2004(v2, v3);
  923.       v4 = *(_DWORD *)(v1 + 20);
  924.       v5 = *(_WORD *)(v1 + 24);
  925.       sub_2026(*(_DWORD *)(v1 + 20), 1, 0, v5);
  926.       sub_206A(v4, 0, 2, v5);
  927.       v1 += 8;
  928.       sub_2008(v4, v5);
  929.     }
  930.     while ( v1 != v0 + 134233212 );
  931.     v0 += 36;
  932.   }
  933.   while ( v0 != 432 );
  934.   v2000293C = v8003C80;
  935.   v20002940 = v8003C84;
  936.   return sub_2004(1073876992, 32);
  937. }
  938.  
  939. //----- (00001DA8) --------------------------------------------------------
  940. int __fastcall sub_1DA8(int a1)
  941. {
  942.   int result; // r0@2
  943.   unsigned int *v2; // r3@4
  944.  
  945.   switch ( a1 )
  946.   {
  947.     case 0:
  948.       return (v40023800 >> 25) & 1;
  949.     case 3:
  950.       return (v40023800 >> 17) & 1;
  951.     case 4:
  952.       v2 = (unsigned int *)1073887232;
  953.       goto LABEL_5;
  954.     case 5:
  955.       v2 = (unsigned int *)1073887344;
  956.       goto LABEL_5;
  957.     case 6:
  958.       v2 = (unsigned int *)1073887348;
  959. LABEL_5:
  960.       result = (*v2 >> 1) & 1;
  961.       break;
  962.     case 1:
  963.       result = (v40023800 >> 29) & 1;
  964.       break;
  965.     case 2:
  966.       result = (v40023800 >> 27) & 1;
  967.       break;
  968.     default:
  969.       result = 0;
  970.       break;
  971.   }
  972.   return result;
  973. }
  974.  
  975. //----- (00001E04) --------------------------------------------------------
  976. int __fastcall sub_1E04(int a1)
  977. {
  978.   int v1; // r2@1
  979.   int result; // r0@2
  980.  
  981.   v1 = a1;
  982.   do
  983.     result = sub_1DA8(v1);
  984.   while ( !result );
  985.   return result;
  986. }
  987.  
  988. //----- (00001E14) --------------------------------------------------------
  989. int __fastcall sub_1E14(int result)
  990. {
  991.   int *v1; // r2@2
  992.   int v2; // r3@2
  993.  
  994.   switch ( result )
  995.   {
  996.     case 0:
  997.       v1 = (int *)1073887232;
  998.       v2 = v40023800 | 0x1000000;
  999.       goto LABEL_3;
  1000.     case 3:
  1001.       v1 = (int *)1073887232;
  1002.       v2 = v40023800 | 0x10000;
  1003.       goto LABEL_3;
  1004.     case 4:
  1005.       v1 = (int *)1073887232;
  1006.       goto LABEL_6;
  1007.     case 5:
  1008.       v1 = (int *)1073887344;
  1009.       goto LABEL_6;
  1010.     case 6:
  1011.       v1 = (int *)1073887348;
  1012. LABEL_6:
  1013.       v2 = *v1 | 1;
  1014.       goto LABEL_3;
  1015.     case 1:
  1016.       v1 = (int *)1073887232;
  1017.       v2 = v40023800 | 0x10000000;
  1018.       goto LABEL_3;
  1019.     case 2:
  1020.       v1 = (int *)1073887232;
  1021.       v2 = v40023800 | 0x4000000;
  1022. LABEL_3:
  1023.       *v1 = v2;
  1024.       break;
  1025.     default:
  1026.       return result;
  1027.   }
  1028.   return result;
  1029. }
  1030.  
  1031. //----- (00001E6C) --------------------------------------------------------
  1032. int __fastcall sub_1E6C(int result)
  1033. {
  1034.   unsigned int *v1; // r2@2
  1035.   unsigned int v2; // r3@2
  1036.  
  1037.   switch ( result )
  1038.   {
  1039.     case 0:
  1040.       v1 = (unsigned int *)1073887232;
  1041.       v2 = v40023800 & 0xFEFFFFFF;
  1042.       goto LABEL_3;
  1043.     case 3:
  1044.       v1 = (unsigned int *)1073887232;
  1045.       v2 = v40023800 & 0xFFFEFFFF;
  1046.       goto LABEL_3;
  1047.     case 4:
  1048.       v1 = (unsigned int *)1073887232;
  1049.       goto LABEL_6;
  1050.     case 5:
  1051.       v1 = (unsigned int *)1073887344;
  1052.       goto LABEL_6;
  1053.     case 6:
  1054.       v1 = (unsigned int *)1073887348;
  1055. LABEL_6:
  1056.       v2 = *v1 & 0xFFFFFFFE;
  1057.       goto LABEL_3;
  1058.     case 1:
  1059.       v1 = (unsigned int *)1073887232;
  1060.       v2 = v40023800 & 0xEFFFFFFF;
  1061.       goto LABEL_3;
  1062.     case 2:
  1063.       v1 = (unsigned int *)1073887232;
  1064.       v2 = v40023800 & 0xFBFFFFFF;
  1065. LABEL_3:
  1066.       *v1 = v2;
  1067.       break;
  1068.     default:
  1069.       return result;
  1070.   }
  1071.   return result;
  1072. }
  1073.  
  1074. //----- (00001EC4) --------------------------------------------------------
  1075. unsigned int __fastcall sub_1EC4(int a1)
  1076. {
  1077.   unsigned int result; // r0@1
  1078.  
  1079.   result = a1 | v40023808 & 0xFFFFFFFC;
  1080.   v40023808 = result;
  1081.   return result;
  1082. }
  1083.  
  1084. //----- (00001ED8) --------------------------------------------------------
  1085. unsigned int __fastcall sub_1ED8(int a1)
  1086. {
  1087.   unsigned int result; // r0@1
  1088.  
  1089.   result = v40023808 & 0xFFFF1FFF | (a1 << 13);
  1090.   v40023808 = result;
  1091.   return result;
  1092. }
  1093.  
  1094. //----- (00001EEC) --------------------------------------------------------
  1095. unsigned int __fastcall sub_1EEC(int a1)
  1096. {
  1097.   unsigned int result; // r0@1
  1098.  
  1099.   result = v40023808 & 0xFFFFE3FF | (a1 << 10);
  1100.   v40023808 = result;
  1101.   return result;
  1102. }
  1103.  
  1104. //----- (00001F00) --------------------------------------------------------
  1105. unsigned int __fastcall sub_1F00(int a1)
  1106. {
  1107.   unsigned int result; // r0@1
  1108.  
  1109.   result = v40023808 & 0xFFFFFF0F | 16 * a1;
  1110.   v40023808 = result;
  1111.   return result;
  1112. }
  1113.  
  1114. //----- (00001F14) --------------------------------------------------------
  1115. signed int __fastcall sub_1F14(char a1, int a2, unsigned int a3, int a4, unsigned int a5)
  1116. {
  1117.   int v5; // r3@1
  1118.   signed int result; // r0@1
  1119.   int v7; // r3@1
  1120.   unsigned int v8; // r1@1
  1121.   signed int v9; // r2@1
  1122.   int v10; // r1@1
  1123.  
  1124.   v5 = (a4 << 24) & 0xF000000 | 0x400000 | a1 & 0x3F;
  1125.   result = 32704;
  1126.   v7 = v5 | (a2 << 6) & 0x7FC0;
  1127.   v8 = a3 >> 1;
  1128.   v9 = a5;
  1129.   v10 = (v8 - 1) << 16;
  1130.   if ( a5 < 2 )
  1131.     v9 = 2;
  1132.   v40023804 = v7 | v10 & 0x30000 | (v9 << 28) & 0x70000000;
  1133.   return result;
  1134. }
  1135.  
  1136. //----- (00001F58) --------------------------------------------------------
  1137. int __fastcall sub_1F58(int a1)
  1138. {
  1139.   int v1; // r4@1
  1140.   int v2; // r0@1
  1141.  
  1142.   v1 = a1;
  1143.   sub_1E14(4);
  1144.   sub_1E04(4);
  1145.   sub_1EC4(0);
  1146.   sub_1E14(3);
  1147.   sub_1E04(3);
  1148.   v2 = *(_BYTE *)(v1 + 15);
  1149.   if ( *(_BYTE *)(v1 + 15) )
  1150.     v2 = 1;
  1151.   sub_320C(v2);
  1152.   sub_1F00(*(_BYTE *)(v1 + 12));
  1153.   sub_1EEC(*(_BYTE *)(v1 + 13));
  1154.   sub_1ED8(*(_BYTE *)(v1 + 14));
  1155.   sub_1F14(*(_BYTE *)v1, *(_WORD *)(v1 + 2), *(_BYTE *)(v1 + 4), *(_BYTE *)(v1 + 5), *(_BYTE *)(v1 + 6));
  1156.   v40023800 |= 0x1000000u;
  1157.   sub_1E04(0);
  1158.   sub_2704(*(_DWORD *)(v1 + 8));
  1159.   sub_1EC4(2);
  1160.   while ( ((v40023808 >> 2) & 3) != 2 )
  1161.     ;
  1162.   v20000138 = *(_DWORD *)(v1 + 16);
  1163.   v2000013C = *(_DWORD *)(v1 + 20);
  1164.   v20000140 = *(_DWORD *)(v1 + 24);
  1165.   return sub_1E6C(4);
  1166. }
  1167.  
  1168. //----- (00002004) --------------------------------------------------------
  1169. int __fastcall sub_2004(int result, int a2)
  1170. {
  1171.   *(_DWORD *)(result + 24) = a2;
  1172.   return result;
  1173. }
  1174.  
  1175. //----- (00002008) --------------------------------------------------------
  1176. int __fastcall sub_2008(int result, int a2)
  1177. {
  1178.   *(_DWORD *)(result + 24) = a2 << 16;
  1179.   return result;
  1180. }
  1181.  
  1182. //----- (0000200E) --------------------------------------------------------
  1183. int __fastcall sub_200E(int a1, int a2)
  1184. {
  1185.   return *(_DWORD *)(a1 + 16) & a2;
  1186. }
  1187.  
  1188. //----- (00002014) --------------------------------------------------------
  1189. int __fastcall sub_2014(int result, int a2)
  1190. {
  1191.   *(_DWORD *)(result + 24) = a2 & ~*(_DWORD *)(result + 20) | ((*(_DWORD *)(result + 20) & a2) << 16);
  1192.   return result;
  1193. }
  1194.  
  1195. //----- (00002026) --------------------------------------------------------
  1196. int __fastcall sub_2026(int result, int a2, int a3, signed int a4)
  1197. {
  1198.   int v4; // r5@1
  1199.   int v5; // r4@1
  1200.   int v6; // r6@1
  1201.   int v7; // lr@3
  1202.  
  1203.   v4 = *(_DWORD *)result;
  1204.   v5 = *(_DWORD *)(result + 12);
  1205.   v6 = 0;
  1206.   do
  1207.   {
  1208.     if ( (a4 >> v6) & 1 )
  1209.     {
  1210.       v7 = ~(3 << 2 * v6);
  1211.       v4 = (a2 << 2 * v6) | v7 & v4;
  1212.       v5 = v7 & v5 | (a3 << 2 * v6);
  1213.     }
  1214.     ++v6;
  1215.   }
  1216.   while ( v6 != 16 );
  1217.   *(_DWORD *)result = v4;
  1218.   *(_DWORD *)(result + 12) = v5;
  1219.   return result;
  1220. }
  1221.  
  1222. //----- (0000206A) --------------------------------------------------------
  1223. int __fastcall sub_206A(int result, int a2, int a3, signed int a4)
  1224. {
  1225.   char v4; // zf@1
  1226.   int v5; // r1@1
  1227.   int v6; // r1@2
  1228.   int v7; // r1@4
  1229.   int v8; // r4@4
  1230.  
  1231.   v4 = a2 == 1;
  1232.   v5 = *(_DWORD *)(result + 4);
  1233.   if ( v4 )
  1234.     v6 = v5 | a4;
  1235.   else
  1236.     v6 = v5 & ~a4;
  1237.   *(_DWORD *)(result + 4) = v6;
  1238.   v7 = *(_DWORD *)(result + 8);
  1239.   v8 = 0;
  1240.   do
  1241.   {
  1242.     if ( (a4 >> v8) & 1 )
  1243.       v7 = v7 & ~(3 << 2 * v8) | (a3 << 2 * v8);
  1244.     ++v8;
  1245.   }
  1246.   while ( v8 != 16 );
  1247.   *(_DWORD *)(result + 8) = v7;
  1248.   return result;
  1249. }
  1250.  
  1251. //----- (000020A0) --------------------------------------------------------
  1252. int __fastcall sub_20A0(int result, int a2, signed int a3)
  1253. {
  1254.   int v3; // r7@1
  1255.   int v4; // r6@1
  1256.   int v5; // r3@1
  1257.   int v6; // r3@5
  1258.  
  1259.   v3 = *(_DWORD *)(result + 32);
  1260.   v4 = *(_DWORD *)(result + 36);
  1261.   v5 = 0;
  1262.   do
  1263.   {
  1264.     if ( (a3 >> v5) & 1 )
  1265.       v3 = v3 & ~(15 << 4 * v5) | (a2 << 4 * v5);
  1266.     ++v5;
  1267.   }
  1268.   while ( v5 != 8 );
  1269.   v6 = 0;
  1270.   do
  1271.   {
  1272.     if ( (a3 >> (v6 + 8)) & 1 )
  1273.       v4 = v4 & ~(15 << 4 * v6) | (a2 << 4 * v6);
  1274.     ++v6;
  1275.   }
  1276.   while ( v6 != 8 );
  1277.   *(_DWORD *)(result + 32) = v3;
  1278.   *(_DWORD *)(result + 36) = v4;
  1279.   return result;
  1280. }
  1281.  
  1282. //----- (000020F8) --------------------------------------------------------
  1283. unsigned int __fastcall sub_20F8(unsigned int result)
  1284. {
  1285.   unsigned int v1; // r0@9
  1286.   _DWORD *v2; // r3@11
  1287.   int v3; // r1@11
  1288.   signed int v4; // r0@11
  1289.  
  1290.   if ( result == 1073819648 )
  1291.   {
  1292.     v1 = 1164;
  1293. LABEL_11:
  1294.     v2 = (_DWORD *)((v1 >> 5) + 1073887232);
  1295.     v3 = *(_DWORD *)((v1 >> 5) + 1073887232);
  1296.     v4 = 1 << (v1 & 0x1F);
  1297.     *v2 = v3 | v4;
  1298.     result = *v2 & ~v4;
  1299.     *v2 = result;
  1300.     return result;
  1301.   }
  1302.   if ( result > 0x40013000 )
  1303.   {
  1304.     if ( result == 1073827840 )
  1305.     {
  1306.       v1 = 1172;
  1307.     }
  1308.     else if ( result == 1073828864 )
  1309.     {
  1310.       v1 = 1173;
  1311.     }
  1312.     else
  1313.     {
  1314.       if ( result != 1073820672 )
  1315.         return result;
  1316.       v1 = 1165;
  1317.     }
  1318.     goto LABEL_11;
  1319.   }
  1320.   if ( result == 1073756160 )
  1321.   {
  1322.     v1 = 1038;
  1323.     goto LABEL_11;
  1324.   }
  1325.   if ( result == 1073757184 )
  1326.   {
  1327.     v1 = 1039;
  1328.     goto LABEL_11;
  1329.   }
  1330.   return result;
  1331. }
  1332.  
  1333. //----- (00002158) --------------------------------------------------------
  1334. _DWORD *__fastcall sub_2158(_DWORD *result)
  1335. {
  1336.   *result |= 0x40u;
  1337.   return result;
  1338. }
  1339.  
  1340. //----- (00002162) --------------------------------------------------------
  1341. int __fastcall sub_2162(int result)
  1342. {
  1343.   *(_DWORD *)result |= 0x200u;
  1344.   *(_DWORD *)(result + 4) &= 0xFFFFFFFB;
  1345.   return result;
  1346. }
  1347.  
  1348. //----- (00002174) --------------------------------------------------------
  1349. _DWORD *__fastcall sub_2174(_DWORD *result)
  1350. {
  1351.   *result |= 0x100u;
  1352.   return result;
  1353. }
  1354.  
  1355. //----- (0000217E) --------------------------------------------------------
  1356. int __fastcall sub_217E(int a1, int a2, int a3, int a4, int a5, int a6)
  1357. {
  1358.   int v6; // r4@1
  1359.  
  1360.   v6 = a6 | 4 | a5 | a4 | a3 | a2 | *(_DWORD *)a1 & 0x3040;
  1361.   *(_DWORD *)(a1 + 4) |= 4u;
  1362.   *(_DWORD *)a1 = v6;
  1363.   return 0;
  1364. }
  1365.  
  1366. //----- (000021A8) --------------------------------------------------------
  1367. unsigned int __fastcall sub_21A8(unsigned int result)
  1368. {
  1369.   if ( result == 1073744896 )
  1370.     goto LABEL_14;
  1371.   if ( result > 0x40000C00 )
  1372.   {
  1373.     if ( result == 1073746944 )
  1374.       goto LABEL_14;
  1375.     if ( result <= 0x40001400 )
  1376.     {
  1377.       if ( result == 1073745920 )
  1378.         goto LABEL_14;
  1379.       return result;
  1380.     }
  1381.     if ( result != 1073807360 && result != 1073808384 )
  1382.       return result;
  1383. LABEL_14:
  1384.     JUMPOUT(&loc_2732);
  1385.   }
  1386.   if ( result == 1073742848 || result == 1073743872 || result == 0x40000000 )
  1387.     goto LABEL_14;
  1388.   return result;
  1389. }
  1390.  
  1391. //----- (00002228) --------------------------------------------------------
  1392. unsigned int *__fastcall sub_2228(unsigned int *result, int a2, int a3, int a4)
  1393. {
  1394.   *result = a4 | a3 | a2 | *result & 0xFFFFFC8F;
  1395.   return result;
  1396. }
  1397.  
  1398. //----- (0000223A) --------------------------------------------------------
  1399. _DWORD *__fastcall sub_223A(_DWORD *result)
  1400. {
  1401.   *result |= 0x80u;
  1402.   return result;
  1403. }
  1404.  
  1405. //----- (00002244) --------------------------------------------------------
  1406. _DWORD *__fastcall sub_2244(_DWORD *result)
  1407. {
  1408.   *result &= 0xFFFFFFF7;
  1409.   return result;
  1410. }
  1411.  
  1412. //----- (0000224E) --------------------------------------------------------
  1413. _DWORD *__fastcall sub_224E(_DWORD *result)
  1414. {
  1415.   *result |= 1u;
  1416.   return result;
  1417. }
  1418.  
  1419. //----- (00002258) --------------------------------------------------------
  1420. int __fastcall sub_2258(int result, int a2)
  1421. {
  1422.   *(_DWORD *)(result + 40) = a2;
  1423.   return result;
  1424. }
  1425.  
  1426. //----- (0000225C) --------------------------------------------------------
  1427. int __fastcall sub_225C(int result, int a2)
  1428. {
  1429.   if ( (result & 0xFFFFFBFF) == 1073807360 )
  1430.     *(_DWORD *)(result + 48) = a2;
  1431.   return result;
  1432. }
  1433.  
  1434. //----- (00002270) --------------------------------------------------------
  1435. int __fastcall sub_2270(int result, int a2)
  1436. {
  1437.   *(_DWORD *)(result + 44) = a2;
  1438.   return result;
  1439. }
  1440.  
  1441. //----- (00002274) --------------------------------------------------------
  1442. int __fastcall sub_2274(int result, int a2)
  1443. {
  1444.   unsigned int v2; // r3@2
  1445.   unsigned int v3; // r3@5
  1446.  
  1447.   switch ( a2 )
  1448.   {
  1449.     case 0:
  1450.       v2 = *(_DWORD *)(result + 24) & 0xFFFFFF7F;
  1451.       goto LABEL_3;
  1452.     case 2:
  1453.       v2 = *(_DWORD *)(result + 24) & 0xFFFF7FFF;
  1454. LABEL_3:
  1455.       *(_DWORD *)(result + 24) = v2;
  1456.       return result;
  1457.     case 4:
  1458.       v3 = *(_DWORD *)(result + 28) & 0xFFFFFF7F;
  1459.       goto LABEL_6;
  1460.     default:
  1461.       return result;
  1462.     case 6:
  1463.       v3 = *(_DWORD *)(result + 28) & 0xFFFF7FFF;
  1464. LABEL_6:
  1465.       *(_DWORD *)(result + 28) = v3;
  1466.       break;
  1467.   }
  1468.   return result;
  1469. }
  1470.  
  1471. //----- (000022A8) --------------------------------------------------------
  1472. int __fastcall sub_22A8(int result, int a2)
  1473. {
  1474.   unsigned int v2; // r3@2
  1475.   unsigned int v3; // r3@5
  1476.  
  1477.   switch ( a2 )
  1478.   {
  1479.     case 0:
  1480.       v2 = *(_DWORD *)(result + 24) & 0xFFFFFFFB;
  1481.       goto LABEL_3;
  1482.     case 2:
  1483.       v2 = *(_DWORD *)(result + 24) & 0xFFFFFBFF;
  1484. LABEL_3:
  1485.       *(_DWORD *)(result + 24) = v2;
  1486.       return result;
  1487.     case 4:
  1488.       v3 = *(_DWORD *)(result + 28) & 0xFFFFFFFB;
  1489.       goto LABEL_6;
  1490.     default:
  1491.       return result;
  1492.     case 6:
  1493.       v3 = *(_DWORD *)(result + 28) & 0xFFFFFBFF;
  1494. LABEL_6:
  1495.       *(_DWORD *)(result + 28) = v3;
  1496.       break;
  1497.   }
  1498.   return result;
  1499. }
  1500.  
  1501. //----- (000022DC) --------------------------------------------------------
  1502. int __fastcall sub_22DC(int result, int a2, int a3)
  1503. {
  1504.   int v3; // r3@3
  1505.   int v4; // r3@21
  1506.  
  1507.   switch ( a2 )
  1508.   {
  1509.     case 0:
  1510.       *(_DWORD *)(result + 24) &= 0xFFFFFFFC;
  1511.       *(_DWORD *)(result + 24) = *(_DWORD *)(result + 24);
  1512.       *(_DWORD *)(result + 24) &= 0xFFFFFF8F;
  1513.       switch ( a3 )
  1514.       {
  1515.         case 1:
  1516.           v3 = *(_DWORD *)(result + 24) | 0x10;
  1517.           goto LABEL_4;
  1518.         case 2:
  1519.           v3 = *(_DWORD *)(result + 24) | 0x20;
  1520.           goto LABEL_4;
  1521.         case 3:
  1522.           v3 = *(_DWORD *)(result + 24) | 0x30;
  1523.           goto LABEL_4;
  1524.         case 4:
  1525.           v3 = *(_DWORD *)(result + 24) | 0x40;
  1526.           goto LABEL_4;
  1527.         case 5:
  1528.           v3 = *(_DWORD *)(result + 24) | 0x50;
  1529.           goto LABEL_4;
  1530.         case 6:
  1531.           v3 = *(_DWORD *)(result + 24) | 0x60;
  1532.           goto LABEL_4;
  1533.         case 7:
  1534.           v3 = *(_DWORD *)(result + 24) | 0x70;
  1535.           goto LABEL_4;
  1536.         case 0:
  1537.           goto LABEL_12;
  1538.         default:
  1539.           return result;
  1540.       }
  1541.     case 2:
  1542.       *(_DWORD *)(result + 24) &= 0xFFFFFCFF;
  1543.       *(_DWORD *)(result + 24) = *(_DWORD *)(result + 24);
  1544.       *(_DWORD *)(result + 24) &= 0xFFFF8FFF;
  1545.       switch ( a3 )
  1546.       {
  1547.         case 0:
  1548. LABEL_12:
  1549.           v3 = *(_DWORD *)(result + 24);
  1550.           goto LABEL_4;
  1551.         case 1:
  1552.           v3 = *(_DWORD *)(result + 24) | 0x1000;
  1553.           goto LABEL_4;
  1554.         case 2:
  1555.           v3 = *(_DWORD *)(result + 24) | 0x2000;
  1556.           goto LABEL_4;
  1557.         case 3:
  1558.           v3 = *(_DWORD *)(result + 24) | 0x3000;
  1559.           goto LABEL_4;
  1560.         case 4:
  1561.           v3 = *(_DWORD *)(result + 24) | 0x4000;
  1562.           goto LABEL_4;
  1563.         case 5:
  1564.           v3 = *(_DWORD *)(result + 24) | 0x5000;
  1565.           goto LABEL_4;
  1566.         case 6:
  1567.           v3 = *(_DWORD *)(result + 24) | 0x6000;
  1568.           goto LABEL_4;
  1569.         case 7:
  1570.           v3 = *(_DWORD *)(result + 24) | 0x7000;
  1571. LABEL_4:
  1572.           *(_DWORD *)(result + 24) = v3;
  1573.           break;
  1574.         default:
  1575.           return result;
  1576.       }
  1577.       break;
  1578.     case 4:
  1579.       *(_DWORD *)(result + 28) &= 0xFFFFFFFC;
  1580.       *(_DWORD *)(result + 28) = *(_DWORD *)(result + 28);
  1581.       *(_DWORD *)(result + 28) &= 0xFFFFFF8F;
  1582.       switch ( a3 )
  1583.       {
  1584.         case 1:
  1585.           v4 = *(_DWORD *)(result + 28) | 0x10;
  1586.           goto LABEL_22;
  1587.         case 2:
  1588.           v4 = *(_DWORD *)(result + 28) | 0x20;
  1589.           goto LABEL_22;
  1590.         case 3:
  1591.           v4 = *(_DWORD *)(result + 28) | 0x30;
  1592.           goto LABEL_22;
  1593.         case 4:
  1594.           v4 = *(_DWORD *)(result + 28) | 0x40;
  1595.           goto LABEL_22;
  1596.         case 5:
  1597.           v4 = *(_DWORD *)(result + 28) | 0x50;
  1598.           goto LABEL_22;
  1599.         case 6:
  1600.           v4 = *(_DWORD *)(result + 28) | 0x60;
  1601.           goto LABEL_22;
  1602.         case 7:
  1603.           v4 = *(_DWORD *)(result + 28) | 0x70;
  1604.           goto LABEL_22;
  1605.         case 0:
  1606.           goto LABEL_30;
  1607.         default:
  1608.           return result;
  1609.       }
  1610.     default:
  1611.       return result;
  1612.     case 6:
  1613.       *(_DWORD *)(result + 28) &= 0xFFFFFCFF;
  1614.       *(_DWORD *)(result + 28) = *(_DWORD *)(result + 28);
  1615.       *(_DWORD *)(result + 28) &= 0xFFFF8FFF;
  1616.       switch ( a3 )
  1617.       {
  1618.         case 0:
  1619. LABEL_30:
  1620.           v4 = *(_DWORD *)(result + 28);
  1621.           goto LABEL_22;
  1622.         case 1:
  1623.           v4 = *(_DWORD *)(result + 28) | 0x1000;
  1624.           goto LABEL_22;
  1625.         case 2:
  1626.           v4 = *(_DWORD *)(result + 28) | 0x2000;
  1627.           goto LABEL_22;
  1628.         case 3:
  1629.           v4 = *(_DWORD *)(result + 28) | 0x3000;
  1630.           goto LABEL_22;
  1631.         case 4:
  1632.           v4 = *(_DWORD *)(result + 28) | 0x4000;
  1633.           goto LABEL_22;
  1634.         case 5:
  1635.           v4 = *(_DWORD *)(result + 28) | 0x5000;
  1636.           goto LABEL_22;
  1637.         case 6:
  1638.           v4 = *(_DWORD *)(result + 28) | 0x6000;
  1639.           goto LABEL_22;
  1640.         case 7:
  1641.           v4 = *(_DWORD *)(result + 28) | 0x7000;
  1642. LABEL_22:
  1643.           *(_DWORD *)(result + 28) = v4;
  1644.           break;
  1645.         default:
  1646.           return result;
  1647.       }
  1648.       break;
  1649.   }
  1650.   return result;
  1651. }
  1652.  
  1653. //----- (00002468) --------------------------------------------------------
  1654. int __fastcall sub_2468(int result, int a2)
  1655. {
  1656.   int v2; // r3@2
  1657.   int v3; // r3@5
  1658.  
  1659.   switch ( a2 )
  1660.   {
  1661.     case 0:
  1662.       v2 = *(_DWORD *)(result + 24) | 8;
  1663.       goto LABEL_3;
  1664.     case 2:
  1665.       v2 = *(_DWORD *)(result + 24) | 0x800;
  1666. LABEL_3:
  1667.       *(_DWORD *)(result + 24) = v2;
  1668.       return result;
  1669.     case 4:
  1670.       v3 = *(_DWORD *)(result + 28) | 8;
  1671.       goto LABEL_6;
  1672.     default:
  1673.       return result;
  1674.     case 6:
  1675.       v3 = *(_DWORD *)(result + 28) | 0x800;
  1676. LABEL_6:
  1677.       *(_DWORD *)(result + 28) = v3;
  1678.       break;
  1679.   }
  1680.   return result;
  1681. }
  1682.  
  1683. //----- (0000249C) --------------------------------------------------------
  1684. int __fastcall sub_249C(int result, int a2)
  1685. {
  1686.   unsigned int v2; // r3@2
  1687.   unsigned int v3; // r3@15
  1688.  
  1689.   switch ( a2 )
  1690.   {
  1691.     case 0:
  1692.       v2 = *(_DWORD *)(result + 32) & 0xFFFFFFFD;
  1693.       goto LABEL_3;
  1694.     case 2:
  1695.       v2 = *(_DWORD *)(result + 32) & 0xFFFFFFDF;
  1696.       goto LABEL_3;
  1697.     case 4:
  1698.       v2 = *(_DWORD *)(result + 32) & 0xFFFFFDFF;
  1699.       goto LABEL_3;
  1700.     case 6:
  1701.       v2 = *(_DWORD *)(result + 32) & 0xFFFFDFFF;
  1702. LABEL_3:
  1703.       *(_DWORD *)(result + 32) = v2;
  1704.       if ( result == 1073807360 )
  1705.         return result;
  1706.       goto LABEL_13;
  1707.     default:
  1708.       if ( result == 1073807360 )
  1709.         goto LABEL_9;
  1710. LABEL_13:
  1711.       if ( result != 1073808384 )
  1712.         return result;
  1713. LABEL_9:
  1714.       if ( a2 == 3 )
  1715.       {
  1716.         v3 = *(_DWORD *)(result + 32) & 0xFFFFFF7F;
  1717.       }
  1718.       else if ( a2 == 5 )
  1719.       {
  1720.         v3 = *(_DWORD *)(result + 32) & 0xFFFFF7FF;
  1721.       }
  1722.       else
  1723.       {
  1724.         if ( a2 != 1 )
  1725.           return result;
  1726.         v3 = *(_DWORD *)(result + 32) & 0xFFFFFFF7;
  1727.       }
  1728.       *(_DWORD *)(result + 32) = v3;
  1729.       return result;
  1730.   }
  1731. }
  1732.  
  1733. //----- (00002510) --------------------------------------------------------
  1734. int __fastcall sub_2510(int result, int a2)
  1735. {
  1736.   int v2; // r3@2
  1737.   int v3; // r3@15
  1738.  
  1739.   switch ( a2 )
  1740.   {
  1741.     case 0:
  1742.       v2 = *(_DWORD *)(result + 32) | 1;
  1743.       goto LABEL_3;
  1744.     case 2:
  1745.       v2 = *(_DWORD *)(result + 32) | 0x10;
  1746.       goto LABEL_3;
  1747.     case 4:
  1748.       v2 = *(_DWORD *)(result + 32) | 0x100;
  1749.       goto LABEL_3;
  1750.     case 6:
  1751.       v2 = *(_DWORD *)(result + 32) | 0x1000;
  1752. LABEL_3:
  1753.       *(_DWORD *)(result + 32) = v2;
  1754.       if ( result == 1073807360 )
  1755.         return result;
  1756.       goto LABEL_13;
  1757.     default:
  1758.       if ( result == 1073807360 )
  1759.         goto LABEL_9;
  1760. LABEL_13:
  1761.       if ( result != 1073808384 )
  1762.         return result;
  1763. LABEL_9:
  1764.       if ( a2 == 3 )
  1765.       {
  1766.         v3 = *(_DWORD *)(result + 32) | 0x40;
  1767.       }
  1768.       else if ( a2 == 5 )
  1769.       {
  1770.         v3 = *(_DWORD *)(result + 32) | 0x400;
  1771.       }
  1772.       else
  1773.       {
  1774.         if ( a2 != 1 )
  1775.           return result;
  1776.         v3 = *(_DWORD *)(result + 32) | 4;
  1777.       }
  1778.       *(_DWORD *)(result + 32) = v3;
  1779.       return result;
  1780.   }
  1781. }
  1782.  
  1783. //----- (00002584) --------------------------------------------------------
  1784. int __fastcall sub_2584(int result, int a2)
  1785. {
  1786.   unsigned int v2; // r3@2
  1787.   unsigned int v3; // r3@15
  1788.  
  1789.   switch ( a2 )
  1790.   {
  1791.     case 0:
  1792.       v2 = *(_DWORD *)(result + 32) & 0xFFFFFFFE;
  1793.       goto LABEL_3;
  1794.     case 2:
  1795.       v2 = *(_DWORD *)(result + 32) & 0xFFFFFFEF;
  1796.       goto LABEL_3;
  1797.     case 4:
  1798.       v2 = *(_DWORD *)(result + 32) & 0xFFFFFEFF;
  1799.       goto LABEL_3;
  1800.     case 6:
  1801.       v2 = *(_DWORD *)(result + 32) & 0xFFFFEFFF;
  1802. LABEL_3:
  1803.       *(_DWORD *)(result + 32) = v2;
  1804.       if ( result == 1073807360 )
  1805.         return result;
  1806.       goto LABEL_13;
  1807.     default:
  1808.       if ( result == 1073807360 )
  1809.         goto LABEL_9;
  1810. LABEL_13:
  1811.       if ( result != 1073808384 )
  1812.         return result;
  1813. LABEL_9:
  1814.       if ( a2 == 3 )
  1815.       {
  1816.         v3 = *(_DWORD *)(result + 32) & 0xFFFFFFBF;
  1817.       }
  1818.       else if ( a2 == 5 )
  1819.       {
  1820.         v3 = *(_DWORD *)(result + 32) & 0xFFFFFBFF;
  1821.       }
  1822.       else
  1823.       {
  1824.         if ( a2 != 1 )
  1825.           return result;
  1826.         v3 = *(_DWORD *)(result + 32) & 0xFFFFFFFB;
  1827.       }
  1828.       *(_DWORD *)(result + 32) = v3;
  1829.       return result;
  1830.   }
  1831. }
  1832.  
  1833. //----- (000025F8) --------------------------------------------------------
  1834. int __fastcall sub_25F8(int result, int a2)
  1835. {
  1836.   int v2; // r3@3
  1837.  
  1838.   if ( (result & 0xFFFFFBFF) == 1073807360 )
  1839.   {
  1840.     switch ( a2 )
  1841.     {
  1842.       case 0:
  1843.         v2 = *(_DWORD *)(result + 4) | 0x100;
  1844.         goto LABEL_4;
  1845.       case 1:
  1846.         v2 = *(_DWORD *)(result + 4) | 0x200;
  1847.         goto LABEL_4;
  1848.       case 2:
  1849.         v2 = *(_DWORD *)(result + 4) | 0x400;
  1850.         goto LABEL_4;
  1851.       case 3:
  1852.         v2 = *(_DWORD *)(result + 4) | 0x800;
  1853.         goto LABEL_4;
  1854.       case 4:
  1855.         v2 = *(_DWORD *)(result + 4) | 0x1000;
  1856.         goto LABEL_4;
  1857.       case 5:
  1858.         v2 = *(_DWORD *)(result + 4) | 0x2000;
  1859.         goto LABEL_4;
  1860.       case 6:
  1861.         v2 = *(_DWORD *)(result + 4) | 0x4000;
  1862. LABEL_4:
  1863.         *(_DWORD *)(result + 4) = v2;
  1864.         break;
  1865.       default:
  1866.         return result;
  1867.     }
  1868.   }
  1869.   return result;
  1870. }
  1871.  
  1872. //----- (00002650) --------------------------------------------------------
  1873. int __fastcall sub_2650(int result, int a2, int a3)
  1874. {
  1875.   switch ( a2 )
  1876.   {
  1877.     case 0:
  1878.       *(_DWORD *)(result + 52) = a3;
  1879.       break;
  1880.     case 2:
  1881.       *(_DWORD *)(result + 56) = a3;
  1882.       break;
  1883.     case 4:
  1884.       *(_DWORD *)(result + 60) = a3;
  1885.       break;
  1886.     case 6:
  1887.       *(_DWORD *)(result + 64) = a3;
  1888.       break;
  1889.     default:
  1890.       return result;
  1891.   }
  1892.   return result;
  1893. }
  1894.  
  1895. //----- (00002670) --------------------------------------------------------
  1896. int __fastcall sub_2670(int result)
  1897. {
  1898.   if ( (result & 0xFFFFFBFF) == 1073807360 )
  1899.     *(_DWORD *)(result + 68) |= 0x8000u;
  1900.   return result;
  1901. }
  1902.  
  1903. //----- (00002688) --------------------------------------------------------
  1904. int __fastcall sub_2688(int result, int a2)
  1905. {
  1906.   int v2; // r3@1
  1907.  
  1908.   v2 = v2000013C;
  1909.   if ( (result & 0xFFFFFBFF) == 1073811456 )
  1910.     v2 = v20000140;
  1911.   *(_DWORD *)(result + 8) = (a2 + 2 * v2) / (unsigned int)(2 * a2);
  1912.   return result;
  1913. }
  1914.  
  1915. //----- (000026B8) --------------------------------------------------------
  1916. int __fastcall sub_26B8(int result, int a2)
  1917. {
  1918.   int v2; // r3@1
  1919.   unsigned int v3; // r3@2
  1920.  
  1921.   v2 = *(_DWORD *)(result + 12);
  1922.   if ( a2 == 8 )
  1923.     v3 = v2 & 0xFFFFEFFF;
  1924.   else
  1925.     v3 = v2 | 0x1000;
  1926.   *(_DWORD *)(result + 12) = v3;
  1927.   return result;
  1928. }
  1929.  
  1930. //----- (000026CA) --------------------------------------------------------
  1931. int __fastcall sub_26CA(int result, int a2)
  1932. {
  1933.   *(_DWORD *)(result + 16) = a2 | *(_DWORD *)(result + 16) & 0xFFFFCFFF;
  1934.   return result;
  1935. }
  1936.  
  1937. //----- (000026D6) --------------------------------------------------------
  1938. int __fastcall sub_26D6(int result, int a2)
  1939. {
  1940.   *(_DWORD *)(result + 12) = a2 | *(_DWORD *)(result + 12) & 0xFFFFF9FF;
  1941.   return result;
  1942. }
  1943.  
  1944. //----- (000026E2) --------------------------------------------------------
  1945. int __fastcall sub_26E2(int result, int a2)
  1946. {
  1947.   *(_DWORD *)(result + 12) = a2 | *(_DWORD *)(result + 12) & 0xFFFFFFF3;
  1948.   return result;
  1949. }
  1950.  
  1951. //----- (000026EE) --------------------------------------------------------
  1952. int __fastcall sub_26EE(int result, int a2)
  1953. {
  1954.   *(_DWORD *)(result + 20) = a2 | *(_DWORD *)(result + 20) & 0xFFFFFCFF;
  1955.   return result;
  1956. }
  1957.  
  1958. //----- (000026FA) --------------------------------------------------------
  1959. int __fastcall sub_26FA(int result)
  1960. {
  1961.   *(_DWORD *)(result + 12) |= 0x2000u;
  1962.   return result;
  1963. }
  1964.  
  1965. //----- (00002704) --------------------------------------------------------
  1966. unsigned int __fastcall sub_2704(int a1)
  1967. {
  1968.   unsigned int result; // r0@1
  1969.  
  1970.   result = a1 | v40023C00 & 0xFFFFFFF8;
  1971.   v40023C00 = result;
  1972.   return result;
  1973. }
  1974.  
  1975. //----- (00002718) --------------------------------------------------------
  1976. int __fastcall sub_2718(unsigned int a1)
  1977. {
  1978.   int *v1; // r3@1
  1979.   int result; // r0@1
  1980.  
  1981.   v1 = (int *)((a1 >> 5) + 1073887232);
  1982.   result = (1 << (a1 & 0x1F)) | *(_DWORD *)((a1 >> 5) + 0x40023800);
  1983.   *v1 = result;
  1984.   return result;
  1985. }
  1986.  
  1987. //----- (00002754) --------------------------------------------------------
  1988. int __fastcall sub_2754(int (**a1)(void), int a2, int a3, int a4, int a5, int a6, __int16 a7)
  1989. {
  1990.   int v7; // r6@1
  1991.   int (**v8)(void); // r5@1
  1992.   int v9; // r8@1
  1993.   int v10; // r7@1
  1994.   int result; // r0@1
  1995.  
  1996.   v7 = a4;
  1997.   v8 = a1;
  1998.   v9 = a2;
  1999.   v10 = a3;
  2000.   result = (*a1)();
  2001.   *(_DWORD *)(result + 12) = a5;
  2002.   *(_DWORD *)(result + 16) = a6;
  2003.   *(_WORD *)(result + 20) = a7;
  2004.   *(_DWORD *)(result + 112) = 134229731;
  2005.   *(_DWORD *)(result + 108) = 134229843;
  2006.   *(_DWORD *)(result + 104) = 134229975;
  2007.   *(_DWORD *)(result + 220) = v8;
  2008.   *(_DWORD *)result = v9;
  2009.   *(_DWORD *)(result + 4) = v10;
  2010.   *(_DWORD *)(result + 8) = v7;
  2011.   *(_DWORD *)(result + 200) = 0;
  2012.   *(_DWORD *)(result + 204) = 0;
  2013.   *(_DWORD *)(result + 208) = 0;
  2014.   *(_DWORD *)(result + 212) = 0;
  2015.   return result;
  2016. }
  2017.  
  2018. //----- (00002C70) --------------------------------------------------------
  2019. signed int __fastcall sub_2C70(int a1, int a2)
  2020. {
  2021.   int v2; // r3@1
  2022.   int *v3; // r4@1
  2023.   int v4; // r2@2
  2024.   int v5; // t1@2
  2025.  
  2026.   v2 = 0;
  2027.   v3 = (int *)(a1 + 200);
  2028.   while ( 1 )
  2029.   {
  2030.     v5 = *v3;
  2031.     ++v3;
  2032.     v4 = v5;
  2033.     if ( !v5 )
  2034.       break;
  2035.     if ( ++v2 == 4 )
  2036.       return -1;
  2037.   }
  2038.   *(_DWORD *)(a1 + 4 * (v2 + 50)) = a2;
  2039.   return v4;
  2040. }
  2041.  
  2042. //----- (000031A8) --------------------------------------------------------
  2043. int __fastcall sub_31A8(int a1)
  2044. {
  2045.   int result; // r0@1
  2046.  
  2047.   result = a1 & 0xFFFFFF;
  2048.   vE000E014 = result;
  2049.   return result;
  2050. }
  2051.  
  2052. //----- (000031B8) --------------------------------------------------------
  2053. int __fastcall sub_31B8(char a1)
  2054. {
  2055.   int result; // r0@1
  2056.  
  2057.   result = a1 & 4;
  2058.   vE000E010 = vE000E010 & 0xFFFFFFFB | result;
  2059.   return result;
  2060. }
  2061.  
  2062. //----- (Set the second bit to 1) --------------------------------------------------------
  2063. void sub_31D0()
  2064. {
  2065.   vE000E010 |= 2u;
  2066. }
  2067.  
  2068. //----- (Set the first bit to 1) --------------------------------------------------------
  2069. void sub_31E0()
  2070. {
  2071.   vE000E010 |= 1u;
  2072. }
  2073.  
  2074. //----- (000031F0) --------------------------------------------------------
  2075. signed int __fastcall sub_31F0(unsigned int a1)
  2076. {
  2077.   _DWORD *v1; // r3@1
  2078.   signed int result; // r0@1
  2079.  
  2080.   v1 = (_DWORD *)(4 * (a1 >> 5) - 0x1FFF1F00);
  2081.   result = 1 << (a1 & 0x1F);
  2082.   *v1 = result;
  2083.   return result;
  2084. }
  2085.  
  2086. //----- (0000320C) --------------------------------------------------------
  2087. int __fastcall sub_320C(int result)
  2088. {
  2089.   int v1; // r3@2
  2090.  
  2091.   if ( !result )
  2092.   {
  2093.     v1 = v40007000 | 0x4000;
  2094. LABEL_3:
  2095.     v40007000 = v1;
  2096.     return result;
  2097.   }
  2098.   if ( result == 1 )
  2099.   {
  2100.     v1 = v40007000 & 0x4000;
  2101.     goto LABEL_3;
  2102.   }
  2103.   return result;
  2104. }
  2105.  
  2106. //----- (00003898) --------------------------------------------------------
  2107. int *__fastcall sub_3898(int *result, unsigned __int8 a2, unsigned int a3)
  2108. {
  2109.   unsigned int v3; // r4@2
  2110.   int *v4; // r3@3
  2111.   unsigned __int8 v5; // cf@4
  2112.   int v6; // r2@9
  2113.   unsigned int v7; // r6@9
  2114.   unsigned int v8; // r2@11
  2115.   int *v9; // r6@12
  2116.   unsigned int v10; // r2@12
  2117.   int v11; // r4@16
  2118.  
  2119.   if ( (_DWORD)result << 30 )
  2120.   {
  2121.     v3 = a3 - 1;
  2122.     if ( !a3 )
  2123.       return result;
  2124.     v4 = result;
  2125.     while ( 1 )
  2126.     {
  2127.       *(_BYTE *)v4 = a2;
  2128.       v4 = (int *)((char *)v4 + 1);
  2129.       if ( !((_DWORD)v4 << 30) )
  2130.         break;
  2131.       v5 = __CFADD__(v3--, -1);
  2132.       if ( !v5 )
  2133.         return result;
  2134.     }
  2135.   }
  2136.   else
  2137.   {
  2138.     v3 = a3;
  2139.     v4 = result;
  2140.   }
  2141.   if ( v3 > 3 )
  2142.   {
  2143.     if ( v3 <= 0xF )
  2144.       goto LABEL_22;
  2145.     v6 = (int)(v4 + 4);
  2146.     v7 = v3;
  2147.     do
  2148.     {
  2149.       v7 -= 16;
  2150.       *(_DWORD *)(v6 - 16) = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
  2151.       *(_DWORD *)(v6 - 12) = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
  2152.       *(_DWORD *)(v6 - 8) = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
  2153.       *(_DWORD *)(v6 - 4) = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
  2154.       v6 += 16;
  2155.     }
  2156.     while ( v7 > 0xF );
  2157.     v8 = (v3 - 16) & 0xFFFFFFF0;
  2158.     v3 &= 0xFu;
  2159.     v4 = (int *)((char *)v4 + v8 + 16);
  2160.     if ( v3 > 3 )
  2161.     {
  2162. LABEL_22:
  2163.       v9 = v4;
  2164.       v10 = v3;
  2165.       do
  2166.       {
  2167.         v10 -= 4;
  2168.         *v9 = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
  2169.         ++v9;
  2170.       }
  2171.       while ( v10 > 3 );
  2172.       v4 = (int *)((char *)v4 + ((v3 - 4) & 0xFFFFFFFC) + 4);
  2173.       v3 &= 3u;
  2174.     }
  2175.   }
  2176.   if ( v3 )
  2177.   {
  2178.     v11 = (int)v4 + v3;
  2179.     do
  2180.     {
  2181.       *(_BYTE *)v4 = a2;
  2182.       v4 = (int *)((char *)v4 + 1);
  2183.     }
  2184.     while ( (int *)v11 != v4 );
  2185.   }
  2186.   return result;
  2187. }
  2188.  
  2189. // ALL OK, 86 function(s) have been successfully decompiled
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!