Create a new version of paste:

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

int sub_298();
int sub_340();
void sub_3A8();
_DWORD *__fastcall sub_3C8(unsigned int a1, int a2);
_DWORD *sub_400();
int sub_4AC();
int sub_510();
unsigned int __fastcall sub_6F0(unsigned int result);
unsigned int __fastcall sub_70E(unsigned int result);
int sub_72C();
signed int sub_D68();
signed int __fastcall sub_E24(int a1);
signed int sub_E54();
unsigned int sub_FFC();
int __fastcall sub_13A8(int a1);
int __fastcall sub_13D0(int a1);
int __fastcall sub_13E4(int a1);
unsigned int __fastcall sub_140C(int a1);
int __fastcall sub_1438(int a1);
unsigned int __fastcall sub_144C(int a1);
unsigned int __fastcall sub_1482(int a1);
int __fastcall sub_14A0(int a1, int a2);
int __fastcall sub_151C(int a1, int a2);
int sub_1580();
unsigned int __fastcall sub_15B0(int a1, int a2, int a3, _BYTE *a4, int a5);
int __fastcall sub_1610(int a1);
unsigned int sub_1688();
int sub_16B4();
int __fastcall sub_1DA8(int a1);
int __fastcall sub_1E04(int a1);
int __fastcall sub_1E14(int result);
int __fastcall sub_1E6C(int result);
unsigned int __fastcall sub_1EC4(int a1);
unsigned int __fastcall sub_1ED8(int a1);
unsigned int __fastcall sub_1EEC(int a1);
unsigned int __fastcall sub_1F00(int a1);
signed int __fastcall sub_1F14(char a1, int a2, unsigned int a3, int a4, unsigned int a5);
int __fastcall sub_1F58(int a1);
int __fastcall sub_2004(int result, int a2);
int __fastcall sub_2008(int result, int a2);
int __fastcall sub_200E(int a1, int a2);
int __fastcall sub_2014(int result, int a2);
int __fastcall sub_2026(int result, int a2, int a3, signed int a4);
int __fastcall sub_206A(int result, int a2, int a3, signed int a4);
int __fastcall sub_20A0(int result, int a2, signed int a3);
unsigned int __fastcall sub_20F8(unsigned int result);
_DWORD *__fastcall sub_2158(_DWORD *result);
int __fastcall sub_2162(int result);
_DWORD *__fastcall sub_2174(_DWORD *result);
int __fastcall sub_217E(int a1, int a2, int a3, int a4, int a5, int a6);
unsigned int __fastcall sub_21A8(unsigned int result);
unsigned int *__fastcall sub_2228(unsigned int *result, int a2, int a3, int a4);
_DWORD *__fastcall sub_223A(_DWORD *result);
_DWORD *__fastcall sub_2244(_DWORD *result);
_DWORD *__fastcall sub_224E(_DWORD *result);
int __fastcall sub_2258(int result, int a2);
int __fastcall sub_225C(int result, int a2);
int __fastcall sub_2270(int result, int a2);
int __fastcall sub_2274(int result, int a2);
int __fastcall sub_22A8(int result, int a2);
int __fastcall sub_22DC(int result, int a2, int a3);
int __fastcall sub_2468(int result, int a2);
int __fastcall sub_249C(int result, int a2);
int __fastcall sub_2510(int result, int a2);
int __fastcall sub_2584(int result, int a2);
int __fastcall sub_25F8(int result, int a2);
int __fastcall sub_2650(int result, int a2, int a3);
int __fastcall sub_2670(int result);
int __fastcall sub_2688(int result, int a2);
int __fastcall sub_26B8(int result, int a2);
int __fastcall sub_26CA(int result, int a2);
int __fastcall sub_26D6(int result, int a2);
int __fastcall sub_26E2(int result, int a2);
int __fastcall sub_26EE(int result, int a2);
int __fastcall sub_26FA(int result);
unsigned int __fastcall sub_2704(int a1);
int __fastcall sub_2718(unsigned int a1);
int __fastcall sub_2754(int (**a1)(void), int a2, int a3, int a4, int a5, int a6, __int16 a7);
signed int __fastcall sub_2C70(int a1, int a2);
int __fastcall sub_31A8(int a1);
int __fastcall sub_31B8(char a1);
void sub_31D0();
void sub_31E0();
signed int __fastcall sub_31F0(unsigned int a1);
int __fastcall sub_320C(int result);
int *__fastcall sub_3898(int *result, unsigned __int8 a2, unsigned int a3);

//-------------------------------------------------------------------------
// Data declarations

_UNKNOWN loc_2732; // weak


//----- (00000298) --------------------------------------------------------
int sub_298()
{
  sub_31F0(0x43u);
  sub_31F0(0x2Au);
  sub_2026(1073872896, 2, 0, 6144);
  sub_20A0(1073872896, 10, 6144);
  sub_2026(1073875968, 1, 0, 4);
  sub_2008(1073875968, 4);
  sub_6F0(1u);
  sub_2004(1073875968, 4);
  v200001C8 = sub_2754((int (**)(void))0x8003F00, 0x8003A93, 0x8003A53, 0x20000000, 3, 536871237, 128);
  return sub_2C70(v200001C8, 134218237);
}

//----- (00000340) --------------------------------------------------------
int sub_340()
{
  sub_1F58(134233740);
  sub_2718(0x600u);
  sub_2718(0x601u);
  sub_2718(0x602u);
  sub_2718(0x603u);
  sub_2718(0x604u);
  sub_2718(0x884u);
  sub_2718(0x88Cu);
  sub_2718(0x80Eu);
  sub_2718(0x80Fu);
  sub_2718(0x800u);
  return sub_2718(0x687u);
}

//----- (000003A8) --------------------------------------------------------
void sub_3A8()
{
  sub_31A8(168000);
  sub_31B8(4);
  sub_31E0();
  sub_31D0();
}

//----- (000003C8) --------------------------------------------------------
_DWORD *__fastcall sub_3C8(unsigned int a1, int a2)
{
  _DWORD *v2; // r4@1
  int v3; // r5@1

  v2 = (_DWORD *)a1;
  v3 = a2;
  sub_20F8(a1);
  sub_217E((int)v2, v3, 0, 0, 2048, 0);
  sub_2162((int)v2);
  sub_2174(v2);
  return sub_2158(v2);
}

//----- (00000400) --------------------------------------------------------
_DWORD *sub_400()
{
  sub_2026(1073872896, 2, 0, 224);
  sub_20A0(1073872896, 5, 224);
  sub_206A(1073872896, 0, 2, 160);
  sub_3C8(0x40013000u, 32);
  sub_2026(1073873920, 2, 0, 57344);
  sub_20A0(1073873920, 5, 57344);
  sub_206A(1073873920, 0, 2, 40960);
  sub_3C8(0x40003800u, 24);
  sub_2026(1073874944, 2, 0, 7168);
  sub_20A0(1073874944, 6, 7168);
  sub_206A(1073874944, 0, 2, 5120);
  return sub_3C8(0x40003C00u, 24);
}

//----- (000004AC) --------------------------------------------------------
int sub_4AC()
{
  sub_2026(1073872896, 2, 1, 1536);
  sub_20A0(1073872896, 7, 1536);
  sub_2688(1073811456, 115200);
  sub_26B8(1073811456, 8);
  sub_26CA(1073811456, 0);
  sub_26E2(1073811456, 12);
  sub_26D6(1073811456, 0);
  sub_26EE(1073811456, 0);
  return sub_26FA(1073811456);
}

//----- (00000510) --------------------------------------------------------
int sub_510()
{
  sub_2026(1073872896, 2, 0, 2);
  sub_206A(1073872896, 0, 0, 2);
  sub_20A0(1073872896, 1, 2);
  sub_21A8(0x40000000u);
  sub_2228((unsigned int *)0x40000000, 0, 0, 0);
  sub_2270(0x40000000, 1680);
  sub_2258(0x40000000, 0);
  sub_225C(0x40000000, 0);
  sub_223A((_DWORD *)0x40000000);
  sub_2244((_DWORD *)0x40000000);
  sub_2584(0x40000000, 2);
  sub_2274(0x40000000, 2);
  sub_2468(0x40000000, 2);
  sub_22A8(0x40000000, 2);
  sub_22DC(0x40000000, 2, 6);
  sub_249C(0x40000000, 2);
  sub_25F8(0x40000000, 2);
  sub_2650(0x40000000, 2, 840);
  sub_223A((_DWORD *)0x40000000);
  sub_2670(0x40000000);
  sub_224E((_DWORD *)0x40000000);
  return sub_2510(0x40000000, 2);
}

//----- (Generate Big Delay) --------------------------------------------------------
unsigned int __fastcall sub_6F0(unsigned int result)
{
  unsigned int i; // r3@1
  signed int v2; // r2@3

  for ( i = 0; i < result; ++i )
  {
    v2 = 42000;
    do
      --v2;
    while ( v2 );
  }
  return result;
}

//----- (Generate Small Delay) --------------------------------------------------------
unsigned int __fastcall sub_70E(unsigned int result)
{
  unsigned int i; // r3@1
  signed int v2; // r2@3

  for ( i = 0; i < result; ++i )
  {
    v2 = 39;
    do
      --v2;
    while ( v2 );
  }
  return result;
}

//----- (0000072C) --------------------------------------------------------
int sub_72C()
{
  return v2000291C;
}

//----- (00000D68) --------------------------------------------------------
signed int sub_D68()
{
  signed int v0; // r4@1
  int v1; // r5@1

  sub_6F0(0x64u);
  v0 = 134232932;
  sub_2026(1073873920, 1, 0, 4096);
  sub_2004(1073873920, 4096);
  sub_2026(1073876992, 1, 0, 2);
  sub_2004(1073876992, 2);
  v1 = 0;
  
  do
  {
    sub_2026(*(_DWORD *)(v1 + 134233004), 0, 0, *(_WORD *)(v1 + 134233008));
    sub_2026(*(_DWORD *)v0, 1, 0, *(_WORD *)(v0 + 4));
    sub_2026(*(_DWORD *)(v0 + 8), 1, 0, *(_WORD *)(v0 + 12));
    v1 += 8;
    sub_2026(*(_DWORD *)(v0 + 16), 1, 0, *(_WORD *)(v0 + 20));
    v0 += 24;
  }
  while ( v1 != 24 );
  
  sub_2026(1073873920, 0, 0, 256);
  sub_2026(1073875968, 0, 0, 8);
  sub_2026(1073873920, 1, 0, 16);
  sub_2004(1073873920, 16);
  return 1;
}

//----- (00000E24) --------------------------------------------------------
signed int __fastcall sub_E24(int a1)
{
  int v1; // r5@1
  int v2; // r7@1
  signed int v3; // r4@1

  v1 = a1;
  v2 = *(_WORD *)(8 * a1 + 0x8003BB0);
  v3 = 10;
  while ( !sub_200E(*(_DWORD *)(8 * v1 + 0x8003BAC), v2) )
  {
    sub_6F0(1u);
    if ( !--v3 )
      return 0;
  }
  return 1;
}

//----- (00000E54) --------------------------------------------------------
signed int sub_E54()
{
  signed int v0; // r5@1
  signed int v1; // r4@1
  int v2; // r6@1
  int v3; // r11@4
  int v4; // r2@5
  int v5; // r8@5
  int v6; // ST0C_4@6
  char v7; // r0@6
  int v8; // r3@6
  int v9; // r10@8
  int v10; // r8@9
  int v11; // r11@9
  int v12; // r2@9
  int v13; // ST08_4@11
  int v14; // r0@11
  char v15; // r3@16
  int v16; // r0@18
  int v17; // r3@19
  int v19; // [sp+0h] [bp-38h]@4
  char v20; // [sp+4h] [bp-34h]@4

  v0 = 536874176;
  sub_3898((int *)0x20000CC0, 0, 0xA5Cu);
  sub_D68();
  sub_1688();
  v1 = 536874176;
  v2 = 0;
  do
  {
    sub_16B4();
    if ( !sub_E24(v2) )
      *(_BYTE *)(v1 + 800) = 1;
    v20 = 4 * v2;
    v19 = 884 * v2;
    v3 = 0;
    do
    {
      v4 = (unsigned __int8)(v20 + v3);
      v5 = 0;
      do
      {
        v6 = v4;
        v7 = v20000098(v4, v5);
        v8 = v19 + 192 * v3 + 12 * v5++ + 536874176;
        *(_BYTE *)(v8 + 8) = v7;
        sub_6F0(1u);
        v4 = v6;
      }
      while ( v5 != 16 );
      ++v3;
    }
    while ( v3 != 4 );
    v9 = 0;
    do
    {
      v10 = v19 + 192 * v9 + 536874176;
      v11 = 0;
      v12 = (unsigned __int8)(v20 + v9);
      do
      {
        if ( *(_BYTE *)(v10 + 8) == 3 )
        {
          v13 = v12;
          v14 = v2000009C(v12, v11);
          v12 = v13;
          if ( v14 )
            ++*(_BYTE *)(v1 + 768);
          else
            *(_BYTE *)(v10 + 8) = 2;
        }
        ++v11;
        v10 += 12;
      }
      while ( v11 != 16 );
      ++v9;
    }
    while ( v9 != 4 );
    if ( *(_BYTE *)(v1 + 768) == 64 )
      v15 = 3;
    else
      v15 = 2;
    *(_BYTE *)(v1 + 800) = v15;
    *(_BYTE *)(v1 + 770) = 26;
    *(_BYTE *)(v1 + 773) = 55;
    *(_BYTE *)(v1 + 774) = 50;
    *(_BYTE *)(v1 + 771) = 0;
    *(_BYTE *)(v1 + 772) = sub_1610(v2);
    *(_DWORD *)(v1 + 788) = sub_72C() + 5000;
    v16 = sub_72C();
    ++v2;
    *(_DWORD *)(v1 + 792) = v16;
    *(_DWORD *)(v1 + 784) = 0;
    *(_DWORD *)(v1 + 776) = 0;
    *(_DWORD *)(v1 + 796) = 0;
    v1 += 884;
  }
  while ( v2 != 3 );
  v17 = v200016A8 + v20001334 + v20000FC0;
  do
  {
    if ( v17 > 181 )
    {
      *(_BYTE *)(v0 + 769) = 64;
      *(_BYTE *)(v0 + 800) = 3;
    }
    else
    {
      LOBYTE(v16) = *(_BYTE *)(v0 + 768);
    }
    if ( v17 <= 181 )
      *(_BYTE *)(v0 + 769) = v16;
    v0 += 884;
  }
  while ( v0 != 536876828 );
  return 1;
}
// 20000098: using guessed type int (__fastcall *)(_DWORD, _DWORD);
// 2000009C: using guessed type int (__fastcall *)(_DWORD, _DWORD);

//----- (00000FFC) --------------------------------------------------------
unsigned int sub_FFC()
{
  signed int v0; // r11@1
  signed int v1; // r9@1
  signed int v2; // r7@1
  int v3; // r6@1
  int v4; // r8@4
  int v5; // r10@5
  int v6; // r4@5
  int v7; // r3@7
  int v8; // r5@9
  int v9; // r2@15
  int v10; // r3@16
  int v11; // r0@18
  int v12; // r2@18
  void (__cdecl *v13)(int); // r3@19
  signed int v14; // r4@21
  signed int v15; // r5@21
  signed int v16; // r6@21
  int v17; // r8@21
  int v18; // r0@23
  int v19; // r3@23
  int v20; // r10@26
  int v21; // r9@27
  int v22; // r7@27
  unsigned int result; // r0@33
  int v24; // r1@36
  int v25; // r0@36
  unsigned int v26; // r0@53
  int v27; // r1@53
  char v28; // cf@53
  int v29; // r0@53
  unsigned int v30; // r0@55
  int v31; // [sp+0h] [bp-38h]@27

  v0 = 536874176;
  v1 = 536876828;
  v2 = 536874176;
  v3 = 0;
  do
  {
    if ( *(_BYTE *)(v2 + 800) == 5 && *(_DWORD *)(v2 + 780) )
    {
      v4 = 0;
      do
      {
        v5 = 0;
        v6 = 884 * v3 + 192 * v4 + 536874176;
        do
        {
          if ( (unsigned int)*(_BYTE *)(v6 + 8) - 2 <= 1 )
          {
            v7 = 0;
            do
            {
              if ( !*(_BYTE *)(v1 + 12 * v7 + 11) )
              {
                v8 = 12 * v7 + 1536 * v3 + 536876828;
                goto LABEL_10;
              }
              ++v7;
            }
            while ( v7 != 128 );
            v8 = v1;
LABEL_10:
            if ( v200000B4((unsigned __int8)(4 * v3 + v4), v5, v8) <= 0 )
            {
              ++*(_DWORD *)(v6 + 4);
            }
            else
            {
              *(_BYTE *)(v8 + 11) = 1;
              *(_DWORD *)(v2 + 784) = sub_72C() + 5000;
              ++*(_DWORD *)v6;
            }
          }
          ++v5;
          v6 += 12;
        }
        while ( v5 != 16 );
        ++v4;
      }
      while ( v4 != 4 );
    }
    ++v3;
    v2 += 884;
    v1 += 1536;
  }
  while ( v3 != 3 );
  v9 = v20000CB8;
  if ( v20000CB8 != v20000CBC )
  {
    v10 = (v20000CB8 + 1) & 7;
    if ( v20000CB8 + 1 <= 0 )
      v10 = -(-(v20000CB8 + 1) & 7);
    v20000CB8 = v10;
    v11 = 220 * v9 + 536872408;
    v12 = *(_BYTE *)(220 * v9 + 0x200005D9);
    if ( (unsigned int)(v12 - 1) <= 6 )
    {
      v13 = *(void (__cdecl **)(int))(8 * v12 + 0x8003B28);
      if ( v13 )
        v13(v11);
    }
  }
  v14 = 134232932;
  v15 = 536874176;
  v16 = 134232932;
  v17 = 0;
  do
  {
    if ( (unsigned int)sub_72C() >= *(_DWORD *)(v15 + 788) )
    {
      *(_BYTE *)(v15 + 772) = sub_1610(v17);
      v18 = sub_72C();
      v19 = *(_BYTE *)(v15 + 800);
      *(_DWORD *)(v15 + 788) = v18 + 10000;
      if ( v19 == 4 )
      {
        if ( *(_BYTE *)(v15 + 772) < (signed int)*(_BYTE *)(v15 + 773) )
          *(_BYTE *)(v15 + 800) = 5;
      }
      else if ( v19 == 5 && *(_BYTE *)(v15 + 772) > (signed int)*(_BYTE *)(v15 + 773) )
      {
        *(_BYTE *)(v15 + 800) = 4;
        sub_2004(*(_DWORD *)v16, *(_WORD *)(v16 + 4));
        sub_2004(*(_DWORD *)(v16 + 8), *(_WORD *)(v16 + 12));
        v20 = 0;
        do
        {
          v31 = (unsigned __int8)(4 * v17 + v20);
          v21 = 0;
          v22 = 884 * v17 + 192 * v20 + 536874176;
          do
          {
            if ( (unsigned int)*(_BYTE *)(v22 + 8) - 2 <= 1 )
            {
              v200000B0(v31, v21);
              v20000094(v31, v21);
              *(_BYTE *)(v22 + 9) = 0;
            }
            ++v21;
            v22 += 12;
          }
          while ( v21 != 16 );
          ++v20;
        }
        while ( v20 != 4 );
      }
    }
    ++v17;
    v15 += 884;
    v16 += 24;
  }
  while ( v17 != 3 );
  do
  {
    result = sub_72C();
    if ( result >= *(_DWORD *)(v0 + 792) )
    {
      *(_DWORD *)(v0 + 792) = sub_72C() + 1000;
      result = sub_72C();
      if ( result >= *(_DWORD *)(v0 + 796) )
      {
        switch ( *(_BYTE *)(v0 + 800) )
        {
          case 0:
            sub_2008(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
            goto LABEL_48;
          case 1:
            sub_2014(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
            goto LABEL_48;
          case 2:
            sub_2004(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
LABEL_48:
            sub_2008(*(_DWORD *)(v14 + 8), *(_WORD *)(v14 + 12));
            v24 = *(_WORD *)(v14 + 20);
            v25 = *(_DWORD *)(v14 + 16);
            goto LABEL_49;
          case 3:
            sub_2004(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
            goto LABEL_36;
          case 5:
            sub_2004(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
            v26 = sub_72C();
            v27 = *(_WORD *)(v14 + 20);
            v28 = v26 >= *(_DWORD *)(v0 + 776) + 5000;
            v29 = *(_DWORD *)(v14 + 16);
            if ( v28 )
            {
              sub_2014(v29, v27);
              *(_DWORD *)(v0 + 784) = 0;
            }
            else
            {
              sub_2004(v29, v27);
            }
            v30 = sub_72C();
            v24 = *(_WORD *)(v14 + 12);
            v28 = v30 >= *(_DWORD *)(v0 + 784);
            v25 = *(_DWORD *)(v14 + 8);
            if ( !v28 )
              goto LABEL_37;
LABEL_49:
            result = sub_2008(v25, v24);
            break;
          case 4:
            sub_2014(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
            sub_2014(*(_DWORD *)(v14 + 8), *(_WORD *)(v14 + 12));
            result = sub_2004(*(_DWORD *)(v14 + 16), *(_WORD *)(v14 + 20));
            break;
          default:
            break;
        }
      }
      else
      {
        sub_2014(*(_DWORD *)v14, *(_WORD *)(v14 + 4));
LABEL_36:
        sub_2014(*(_DWORD *)(v14 + 8), *(_WORD *)(v14 + 12));
        v24 = *(_WORD *)(v14 + 20);
        v25 = *(_DWORD *)(v14 + 16);
LABEL_37:
        result = sub_2014(v25, v24);
      }
    }
    v14 += 24;
    v0 += 884;
  }
  while ( v14 != 134233004 );
  return result;
}
// 20000094: using guessed type int (__fastcall *)(_DWORD, _DWORD);
// 200000B0: using guessed type int (__fastcall *)(_DWORD, _DWORD);
// 200000B4: using guessed type int (__fastcall *)(_DWORD, _DWORD, _DWORD);

//----- (000013A8) --------------------------------------------------------
int __fastcall sub_13A8(int a1)
{
  int v1; // r0@1
  signed int v2; // r5@1
  int v3; // r4@1

  v1 = 16 * a1 + 134233148;
  v2 = *(_WORD *)(v1 + 12);
  v3 = *(_DWORD *)(v1 + 8);
  sub_2026(*(_DWORD *)(v1 + 8), 1, 0, v2);
  return sub_2004(v3, v2);
}

//----- (000013D0) --------------------------------------------------------
int __fastcall sub_13D0(int a1)
{
  return sub_2004(*(_DWORD *)(16 * a1 + 0x8003C3C), *(_WORD *)(16 * a1 + 0x8003C40));
}

//----- (000013E4) --------------------------------------------------------
int __fastcall sub_13E4(int a1)
{
  int v1; // r0@1
  signed int v2; // r5@1
  int v3; // r4@1

  v1 = 16 * a1 + 134233148;
  v2 = *(_WORD *)(v1 + 12);
  v3 = *(_DWORD *)(v1 + 8);
  sub_2026(*(_DWORD *)(v1 + 8), 1, 0, v2);
  return sub_2008(v3, v2);
}

//----- (0000140C) --------------------------------------------------------
unsigned int __fastcall sub_140C(int a1)
{
  int v1; // r4@1

  v1 = a1;
  sub_13E4(a1);
  sub_70E(1u);
  sub_13D0(v1);
  sub_70E(1u);
  sub_13A8(v1);
  return sub_70E(1u);
}

//----- (00001438) --------------------------------------------------------
int __fastcall sub_1438(int a1)
{
  return sub_2008(*(_DWORD *)(16 * a1 + 0x8003C3C), *(_WORD *)(16 * a1 + 0x8003C40));
}

//----- (0000144C) --------------------------------------------------------
unsigned int __fastcall sub_144C(int a1)
{
  int v1; // r4@1

  v1 = a1;
  sub_13A8(a1);
  sub_70E(1u);
  sub_13D0(v1);
  sub_70E(1u);
  sub_13E4(v1);
  sub_70E(1u);
  sub_1438(v1);
  return sub_70E(1u);
}

//----- (00001482) --------------------------------------------------------
unsigned int __fastcall sub_1482(int a1)
{
  int v1; // r4@1

  v1 = a1;
  sub_13D0(a1);
  sub_70E(1u);
  sub_1438(v1);
  return sub_70E(1u);
}

//----- (000014A0) --------------------------------------------------------
int __fastcall sub_14A0(int a1, int a2)
{
  int v2; // r7@1
  signed int v3; // r9@1
  int v4; // r4@1
  int v5; // r8@1
  int v6; // r6@1
  int v7; // r5@1

  v2 = *(_DWORD *)(16 * a1 + 0x8003C44);
  v3 = *(_WORD *)(16 * a1 + 0x8003C48);
  v4 = a1;
  v5 = a2;
  sub_2026(*(_DWORD *)(16 * a1 + 0x8003C44), 0, 0, v3);
  v6 = 0;
  v7 = 0;
  do
  {
    sub_70E(1u);
    sub_13D0(v4);
    sub_70E(1u);
    if ( sub_200E(v2, v3) )
      v7 = (unsigned __int8)(v7 | (128 >> v6));
    ++v6;
    sub_1438(v4);
  }
  while ( v6 != 8 );
  if ( v5 )
    sub_13A8(v4);
  else
    sub_13E4(v4);
  sub_1482(v4);
  return v7;
}

//----- (0000151C) --------------------------------------------------------
int __fastcall sub_151C(int a1, int a2)
{
  int v2; // r4@1
  int v3; // r6@1
  int v4; // r5@1
  int v5; // r5@5
  signed int v6; // r6@5

  v2 = a1;
  v3 = a2;
  v4 = 0;
  do
  {
    if ( (128 >> v4) & v3 )
      sub_13A8(v2);
    else
      sub_13E4(v2);
    ++v4;
    sub_1482(v2);
  }
  while ( v4 != 8 );
  v5 = *(_DWORD *)(16 * v2 + 0x8003C44);
  v6 = *(_WORD *)(16 * v2 + 0x8003C48);
  sub_2026(*(_DWORD *)(16 * v2 + 0x8003C44), 0, 0, v6);
  sub_13D0(v2);
  sub_70E(1u);
  sub_200E(v5, v6);
  return sub_1438(v2);
}

//----- (00001580) --------------------------------------------------------
int sub_1580()
{
  signed int v0; // r4@1
  int result; // r0@2

  v0 = 134233148;
  do
  {
    sub_2026(*(_DWORD *)v0, 1, 0, *(_WORD *)(v0 + 4));
    v0 += 16;
    result = sub_2026(*(_DWORD *)(v0 - 8), 1, 0, *(_WORD *)(v0 - 4));
  }
  while ( v0 != 134233196 );
  return result;
}

//----- (000015B0) --------------------------------------------------------
unsigned int __fastcall sub_15B0(int a1, int a2, int a3, _BYTE *a4, int a5)
{
  int v5; // r4@1
  int v6; // r7@1
  int v7; // r8@1
  _BYTE *v8; // r6@1
  _BYTE *v9; // r7@1
  unsigned int v10; // r5@1

  v5 = a1;
  v6 = a2;
  v7 = a3;
  v8 = a4;
  sub_144C(a1);
  sub_151C(v5, v6 & 0xFE);
  sub_151C(v5, v7);
  sub_144C(v5);
  sub_151C(v5, v6 | 1);
  v9 = v8;
  v10 = a5 - 1;
  while ( v10 > v9 - v8 )
    *v9++ = sub_14A0(v5, 0);
  v8[v10] = sub_14A0(v5, 1);
  return sub_140C(v5);
}

//----- (00001610) --------------------------------------------------------
int __fastcall sub_1610(int a1)
{
  int v1; // r4@1
  int v2; // r3@2
  signed int v3; // r0@3
  int v4; // r4@3
  int v5; // r2@3
  signed int v6; // r3@3
  char v8; // [sp+Fh] [bp-11h]@1

  v1 = a1;
  sub_15B0(a1, 144, 0, &v8, 1);
  if ( (unsigned __int8)(v8 - 1) <= 0x7Du )
  {
    v2 = *(_DWORD *)(4 * v1 + 0x20002930);
    *(_BYTE *)(5 * v1 + 536881440 + v2) = v8;
    *(_DWORD *)(4 * v1 + 0x20002930) = (v2 + 1) % 5;
  }
  v3 = 0;
  v4 = 5 * v1 + 536881440;
  v5 = 0;
  v6 = 0;
  do
  {
    if ( *(_BYTE *)(v4 + v5) )
    {
      v6 += *(_BYTE *)(v4 + v5);
      ++v3;
    }
    ++v5;
  }
  while ( v5 != 5 );
  if ( !v3 )
    v3 = 1;
  return (char)(v6 / v3);
}

//----- (00001688) --------------------------------------------------------
unsigned int sub_1688()
{
  sub_2004(1073876992, 2);
  sub_6F0(1u);
  sub_2008(1073876992, 2);
  return sub_6F0(2u);
}

//----- (000016B4) --------------------------------------------------------
int sub_16B4()
{
  int v0; // r5@1
  int v1; // r4@2
  int v2; // r7@3
  signed int v3; // r8@3
  int v4; // r7@3
  signed int v5; // r8@3

  v0 = 0;
  do
  {
    v1 = v0 + 134233196;
    do
    {
      v2 = *(_DWORD *)(v1 + 4);
      v3 = *(_WORD *)(v1 + 8);
      sub_2026(*(_DWORD *)(v1 + 4), 1, 0, v3);
      sub_206A(v2, 0, 2, v3);
      sub_2004(v2, v3);
      v4 = *(_DWORD *)(v1 + 20);
      v5 = *(_WORD *)(v1 + 24);
      sub_2026(*(_DWORD *)(v1 + 20), 1, 0, v5);
      sub_206A(v4, 0, 2, v5);
      v1 += 8;
      sub_2008(v4, v5);
    }
    while ( v1 != v0 + 134233212 );
    v0 += 36;
  }
  while ( v0 != 432 );
  v2000293C = v8003C80;
  v20002940 = v8003C84;
  return sub_2004(1073876992, 32);
}

//----- (00001DA8) --------------------------------------------------------
int __fastcall sub_1DA8(int a1)
{
  int result; // r0@2
  unsigned int *v2; // r3@4

  switch ( a1 )
  {
    case 0:
      return (v40023800 >> 25) & 1;
    case 3:
      return (v40023800 >> 17) & 1;
    case 4:
      v2 = (unsigned int *)1073887232;
      goto LABEL_5;
    case 5:
      v2 = (unsigned int *)1073887344;
      goto LABEL_5;
    case 6:
      v2 = (unsigned int *)1073887348;
LABEL_5:
      result = (*v2 >> 1) & 1;
      break;
    case 1:
      result = (v40023800 >> 29) & 1;
      break;
    case 2:
      result = (v40023800 >> 27) & 1;
      break;
    default:
      result = 0;
      break;
  }
  return result;
}

//----- (00001E04) --------------------------------------------------------
int __fastcall sub_1E04(int a1)
{
  int v1; // r2@1
  int result; // r0@2

  v1 = a1;
  do
    result = sub_1DA8(v1);
  while ( !result );
  return result;
}

//----- (00001E14) --------------------------------------------------------
int __fastcall sub_1E14(int result)
{
  int *v1; // r2@2
  int v2; // r3@2

  switch ( result )
  {
    case 0:
      v1 = (int *)1073887232;
      v2 = v40023800 | 0x1000000;
      goto LABEL_3;
    case 3:
      v1 = (int *)1073887232;
      v2 = v40023800 | 0x10000;
      goto LABEL_3;
    case 4:
      v1 = (int *)1073887232;
      goto LABEL_6;
    case 5:
      v1 = (int *)1073887344;
      goto LABEL_6;
    case 6:
      v1 = (int *)1073887348;
LABEL_6:
      v2 = *v1 | 1;
      goto LABEL_3;
    case 1:
      v1 = (int *)1073887232;
      v2 = v40023800 | 0x10000000;
      goto LABEL_3;
    case 2:
      v1 = (int *)1073887232;
      v2 = v40023800 | 0x4000000;
LABEL_3:
      *v1 = v2;
      break;
    default:
      return result;
  }
  return result;
}

//----- (00001E6C) --------------------------------------------------------
int __fastcall sub_1E6C(int result)
{
  unsigned int *v1; // r2@2
  unsigned int v2; // r3@2

  switch ( result )
  {
    case 0:
      v1 = (unsigned int *)1073887232;
      v2 = v40023800 & 0xFEFFFFFF;
      goto LABEL_3;
    case 3:
      v1 = (unsigned int *)1073887232;
      v2 = v40023800 & 0xFFFEFFFF;
      goto LABEL_3;
    case 4:
      v1 = (unsigned int *)1073887232;
      goto LABEL_6;
    case 5:
      v1 = (unsigned int *)1073887344;
      goto LABEL_6;
    case 6:
      v1 = (unsigned int *)1073887348;
LABEL_6:
      v2 = *v1 & 0xFFFFFFFE;
      goto LABEL_3;
    case 1:
      v1 = (unsigned int *)1073887232;
      v2 = v40023800 & 0xEFFFFFFF;
      goto LABEL_3;
    case 2:
      v1 = (unsigned int *)1073887232;
      v2 = v40023800 & 0xFBFFFFFF;
LABEL_3:
      *v1 = v2;
      break;
    default:
      return result;
  }
  return result;
}

//----- (00001EC4) --------------------------------------------------------
unsigned int __fastcall sub_1EC4(int a1)
{
  unsigned int result; // r0@1

  result = a1 | v40023808 & 0xFFFFFFFC;
  v40023808 = result;
  return result;
}

//----- (00001ED8) --------------------------------------------------------
unsigned int __fastcall sub_1ED8(int a1)
{
  unsigned int result; // r0@1

  result = v40023808 & 0xFFFF1FFF | (a1 << 13);
  v40023808 = result;
  return result;
}

//----- (00001EEC) --------------------------------------------------------
unsigned int __fastcall sub_1EEC(int a1)
{
  unsigned int result; // r0@1

  result = v40023808 & 0xFFFFE3FF | (a1 << 10);
  v40023808 = result;
  return result;
}

//----- (00001F00) --------------------------------------------------------
unsigned int __fastcall sub_1F00(int a1)
{
  unsigned int result; // r0@1

  result = v40023808 & 0xFFFFFF0F | 16 * a1;
  v40023808 = result;
  return result;
}

//----- (00001F14) --------------------------------------------------------
signed int __fastcall sub_1F14(char a1, int a2, unsigned int a3, int a4, unsigned int a5)
{
  int v5; // r3@1
  signed int result; // r0@1
  int v7; // r3@1
  unsigned int v8; // r1@1
  signed int v9; // r2@1
  int v10; // r1@1

  v5 = (a4 << 24) & 0xF000000 | 0x400000 | a1 & 0x3F;
  result = 32704;
  v7 = v5 | (a2 << 6) & 0x7FC0;
  v8 = a3 >> 1;
  v9 = a5;
  v10 = (v8 - 1) << 16;
  if ( a5 < 2 )
    v9 = 2;
  v40023804 = v7 | v10 & 0x30000 | (v9 << 28) & 0x70000000;
  return result;
}

//----- (00001F58) --------------------------------------------------------
int __fastcall sub_1F58(int a1)
{
  int v1; // r4@1
  int v2; // r0@1

  v1 = a1;
  sub_1E14(4);
  sub_1E04(4);
  sub_1EC4(0);
  sub_1E14(3);
  sub_1E04(3);
  v2 = *(_BYTE *)(v1 + 15);
  if ( *(_BYTE *)(v1 + 15) )
    v2 = 1;
  sub_320C(v2);
  sub_1F00(*(_BYTE *)(v1 + 12));
  sub_1EEC(*(_BYTE *)(v1 + 13));
  sub_1ED8(*(_BYTE *)(v1 + 14));
  sub_1F14(*(_BYTE *)v1, *(_WORD *)(v1 + 2), *(_BYTE *)(v1 + 4), *(_BYTE *)(v1 + 5), *(_BYTE *)(v1 + 6));
  v40023800 |= 0x1000000u;
  sub_1E04(0);
  sub_2704(*(_DWORD *)(v1 + 8));
  sub_1EC4(2);
  while ( ((v40023808 >> 2) & 3) != 2 )
    ;
  v20000138 = *(_DWORD *)(v1 + 16);
  v2000013C = *(_DWORD *)(v1 + 20);
  v20000140 = *(_DWORD *)(v1 + 24);
  return sub_1E6C(4);
}

//----- (00002004) --------------------------------------------------------
int __fastcall sub_2004(int result, int a2)
{
  *(_DWORD *)(result + 24) = a2;
  return result;
}

//----- (00002008) --------------------------------------------------------
int __fastcall sub_2008(int result, int a2)
{
  *(_DWORD *)(result + 24) = a2 << 16;
  return result;
}

//----- (0000200E) --------------------------------------------------------
int __fastcall sub_200E(int a1, int a2)
{
  return *(_DWORD *)(a1 + 16) & a2;
}

//----- (00002014) --------------------------------------------------------
int __fastcall sub_2014(int result, int a2)
{
  *(_DWORD *)(result + 24) = a2 & ~*(_DWORD *)(result + 20) | ((*(_DWORD *)(result + 20) & a2) << 16);
  return result;
}

//----- (00002026) --------------------------------------------------------
int __fastcall sub_2026(int result, int a2, int a3, signed int a4)
{
  int v4; // r5@1
  int v5; // r4@1
  int v6; // r6@1
  int v7; // lr@3

  v4 = *(_DWORD *)result;
  v5 = *(_DWORD *)(result + 12);
  v6 = 0;
  do
  {
    if ( (a4 >> v6) & 1 )
    {
      v7 = ~(3 << 2 * v6);
      v4 = (a2 << 2 * v6) | v7 & v4;
      v5 = v7 & v5 | (a3 << 2 * v6);
    }
    ++v6;
  }
  while ( v6 != 16 );
  *(_DWORD *)result = v4;
  *(_DWORD *)(result + 12) = v5;
  return result;
}

//----- (0000206A) --------------------------------------------------------
int __fastcall sub_206A(int result, int a2, int a3, signed int a4)
{
  char v4; // zf@1
  int v5; // r1@1
  int v6; // r1@2
  int v7; // r1@4
  int v8; // r4@4

  v4 = a2 == 1;
  v5 = *(_DWORD *)(result + 4);
  if ( v4 )
    v6 = v5 | a4;
  else
    v6 = v5 & ~a4;
  *(_DWORD *)(result + 4) = v6;
  v7 = *(_DWORD *)(result + 8);
  v8 = 0;
  do
  {
    if ( (a4 >> v8) & 1 )
      v7 = v7 & ~(3 << 2 * v8) | (a3 << 2 * v8);
    ++v8;
  }
  while ( v8 != 16 );
  *(_DWORD *)(result + 8) = v7;
  return result;
}

//----- (000020A0) --------------------------------------------------------
int __fastcall sub_20A0(int result, int a2, signed int a3)
{
  int v3; // r7@1
  int v4; // r6@1
  int v5; // r3@1
  int v6; // r3@5

  v3 = *(_DWORD *)(result + 32);
  v4 = *(_DWORD *)(result + 36);
  v5 = 0;
  do
  {
    if ( (a3 >> v5) & 1 )
      v3 = v3 & ~(15 << 4 * v5) | (a2 << 4 * v5);
    ++v5;
  }
  while ( v5 != 8 );
  v6 = 0;
  do
  {
    if ( (a3 >> (v6 + 8)) & 1 )
      v4 = v4 & ~(15 << 4 * v6) | (a2 << 4 * v6);
    ++v6;
  }
  while ( v6 != 8 );
  *(_DWORD *)(result + 32) = v3;
  *(_DWORD *)(result + 36) = v4;
  return result;
}

//----- (000020F8) --------------------------------------------------------
unsigned int __fastcall sub_20F8(unsigned int result)
{
  unsigned int v1; // r0@9
  _DWORD *v2; // r3@11
  int v3; // r1@11
  signed int v4; // r0@11

  if ( result == 1073819648 )
  {
    v1 = 1164;
LABEL_11:
    v2 = (_DWORD *)((v1 >> 5) + 1073887232);
    v3 = *(_DWORD *)((v1 >> 5) + 1073887232);
    v4 = 1 << (v1 & 0x1F);
    *v2 = v3 | v4;
    result = *v2 & ~v4;
    *v2 = result;
    return result;
  }
  if ( result > 0x40013000 )
  {
    if ( result == 1073827840 )
    {
      v1 = 1172;
    }
    else if ( result == 1073828864 )
    {
      v1 = 1173;
    }
    else
    {
      if ( result != 1073820672 )
        return result;
      v1 = 1165;
    }
    goto LABEL_11;
  }
  if ( result == 1073756160 )
  {
    v1 = 1038;
    goto LABEL_11;
  }
  if ( result == 1073757184 )
  {
    v1 = 1039;
    goto LABEL_11;
  }
  return result;
}

//----- (00002158) --------------------------------------------------------
_DWORD *__fastcall sub_2158(_DWORD *result)
{
  *result |= 0x40u;
  return result;
}

//----- (00002162) --------------------------------------------------------
int __fastcall sub_2162(int result)
{
  *(_DWORD *)result |= 0x200u;
  *(_DWORD *)(result + 4) &= 0xFFFFFFFB;
  return result;
}

//----- (00002174) --------------------------------------------------------
_DWORD *__fastcall sub_2174(_DWORD *result)
{
  *result |= 0x100u;
  return result;
}

//----- (0000217E) --------------------------------------------------------
int __fastcall sub_217E(int a1, int a2, int a3, int a4, int a5, int a6)
{
  int v6; // r4@1

  v6 = a6 | 4 | a5 | a4 | a3 | a2 | *(_DWORD *)a1 & 0x3040;
  *(_DWORD *)(a1 + 4) |= 4u;
  *(_DWORD *)a1 = v6;
  return 0;
}

//----- (000021A8) --------------------------------------------------------
unsigned int __fastcall sub_21A8(unsigned int result)
{
  if ( result == 1073744896 )
    goto LABEL_14;
  if ( result > 0x40000C00 )
  {
    if ( result == 1073746944 )
      goto LABEL_14;
    if ( result <= 0x40001400 )
    {
      if ( result == 1073745920 )
        goto LABEL_14;
      return result;
    }
    if ( result != 1073807360 && result != 1073808384 )
      return result;
LABEL_14:
    JUMPOUT(&loc_2732);
  }
  if ( result == 1073742848 || result == 1073743872 || result == 0x40000000 )
    goto LABEL_14;
  return result;
}

//----- (00002228) --------------------------------------------------------
unsigned int *__fastcall sub_2228(unsigned int *result, int a2, int a3, int a4)
{
  *result = a4 | a3 | a2 | *result & 0xFFFFFC8F;
  return result;
}

//----- (0000223A) --------------------------------------------------------
_DWORD *__fastcall sub_223A(_DWORD *result)
{
  *result |= 0x80u;
  return result;
}

//----- (00002244) --------------------------------------------------------
_DWORD *__fastcall sub_2244(_DWORD *result)
{
  *result &= 0xFFFFFFF7;
  return result;
}

//----- (0000224E) --------------------------------------------------------
_DWORD *__fastcall sub_224E(_DWORD *result)
{
  *result |= 1u;
  return result;
}

//----- (00002258) --------------------------------------------------------
int __fastcall sub_2258(int result, int a2)
{
  *(_DWORD *)(result + 40) = a2;
  return result;
}

//----- (0000225C) --------------------------------------------------------
int __fastcall sub_225C(int result, int a2)
{
  if ( (result & 0xFFFFFBFF) == 1073807360 )
    *(_DWORD *)(result + 48) = a2;
  return result;
}

//----- (00002270) --------------------------------------------------------
int __fastcall sub_2270(int result, int a2)
{
  *(_DWORD *)(result + 44) = a2;
  return result;
}

//----- (00002274) --------------------------------------------------------
int __fastcall sub_2274(int result, int a2)
{
  unsigned int v2; // r3@2
  unsigned int v3; // r3@5

  switch ( a2 )
  {
    case 0:
      v2 = *(_DWORD *)(result + 24) & 0xFFFFFF7F;
      goto LABEL_3;
    case 2:
      v2 = *(_DWORD *)(result + 24) & 0xFFFF7FFF;
LABEL_3:
      *(_DWORD *)(result + 24) = v2;
      return result;
    case 4:
      v3 = *(_DWORD *)(result + 28) & 0xFFFFFF7F;
      goto LABEL_6;
    default:
      return result;
    case 6:
      v3 = *(_DWORD *)(result + 28) & 0xFFFF7FFF;
LABEL_6:
      *(_DWORD *)(result + 28) = v3;
      break;
  }
  return result;
}

//----- (000022A8) --------------------------------------------------------
int __fastcall sub_22A8(int result, int a2)
{
  unsigned int v2; // r3@2
  unsigned int v3; // r3@5

  switch ( a2 )
  {
    case 0:
      v2 = *(_DWORD *)(result + 24) & 0xFFFFFFFB;
      goto LABEL_3;
    case 2:
      v2 = *(_DWORD *)(result + 24) & 0xFFFFFBFF;
LABEL_3:
      *(_DWORD *)(result + 24) = v2;
      return result;
    case 4:
      v3 = *(_DWORD *)(result + 28) & 0xFFFFFFFB;
      goto LABEL_6;
    default:
      return result;
    case 6:
      v3 = *(_DWORD *)(result + 28) & 0xFFFFFBFF;
LABEL_6:
      *(_DWORD *)(result + 28) = v3;
      break;
  }
  return result;
}

//----- (000022DC) --------------------------------------------------------
int __fastcall sub_22DC(int result, int a2, int a3)
{
  int v3; // r3@3
  int v4; // r3@21

  switch ( a2 )
  {
    case 0:
      *(_DWORD *)(result + 24) &= 0xFFFFFFFC;
      *(_DWORD *)(result + 24) = *(_DWORD *)(result + 24);
      *(_DWORD *)(result + 24) &= 0xFFFFFF8F;
      switch ( a3 )
      {
        case 1:
          v3 = *(_DWORD *)(result + 24) | 0x10;
          goto LABEL_4;
        case 2:
          v3 = *(_DWORD *)(result + 24) | 0x20;
          goto LABEL_4;
        case 3:
          v3 = *(_DWORD *)(result + 24) | 0x30;
          goto LABEL_4;
        case 4:
          v3 = *(_DWORD *)(result + 24) | 0x40;
          goto LABEL_4;
        case 5:
          v3 = *(_DWORD *)(result + 24) | 0x50;
          goto LABEL_4;
        case 6:
          v3 = *(_DWORD *)(result + 24) | 0x60;
          goto LABEL_4;
        case 7:
          v3 = *(_DWORD *)(result + 24) | 0x70;
          goto LABEL_4;
        case 0:
          goto LABEL_12;
        default:
          return result;
      }
    case 2:
      *(_DWORD *)(result + 24) &= 0xFFFFFCFF;
      *(_DWORD *)(result + 24) = *(_DWORD *)(result + 24);
      *(_DWORD *)(result + 24) &= 0xFFFF8FFF;
      switch ( a3 )
      {
        case 0:
LABEL_12:
          v3 = *(_DWORD *)(result + 24);
          goto LABEL_4;
        case 1:
          v3 = *(_DWORD *)(result + 24) | 0x1000;
          goto LABEL_4;
        case 2:
          v3 = *(_DWORD *)(result + 24) | 0x2000;
          goto LABEL_4;
        case 3:
          v3 = *(_DWORD *)(result + 24) | 0x3000;
          goto LABEL_4;
        case 4:
          v3 = *(_DWORD *)(result + 24) | 0x4000;
          goto LABEL_4;
        case 5:
          v3 = *(_DWORD *)(result + 24) | 0x5000;
          goto LABEL_4;
        case 6:
          v3 = *(_DWORD *)(result + 24) | 0x6000;
          goto LABEL_4;
        case 7:
          v3 = *(_DWORD *)(result + 24) | 0x7000;
LABEL_4:
          *(_DWORD *)(result + 24) = v3;
          break;
        default:
          return result;
      }
      break;
    case 4:
      *(_DWORD *)(result + 28) &= 0xFFFFFFFC;
      *(_DWORD *)(result + 28) = *(_DWORD *)(result + 28);
      *(_DWORD *)(result + 28) &= 0xFFFFFF8F;
      switch ( a3 )
      {
        case 1:
          v4 = *(_DWORD *)(result + 28) | 0x10;
          goto LABEL_22;
        case 2:
          v4 = *(_DWORD *)(result + 28) | 0x20;
          goto LABEL_22;
        case 3:
          v4 = *(_DWORD *)(result + 28) | 0x30;
          goto LABEL_22;
        case 4:
          v4 = *(_DWORD *)(result + 28) | 0x40;
          goto LABEL_22;
        case 5:
          v4 = *(_DWORD *)(result + 28) | 0x50;
          goto LABEL_22;
        case 6:
          v4 = *(_DWORD *)(result + 28) | 0x60;
          goto LABEL_22;
        case 7:
          v4 = *(_DWORD *)(result + 28) | 0x70;
          goto LABEL_22;
        case 0:
          goto LABEL_30;
        default:
          return result;
      }
    default:
      return result;
    case 6:
      *(_DWORD *)(result + 28) &= 0xFFFFFCFF;
      *(_DWORD *)(result + 28) = *(_DWORD *)(result + 28);
      *(_DWORD *)(result + 28) &= 0xFFFF8FFF;
      switch ( a3 )
      {
        case 0:
LABEL_30:
          v4 = *(_DWORD *)(result + 28);
          goto LABEL_22;
        case 1:
          v4 = *(_DWORD *)(result + 28) | 0x1000;
          goto LABEL_22;
        case 2:
          v4 = *(_DWORD *)(result + 28) | 0x2000;
          goto LABEL_22;
        case 3:
          v4 = *(_DWORD *)(result + 28) | 0x3000;
          goto LABEL_22;
        case 4:
          v4 = *(_DWORD *)(result + 28) | 0x4000;
          goto LABEL_22;
        case 5:
          v4 = *(_DWORD *)(result + 28) | 0x5000;
          goto LABEL_22;
        case 6:
          v4 = *(_DWORD *)(result + 28) | 0x6000;
          goto LABEL_22;
        case 7:
          v4 = *(_DWORD *)(result + 28) | 0x7000;
LABEL_22:
          *(_DWORD *)(result + 28) = v4;
          break;
        default:
          return result;
      }
      break;
  }
  return result;
}

//----- (00002468) --------------------------------------------------------
int __fastcall sub_2468(int result, int a2)
{
  int v2; // r3@2
  int v3; // r3@5

  switch ( a2 )
  {
    case 0:
      v2 = *(_DWORD *)(result + 24) | 8;
      goto LABEL_3;
    case 2:
      v2 = *(_DWORD *)(result + 24) | 0x800;
LABEL_3:
      *(_DWORD *)(result + 24) = v2;
      return result;
    case 4:
      v3 = *(_DWORD *)(result + 28) | 8;
      goto LABEL_6;
    default:
      return result;
    case 6:
      v3 = *(_DWORD *)(result + 28) | 0x800;
LABEL_6:
      *(_DWORD *)(result + 28) = v3;
      break;
  }
  return result;
}

//----- (0000249C) --------------------------------------------------------
int __fastcall sub_249C(int result, int a2)
{
  unsigned int v2; // r3@2
  unsigned int v3; // r3@15

  switch ( a2 )
  {
    case 0:
      v2 = *(_DWORD *)(result + 32) & 0xFFFFFFFD;
      goto LABEL_3;
    case 2:
      v2 = *(_DWORD *)(result + 32) & 0xFFFFFFDF;
      goto LABEL_3;
    case 4:
      v2 = *(_DWORD *)(result + 32) & 0xFFFFFDFF;
      goto LABEL_3;
    case 6:
      v2 = *(_DWORD *)(result + 32) & 0xFFFFDFFF;
LABEL_3:
      *(_DWORD *)(result + 32) = v2;
      if ( result == 1073807360 )
        return result;
      goto LABEL_13;
    default:
      if ( result == 1073807360 )
        goto LABEL_9;
LABEL_13:
      if ( result != 1073808384 )
        return result;
LABEL_9:
      if ( a2 == 3 )
      {
        v3 = *(_DWORD *)(result + 32) & 0xFFFFFF7F;
      }
      else if ( a2 == 5 )
      {
        v3 = *(_DWORD *)(result + 32) & 0xFFFFF7FF;
      }
      else
      {
        if ( a2 != 1 )
          return result;
        v3 = *(_DWORD *)(result + 32) & 0xFFFFFFF7;
      }
      *(_DWORD *)(result + 32) = v3;
      return result;
  }
}

//----- (00002510) --------------------------------------------------------
int __fastcall sub_2510(int result, int a2)
{
  int v2; // r3@2
  int v3; // r3@15

  switch ( a2 )
  {
    case 0:
      v2 = *(_DWORD *)(result + 32) | 1;
      goto LABEL_3;
    case 2:
      v2 = *(_DWORD *)(result + 32) | 0x10;
      goto LABEL_3;
    case 4:
      v2 = *(_DWORD *)(result + 32) | 0x100;
      goto LABEL_3;
    case 6:
      v2 = *(_DWORD *)(result + 32) | 0x1000;
LABEL_3:
      *(_DWORD *)(result + 32) = v2;
      if ( result == 1073807360 )
        return result;
      goto LABEL_13;
    default:
      if ( result == 1073807360 )
        goto LABEL_9;
LABEL_13:
      if ( result != 1073808384 )
        return result;
LABEL_9:
      if ( a2 == 3 )
      {
        v3 = *(_DWORD *)(result + 32) | 0x40;
      }
      else if ( a2 == 5 )
      {
        v3 = *(_DWORD *)(result + 32) | 0x400;
      }
      else
      {
        if ( a2 != 1 )
          return result;
        v3 = *(_DWORD *)(result + 32) | 4;
      }
      *(_DWORD *)(result + 32) = v3;
      return result;
  }
}

//----- (00002584) --------------------------------------------------------
int __fastcall sub_2584(int result, int a2)
{
  unsigned int v2; // r3@2
  unsigned int v3; // r3@15

  switch ( a2 )
  {
    case 0:
      v2 = *(_DWORD *)(result + 32) & 0xFFFFFFFE;
      goto LABEL_3;
    case 2:
      v2 = *(_DWORD *)(result + 32) & 0xFFFFFFEF;
      goto LABEL_3;
    case 4:
      v2 = *(_DWORD *)(result + 32) & 0xFFFFFEFF;
      goto LABEL_3;
    case 6:
      v2 = *(_DWORD *)(result + 32) & 0xFFFFEFFF;
LABEL_3:
      *(_DWORD *)(result + 32) = v2;
      if ( result == 1073807360 )
        return result;
      goto LABEL_13;
    default:
      if ( result == 1073807360 )
        goto LABEL_9;
LABEL_13:
      if ( result != 1073808384 )
        return result;
LABEL_9:
      if ( a2 == 3 )
      {
        v3 = *(_DWORD *)(result + 32) & 0xFFFFFFBF;
      }
      else if ( a2 == 5 )
      {
        v3 = *(_DWORD *)(result + 32) & 0xFFFFFBFF;
      }
      else
      {
        if ( a2 != 1 )
          return result;
        v3 = *(_DWORD *)(result + 32) & 0xFFFFFFFB;
      }
      *(_DWORD *)(result + 32) = v3;
      return result;
  }
}

//----- (000025F8) --------------------------------------------------------
int __fastcall sub_25F8(int result, int a2)
{
  int v2; // r3@3

  if ( (result & 0xFFFFFBFF) == 1073807360 )
  {
    switch ( a2 )
    {
      case 0:
        v2 = *(_DWORD *)(result + 4) | 0x100;
        goto LABEL_4;
      case 1:
        v2 = *(_DWORD *)(result + 4) | 0x200;
        goto LABEL_4;
      case 2:
        v2 = *(_DWORD *)(result + 4) | 0x400;
        goto LABEL_4;
      case 3:
        v2 = *(_DWORD *)(result + 4) | 0x800;
        goto LABEL_4;
      case 4:
        v2 = *(_DWORD *)(result + 4) | 0x1000;
        goto LABEL_4;
      case 5:
        v2 = *(_DWORD *)(result + 4) | 0x2000;
        goto LABEL_4;
      case 6:
        v2 = *(_DWORD *)(result + 4) | 0x4000;
LABEL_4:
        *(_DWORD *)(result + 4) = v2;
        break;
      default:
        return result;
    }
  }
  return result;
}

//----- (00002650) --------------------------------------------------------
int __fastcall sub_2650(int result, int a2, int a3)
{
  switch ( a2 )
  {
    case 0:
      *(_DWORD *)(result + 52) = a3;
      break;
    case 2:
      *(_DWORD *)(result + 56) = a3;
      break;
    case 4:
      *(_DWORD *)(result + 60) = a3;
      break;
    case 6:
      *(_DWORD *)(result + 64) = a3;
      break;
    default:
      return result;
  }
  return result;
}

//----- (00002670) --------------------------------------------------------
int __fastcall sub_2670(int result)
{
  if ( (result & 0xFFFFFBFF) == 1073807360 )
    *(_DWORD *)(result + 68) |= 0x8000u;
  return result;
}

//----- (00002688) --------------------------------------------------------
int __fastcall sub_2688(int result, int a2)
{
  int v2; // r3@1

  v2 = v2000013C;
  if ( (result & 0xFFFFFBFF) == 1073811456 )
    v2 = v20000140;
  *(_DWORD *)(result + 8) = (a2 + 2 * v2) / (unsigned int)(2 * a2);
  return result;
}

//----- (000026B8) --------------------------------------------------------
int __fastcall sub_26B8(int result, int a2)
{
  int v2; // r3@1
  unsigned int v3; // r3@2

  v2 = *(_DWORD *)(result + 12);
  if ( a2 == 8 )
    v3 = v2 & 0xFFFFEFFF;
  else
    v3 = v2 | 0x1000;
  *(_DWORD *)(result + 12) = v3;
  return result;
}

//----- (000026CA) --------------------------------------------------------
int __fastcall sub_26CA(int result, int a2)
{
  *(_DWORD *)(result + 16) = a2 | *(_DWORD *)(result + 16) & 0xFFFFCFFF;
  return result;
}

//----- (000026D6) --------------------------------------------------------
int __fastcall sub_26D6(int result, int a2)
{
  *(_DWORD *)(result + 12) = a2 | *(_DWORD *)(result + 12) & 0xFFFFF9FF;
  return result;
}

//----- (000026E2) --------------------------------------------------------
int __fastcall sub_26E2(int result, int a2)
{
  *(_DWORD *)(result + 12) = a2 | *(_DWORD *)(result + 12) & 0xFFFFFFF3;
  return result;
}

//----- (000026EE) --------------------------------------------------------
int __fastcall sub_26EE(int result, int a2)
{
  *(_DWORD *)(result + 20) = a2 | *(_DWORD *)(result + 20) & 0xFFFFFCFF;
  return result;
}

//----- (000026FA) --------------------------------------------------------
int __fastcall sub_26FA(int result)
{
  *(_DWORD *)(result + 12) |= 0x2000u;
  return result;
}

//----- (00002704) --------------------------------------------------------
unsigned int __fastcall sub_2704(int a1)
{
  unsigned int result; // r0@1

  result = a1 | v40023C00 & 0xFFFFFFF8;
  v40023C00 = result;
  return result;
}

//----- (00002718) --------------------------------------------------------
int __fastcall sub_2718(unsigned int a1)
{
  int *v1; // r3@1
  int result; // r0@1

  v1 = (int *)((a1 >> 5) + 1073887232);
  result = (1 << (a1 & 0x1F)) | *(_DWORD *)((a1 >> 5) + 0x40023800);
  *v1 = result;
  return result;
}

//----- (00002754) --------------------------------------------------------
int __fastcall sub_2754(int (**a1)(void), int a2, int a3, int a4, int a5, int a6, __int16 a7)
{
  int v7; // r6@1
  int (**v8)(void); // r5@1
  int v9; // r8@1
  int v10; // r7@1
  int result; // r0@1

  v7 = a4;
  v8 = a1;
  v9 = a2;
  v10 = a3;
  result = (*a1)();
  *(_DWORD *)(result + 12) = a5;
  *(_DWORD *)(result + 16) = a6;
  *(_WORD *)(result + 20) = a7;
  *(_DWORD *)(result + 112) = 134229731;
  *(_DWORD *)(result + 108) = 134229843;
  *(_DWORD *)(result + 104) = 134229975;
  *(_DWORD *)(result + 220) = v8;
  *(_DWORD *)result = v9;
  *(_DWORD *)(result + 4) = v10;
  *(_DWORD *)(result + 8) = v7;
  *(_DWORD *)(result + 200) = 0;
  *(_DWORD *)(result + 204) = 0;
  *(_DWORD *)(result + 208) = 0;
  *(_DWORD *)(result + 212) = 0;
  return result;
}

//----- (00002C70) --------------------------------------------------------
signed int __fastcall sub_2C70(int a1, int a2)
{
  int v2; // r3@1
  int *v3; // r4@1
  int v4; // r2@2
  int v5; // t1@2

  v2 = 0;
  v3 = (int *)(a1 + 200);
  while ( 1 )
  {
    v5 = *v3;
    ++v3;
    v4 = v5;
    if ( !v5 )
      break;
    if ( ++v2 == 4 )
      return -1;
  }
  *(_DWORD *)(a1 + 4 * (v2 + 50)) = a2;
  return v4;
}

//----- (000031A8) --------------------------------------------------------
int __fastcall sub_31A8(int a1)
{
  int result; // r0@1

  result = a1 & 0xFFFFFF;
  vE000E014 = result;
  return result;
}

//----- (000031B8) --------------------------------------------------------
int __fastcall sub_31B8(char a1)
{
  int result; // r0@1

  result = a1 & 4;
  vE000E010 = vE000E010 & 0xFFFFFFFB | result;
  return result;
}

//----- (Set the second bit to 1) --------------------------------------------------------
void sub_31D0()
{
  vE000E010 |= 2u;
}

//----- (Set the first bit to 1) --------------------------------------------------------
void sub_31E0()
{
  vE000E010 |= 1u;
}

//----- (000031F0) --------------------------------------------------------
signed int __fastcall sub_31F0(unsigned int a1)
{
  _DWORD *v1; // r3@1
  signed int result; // r0@1

  v1 = (_DWORD *)(4 * (a1 >> 5) - 0x1FFF1F00);
  result = 1 << (a1 & 0x1F);
  *v1 = result;
  return result;
}

//----- (0000320C) --------------------------------------------------------
int __fastcall sub_320C(int result)
{
  int v1; // r3@2

  if ( !result )
  {
    v1 = v40007000 | 0x4000;
LABEL_3:
    v40007000 = v1;
    return result;
  }
  if ( result == 1 )
  {
    v1 = v40007000 & 0x4000;
    goto LABEL_3;
  }
  return result;
}

//----- (00003898) --------------------------------------------------------
int *__fastcall sub_3898(int *result, unsigned __int8 a2, unsigned int a3)
{
  unsigned int v3; // r4@2
  int *v4; // r3@3
  unsigned __int8 v5; // cf@4
  int v6; // r2@9
  unsigned int v7; // r6@9
  unsigned int v8; // r2@11
  int *v9; // r6@12
  unsigned int v10; // r2@12
  int v11; // r4@16

  if ( (_DWORD)result << 30 )
  {
    v3 = a3 - 1;
    if ( !a3 )
      return result;
    v4 = result;
    while ( 1 )
    {
      *(_BYTE *)v4 = a2;
      v4 = (int *)((char *)v4 + 1);
      if ( !((_DWORD)v4 << 30) )
        break;
      v5 = __CFADD__(v3--, -1);
      if ( !v5 )
        return result;
    }
  }
  else
  {
    v3 = a3;
    v4 = result;
  }
  if ( v3 > 3 )
  {
    if ( v3 <= 0xF )
      goto LABEL_22;
    v6 = (int)(v4 + 4);
    v7 = v3;
    do
    {
      v7 -= 16;
      *(_DWORD *)(v6 - 16) = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
      *(_DWORD *)(v6 - 12) = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
      *(_DWORD *)(v6 - 8) = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
      *(_DWORD *)(v6 - 4) = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
      v6 += 16;
    }
    while ( v7 > 0xF );
    v8 = (v3 - 16) & 0xFFFFFFF0;
    v3 &= 0xFu;
    v4 = (int *)((char *)v4 + v8 + 16);
    if ( v3 > 3 )
    {
LABEL_22:
      v9 = v4;
      v10 = v3;
      do
      {
        v10 -= 4;
        *v9 = a2 | (a2 << 8) | ((a2 | (a2 << 8)) << 16);
        ++v9;
      }
      while ( v10 > 3 );
      v4 = (int *)((char *)v4 + ((v3 - 4) & 0xFFFFFFFC) + 4);
      v3 &= 3u;
    }
  }
  if ( v3 )
  {
    v11 = (int)v4 + v3;
    do
    {
      *(_BYTE *)v4 = a2;
      v4 = (int *)((char *)v4 + 1);
    }
    while ( (int *)v11 != v4 );
  }
  return result;
}

// ALL OK, 86 function(s) have been successfully decompiled